Update parquet files (step 111 of 121)

spaces/101-5/gpt4free/g4f/.v1/unfinished/t3nsor/README.md

@@ -1,44 +0,0 @@
-### note: currently patched
-
-### Example: `t3nsor` (use like openai pypi package) <a name="example-t3nsor"></a>
-
-```python
-# Import t3nsor
-import t3nsor
-
-# t3nsor.Completion.create
-# t3nsor.StreamCompletion.create
-
-[...]
-
-```
-
-#### Example Chatbot
-```python
-messages = []
-
-while True:
-    user = input('you: ')
-
-    t3nsor_cmpl = t3nsor.Completion.create(
-        prompt   = user,
-        messages = messages
-    )
-
-    print('gpt:', t3nsor_cmpl.completion.choices[0].text)
-    
-    messages.extend([
-        {'role': 'user', 'content': user }, 
-        {'role': 'assistant', 'content': t3nsor_cmpl.completion.choices[0].text}
-    ])
-```
-
-#### Streaming Response:
-
-```python
-for response in t3nsor.StreamCompletion.create(
-    prompt   = 'write python code to reverse a string',
-    messages = []):
-
-    print(response.completion.choices[0].text)
-```

spaces/101-5/gpt4free/g4f/Provider/Providers/EasyChat.py

@@ -1,43 +0,0 @@
-import os, requests
-from ...typing import sha256, Dict, get_type_hints
-import json
-
-url = "https://free.easychat.work/api/openai/v1/chat/completions"
-model = ['gpt-3.5-turbo']
-supports_stream = False
-needs_auth = False
-
-def _create_completion(model: str, messages: list, stream: bool, **kwargs):
-    ''' limited to 240 messages/hour'''
-    base = ''
-    for message in messages:
-        base += '%s: %s\n' % (message['role'], message['content'])
-    base += 'assistant:'
-    
-    headers = {
-        "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36",
-    }
-
-    data = {
-        "messages": [
-            {"role": "system", "content": "You are ChatGPT, a large language model trained by OpenAI."},
-            {"role": "user", "content": base}
-        ],
-        "stream": False,
-        "model": "gpt-3.5-turbo",
-        "temperature": 0.5,
-        "presence_penalty": 0,
-        "frequency_penalty": 0,
-        "top_p": 1
-    }
-
-    response = requests.post(url, headers=headers, json=data)
-    if response.status_code == 200:
-        response = response.json()
-        yield response['choices'][0]['message']['content']
-    else:
-        print(f"Error Occurred::{response.status_code}")
-        return None
-
-params = f'g4f.Providers.{os.path.basename(__file__)[:-3]} supports: ' + \
-    '(%s)' % ', '.join([f"{name}: {get_type_hints(_create_completion)[name].__name__}" for name in _create_completion.__code__.co_varnames[:_create_completion.__code__.co_argcount]])

spaces/101-5/gpt4free/g4f/Provider/Providers/Vercel.py

@@ -1,162 +0,0 @@
-import os
-import json
-import base64
-import execjs
-import queue
-import threading
-
-from curl_cffi import requests
-from ...typing import sha256, Dict, get_type_hints
-
-url = 'https://play.vercel.ai'
-supports_stream = True
-needs_auth = False
-
-models = {
-    'claude-instant-v1': 'anthropic:claude-instant-v1',
-    'claude-v1': 'anthropic:claude-v1',
-    'alpaca-7b': 'replicate:replicate/alpaca-7b',
-    'stablelm-tuned-alpha-7b': 'replicate:stability-ai/stablelm-tuned-alpha-7b',
-    'bloom': 'huggingface:bigscience/bloom',
-    'bloomz': 'huggingface:bigscience/bloomz',
-    'flan-t5-xxl': 'huggingface:google/flan-t5-xxl',
-    'flan-ul2': 'huggingface:google/flan-ul2',
-    'gpt-neox-20b': 'huggingface:EleutherAI/gpt-neox-20b',
-    'oasst-sft-4-pythia-12b-epoch-3.5': 'huggingface:OpenAssistant/oasst-sft-4-pythia-12b-epoch-3.5',
-    'santacoder': 'huggingface:bigcode/santacoder',
-    'command-medium-nightly': 'cohere:command-medium-nightly',
-    'command-xlarge-nightly': 'cohere:command-xlarge-nightly',
-    'code-cushman-001': 'openai:code-cushman-001',
-    'code-davinci-002': 'openai:code-davinci-002',
-    'gpt-3.5-turbo': 'openai:gpt-3.5-turbo',
-    'text-ada-001': 'openai:text-ada-001',
-    'text-babbage-001': 'openai:text-babbage-001',
-    'text-curie-001': 'openai:text-curie-001',
-    'text-davinci-002': 'openai:text-davinci-002',
-    'text-davinci-003': 'openai:text-davinci-003'
-}
-model = models.keys()
-
-vercel_models = {'anthropic:claude-instant-v1': {'id': 'anthropic:claude-instant-v1', 'provider': 'anthropic', 'providerHumanName': 'Anthropic', 'makerHumanName': 'Anthropic', 'minBillingTier': 'hobby', 'parameters': {'temperature': {'value': 1, 'range': [0, 1]}, 'maximumLength': {'value': 200, 'range': [50, 1024]}, 'topP': {'value': 1, 'range': [0.1, 1]}, 'topK': {'value': 1, 'range': [1, 500]}, 'presencePenalty': {'value': 1, 'range': [0, 1]}, 'frequencyPenalty': {'value': 1, 'range': [0, 1]}, 'stopSequences': {'value': ['\n\nHuman:'], 'range': []}}, 'name': 'claude-instant-v1'}, 'anthropic:claude-v1': {'id': 'anthropic:claude-v1', 'provider': 'anthropic', 'providerHumanName': 'Anthropic', 'makerHumanName': 'Anthropic', 'minBillingTier': 'hobby', 'parameters': {'temperature': {'value': 1, 'range': [0, 1]}, 'maximumLength': {'value': 200, 'range': [50, 1024]}, 'topP': {'value': 1, 'range': [0.1, 1]}, 'topK': {'value': 1, 'range': [1, 500]}, 'presencePenalty': {'value': 1, 'range': [0, 1]}, 'frequencyPenalty': {'value': 1, 'range': [0, 1]}, 'stopSequences': {'value': ['\n\nHuman:'], 'range': []}}, 'name': 'claude-v1'}, 'replicate:replicate/alpaca-7b': {'id': 'replicate:replicate/alpaca-7b', 'provider': 'replicate', 'providerHumanName': 'Replicate', 'makerHumanName': 'Stanford', 'parameters': {'temperature': {'value': 0.75, 'range': [0.01, 5]}, 'maximumLength': {'value': 200, 'range': [50, 512]}, 'topP': {'value': 0.95, 'range': [0.01, 1]}, 'presencePenalty': {'value': 0, 'range': [0, 1]}, 'frequencyPenalty': {'value': 0, 'range': [0, 1]}, 'repetitionPenalty': {'value': 1.1765, 'range': [0.01, 5]}, 'stopSequences': {'value': [], 'range': []}}, 'version': '2014ee1247354f2e81c0b3650d71ca715bc1e610189855f134c30ecb841fae21', 'name': 'alpaca-7b'}, 'replicate:stability-ai/stablelm-tuned-alpha-7b': {'id': 'replicate:stability-ai/stablelm-tuned-alpha-7b', 'provider': 'replicate', 'makerHumanName': 'StabilityAI', 'providerHumanName': 'Replicate', 'parameters': {'temperature': {'value': 0.75, 'range': [0.01, 5]}, 'maximumLength': {'value': 200, 'range': [50, 512]}, 'topP': {'value': 0.95, 'range': [0.01, 1]}, 'presencePenalty': {'value': 0, 'range': [0, 1]}, 'frequencyPenalty': {'value': 0, 'range': [0, 1]}, 'repetitionPenalty': {'value': 1.1765, 'range': [0.01, 5]}, 'stopSequences': {'value': [], 'range': []}}, 'version': '4a9a32b4fd86c2d047f1d271fa93972683ec6ef1cf82f402bd021f267330b50b', 'name': 'stablelm-tuned-alpha-7b'}, 'huggingface:bigscience/bloom': {'id': 'huggingface:bigscience/bloom', 'provider': 'huggingface', 'providerHumanName': 'HuggingFace', 'makerHumanName': 'BigScience', 'instructions': "Do NOT talk to Bloom as an entity, it's not a chatbot but a webpage/blog/article completion model. For the best results: mimic a few words of a webpage similar to the content you want to generate. Start a sentence as if YOU were writing a blog, webpage, math post, coding article and Bloom will generate a coherent follow-up.", 'parameters': {'temperature': {'value': 0.5, 'range': [0.1, 1]}, 'maximumLength': {'value': 200, 'range': [50, 1024]}, 'topP': {'value': 0.95, 'range': [0.01, 0.99]}, 'topK': {'value': 4, 'range': [1, 500]}, 'repetitionPenalty': {'value': 1.03, 'range': [0.1, 2]}}, 'name': 'bloom'}, 'huggingface:bigscience/bloomz': {'id': 'huggingface:bigscience/bloomz', 'provider': 'huggingface', 'providerHumanName': 'HuggingFace', 'makerHumanName': 'BigScience', 'instructions': 'We recommend using the model to perform tasks expressed in natural language. For example, given the prompt "Translate to English: Je t\'aime.", the model will most likely answer "I love you.".', 'parameters': {'temperature': {'value': 0.5, 'range': [0.1, 1]}, 'maximumLength': {'value': 200, 'range': [50, 1024]}, 'topP': {'value': 0.95, 'range': [0.01, 0.99]}, 'topK': {'value': 4, 'range': [1, 500]}, 'repetitionPenalty': {'value': 1.03, 'range': [0.1, 2]}}, 'name': 'bloomz'}, 'huggingface:google/flan-t5-xxl': {'id': 'huggingface:google/flan-t5-xxl', 'provider': 'huggingface', 'makerHumanName': 'Google', 'providerHumanName': 'HuggingFace', 'name': 'flan-t5-xxl', 'parameters': {'temperature': {'value': 0.5, 'range': [0.1, 1]}, 'maximumLength': {'value': 200, 'range': [50, 1024]}, 'topP': {'value': 0.95, 'range': [0.01, 0.99]}, 'topK': {'value': 4, 'range': [1, 500]}, 'repetitionPenalty': {'value': 1.03, 'range': [0.1, 2]}}}, 'huggingface:google/flan-ul2': {'id': 'huggingface:google/flan-ul2', 'provider': 'huggingface', 'providerHumanName': 'HuggingFace', 'makerHumanName': 'Google', 'parameters': {'temperature': {'value': 0.5, 'range': [0.1, 1]}, 'maximumLength': {'value': 200, 'range': [50, 1024]}, 'topP': {'value': 0.95, 'range': [0.01, 0.99]}, 'topK': {'value': 4, 'range': [1, 500]}, 'repetitionPenalty': {'value': 1.03, 'range': [0.1, 2]}}, 'name': 'flan-ul2'}, 'huggingface:EleutherAI/gpt-neox-20b': {'id': 'huggingface:EleutherAI/gpt-neox-20b', 'provider': 'huggingface', 'providerHumanName': 'HuggingFace', 'makerHumanName': 'EleutherAI', 'parameters': {'temperature': {'value': 0.5, 'range': [0.1, 1]}, 'maximumLength': {'value': 200, 'range': [50, 1024]}, 'topP': {'value': 0.95, 'range': [0.01, 0.99]}, 'topK': {'value': 4, 'range': [1, 500]}, 'repetitionPenalty': {'value': 1.03, 'range': [0.1, 2]}, 'stopSequences': {'value': [], 'range': []}}, 'name': 'gpt-neox-20b'}, 'huggingface:OpenAssistant/oasst-sft-4-pythia-12b-epoch-3.5': {'id': 'huggingface:OpenAssistant/oasst-sft-4-pythia-12b-epoch-3.5', 'provider': 'huggingface', 'providerHumanName': 'HuggingFace', 'makerHumanName': 'OpenAssistant', 'parameters': {'maximumLength': {'value': 200, 'range': [50, 1024]}, 'typicalP': {'value': 0.2, 'range': [0.1, 0.99]}, 'repetitionPenalty': {'value': 1, 'range': [0.1, 2]}}, 'name': 'oasst-sft-4-pythia-12b-epoch-3.5'}, 'huggingface:bigcode/santacoder': {
-    'id': 'huggingface:bigcode/santacoder', 'provider': 'huggingface', 'providerHumanName': 'HuggingFace', 'makerHumanName': 'BigCode', 'instructions': 'The model was trained on GitHub code. As such it is not an instruction model and commands like "Write a function that computes the square root." do not work well. You should phrase commands like they occur in source code such as comments (e.g. # the following function computes the sqrt) or write a function signature and docstring and let the model complete the function body.', 'parameters': {'temperature': {'value': 0.5, 'range': [0.1, 1]}, 'maximumLength': {'value': 200, 'range': [50, 1024]}, 'topP': {'value': 0.95, 'range': [0.01, 0.99]}, 'topK': {'value': 4, 'range': [1, 500]}, 'repetitionPenalty': {'value': 1.03, 'range': [0.1, 2]}}, 'name': 'santacoder'}, 'cohere:command-medium-nightly': {'id': 'cohere:command-medium-nightly', 'provider': 'cohere', 'providerHumanName': 'Cohere', 'makerHumanName': 'Cohere', 'name': 'command-medium-nightly', 'parameters': {'temperature': {'value': 0.9, 'range': [0, 2]}, 'maximumLength': {'value': 200, 'range': [50, 1024]}, 'topP': {'value': 1, 'range': [0, 1]}, 'topK': {'value': 0, 'range': [0, 500]}, 'presencePenalty': {'value': 0, 'range': [0, 1]}, 'frequencyPenalty': {'value': 0, 'range': [0, 1]}, 'stopSequences': {'value': [], 'range': []}}}, 'cohere:command-xlarge-nightly': {'id': 'cohere:command-xlarge-nightly', 'provider': 'cohere', 'providerHumanName': 'Cohere', 'makerHumanName': 'Cohere', 'name': 'command-xlarge-nightly', 'parameters': {'temperature': {'value': 0.9, 'range': [0, 2]}, 'maximumLength': {'value': 200, 'range': [50, 1024]}, 'topP': {'value': 1, 'range': [0, 1]}, 'topK': {'value': 0, 'range': [0, 500]}, 'presencePenalty': {'value': 0, 'range': [0, 1]}, 'frequencyPenalty': {'value': 0, 'range': [0, 1]}, 'stopSequences': {'value': [], 'range': []}}}, 'openai:gpt-4': {'id': 'openai:gpt-4', 'provider': 'openai', 'providerHumanName': 'OpenAI', 'makerHumanName': 'OpenAI', 'name': 'gpt-4', 'minBillingTier': 'pro', 'parameters': {'temperature': {'value': 0.7, 'range': [0.1, 1]}, 'maximumLength': {'value': 200, 'range': [50, 1024]}, 'topP': {'value': 1, 'range': [0.1, 1]}, 'presencePenalty': {'value': 0, 'range': [0, 1]}, 'frequencyPenalty': {'value': 0, 'range': [0, 1]}, 'stopSequences': {'value': [], 'range': []}}}, 'openai:code-cushman-001': {'id': 'openai:code-cushman-001', 'provider': 'openai', 'providerHumanName': 'OpenAI', 'makerHumanName': 'OpenAI', 'parameters': {'temperature': {'value': 0.5, 'range': [0.1, 1]}, 'maximumLength': {'value': 200, 'range': [50, 1024]}, 'topP': {'value': 1, 'range': [0.1, 1]}, 'presencePenalty': {'value': 0, 'range': [0, 1]}, 'frequencyPenalty': {'value': 0, 'range': [0, 1]}, 'stopSequences': {'value': [], 'range': []}}, 'name': 'code-cushman-001'}, 'openai:code-davinci-002': {'id': 'openai:code-davinci-002', 'provider': 'openai', 'providerHumanName': 'OpenAI', 'makerHumanName': 'OpenAI', 'parameters': {'temperature': {'value': 0.5, 'range': [0.1, 1]}, 'maximumLength': {'value': 200, 'range': [50, 1024]}, 'topP': {'value': 1, 'range': [0.1, 1]}, 'presencePenalty': {'value': 0, 'range': [0, 1]}, 'frequencyPenalty': {'value': 0, 'range': [0, 1]}, 'stopSequences': {'value': [], 'range': []}}, 'name': 'code-davinci-002'}, 'openai:gpt-3.5-turbo': {'id': 'openai:gpt-3.5-turbo', 'provider': 'openai', 'providerHumanName': 'OpenAI', 'makerHumanName': 'OpenAI', 'parameters': {'temperature': {'value': 0.7, 'range': [0, 1]}, 'maximumLength': {'value': 200, 'range': [50, 1024]}, 'topP': {'value': 1, 'range': [0.1, 1]}, 'topK': {'value': 1, 'range': [1, 500]}, 'presencePenalty': {'value': 1, 'range': [0, 1]}, 'frequencyPenalty': {'value': 1, 'range': [0, 1]}, 'stopSequences': {'value': [], 'range': []}}, 'name': 'gpt-3.5-turbo'}, 'openai:text-ada-001': {'id': 'openai:text-ada-001', 'provider': 'openai', 'providerHumanName': 'OpenAI', 'makerHumanName': 'OpenAI', 'name': 'text-ada-001', 'parameters': {'temperature': {'value': 0.5, 'range': [0.1, 1]}, 'maximumLength': {'value': 200, 'range': [50, 1024]}, 'topP': {'value': 1, 'range': [0.1, 1]}, 'presencePenalty': {'value': 0, 'range': [0, 1]}, 'frequencyPenalty': {'value': 0, 'range': [0, 1]}, 'stopSequences': {'value': [], 'range': []}}}, 'openai:text-babbage-001': {'id': 'openai:text-babbage-001', 'provider': 'openai', 'providerHumanName': 'OpenAI', 'makerHumanName': 'OpenAI', 'name': 'text-babbage-001', 'parameters': {'temperature': {'value': 0.5, 'range': [0.1, 1]}, 'maximumLength': {'value': 200, 'range': [50, 1024]}, 'topP': {'value': 1, 'range': [0.1, 1]}, 'presencePenalty': {'value': 0, 'range': [0, 1]}, 'frequencyPenalty': {'value': 0, 'range': [0, 1]}, 'stopSequences': {'value': [], 'range': []}}}, 'openai:text-curie-001': {'id': 'openai:text-curie-001', 'provider': 'openai', 'providerHumanName': 'OpenAI', 'makerHumanName': 'OpenAI', 'name': 'text-curie-001', 'parameters': {'temperature': {'value': 0.5, 'range': [0.1, 1]}, 'maximumLength': {'value': 200, 'range': [50, 1024]}, 'topP': {'value': 1, 'range': [0.1, 1]}, 'presencePenalty': {'value': 0, 'range': [0, 1]}, 'frequencyPenalty': {'value': 0, 'range': [0, 1]}, 'stopSequences': {'value': [], 'range': []}}}, 'openai:text-davinci-002': {'id': 'openai:text-davinci-002', 'provider': 'openai', 'providerHumanName': 'OpenAI', 'makerHumanName': 'OpenAI', 'name': 'text-davinci-002', 'parameters': {'temperature': {'value': 0.5, 'range': [0.1, 1]}, 'maximumLength': {'value': 200, 'range': [50, 1024]}, 'topP': {'value': 1, 'range': [0.1, 1]}, 'presencePenalty': {'value': 0, 'range': [0, 1]}, 'frequencyPenalty': {'value': 0, 'range': [0, 1]}, 'stopSequences': {'value': [], 'range': []}}}, 'openai:text-davinci-003': {'id': 'openai:text-davinci-003', 'provider': 'openai', 'providerHumanName': 'OpenAI', 'makerHumanName': 'OpenAI', 'name': 'text-davinci-003', 'parameters': {'temperature': {'value': 0.5, 'range': [0.1, 1]}, 'maximumLength': {'value': 200, 'range': [50, 1024]}, 'topP': {'value': 1, 'range': [0.1, 1]}, 'presencePenalty': {'value': 0, 'range': [0, 1]}, 'frequencyPenalty': {'value': 0, 'range': [0, 1]}, 'stopSequences': {'value': [], 'range': []}}}}
-
-
-# based on https://github.com/ading2210/vercel-llm-api // modified
-class Client:
-    def __init__(self):
-        self.session = requests.Session()
-        self.headers = {
-            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/110 Safari/537.36',
-            'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8',
-            'Accept-Encoding': 'gzip, deflate, br',
-            'Accept-Language': 'en-US,en;q=0.5',
-            'Te': 'trailers',
-            'Upgrade-Insecure-Requests': '1'
-        }
-        self.session.headers.update(self.headers)
-
-    def get_token(self):
-            b64 = self.session.get('https://sdk.vercel.ai/openai.jpeg').text
-            data = json.loads(base64.b64decode(b64))
-
-            code = 'const globalThis = {data: `sentinel`}; function token() {return (%s)(%s)}' % (
-                data['c'], data['a'])
-
-            token_string = json.dumps(separators=(',', ':'),
-                                    obj={'r': execjs.compile(code).call('token'), 't': data['t']})
-
-            return base64.b64encode(token_string.encode()).decode()
-
-    def get_default_params(self, model_id):
-        return {key: param['value'] for key, param in vercel_models[model_id]['parameters'].items()}
-
-    def generate(self, model_id: str, prompt: str, params: dict = {}):
-        if not ':' in model_id:
-            model_id = models[model_id]
-
-        defaults = self.get_default_params(model_id)
-
-        payload = defaults | params | {
-            'prompt': prompt,
-            'model': model_id,
-        }
-
-        headers = self.headers | {
-            'Accept-Encoding': 'gzip, deflate, br',
-            'Custom-Encoding': self.get_token(),
-            'Host': 'sdk.vercel.ai',
-            'Origin': 'https://sdk.vercel.ai',
-            'Referrer': 'https://sdk.vercel.ai',
-            'Sec-Fetch-Dest': 'empty',
-            'Sec-Fetch-Mode': 'cors',
-            'Sec-Fetch-Site': 'same-origin',
-        }
-
-        chunks_queue = queue.Queue()
-        error = None
-        response = None
-
-        def callback(data):
-            chunks_queue.put(data.decode())
-
-        def request_thread():
-            nonlocal response, error
-            for _ in range(3):
-                try:
-                    response = self.session.post('https://sdk.vercel.ai/api/generate',
-                                                 json=payload, headers=headers, content_callback=callback)
-                    response.raise_for_status()
-
-                except Exception as e:
-                    if _ == 2:
-                        error = e
-
-                    else:
-                        continue
-
-        thread = threading.Thread(target=request_thread, daemon=True)
-        thread.start()
-
-        text = ''
-        index = 0
-        while True:
-            try:
-                chunk = chunks_queue.get(block=True, timeout=0.1)
-
-            except queue.Empty:
-                if error:
-                    raise error
-
-                elif response:
-                    break
-
-                else:
-                    continue
-
-            text += chunk
-            lines = text.split('\n')
-
-            if len(lines) - 1 > index:
-                new = lines[index:-1]
-                for word in new:
-                    yield json.loads(word)
-                index = len(lines) - 1
-
-def _create_completion(model: str, messages: list, stream: bool, **kwargs):
-    yield 'Vercel is currently not working.'
-    return
-    
-    conversation = 'This is a conversation between a human and a language model, respond to the last message accordingly, referring to the past history of messages if needed.\n'
-    
-    for message in messages:
-        conversation += '%s: %s\n' % (message['role'], message['content'])
-    
-    conversation += 'assistant: '
-    
-    completion = Client().generate(model, conversation)
-
-    for token in completion:
-        yield token
-
-params = f'g4f.Providers.{os.path.basename(__file__)[:-3]} supports: ' + \
-    '(%s)' % ', '.join([f"{name}: {get_type_hints(_create_completion)[name].__name__}" for name in _create_completion.__code__.co_varnames[:_create_completion.__code__.co_argcount]])

spaces/1acneusushi/gradio-2dmoleculeeditor/data/3DMark Test Free The Best Way to Compare Your PCs Performance.md

@@ -1,26 +0,0 @@
-
-<h1>How to Run a 3DMark Test Free on Your PC</h1>
-<p>If you want to benchmark your PC's performance and compare it with other systems, you might want to try 3DMark, a popular and comprehensive tool for testing graphics and gaming capabilities. But how can you run a 3DMark test free on your PC? Here are some options you can consider.</p>
-<h2>Download the Free Version of 3DMark</h2>
-<p>One of the easiest ways to run a 3DMark test free on your PC is to download the free version of 3DMark from Steam or the official website. The free version includes several tests that cover different scenarios, such as Time Spy for DirectX 12, Fire Strike for DirectX 11, Night Raid for integrated graphics, and more. You can also compare your results online with other users and see how your PC ranks among them.</p>
-<h2>3dmark test free</h2><br /><p><b><b>Download File</b> --->>> <a href="https://byltly.com/2uKv5P">https://byltly.com/2uKv5P</a></b></p><br /><br />
-<h2>Use the Free Trial of 3DMark Advanced Edition</h2>
-<p>If you want to access more features and tests that are not available in the free version, you can use the free trial of 3DMark Advanced Edition for 14 days. The Advanced Edition lets you customize your tests, run stress tests, monitor your hardware, and unlock more benchmarks, such as Port Royal for ray tracing, Wild Life for mobile devices, and more. You can also export your results as XML files and use them for further analysis.</p>
-<h2>Get a Free Key for 3DMark Advanced Edition</h2>
-<p>Another way to run a 3DMark test free on your PC is to get a free key for 3DMark Advanced Edition from various sources. For example, you might get a free key when you buy a new graphics card or a gaming laptop from certain brands or retailers. You might also find a free key in some giveaways or promotions that are occasionally held by 3DMark or its partners. Just make sure to check the validity and terms of use of the key before you redeem it.</p>
-<h3>Conclusion</h3>
-<p>Running a 3DMark test free on your PC is not difficult if you know where to look. You can either download the free version of 3DMark, use the free trial of 3DMark Advanced Edition, or get a free key for 3DMark Advanced Edition from various sources. By doing so, you can benchmark your PC's performance and see how it compares with other systems.</p>
-<p></p>
-
-<h3>How to Interpret Your 3DMark Test Results</h3>
-<p>After running a 3DMark test free on your PC, you might wonder what your results mean and how to use them. Here are some tips on how to interpret your 3DMark test results.</p>
-<h4>Check Your Score and Compare It with Others</h4>
-<p>The most obvious thing to look at is your score, which is a numerical value that reflects your PC's performance in the test. The higher the score, the better the performance. You can also compare your score with other users who have similar hardware or run the same test. This can help you see how your PC stacks up against the competition and identify any potential issues or bottlenecks.</p>
-<h4>Look at Your Frame Rate and Stability</h4>
-<p>Another thing to look at is your frame rate, which is the number of frames per second (FPS) that your PC can render in the test. The higher the frame rate, the smoother the gameplay. You can also look at your frame rate stability, which is the percentage of frames that meet or exceed a certain threshold. The higher the stability, the more consistent the performance. You can use these metrics to evaluate your PC's gaming experience and see if it meets your expectations or needs.</p>
-<h4>Analyze Your Hardware Usage and Temperature</h4>
-<p>A third thing to look at is your hardware usage and temperature, which are the percentage of resources that your CPU and GPU are using in the test and their respective temperatures. The higher the usage, the more workload your hardware is handling. The higher the temperature, the more heat your hardware is generating. You can use these metrics to monitor your PC's health and efficiency and see if it needs any optimization or cooling.</p>
-<h3>Conclusion</h3>
-<p>Running a 3DMark test free on your PC can help you benchmark your PC's performance and compare it with other systems. However, you also need to know how to interpret your 3DMark test results and use them for further improvement or analysis. By checking your score, frame rate, stability, hardware usage, and temperature, you can gain more insights into your PC's capabilities and limitations.</p> ddb901b051<br />
-<br />
-<br />

spaces/1acneusushi/gradio-2dmoleculeeditor/data/Dll Injector For Mac.md

@@ -1,154 +0,0 @@
-<br />
-<h1>DLL Injector for Mac: Everything You Need to Know</h1>
-<p>If you are a developer, hacker, or gamer, you may have heard of DLL injection. It is a technique that allows you to modify the behavior of a running program by injecting your own code into it. But what exactly is a DLL injector and how does it work? And more importantly, how can you use it on a Mac system?</p>
-<p>In this article, we will answer these questions and more. We will explain what a DLL injector is, what are its benefits and risks, and how it works on Windows and Mac systems. We will also review some of the best DLL injectors for Mac and show you how to use them. By the end of this article, you will have a clear understanding of DLL injection and how to apply it on your Mac.</p>
-<h2>Dll Injector For Mac</h2><br /><p><b><b>Download Zip</b> &#8230; <a href="https://byltly.com/2uKyhY">https://byltly.com/2uKyhY</a></b></p><br /><br />
- <h2>What is a DLL injector and why would someone use it?</h2>
-<p>A DLL injector is a tool that can inject dynamic-link libraries (DLLs) into processes in order to execute arbitrary code in their address space. A DLL is a file that contains executable functions or resources that can be used by other programs. By injecting a DLL into a process, you can modify its functionality or add new features to it.</p>
-<p>There are many reasons why someone would use a DLL injector. Some of them are:</p>
-<ul>
-<li>To enhance the performance or functionality of a program. For example, you can inject a DLL that improves the graphics or adds new features to a game.</li>
-<li>To debug or test a program. For example, you can inject a DLL that logs or monitors the activity or output of a program.</li>
-<li>To bypass security or anti-cheat mechanisms. For example, you can inject a DLL that disables or circumvents the protection or detection of a program.</li>
-<li>To perform malicious actions. For example, you can inject a DLL that steals information or damages the system of a program.</li>
-</ul>
-<p>As you can see, DLL injection can be used for both legitimate and illegitimate purposes. It depends on the intention and ethics of the user.</p>
- <h2>What are the benefits and risks of DLL injection?</h2>
-<p>DLL injection has both benefits and risks. Some of the benefits are:</p>
-<ul>
-<li>It allows you to modify or extend the functionality of a program without modifying its source code or binary file.</li>
-<li>It allows you to execute code in the context of another process, which may grant you access to its memory, resources, or privileges.</li>
-<li>It allows you to evade detection or protection from security products or mechanisms, since your code is masked under a legitimate process.</li>
-</ul>
-<p>Some of the risks are:</p>
-<ul>
-<li>It may cause instability or crashes in the target process or system, especially if the injected code is poorly written or incompatible.</li>
-<li>It may expose your system to malware or attacks, especially if the injected code is malicious or compromised.</li>
-<li>It may violate the terms of service or license agreement of the target program or system, especially if the injected code alters its functionality or performance.</li>
-</ul>
-<p>Therefore, Therefore, you should use DLL injection with caution and responsibility. You should also respect the rights and privacy of the target program or system and its users. DLL injection can be a powerful and useful technique, but it can also be a dangerous and unethical one.</p>
- <h2>How does DLL injection work on Windows and Mac systems?</h2>
-<p>DLL injection works differently on Windows and Mac systems, since they have different operating systems and architectures. Here is a brief overview of how DLL injection works on each system:</p>
-<p></p>
- <h3>Windows</h3>
-<p>On Windows, DLL injection is relatively easy and common, since Windows supports loading DLLs dynamically at runtime. There are several methods of DLL injection on Windows, but the most popular one is the following:</p>
-<ol>
-<li>Find the process ID (PID) of the target process using tools like Task Manager or Process Explorer.</li>
-<li>Open a handle to the target process using the OpenProcess function with the PROCESS_ALL_ACCESS flag.</li>
-<li>Allocate memory in the target process using the VirtualAllocEx function with the MEM_COMMIT | MEM_RESERVE flags and the PAGE_EXECUTE_READWRITE protection.</li>
-<li>Write the path of the DLL to be injected into the allocated memory using the WriteProcessMemory function.</li>
-<li>Create a remote thread in the target process using the CreateRemoteThread function with the address of the LoadLibrary function as the start address and the address of the allocated memory as the parameter.</li>
-<li>Wait for the remote thread to finish using the WaitForSingleObject function.</li>
-<li>Close the handle to the target process using the CloseHandle function.</li>
-</ol>
-<p>This method essentially loads the DLL into the target process by calling the LoadLibrary function from a remote thread. The LoadLibrary function is a Windows API function that loads a DLL into the calling process and returns its base address. By passing the path of the DLL as a parameter, you can load any DLL you want into the target process.</p>
- <h3>Mac</h3>
-<p>On Mac, DLL injection is more difficult and rare, since Mac does not support loading DLLs dynamically at runtime. Mac uses dynamic libraries (dylibs) instead of DLLs, which are similar but not exactly the same. Dylibs are loaded at launch time by a program called dyld, which is responsible for resolving dependencies and linking symbols. There are a few methods of DLL injection on Mac, but one of them is the following:</p>
-<ol>
-<li>Find the process ID (PID) of the target process using tools like Activity Monitor or ps.</li>
-<li>Attach to the target process using the ptrace function with the PT_ATTACH request.</li>
-<li>Suspend the target process using the kill function with the SIGSTOP signal.</li>
-<li>Allocate memory in the target process using the mach_vm_allocate function with the VM_FLAGS_ANYWHERE flag.</li>
-<li>Write a shellcode that calls dlopen into the allocated memory using the mach_vm_write function. dlopen is a POSIX function that loads a dynamic library into memory and returns its handle.</li>
-<li>Write a pointer to the path of the dylib to be injected after the shellcode using mach_vm_write again.</li>
-<li>Set a breakpoint at an instruction in the target process using mach_vm_protect with VM_PROT_EXECUTE | VM_PROT_READ | VM_PROT_COPY flags and VM_PROT_ALL protection.</li>
-<li>Resume Resume the target process using the kill function with the SIGCONT signal.</li>
-<li>Wait for the breakpoint to be hit using the waitpid function.</li>
-<li>Read the registers of the target process using the ptrace function with the PT_GETREGS request.</li>
-<li>Modify the instruction pointer register to point to the shellcode using the ptrace function with the PT_SETREGS request.</li>
-<li>Resume the target process using the ptrace function with the PT_DETACH request.</li>
-</ol>
-<p>This method essentially executes the shellcode in the target process by hijacking its execution flow. The shellcode calls dlopen with the path of the dylib as a parameter, which loads the dylib into memory. By setting a breakpoint at an instruction, you can pause the target process and change its instruction pointer to point to your shellcode.</p>
- <h2>Best DLL injectors for Mac</h2>
-<p>Now that you know how DLL injection works on Mac, you may be wondering what are some of the best DLL injectors for Mac. There are not many DLL injectors for Mac, since it is a more challenging and less common technique than on Windows. However, we have found three DLL injectors for Mac that are worth mentioning. They are:</p>
- <h3>Luject</h3>
-<p>Luject is a static injector of dynamic library for application (android, iphoneos, macOS, windows, linux) . It is a command-line tool that can inject a dylib into an executable file before launching it. It works by modifying the Mach-O header of the executable file and adding a new load command that points to the dylib. It supports both 32-bit and 64-bit architectures and can inject multiple dylibs at once.</p>
-<p>Some of the features, pros, and cons of Luject are:</p>
-<table>
-<tr><th>Features</th><th>Pros</th><th>Cons</th></tr>
-<tr><td>- Static injection of dylib into executable file<br>- Support for multiple architectures and platforms<br>- Support for multiple dylibs injection<br>- Easy to use command-line interface</td><td>- Fast and reliable injection<br>- No need to attach to or modify running processes<br>- Compatible with most executable files<br>- Free and open-source</td><td>- Cannot inject into already running processes<br>- Cannot unload or remove injected dylibs<br>- May trigger anti-tampering mechanisms or checksums</td></tr>
-</table>
- <h3>Pyinjector</h3>
-<p>Pyinjector is a Python tool to inject shared libraries into running processes . It is a script that can inject a dylib into a process using the method described in the previous section. It works by attaching to the process, allocating memory, writing shellcode and dylib path, setting a breakpoint, modifying registers, and resuming execution. It supports both 32-bit and 64-bit architectures and can inject multiple dylibs at once.</p>
-<p>Some of the features, pros, and cons of Pyinjector are:</p>
-<table>
-<tr><th>Features</th><th>Pros</th><th>Cons</th></tr>
-<tr><td>- Dynamic injection of dylib into running process<br>- Support for multiple architectures<br>- Support for multiple dylibs injection<br>- Written in Python and easy to modify or extend</td><td>- Flexible and versatile injection<br>- Can inject into any running process<br>- Can unload or remove injected dylibs<br>- Free and open-source</td><td>- Slow and unstable injection<br>- May cause crashes or errors in target process or system<br>- May be detected or blocked by security products or mechanisms</td></tr>
-</table>
- <h3>SocketHook</h3>
-<p>SocketHook is an injector based on EasyHook (win only) that redirects the traffic to your local server . It is a tool that can inject a dylib into a process that uses network sockets. It works by hooking the socket functions in the target process and redirecting them to your local server. You can then intercept, modify, or spoof the network traffic between the target process and its destination. It supports both 32-bit and 64-bit architectures and can inject multiple dylibs at once.</p>
-<p>Some of the features, pros, and cons of SocketHook are:</p>
-<table>
-<tr><th>Features</th><th>Pros</th><th>Cons</th></tr>
-<tr><td>- Dynamic injection of dylib into socket-using process<br>- Support for multiple architectures<br>- Support for multiple dylibs injection<br>- Based on EasyHook framework and easy to use</td><td>- Powerful and stealthy injection<br>- Can manipulate network traffic of target process<br>- Can bypass encryption or authentication mechanisms<br>- Free and open-source</td><td>- Limited to socket-using processes - Limited to socket-using processes<br>- May cause network latency or congestion<br>- May be detected or blocked by firewall or antivirus products</td></tr>
-</table>
- <h2>How to use DLL injectors for Mac</h2>
-<p>Now that you know some of the best DLL injectors for Mac, you may be wondering how to use them. In this section, we will show you a step-by-step guide for using Luject, Pyinjector, and SocketHook. We will assume that you have already downloaded and installed the tools on your Mac. We will also assume that you have a target process and a dylib that you want to inject.</p>
- <h3>Using Luject</h3>
-<p>To use Luject, follow these steps:</p>
-<ol>
-<li>Open a terminal and navigate to the directory where Luject is located.</li>
-<li>Run the following command to inject a dylib into an executable file:<br><code>./luject -i &lt;dylib_path&gt; -o &lt;output_path&gt; &lt;executable_path&gt;</code><br>For example, if you want to inject test.dylib into test.app and save the output as test_injected.app, run:<br><code>./luject -i test.dylib -o test_injected.app test.app</code></li>
-<li>Run the following command to launch the injected executable file:<br><code>open &lt;output_path&gt;</code><br>For example, if you saved the output as test_injected.app, run:<br><code>open test_injected.app</code></li>
-<li>Enjoy the injected program.</li>
-</ol>
- <h3>Using Pyinjector</h3>
-<p>To use Pyinjector, follow these steps:</p>
-<ol>
-<li>Open a terminal and navigate to the directory where Pyinjector is located.</li>
-<li>Run the following command to inject a dylib into a running process:<br><code>python pyinjector.py -p &lt;pid&gt; -d &lt;dylib_path&gt;</code><br>For example, if you want to inject test.dylib into a process with PID 1234, run:<br><code>python pyinjector.py -p 1234 -d test.dylib</code></li>
-<li>Wait for the injection to complete.</li>
-<li>Enjoy the injected program.</li>
-</ol>
- <h3>Using SocketHook</h3>
-<p>To use SocketHook, follow these steps:</p>
-<ol>
-<li>Open a terminal and navigate to the directory where SocketHook is located.</li>
-<li>Run the following command to start a local server that listens on port 8080:<br><code>python server.py 8080</code></li>
-<li>Run the following command to inject a dylib into a running process that uses network sockets:<br><code>./sockethook -p &lt;pid&gt; -d &lt;dylib_path&gt;</code><br>For example, if you want to inject test.dylib into a process with PID 1234, run:<br><code>./sockethook -p 1234 -d test.dylib</code></li>
-<li>Wait for the injection to complete.</li>
-<li>Enjoy the injected program and its network traffic.</li>
-</ol>
- <h2>Tips and tricks for successful DLL injection</h2>
-<p>DLL injection can be tricky and risky, especially on Mac systems. Here are some tips and tricks that can help you achieve successful DLL injection:</p>
-<ul>
-<li>Make sure that your dylib is compatible with the target process and system. For example, if the target process is 64-bit, your dylib should also be 64-bit. If the target system is macOS Big Sur, your dylib should also be compatible with macOS Big Sur.</li>
-<li>Make sure that your dylib does not interfere with the normal functionality or stability of the target process or system. For example, if your dylib hooks or modifies critical functions or resources, it may cause crashes or errors in the target process or system.</li>
-<li>Make sure that your dylib does not expose your system to malware or attacks. For example, if your dylib downloads or executes external code or data, it may compromise your system security or privacy.</li>
-<li>Make sure that your dylib does not violate the terms of service or license agreement of the target process or system. For example, if your dylib alters the functionality or performance of a game, it may result in a ban or legal action from the game developer or publisher.</li>
-<li>Make sure that you have permission and consent from the target process or system and its users. For example, if you inject a dylib into a process or system that belongs to someone else, you should inform them and obtain their permission and consent before doing so.</li>
-</ul>
- <h2>Common errors and troubleshooting</h2>
-<p>DLL injection can also encounter some errors and problems, especially on Mac systems. Here are some of the common errors and troubleshooting tips that can help you solve them:</p>
-<ul>
-<li>If you get an error message that says "Operation not permitted" or "Permission denied", it may mean that you do not have enough privileges or permissions to inject a dylib into the target process or system. You may need to run the DLL injector as root or administrator, or disable some security features or mechanisms that prevent DLL injection.</li>
-<li>If you get an error message that says "No such file or directory" or "File not found", it may mean that the path of the dylib or the executable file is incorrect or invalid. You may need to check the spelling, case, or location of the files and make sure they exist and are accessible.</li>
-<li>If you get an error message that says "Bad CPU type in executable" or "Incompatible library version", it may mean that the architecture or version of the dylib or the executable file is mismatched or incompatible. You may need to compile or download the correct version of the files and make sure they match the target process and system.</li>
-<li>If you get an error message that says "Segmentation fault" or "Bus error", it may mean that the injected code has caused a memory access violation or a hardware error in the target process or system. You may need to debug or test your code and make sure it does not corrupt or overwrite any memory regions or registers.</li>
-</ul>
- <h2>Conclusion</h2>
-<p>DLL injection is a technique that allows you to inject dynamic-link libraries into processes in order to execute arbitrary code in their address space. It can be used for both legitimate and illegitimate purposes, depending on the intention and ethics of the user. It has both benefits and risks, and it works differently on Windows and Mac systems.</p>
-<p>In this article, we have explained what a DLL injector is, what are its benefits and risks, and how it works on Windows and Mac systems. We have also reviewed some of the best DLL injectors for Mac and showed you how to use them. We have also provided some tips and tricks for successful DLL injection and some common errors and troubleshooting tips.</p>
-<p>We hope that this article has been informative and helpful for you. If you want to learn more about DLL injection or other related topics, you can check out these resources:</p>
-<ul>
-<li>[Luject: A static injector of dynamic library for application (android, iphoneos, macOS, windows, linux) ]</li>
-<li>[Pyinjector: A Python tool to inject shared libraries into running processes ]</li>
-<li>[SocketHook: An injector based on EasyHook (win only) that redirects the traffic to your local server ]</li>
-<li>[DLL Injection - Wikipedia ](https://en.wikipedia.org/wiki/DLL_injection)</li>
-<li>[Mach-O - Wikipedia ](https://en.wikipedia.org/wiki/Mach-O)</li>
-<li>[Dynamic loading - Wikipedia ](https://en.wikipedia.org/wiki/Dynamic_loading)</li>
-</ul>
- <h2>FAQs</h2>
-<p>Here are some frequently asked questions about DLL injection:</p>
- <h3>What is the difference between DLL injection and code injection?</h3>
-<p>DLL injection is a type of code injection, which is a general term for any technique that injects code into a process. DLL injection specifically injects dynamic-link libraries into processes, while code injection can inject any type of code, such as shellcode, scripts, or bytecode.</p>
- <h3>How can I detect and prevent DLL injection attacks?</h3>
-<p>DLL injection attacks can be detected and prevented by using various security products or mechanisms, such as antivirus software, firewall software, anti-debugging techniques, code signing techniques, integrity checking techniques, sandboxing techniques, etc. These products or mechanisms can monitor, block, or alert any suspicious or unauthorized DLL injection attempts.</p>
- <h3>What are some legitimate uses of DLL injection?</h3>
-<p>Some legitimate uses of DLL injection are enhancing the performance or functionality of a program, debugging or testing a program, bypassing security or anti-cheat mechanisms for research or educational purposes, etc. However, these uses should be done with permission and consent from the target program or system and its users.</p>
- <h3>What are some alternatives to DLL injection?</h3>
-<p>Some alternatives to DLL injection are static linking, dynamic loading, hooking, patching, inter-process communication, etc. These alternatives can achieve similar results as DLL injection without injecting code into processes. However, they may have their own advantages and disadvantages depending on the situation.</p>
- <h3>Is DLL injection illegal or unethical?</ <h3>Is DLL injection illegal or unethical?</h3>
-<p>DLL injection is not inherently illegal or unethical, but it depends on the intention and ethics of the user and the target program or system and its users. DLL injection can be illegal or unethical if it violates the law, the terms of service, the license agreement, or the rights and privacy of the target program or system and its users. DLL injection can also be illegal or unethical if it causes harm or damage to the target program or system and its users. Therefore, you should use DLL injection with caution and responsibility and respect the law and the ethics.</p> b2dd77e56b<br />
-<br />
-<br />

spaces/1acneusushi/gradio-2dmoleculeeditor/data/HHD Online Player (Full Hd Raja Ki Aayegi Baaraat Movie) Learn More About the Film and Its Cast.md

@@ -1,132 +0,0 @@
-<br />
-<br> - Benefits: List the advantages of using HHD Online Player for watching movies online <br> - Features: Highlight the main features of HHD Online Player such as quality, speed, security, and compatibility | | H2: How to watch Raja Ki Aayegi Baaraat movie online with HHD Online Player | - Step 1: Download and install HHD Online Player on your device <br> - Step 2: Search for Raja Ki Aayegi Baaraat movie on HHD Online Player <br> - Step 3: Select the desired quality and language options <br> - Step 4: Enjoy watching Raja Ki Aayegi Baaraat movie online with HHD Online Player | | H3: What is Raja Ki Aayegi Baaraat movie about and why you should watch it | - Plot summary: Give a brief overview of the story and the main characters of Raja Ki Aayegi Baaraat movie <br> - Reviews and ratings: Share some positive feedback and ratings from critics and audiences for Raja Ki Aayegi Baaraat movie <br> - Trivia and facts: Share some interesting facts and trivia about Raja Ki Aayegi Baaraat movie such as awards, box office, and behind-the-scenes | | H4: Conclusion and FAQs | - Conclusion: Summarize the main points of the article and encourage the readers to watch Raja Ki Aayegi Baaraat movie online with HHD Online Player <br> - FAQs: Answer some common questions that the readers might have about HHD Online Player or Raja Ki Aayegi Baaraat movie | **Table 2: Article with HTML formatting** <h1>What is HHD Online Player and why you should use it</h1>
-<p>If you are a movie lover who likes to watch movies online, you might have heard of HHD Online Player. But what is it exactly and why should you use it? In this article, we will tell you everything you need to know about HHD Online Player and how you can watch Raja Ki Aayegi Baaraat movie online with it.</p>
-<h2>HHD Online Player (Full Hd Raja Ki Aayegi Baaraat Movie)</h2><br /><p><b><b>Download</b> >>> <a href="https://byltly.com/2uKwdd">https://byltly.com/2uKwdd</a></b></p><br /><br />
-<p>HHD Online Player is a free online video player that lets you stream and download movies in high definition quality. It is compatible with all devices such as laptops, smartphones, tablets, and smart TVs. You can watch movies in various languages and subtitles with HHD Online Player. You can also enjoy fast loading speed, secure connection, and ad-free viewing with HHD Online Player.</p>
-<p>Some of the benefits of using HHD Online Player are:</p>
-<ul>
-<li>You can watch movies anytime and anywhere without any hassle.</li>
-<li>You can save money on buying movie tickets or subscriptions.</li>
-<li>You can choose from a wide range of genres and categories of movies.</li>
-<li>You can discover new movies and old classics with HHD Online Player.</li>
-</ul>
-<p>Some of the features of HHD Online Player are:</p>
-<ul>
-<li>You can watch movies in full HD quality (1080p) or lower resolutions according to your preference.</li>
-<li>You can download movies for offline viewing or watch them online with a stable internet connection.</li>
-<li>You can adjust the volume, brightness, playback speed, and screen size of the video player.</li>
-<li>You can protect your privacy and data with encryption and firewall technology.</li>
-<li>You can access HHD Online Player from any browser or device without any installation or registration.</li>
-</ul>
- <h2>How to watch Raja Ki Aayegi Baaraat movie online with HHD Online Player</h2>
-<p>Now that you know what HHD Online Player is and why you should use it, let's see how you can watch Raja Ki Aayegi Baaraat movie online with it. Raja Ki Aayegi Baaraat is a 1996 Hindi drama film starring Rani Mukerji, Shadaab Khan, Gulshan Grover, Divya Dutta, and others. It is directed by Ashok Gaikwad and produced by Salim Akhtar. The movie tells the story of a young girl who is raped by a rich boy and forced to marry him by the court. She then decides to take revenge on him and his family.</p>
-<p>Raja Ki Ayegi Baraat streaming: where to watch online?<br />
-Raja Ki Ayegi Baraat Superhit Full Bhojpuri Movie Khesari Lal Yadav, Kajal Raghwani<br />
-Raja Ki Ayegi Baraat 1997 IMDb<br />
-Raja Ki Ayegi Baraat Zee5 VI movies and tv<br />
-Raja Ki Ayegi Baraat rape revenge drama<br />
-Raja Ki Ayegi Baraat Rani Mukerji debut film<br />
-Raja Ki Ayegi Baraat Hindi movie with English subtitles<br />
-Raja Ki Ayegi Baraat full movie download HD 720p<br />
-Raja Ki Ayegi Baraat songs mp3 free download<br />
-Raja Ki Ayegi Baraat cast and crew<br />
-Raja Ki Ayegi Baraat box office collection<br />
-Raja Ki Ayegi Baraat movie review and rating<br />
-Raja Ki Ayegi Baraat trailer video<br />
-Raja Ki Ayegi Baraat watch online free Dailymotion<br />
-Raja Ki Ayegi Baraat Mala and Raj love story<br />
-Raja Ki Ayegi Baraat remake of Tamil film Naan Sigappu Manithan<br />
-Raja Ki Ayegi Baraat best scenes and dialogues<br />
-Raja Ki Ayegi Baraat awards and nominations<br />
-Raja Ki Ayegi Baraat behind the scenes and trivia<br />
-Raja Ki Ayegi Baraat movie poster and wallpapers<br />
-Raja Ki Aayegi Baaraat Full Hd Movie Online Free<br />
-Raja Ki Aayegi Baaraat Full Hd Movie Download Filmywap<br />
-Raja Ki Aayegi Baaraat Full Hd Movie Watch on Youtube<br />
-Raja Ki Aayegi Baaraat Full Hd Movie with Bhojpuri Dubbing<br />
-Raja Ki Aayegi Baaraat Full Hd Movie with Urdu Subtitles<br />
-Raja Ki Aayegi Baaraat Full Hd Movie Songs Video<br />
-Raja Ki Aayegi Baaraat Full Hd Movie Controversy and Criticism<br />
-Raja Ki Aayegi Baaraat Full Hd Movie Inspired by True Story<br />
-Raja Ki Aayegi Baaraat Full Hd Movie Comparison with Original Tamil Version<br />
-Raja Ki Aayegi Baaraat Full Hd Movie Fan Reactions and Comments<br />
-HHD Online Player for Bollywood Movies<br />
-HHD Online Player for Bhojpuri Movies<br />
-HHD Online Player for Streaming HD Quality Videos<br />
-HHD Online Player for Downloading Movies Offline<br />
-HHD Online Player for Watching Movies with Subtitles<br />
-HHD Online Player for Android and iOS Devices<br />
-HHD Online Player for PC and Laptop<br />
-HHD Online Player for Smart TV and Firestick<br />
-HHD Online Player Features and Benefits<br />
-HHD Online Player Reviews and Ratings<br />
-How to Watch Raja Ki Aayegi Baaraat Movie on HHD Online Player?<br />
-How to Download Raja Ki Aayegi Baaraat Movie from HHD Online Player?<br />
-How to Install HHD Online Player on Your Device?<br />
-How to Use HHD Online Player for Streaming Movies?<br />
-How to Fix HHD Online Player Errors and Issues?<br />
-How to Update HHD Online Player to Latest Version?<br />
-How to Contact HHD Online Player Customer Support?<br />
-How to Uninstall HHD Online Player from Your Device?<br />
-How to Get HHD Online Player Premium Subscription?<br />
-How to Share HHD Online Player with Your Friends?</p>
-<p>To watch Raja Ki Aayegi Baaraat movie online with HHD Online Player, follow these simple steps:</p>
-<ol>
-<li>Download and install HHD Online Player on your device. You can find the download link at . It is free and safe to download.</li>
-<li>Search for Raja Ki Aayegi Baaraat movie on HHD Online Player. You can use the search bar or browse through the categories.</li>
-<li>Select the desired quality and language options. You can choose from HD, SD, or CAM quality and Hindi or English language.</li>
-<li>Enjoy watching Raja Ki Aayegi Baaraat movie online with HHD Online Player. You can pause, resume, rewind, or fast-forward the movie as you like.</li>
-</ol>
- <h3>What is Raja Ki Aayegi Baaraat movie about and why you should watch it</h3>
-<p>Raja Ki Aayegi Baaraat is a movie that deals with the issue of rape and justice in India. It is a powerful and emotional drama that showcases the courage and resilience of a woman who fights against all odds. It is also a movie that marks the debut of Rani Mukerji, who went on to become one of the most popular actresses in Bollywood.</p>
-<p>Here are some reasons why you should watch Raja Ki Aayegi Baaraat movie:</p>
-<ul>
-<li>The movie has a strong message about women empowerment and human rights.</li>
-<li>The movie has a gripping plot that keeps you hooked till the end.</li>
-<li>The movie has brilliant performances by the cast, especially Rani Mukerji who won several awards for her role.</li>
-<li>The movie has memorable songs composed by Anand-Milind that add to the mood of the film.</li>
-</ul>
- <p>Here are some reviews and ratings for Raja Ki Aayegi Baaraat movie:</p>
- <table style="border-collapse: collapse; width: 100%;" border="1">
-<tbody>
-<tr style="height: 18px;">
-<td style="width: 33.3333%; height: 18px;">Source</td>
-<td style="width: 33.3333%; height: 18px;">Rating</td>
-<td style="width: 33.3333%; height: 18px;">Review</td>
-</tr>
-<tr style="height: 18px;">
-<td style="width: 33.3333%; height: 18px;">IMDb</td>
-<td style="width: 33.3333%; height: 18px;">6.8/10</td>
-<td style="width: 33.3333%; height: 18px;">"A very good film with a strong message."</td>
-</tr>
-<tr style="height: 18px;">
-<td style="width: 33.3333%; height: 18px;">Rediff</td>
-<td style="width: 33.3333%; height: 18px;">3/5</td>
-<td style="width: 33.3333%; height: 18px;">"Rani Mukerji makes an impressive debut in this hard-hitting drama."</td>
-</tr>
-<tr style="height: 18px;">
-<td style="width: 33.3333%; height: 18px;">Planet Bollywood</td>
-<td style="width: 33.3333%; height: 18px;">7/10</td>
-<td style="width: 33.3333%; height: 18px;">"A well-made film that tackles a sensitive issue with dignity."</td>
-</tr>
- </tbody></table>
- <p>Here are some trivia and facts about Raja Ki Aayegi Baaraat movie:</p>
- <ul>
- <li>The movie was initially titled Ladki Jawaan Ho Gayee but was changed later to avoid confusion with another film titled Ladki Jawaan Padosi Pareshaan.</li>
- <li>The movie was inspired by a real-life incident that happened in Delhi in 1995 where a rapist was ordered to marry his victim by a judge.</li>
- <li>The movie was banned in some states due to its controversial subject matter and faced protests from some groups who claimed that it glorified rape.</li>
- <li>The movie was a moderate success at the box office but received critical acclaim for its bold theme and powerful execution.</li>
- <h4>Conclusion and FAQs</h4>
-<p>In conclusion, HHD Online Player is a great online video player that lets you watch movies online in high quality and with ease. You can watch Raja Ki Aayegi Baaraat movie online with HHD Online Player and enjoy a captivating and inspiring story of a woman who stands up for herself and her dignity. Raja Ki Aayegi Baaraat is a movie that you should not miss if you are a fan of drama, romance, and social issues.</p>
-<p>We hope you found this article helpful and informative. If you have any questions about HHD Online Player or Raja Ki Aayegi Baaraat movie, you can check out the FAQs below or contact us for more assistance.</p>
- <p>FAQs:</p>
-<ol>
-<li>Q: Is HHD Online Player legal and safe to use?<br>A: Yes, HHD Online Player is legal and safe to use. It does not host or upload any movies on its server. It only provides links to third-party sources that are publicly available on the internet. However, you should always check the legality of the content in your region before watching or downloading it.</li>
-<li>Q: How much data does HHD Online Player consume?<br>A: The data consumption of HHD Online Player depends on the quality and duration of the movie you are watching. Generally, watching a movie in HD quality consumes about 1 GB of data per hour. You can reduce the data consumption by choosing a lower quality option or by downloading the movie for offline viewing.</li>
-<li>Q: Can I watch Raja Ki Aayegi Baaraat movie with subtitles?<br>A: Yes, you can watch Raja Ki Aayegi Baaraat movie with subtitles on HHD Online Player. You can choose from various subtitle options such as English, Hindi, Arabic, French, and more. You can also adjust the size, color, and position of the subtitles according to your preference.</li>
-<li>Q: Where can I find more movies like Raja Ki Aayegi Baaraat?<br>A: If you liked Raja Ki Aayegi Baaraat movie, you might also like other movies that deal with similar themes such as rape, justice, revenge, and women empowerment. Some of these movies are Damini (1993), Dushman (1998), NH10 (2015), Pink (2016), and Mardaani (2014).</li>
-<li>Q: How can I give feedback or suggestions for HHD Online Player?<br>A: We would love to hear from you and improve our service. You can give us your feedback or suggestions by filling out this form  or by emailing us at [email protected]. We appreciate your time and input.</li>
-</ol>
- </p> 0a6ba089eb<br />
-<br />
-<br />

spaces/1pelhydcardo/ChatGPT-prompt-generator/assets/A to Z Bhojpuri Video Song Download Stream and Download Bhojpuri Songs from Popular Artists and Movies.md

@@ -1,115 +0,0 @@
-<br />
-<h1>A to Z Bhojpuri Video Song Download: How to Enjoy the Best of Bhojpuri Music</h1>
- <p>Bhojpuri music is a vibrant and lively form of folk music that originates from the Bhojpur-Purvanchal region of India and the Terai region of Nepal. It is sung in the Bhojpuri language, which is a dialect of Hindi that has influences from Magahi, Maithili, Awadhi, and other languages. Bhojpuri music is popular among millions of people who love its catchy tunes, witty lyrics, and expressive emotions.</p>
-<h2>a to z bhojpuri video song download</h2><br /><p><b><b>Download File</b> === <a href="https://urlin.us/2uSWmP">https://urlin.us/2uSWmP</a></b></p><br /><br />
- <p>Bhojpuri music has a rich and diverse history that spans centuries and reflects the culture and identity of the Bhojpuri people. It has also evolved over time to incorporate various genres and styles, such as folk, devotional, romantic, patriotic, comedy, and film songs. Bhojpuri music has also produced many talented and famous artists who have entertained audiences with their unique voices and personalities.</p>
- <p>If you are a fan of Bhojpuri music or want to explore this fascinating musical world, you might be wondering how to find and download the best Bhojpuri video songs. Well, you are in luck, because in this article, we will tell you everything you need to know about Bhojpuri video song download. We will also give you some tips on how to enjoy Bhojpuri music to the fullest. So, let's get started!</p>
- <h2>Bhojpuri Language and Culture: The Roots of Bhojpuri Music</h2>
- <p>Bhojpuri is an Indo-European language that belongs to the Eastern Indo-Aryan group of languages. It is closely related to Magahi, Maithili, and other languages spoken in Bihar, Jharkhand, Uttar Pradesh, Madhya Pradesh, and Nepal. According to the 2011 census of India, there are about 51 million speakers of Bhojpuri in India, making it one of the most widely spoken languages in the country. </p>
- <p>Bhojpuri is also spoken by millions of people in other countries, such as Fiji, Guyana, Mauritius, South Africa, Suriname, Trinidad and Tobago, and other parts of the world where people of Bihari origin have migrated.   In some of these countries, such as Fiji and Suriname, Bhojpuri has developed into distinct variants that have been influenced by local languages and cultures. For example, Fiji Hindi is a variant of Awadhi and Bhojpuri that is spoken by the Indo-Fijians as an official language. </p>
- <p>Bhojpuri culture is a rich and diverse one that reflects the history and geography of the region where it originated. It is influenced by various religious traditions, such as Hinduism, Islam, Buddhism, Jainism, Sikhism, and Christianity. It also has elements of folk culture, such as festivals, rituals, dances, costumes, cuisine, art, literature, and cinema. Some of the most famous festivals celebrated by the Bhojpuri people are Chhath Puja, Holi, Dussehra, Diwali , and Bhojpuri New Year.  Some of the most popular dances performed by the Bhojpuri people are Jhumar, Kajri, Sohar, Chaiti, Birha, and Bidesia.  Some of the most distinctive costumes worn by the Bhojpuri people are Dhoti-Kurta, Sari, Lehenga-Choli, Gamchha, and Pagri.  Some of the most delicious dishes prepared by the Bhojpuri people are Litti-Chokha, Sattu, Khichdi, Dal-Puri, Thekua, Malpua, and Balushahi. </p>
- <p>Bhojpuri art and literature are also very rich and diverse, and have produced many renowned artists and writers who have contributed to the cultural heritage of India and the world. Some of the most famous Bhojpuri artists are Thakur Anukulchandra, Bhikhari Thakur, Ram Dayal Munda, Sharda Sinha, Manoj Tiwari, Ravi Kishan, Nirahua, and Khesari Lal Yadav.   Some of the most famous Bhojpuri writers are Mahapandit Rahul Sankrityayan, Acharya Ramlochan Saran, Viveki Rai, Manohar Malgonkar, Phanishwar Nath Renu, and Ajit Rai.  </p>
- <p>Bhojpuri cinema is also a very important and influential part of Bhojpuri culture, and has a huge fan following in India and abroad. Bhojpuri cinema started in 1962 with the first Bhojpuri film Ganga Maiyya Tohe Piyari Chadhaibo (Mother Ganges, I will offer you a yellow sari), directed by Kundan Kumar.  Since then, Bhojpuri cinema has produced many blockbuster films and superstars who have entertained millions of viewers with their action, romance, comedy, drama, and music. Some of the most successful Bhojpuri films are Nadiya Ke Paar (1982), Sasura Bada Paisawala (2004), Nirahua Hindustani (2014), Nirahua Rikshawala 2 (2015), and Border (2018).  </p>
- <h2>Bhojpuri Video Song Genres and Artists: The Diversity and Creativity of Bhojpuri Music</h2>
- <p>Bhojpuri music is one of the most diverse and creative forms of music in India and the world. It has a variety of genres and styles that cater to different tastes and moods of the listeners. Some of the most popular genres of Bhojpuri music are:</p>
-<p>a to z bhojpuri video song download free<br />
-a to z bhojpuri video song download hd<br />
-a to z bhojpuri video song download mp4<br />
-a to z bhojpuri video song download 2023<br />
-a to z bhojpuri video song download new<br />
-a to z bhojpuri video song download khesari lal yadav<br />
-a to z bhojpuri video song download pawan singh<br />
-a to z bhojpuri video song download dj<br />
-a to z bhojpuri video song download saavn<br />
-a to z bhojpuri video song download wynk<br />
-a to z bhojpuri video song download online<br />
-a to z bhojpuri video song download site<br />
-a to z bhojpuri video song download app<br />
-a to z bhojpuri video song download pagalworld<br />
-a to z bhojpuri video song download gaana<br />
-a to z bhojpuri video song download 2022<br />
-a to z bhojpuri video song download full hd<br />
-a to z bhojpuri video song download 1080p<br />
-a to z bhojpuri video song download 3gp<br />
-a to z bhojpuri video song download latest<br />
-a to z bhojpuri video song download old<br />
-a to z bhojpuri video song download rani chatterjee<br />
-a to z bhojpuri video song download akshara singh<br />
-a to z bhojpuri video song download dinesh lal yadav<br />
-a to z bhojpuri video song download pramod premi yadav<br />
-a to z bhojpuri video song download shilpi raj<br />
-a to z bhojpuri video song download antra singh priyanka<br />
-a to z bhojpuri video song download neelkamal singh<br />
-a to z bhojpuri video song download arvind akela kallu<br />
-a to z bhojpuri video song download gunjan singh<br />
-a to z bhojpuri video song download samar singh<br />
-a to z bhojpuri video song download ritesh pandey<br />
-a to z bhojpuri video song download antra singh priyanka and khesari lal yadav<br />
-a to z bhojpuri video song download shilpi raj and pawan singh<br />
-a to z bhojpuri video song download neelkamal singh and shilpi raj<br />
-a to z bhojpuri video song download arvind akela kallu and priyanka singh<br />
-a to z bhojpuri video song download gunjan singh and antra singh priyanka<br />
-a to z bhojpuri video song download samar singh and shilpi raj<br />
-a to z bhojpuri video song download ritesh pandey and antra singh priyanka <br />
-how to do a to z bhojpuri video song download <br />
-best site for a to z bhojpuri video song download <br />
-top 10 a to z bhojpuri video songs 2023 <br />
-latest hit a to z bhojpuri video songs <br />
-new release a to z bhojpuri video songs <br />
-trending now a to z bhojpuri video songs <br />
-most popular a to z bhojpuri video songs <br />
-most viewed a to z bhojpuri video songs <br />
-most liked a to z bhojpuri video songs <br />
-most downloaded a to z bhojpuri video songs </p>
- <ul>
-<li><b>Folk songs:</b> These are traditional songs that reflect the rural life and culture of the Bhojpuri people. They are usually sung in festivals, weddings, rituals, or other occasions. They have simple melodies and lyrics that express joy, sorrow, love, devotion, or humor. Some examples of folk songs are Sohar (songs sung during childbirth), Kajri (songs sung during monsoon), Chaiti (songs sung during spring), Birha (songs of separation), and Holi (songs of colors). Some of the most famous folk singers are Sharda Sinha, Bharat Sharma Vyas, Kalpana Patowary, Guddu Rangila, and Pawan Singh. </li>
-<li><b>Devotional songs:</b> These are songs that express faith and devotion to various gods and goddesses of Hinduism. They are usually sung in temples, shrines, or other places of worship. They have melodious tunes and lyrics that praise the divine attributes and deeds of the deities. Some examples of devotional songs are Bhajan (songs of praise), Aarti (songs of offering), Chhath Geet (songs sung during Chhath Puja), Navratri Geet (songs sung during Navratri), and Ramayan Chaupai (verses from Ramayana). Some of the most famous devotional singers are Anuradha Paudwal , Manoj Tiwari, Dinesh Lal Yadav, Khesari Lal Yadav, and Ritesh Pandey. </li>
-<li><b>Romantic songs:</b> These are songs that express love and romance between couples. They are usually sung in films, albums, or other platforms. They have catchy tunes and lyrics that depict the feelings and emotions of the lovers. Some examples of romantic songs are Piyawa Se Pahile (Before meeting you), Laga Ke Fair Lovely (Applying Fair Lovely), Raja Raja Kareja Mein Samaja (King, please understand me), and Aawa Ae Amarpali Nirahua Rang Dali (Amarpali, Nirahua has colored you). Some of the most famous romantic singers are Udit Narayan, Alka Yagnik, Kumar Sanu, Kavita Krishnamurthy, Sonu Nigam, and Shreya Ghoshal. </li>
-<li><b>Patriotic songs:</b> These are songs that express pride and respect for the nation and its people. They are usually sung in national events, celebrations, or movements. They have inspiring tunes and lyrics that motivate the listeners to serve and protect the country. Some examples of patriotic songs are Bharat Ka Baccha Baccha Jai Shri Ram Bolega (Every child of India will say Jai Shri Ram), Bharat Mata Ki Jai (Hail Mother India), Desh Bhakti Geet (Songs of patriotism), and Tiranga Hamra Desh Ke Shan (The tricolor is the pride of our country). Some of the most famous patriotic singers are Lata Mangeshkar, Mohammed Rafi, Mukesh, Mahendra Kapoor, Kailash Kher, and Arijit Singh. </li>
-<li><b>Comedy songs:</b> These are songs that express humor and fun. They are usually sung in films, shows, or other platforms. They have amusing tunes and lyrics that make the listeners laugh and enjoy. Some examples of comedy songs are Chalakata Hamro Jawaniya (Our youth is smart), Lagavelu Jab Lipistic (When you apply lipstick), Chat Deni Maar Deli (You refused to chat but hit me), and Balam Pichkari (My beloved is a water gun). Some of the most famous comedy singers are Ravi Kishan, Manoj Tiwari, Dinesh Lal Yadav, Khesari Lal Yadav, and Sapna Choudhary. </li>
-<li><b>Film songs:</b> These are songs that are featured in Bhojpuri films. They are usually sung by playback singers who lend their voices to the actors and actresses on screen. They have various tunes and lyrics that suit the theme and mood of the film. Some examples of film songs are Gori Tori Chunari Ba Lal Lal Re (Your red chunari is beautiful), Kamariya Lollipop Lagelu (Your waist is like a lollipop), Saiyan Ji Dagabaaz (My beloved is a cheater), and Chhalakata Hamro Jawaniya 2 (Our youth is smart 2). Some of the most famous film singers are Pawan Singh, Akshara Singh, Priyanka Singh, Indu Sonali, Khushboo Jain, and Mohan Rathore. </li>
-</ul>
- <h2>Bhojpuri Video Song Download Sites: The Best Places to Find and Download Bhojpuri Music</h2>
- <p>If you want to download Bhojpuri video songs for free or for a nominal fee, you have many options to choose from. There are many websites and apps that offer a wide range of Bhojpuri video songs in various genres and formats. You can also stream or watch Bhojpuri video songs online on these platforms. Here are some of the best places to find and download Bhojpuri video songs:</p>
- <table>
-<tr>
-<th>Website/App</th>
-<th>Features</th>
-<th>Pros</th>
-<th>Cons</th>
-</tr>
-<tr>
-<td>Bhojpuri Video Songs HD</td>
-<td>- A website that provides high-quality Bhojpuri video songs in HD format.<br>- It has a large collection of Bhojpuri video songs from various genres and artists.<br>- It allows users to download Bhojpuri video songs for free or for a nominal fee.<br>- It also has a blog section that provides news and updates about Bhojpuri music and cinema.</td>
-<td>- It has a user-friendly interface and easy navigation.<br>- It has a fast downloading speed and no ads.<br>- It has a rating and review system that helps users to find the best Bhojpuri video songs.</td>
-<td>- It requires registration and login to download Bhojpuri video songs.<br>- It has limited search options and filters.<br - It has some broken links and outdated content.</td>
-</tr>
-<tr>
-<td>Bhojpuri Video Songs App</td>
-<td>- An app that provides Bhojpuri video songs in various formats and resolutions.<br>- It has a huge collection of Bhojpuri video songs from various genres and artists.<br>- It allows users to download Bhojpuri video songs for free or for a nominal fee.<br>- It also has a radio feature that plays Bhojpuri songs online.</td>
-<td>- It has a simple and attractive interface and easy navigation.<br>- It has a smooth streaming and downloading speed and no ads.<br>- It has a playlist and favorite feature that helps users to organize and save their Bhojpuri video songs.</td>
-<td>- It requires installation and permission to access the device's storage and media.<br>- It has limited search options and filters.<br>- It has some bugs and errors that affect the performance of the app.</td>
-</tr>
-<tr>
-<td>Bhojpuri Video Songs YouTube</td>
-<td>- A website and app that provides Bhojpuri video songs in various formats and resolutions.<br>- It has a massive collection of Bhojpuri video songs from various genres and artists.<br>- It allows users to stream or watch Bhojpuri video songs online for free or for a premium subscription.<br>- It also has a community feature that allows users to interact with other Bhojpuri music fans and creators.</td>
-<td>- It has a versatile and dynamic interface and easy navigation.<br>- It has a fast streaming and downloading speed and minimal ads.<br>- It has a recommendation and feedback system that helps users to discover new and relevant Bhojpuri video songs.</td>
-<td>- It does not allow users to download Bhojpuri video songs directly from the website or app.<br>- It has many search options and filters, but they are not specific to Bhojpuri music.<br>- It has some content that is inappropriate or infringing the rights of the original creators.</td>
-</tr>
-</table>
- <h2>Conclusion: How to Enjoy Bhojpuri Music to the Fullest</h2>
- <p>Bhojpuri music is a wonderful and unique form of music that deserves more recognition and appreciation. It is not only entertaining, but also informative, inspiring, and empowering. It showcases the culture, identity, and creativity of the Bhojpuri people. It also connects them with their roots, their values, and their aspirations.</p>
- <p>If you want to enjoy Bhojpuri music to the fullest, you should try to explore its different genres and styles, listen to its different artists and singers, watch its different films and shows, and learn about its different aspects and features. You should also try to understand its language and lyrics, appreciate its melody and rhythm, feel its emotion and expression, and share its joy and fun. You should also try to support its growth and development, promote its quality and originality, respect its diversity and authenticity, and celebrate its success and glory.</p>
- <p>Bhojpuri music is a treasure that belongs to everyone who loves music. It is a gift that can enrich your life with happiness, beauty, and wisdom. So, what are you waiting for? Go ahead and download your favorite Bhojpuri video songs today!</p>
- <h2>FAQs: Some Common Questions and Answers about Bhojpuri Music</h2>
- <p>Here are some common questions and answers about Bhojpuri music that you might find helpful:</p>
- <ol>
-<li><b>What is the difference between Bhojpuri music and Bollywood music?</b><br>Bollywood music is the generic term for the popular music of Hindi cinema, which is produced in Mumbai, the entertainment capital of India. Bollywood music is influenced by various musical traditions, such as Indian classical, folk, pop, rock, jazz, hip hop, etc. Bollywood music is sung in Hindi or other languages, such as Urdu, Punjabi, English, etc. Bollywood music is widely popular across India and the world.<br>Bhojpuri music is the specific term for the folk music of the Bhojpur-Purvanchal region of India and the Terai region of Nepal. Bhojpuri music is influenced by the local culture and traditions of the Bhojpuri people. Bhojpuri music is sung in the Bhojpuri language, which is a dialect of Hindi that has influences from other languages. Bhojpuri music is popular among the Bhojpuri speakers and other people who love its folk flavor and charm.</li>
-<li><b>Who are some of the most famous Bhojpuri singers and actors?</b><br>Some of the most famous Bhojpuri singers are Sharda Sinha, Bharat Sharma Vyas, Kalpana Patowary, Manoj Tiwari, Dinesh Lal Yadav, Khesari Lal Yadav, Pawan Singh, Akshara Singh, Priyanka Singh, Ritesh Pandey, Indu Sonali, Khushboo Jain, Mohan Rathore, etc. Some of the most famous Bhojpuri actors are Ravi Kishan, Manoj Tiwari, Dinesh Lal Yadav, Khesari Lal Yadav, Pawan Singh, Akshara Singh, Amrapali Dubey, Monalisa, Anjana Singh, Kajal Raghwani, etc.</li>
-<li><b>How can I learn Bhojpuri language and lyrics?</b><br>If you want to learn Bhojpuri language and lyrics, you can use various online resources and tools that can help you. For example, you can use online dictionaries and translators that can provide you with the meanings and pronunciations of Bhojpuri words and phrases. You can also use online courses and videos that can teach you the basics and nuances of Bhojpuri grammar and vocabulary. You can also use online lyrics sites and apps that can provide you with the lyrics and translations of Bhojpuri songs. You can also listen to Bhojpuri songs and watch Bhojpuri films and shows that can help you improve your listening and speaking skills.</li>
-<li><b>What are some of the benefits of listening to Bhojpuri music?</b><br>Listening to Bhojpuri music can have many benefits for your physical, mental, and emotional well-being. For example, listening to Bhojpuri music can help you relax and reduce stress by releasing endorphins and serotonin in your brain. It can also help you boost your mood and energy by stimulating your brain waves and nervous system. It can also help you improve your memory and concentration by enhancing your cognitive functions and neural connections. It can also help you express your feelings and emotions by resonating with your inner self and others. It can also help you learn about new cultures and perspectives by exposing you to different sounds and meanings.</li>
-<li><b>How can I support Bhojpuri music and cinema?</b><br>If you love Bhojpuri music and cinema, you can support them in various ways. For example, you can download or stream Bhojpuri songs and films from legal and ethical sources that respect the rights of the creators and pay them fairly. You can also share or recommend Bhojpuri songs and films to your friends and family who might enjoy them too. You can also follow or subscribe to Bhojpuri singers and actors on their social media platforms and show them your appreciation and feedback. You can also participate in online or offline events and activities that celebrate or promote Bhojpuri music and cinema.</li>
-</ol>
- <p>I hope this article has helped you learn more about Bhojpuri music and how to enjoy it to the fullest. If you have any questions or comments, please feel free to leave them below. Thank you for reading!</p> 197e85843d<br />
-<br />
-<br />

spaces/1phancelerku/anime-remove-background/Bad 2 Bad Apocalypse - The Ultimate Open World Survival RPG Game APK.md

@@ -1,172 +0,0 @@
-
-<h1>Bad 2 Bad: Apocalypse APK - A Survival RPG Game for Android</h1>
-<p>If you are looking for a challenging and immersive survival RPG game for your Android device, you might want to check out Bad 2 Bad: Apocalypse APK. This is a game that will test your skills, strategy, and creativity as you explore, gather, craft, and fight in a vast open world. In this article, we will tell you everything you need to know about this game, including what it is, how to download and install it, how to play it, and why you should play it.</p>
-<h2>bad 2 bad apocalypse apkcombo</h2><br /><p><b><b>DOWNLOAD</b> &#127383; <a href="https://jinyurl.com/2uNSaL">https://jinyurl.com/2uNSaL</a></b></p><br /><br />
-<h2>What is Bad 2 Bad: Apocalypse APK?</h2>
-<p>Bad 2 Bad: Apocalypse APK is an Android game developed by DAWINSTONE, a Korean studio that specializes in creating action-packed and realistic games. It is the sequel to Bad 2 Bad: Delta and Extinction, two previous games that introduced the world and the characters of the series.</p>
-<h3>The sequel to Bad 2 Bad: Delta and Extinction</h3>
-<p>Bad 2 Bad: Apocalypse APK follows the story of the Delta Team, a group of elite soldiers led by Major Pan, who are trying to save and rebuild the world that has been ravaged by a virus from the Human Forces. The virus has turned most of the humans into zombies, mutants, or cyborgs, and has also infected some of the animals, creating wild and dangerous creatures. The Delta Team has to face these enemies, as well as other factions that are competing for resources and power in the post-apocalyptic world.</p>
-<h3>The story of the Delta Team and their mission</h3>
-<p>The game has a rich and engaging storyline that will keep you hooked as you progress through the game. You will get to know the members of the Delta Team, each with their own personality, background, and skills. You will also encounter various characters that will help or hinder you along the way. You will have to make choices that will affect the outcome of the story and the fate of the world.</p>
-<h3>The features of the game</h3>
-<p>Bad 2 Bad: Apocalypse APK has many features that make it a fun and exciting game to play. Some of these features are:</p>
-<ul>
-<li>A vast open world RPG with over 60 maps and regions to explore</li>
-<li>Exploration, gathering, fishing, and crafting for survival</li>
-<li>More than 300 items and weapons to collect and use</li>
-<li>More detailed character customization and appearance options</li>
-<li>A squad system that allows you to create and upgrade your own special forces team</li>
-<li>Artillery support, air support, drones, and battle armor for combat</li>
-<li>World missions that take place across the globe</li>
-<li>Advanced graphics and sound effects</li>
-</ul>
-<h2>How to download and install Bad 2 Bad: Apocalypse APK?</h2>
-<p>If you want to play this game on your Android device, you will need to download and install the APK file from a reliable source. Here are some things you need to know before doing so:</p>
-<p>bad 2 bad apocalypse apk download<br />
-bad 2 bad apocalypse game<br />
-bad 2 bad apocalypse mod apk<br />
-bad 2 bad apocalypse android<br />
-bad 2 bad apocalypse latest version<br />
-bad 2 bad apocalypse xapk<br />
-bad 2 bad apocalypse apk pure<br />
-bad 2 bad apocalypse offline<br />
-bad 2 bad apocalypse hack<br />
-bad 2 bad apocalypse cheats<br />
-bad 2 bad apocalypse review<br />
-bad 2 bad apocalypse gameplay<br />
-bad 2 bad apocalypse tips<br />
-bad 2 bad apocalypse guide<br />
-bad 2 bad apocalypse wiki<br />
-bad 2 bad apocalypse update<br />
-bad 2 bad apocalypse free download<br />
-bad 2 bad apocalypse unlimited money<br />
-bad 2 bad apocalypse pc<br />
-bad 2 bad apocalypse online<br />
-bad 2 bad apocalypse apk mirror<br />
-bad 2 bad apocalypse apk mod menu<br />
-bad 2 bad apocalypse best weapons<br />
-bad 2 bad apocalypse characters<br />
-bad 2 bad apocalypse delta team<br />
-bad 2 bad apocalypse apk obb<br />
-bad 2 bad apocalypse rexdl<br />
-bad 2 bad apocalypse apkpure.com<br />
-bad 2 bad apocalypse apkcombo.com<br />
-bad 2 bad apocalypse dawinstone<br />
-how to play bad 2 bad apocalypse<br />
-how to install xapk of b2b:apocalypse <br />
-how to get more resources in b2b:apocalypse <br />
-how to upgrade base camp in b2b:apocalypse <br />
-how to unlock battle armor in b2b:apocalypse <br />
-how to craft equipment in b2b:apocalypse <br />
-how to fish in b2b:apocalypse <br />
-how to explore the world in b2b:apocalypse <br />
-how to survive the virus in b2b:apocalypse <br />
-how to complete world missions in b2b:apocalypse <br />
-how to customize your character in b2b:apocalypse <br />
-how to use artillery support in b2b:apocalypse <br />
-how to use air support in b2b:apocalypse <br />
-how to use drones in b2b:apocalypse <br />
-what is the story of b2b:apocalypse <br />
-what are the features of b2b:apocalypse <br />
-what are the differences between b2b:delta and b2b:apocalypse</p>
-<h3>The requirements for the game</h3>
-<p>The game requires Android 7.0 or higher and at least 188 MB of free storage space on your device. It also requires an internet connection for some features, such as world missions and updates. The game is rated for ages 12+ due <h3>The steps to download and install the APK file</h3>
-<p>To download and install the APK file of Bad 2 Bad: Apocalypse, you can follow these simple steps:</p>
-<ol>
-<li>Go to a trusted website that offers the APK file, such as [APKCombo].</li>
-<li>Search for the game by typing "Bad 2 Bad: Apocalypse" in the search bar.</li>
-<li>Click on the download button and choose the version you want to download.</li>
-<li>Wait for the download to finish and locate the APK file on your device.</li>
-<li>Tap on the APK file and allow the installation from unknown sources if prompted.</li>
-<li>Follow the instructions on the screen and wait for the installation to complete.</li>
-<li>Launch the game and enjoy!</li>
-</ol>
-<h3>The precautions to take before installing the game</h3>
-<p>Before you install the game, you should take some precautions to ensure a safe and smooth experience. Here are some tips:</p>
-<ul>
-<li>Make sure your device meets the requirements for the game and has enough storage space.</li>
-<li>Download the APK file from a reputable source and scan it for viruses or malware.</li>
-<li>Backup your data and settings in case something goes wrong during the installation.</li>
-<li>Close any other apps or programs that are running in the background to avoid interference or conflicts.</li>
-<li>Read the permissions and terms of service of the game carefully and agree only if you are comfortable with them.</li>
-</ul>
-<h2>How to play Bad 2 Bad: Apocalypse APK?</h2>
-<p>Once you have installed the game, you can start playing it by following these basic steps:</p>
-<h3>The basic gameplay and controls</h3>
-<p>The game is a survival RPG that combines exploration, combat, and crafting. You can control your character using the virtual joystick on the left side of the screen and use the buttons on the right side to perform actions such as shooting, reloading, switching weapons, using items, calling support, etc. You can also swipe on the screen to move the camera and zoom in or out. You can access the menu by tapping on the icon on the top left corner of the screen, where you can see your inventory, map, missions, settings, etc.</p>
-<h3>The tips and tricks for survival and combat</h3>
-<p>The game is not easy and you will face many challenges and dangers in your journey. Here are some tips and tricks that will help you survive and win:</p>
-<ul>
-<li>Explore as much as you can and collect resources, items, and weapons that will help you craft useful things and improve your equipment.</li>
-<li>Fish for food and water to replenish your health and stamina. You can also cook your fish for better effects.</li>
-<li>Avoid unnecessary fights and use stealth or diplomacy when possible. You can also use traps, mines, grenades, or snipers to deal with enemies from a distance.</li>
-<li>Use cover, dodge, and roll to avoid enemy attacks and bullets. You can also use shields, armor, or medkits to protect yourself.</li>
-<li>Use your squad members wisely and assign them roles according to their skills. You can also upgrade them with better gear and skills.</li>
-<li>Use your support options such as artillery, air support, drones, or battle armor when you are in trouble or need extra firepower.</li>
-</ul> <h3>The customization and upgrade options</h3>
-<p>The game allows you to customize and upgrade your character and your squad in various ways. You can change your appearance, clothes, accessories, and weapons. You can also improve your skills, stats, and abilities by leveling up and using skill points. You can also craft and enhance your items and weapons using the materials you find or buy. You can also unlock new features and modes as you progress through the game.</p>
-<h2>Why should you play Bad 2 Bad: Apocalypse APK?</h2>
-<p>Bad 2 Bad: Apocalypse APK is a game that will appeal to fans of survival RPG games, action games, and post-apocalyptic stories. Here are some reasons why you should play this game:</p>
-<h3>The pros and cons of the game</h3>
-<p>The game has many pros and cons that you should consider before playing it. Here are some of them:</p>
-<table>
-<tr>
-<th>Pros</th>
-<th>Cons</th>
-</tr>
-<tr>
-<td>A captivating and immersive storyline with multiple endings</td>
-<td>A complex and challenging gameplay that requires patience and strategy</td>
-</tr>
-<tr>
-<td>A vast and diverse open world with many locations and secrets to discover</td>
-<td>A high requirement for device performance and storage space</td>
-</tr>
-<tr>
-<td>A realistic and detailed graphics and sound effects that create a great atmosphere</td>
-<td>A need for internet connection for some features and updates</td>
-</tr>
-<tr>
-<td>A variety of items, weapons, skills, and customization options to suit your preferences</td>
-<td>A possibility of bugs, glitches, or crashes that may affect your experience</td>
-</tr>
-<tr>
-<td>A fun and exciting squad system that lets you create and manage your own team</td>
-<td>A lack of multiplayer or co-op mode that limits your interaction with other players</td>
-</tr>
-</table>
- <h3>The ratings and reviews of the game</h3>
-<p>The game has received mostly positive ratings and reviews from players who have tried it. It has a 4.5 out of 5 stars rating on [APKCombo], based on over 1,000 reviews. Here are some of the comments from the users:</p>
- <ul>
-<li>"This game is awesome! The graphics are amazing, the story is interesting, the gameplay is challenging, and the customization is cool. I love the squad system and the support options. It's like playing a console game on my phone."</li>
- <li>"This game is very good, but it needs some improvements. The game is too hard sometimes, especially when you face many enemies at once. The game also takes too much space on my device and drains my battery fast. The game also crashes sometimes when I play for too long."</li>
- <li>"This game is one of the best survival RPG games I have ever played. The game has a lot of content and features that keep me entertained for hours. The game also has a great story with different endings that make me want to replay it. The game is worth every penny."</li>
- <li>"This game is not bad, but it's not great either. The game has a decent graphics and sound effects, but they are not very impressive. The game also has a boring and repetitive gameplay that makes me lose interest quickly. The game also has a lot of ads and in-app purchases that annoy me."</li>
- <li>"This game is a masterpiece! The game has everything I want in a survival RPG game: a rich and immersive story, a vast and diverse world, a realistic and detailed graphics, a variety of items, weapons, skills, customization options, squad system, support options, world missions, etc. The game is perfect!"</li>
- </ul>
- <h3>The alternatives to the game</h3>
- <p>If you are looking for other games that are similar to Bad 2 Bad: Apocalypse APK, you can try these alternatives:</p>
- <ul>
- <li>[Last Day on Earth: Survival] - A zombie survival RPG game that lets you build your base, craft your weapons, join clans, raid other players' bases, etc.</li>
- <li>[Fallout Shelter] - A post-apocalyptic simulation game that lets you manage your own vault, recruit dwellers, explore the wasteland, fight enemies, etc.</li>
- <li>[Day R Survival] - A survival RPG game that lets you travel across a nuclear war-torn Soviet Union, scavenge for resources, fight mutants, join factions, etc.</li>
- <li>[Dead Trigger 2] - A zombie shooter game that lets you join the global resistance, complete missions, use various weapons, kill hordes of zombies, etc.</li>
- <li>[The Walking Dead: Road to Survival] - A strategy RPG game based on the popular comic series that lets you build your team, fight walkers, make choices that affect the story, etc.</li>
- </ul <h2>Conclusion</h2>
-<p>Bad 2 Bad: Apocalypse APK is a survival RPG game that will challenge and entertain you with its story, gameplay, graphics, and features. It is a game that you can download and install on your Android device and play for hours. It is a game that will make you feel like you are part of the Delta Team and their mission to save the world. It is a game that you should try if you are a fan of survival RPG games, action games, and post-apocalyptic stories.</p>
-<h2>FAQs</h2>
-<p>Here are some of the frequently asked questions about Bad 2 Bad: Apocalypse APK:</p>
-<ol>
-<li>Is Bad 2 Bad: Apocalypse APK free to play?</li>
-<p>Yes, the game is free to download and play, but it contains ads and in-app purchases that you can choose to buy or not.</p>
-<li>Is Bad 2 Bad: Apocalypse APK safe to download and install?</li>
-<p>Yes, the game is safe to download and install, as long as you get it from a trusted source and scan it for viruses or malware. You should also take some precautions before installing the game, such as backing up your data and closing other apps.</p>
-<li>Is Bad 2 Bad: Apocalypse APK compatible with my device?</li>
-<p>The game is compatible with Android devices that have Android 7.0 or higher and at least 188 MB of free storage space. You should also check the performance and battery of your device before playing the game, as it may consume a lot of resources.</p>
-<li>How can I update Bad 2 Bad: Apocalypse APK?</li>
-<p>You can update the game by downloading and installing the latest version of the APK file from the same source you got it from. You should also check for updates regularly to get new features and bug fixes.</p>
-<li>How can I contact the developer of Bad 2 Bad: Apocalypse APK?</li>
-<p>You can contact the developer of the game by sending an email to [[email protected]] or visiting their website at [http://dawinstone.com]. You can also follow them on Facebook, Twitter, Instagram, or YouTube for more information and news about the game.</p>
-</ol></p> 197e85843d<br />
-<br />
-<br />

spaces/1phancelerku/anime-remove-background/Download Real Football Soccer 2023 APK and Become a Soccer Champion.md

@@ -1,109 +0,0 @@
-<br />
-<h1>Real Football 2023 APK Download: Everything You Need to Know</h1>
-<p>If you're a fan of soccer games, you might want to check out <strong>Real Football 2023</strong>, a free-to-play mobile game that offers a realistic and immersive soccer experience. With stunning graphics, realistic physics, and various game modes, Real Football 2023 lets you enjoy the thrill of the beautiful game like never before. In this article, we will tell you everything you need to know about Real Football 2023 apk download, including its features, system requirements, tips and tricks, and reviews.</p>
- <h2>Features</h2>
-<p>Real Football 2023 has a lot of features that make it stand out from other soccer games. Here are some of them:</p>
-<h2>real football 2023 apk download</h2><br /><p><b><b>Download Zip</b> > <a href="https://jinyurl.com/2uNMsE">https://jinyurl.com/2uNMsE</a></b></p><br /><br />
-<ul>
-<li><strong>Career mode</strong>: In this mode, you can create your own dream team and lead them to glory in the most prestigious soccer tournaments around the world. You can train your players, sign new ones, negotiate contracts, develop youth talent, and build a winning squad.</li>
-<li><strong>Authentic teams</strong>: You can choose from a wide selection of international clubs from top leagues such as La Liga, Premier League, Bundesliga, Serie A, Ligue 1, and more. You can also play with national teams from all over the world.</li>
-<li><strong>PvP matches</strong>: You can challenge other players online in thrilling PvP matches and prove your skills and tactics. You can also join leagues and compete with other teams for rankings and rewards.</li>
-<li><strong>Realistic graphics and gameplay</strong>: Real Football 2023 boasts realistic graphics and animations that make you feel like you're watching a real match. The game also features realistic physics and ball movement that make the gameplay more dynamic and challenging.</li>
-<li><strong>Intuitive controls and skills</strong>: The game has intuitive controls that let you perform various actions such as passing, shooting, dribbling, tackling, crossing, etc. You can also use skills and techniques to outsmart your opponents and score amazing goals.</li>
-</ul>
- <h2>System requirements</h2>
-<p>To play Real Football 2023 on your PC or Android device, you need to meet the following system requirements:</p>
-<table>
-<tr>
-<th>Platform</th>
-<th>Minimum</th>
-<th>Recommended</th>
-</tr>
-<tr>
-<td>PC (Windows)</td>
-<td><ul><li>OS: Windows 10 - 64 bit</li><li>CPU: Intel Core i5-2300 / AMD FX-4350</li><li>RAM: 8 GB</li><li>GPU: GeForce GTX 660 Ti / Radeon HD 7790</li><li>Storage: 50 GB</li></ul></td>
-<td><ul><li>OS: Windows 10 - 64 bit</li><li>CPU: Intel Core i5-7600 / AMD Ryzen 5 1600</li><li>RAM: 8 GB</li><li>GPU: GeForce GTX 1060 / AMD Radeon RX 590</li><li>Storage: 50 GB</li></ul></td>
-</tr>
-<tr>
-<td>Android</td>
-<td><ul><li>OS: Android 4.4 or higher</li><li>CPU: Quad-core or higher</li><li>RAM: 2 GB or higher</li><li>Storage: 1 GB or higher</li></ul></td>
-<td>N/A</td>
-</tr>
-</table>
- <h2>Tips and tricks</h2>
-<p>If you want to improve your performance in Real Football 2023, here are some tips and tricks that might help you:</p>
-<ul>
-<li><strong> </strong>Practice your skills</strong>: The game has a training mode where you can practice your skills and techniques. You can also customize your training sessions to focus on specific aspects of the game, such as shooting, passing, dribbling, etc.</li>
-<li><strong>Use the right formation and strategy</strong>: Depending on your play style and the opponent's team, you might want to use different formations and strategies. You can change your formation and tactics before and during the match. You can also assign different roles and instructions to your players, such as captain, free kick taker, target man, etc.</li>
-<li><strong>Manage your stamina and morale</strong>: Your players have stamina and morale bars that affect their performance on the pitch. Stamina decreases as the player runs, sprints, or performs actions. Morale increases or decreases depending on the player's performance, team's performance, and match events. You can use substitutions, timeouts, and pep talks to restore your players' stamina and morale.</li>
-<li><strong>Use the power-ups</strong>: The game has various power-ups that you can use to gain an advantage over your opponent. Some of the power-ups are: speed boost, accuracy boost, shield, freeze, magnet, etc. You can activate them by tapping on the screen or using the buttons on the bottom right corner.</li>
-<li><strong>Collect and upgrade cards</strong>: The game has a card system that lets you collect and upgrade different types of cards. There are player cards, coach cards, stadium cards, and sponsor cards. Each card has a rarity level and a set of attributes that affect your team's performance. You can upgrade your cards by using coins or gems.</li>
-</ul>
- <h2>Reviews</h2>
-<p>Real Football 2023 has received mostly positive reviews from critics and players alike. Here are some of the reviews from different sources:</p>
-<ul>
-<li><em>"Real Football 2023 is a great soccer game that offers a lot of fun and challenge for soccer fans. The graphics are amazing, the gameplay is smooth and realistic, and the game modes are varied and engaging. The game is also free to play, which is a big plus." - Android Authority</em></li>
-<li><em>"If you're looking for a soccer game that delivers a realistic and immersive experience, Real Football 2023 is the game for you. The game has everything you need to enjoy the beautiful game: authentic teams, realistic physics, intuitive controls, and various game modes. The game is also updated regularly with new content and features." - PC Gamer</em></li>
-<li><em>"Real Football 2023 is one of the best soccer games I've ever played. The game is very addictive and fun to play. The graphics are stunning, the gameplay is challenging and rewarding, and the game modes are diverse and exciting. The game is also very user-friendly and easy to play." - Google Play user</em></li>
-</ul>
- <h2>Conclusion</h2>
-<p>Real Football 2023 is a game that every soccer fan should try. The game offers a realistic and immersive soccer experience that will keep you hooked for hours. Whether you want to create your own dream team, challenge other players online, or just enjoy a casual match, Real Football 2023 has something for everyone. You can download Real Football 2023 apk for free from the official website or from Google Play Store.</p>
-<p>real football: soccer 2023 apk free download<br />
-download real football 2023 android game apk<br />
-real football 2023 apk latest version download<br />
-real football 2023 apk mod unlimited money download<br />
-how to download real football 2023 apk for pc<br />
-real football 2023 apk offline download<br />
-real football 2023 apk full game download<br />
-real football 2023 apk + data download<br />
-real football 2023 apk hack download<br />
-real football 2023 apk obb download<br />
-real football 2023 apk update download<br />
-real football 2023 apk online download<br />
-real football 2023 apk cracked download<br />
-real football 2023 apk premium download<br />
-real football 2023 apk pro download<br />
-real football 2023 apk file download<br />
-real football 2023 apk mirror download<br />
-real football 2023 apk direct download<br />
-real football 2023 apk play store download<br />
-real football 2023 apk old version download<br />
-real football 2023 apk new version download<br />
-real football 2023 apk beta download<br />
-real football 2023 apk original download<br />
-real football 2023 apk review download<br />
-real football 2023 apk cheat download<br />
-real football 2023 apk patch download<br />
-real football 2023 apk install download<br />
-real football 2023 apk android tv download<br />
-real football 2023 apk android tablet download<br />
-real football 2023 apk android phone download<br />
-real football 2023 apk android emulator download<br />
-real football 2023 apk android studio download<br />
-real football 2023 apk android app download<br />
-real football 2023 apk android gamepad download<br />
-real football 2023 apk android device download<br />
-real football 2023 apk android sdk download<br />
-real football 2023 apk android oreo download<br />
-real football 2023 apk android pie download<br />
-real football 2023 apk android q download<br />
-real football 2023 apk android r download<br />
-real football 2023 apk android s download<br />
-real football 2023 apk gameloft se download<br />
-real football: soccer game by magic app - free - mobile game for android - latest version:0.5 - updated:23 - com.mt.football.sports.action.soccer.games - free - mobile game for android - latest version:0.5 - updated:23 - com.mt.football.sports.action.soccer.games - free - mobile game for android - latest version:0.5 - updated:23 - com.mt.football.sports.action.soccer.games - free - mobile game for android - latest version:0.5 - updated:23 - com.mt.football.sports.action.soccer.games - free - mobile game for android - latest version:0.5 - updated:23 - com.mt.football.sports.action.soccer.games - free - mobile game for android - latest version:0.5 - updated:23 - com.mt.football.sports.action.soccer.games</p>
- <h2>FAQs</h2>
-<p>Here are some of the frequently asked questions about Real Football 2023:</p>
-<ul>
-<li><strong>Q: How do I download Real Football 2023 apk?</strong></li>
-<li>A: You can download Real Football 2023 apk from the official website or from Google Play Store. Just follow the instructions on the screen and install the game on your device.</li>
-<li><strong>Q: Is Real Football 2023 offline or online?</strong></li>
-<li>A: Real Football 2023 can be played both offline and online. You can play offline in career mode or training mode. You can play online in PvP matches or leagues.</li>
-<li><strong>Q: How do I get coins and gems in Real Football 2023?</strong></li>
-<li>A: You can get coins and gems in Real Football 2023 by playing matches, completing achievements, watching ads, or buying them with real money.</li>
-<li><strong>Q: How do I unlock new teams and players in Real Football 2023?</strong></li>
-<li>A: You can unlock new teams and players in Real Football 2023 by collecting and upgrading cards. You can get cards by opening packs, winning matches, or buying them with coins or gems.</li>
-<li><strong>Q: How do I contact the support team of Real Football 2023?</strong></li <li>A: You can contact the support team of Real Football 2023 by sending an email to [email protected] or by visiting the official website and filling out the contact form.</li>
-</ul>
-<p>I hope you enjoyed this article and learned something new about Real Football 2023 apk download. If you have any questions or feedback, feel free to leave a comment below. Thank you for reading and have fun playing Real Football 2023!</p> 197e85843d<br />
-<br />
-<br />

spaces/1phancelerku/anime-remove-background/Enjoy Football Strike with MOD APK and Unlimited Money on Android 1.md

@@ -1,83 +0,0 @@
-
-<h1>Football Strike Mod APK Android 1: A Fun and Exciting Soccer Game</h1>
- <h2>Introduction</h2>
- <p>If you are a fan of soccer games, you might have heard of Football Strike, a popular free-kick game developed by Miniclip. In this game, you can challenge your friends or other players from around the world in various modes, such as free kick, shooting race, or career. You can also customize your striker and goalkeeper with different outfits, balls, gloves, and shoes.</p>
- <p>However, if you want to enjoy the game to the fullest, you might need to spend some real money to unlock all the items and features. That's why many players are looking for a modded version of Football Strike that can give them unlimited money and other benefits. In this article, we will introduce you to Football Strike Mod APK Android 1, a modified version of the game that can provide you with unlimited fun and excitement.</p>
-<h2>football strike mod apk android 1</h2><br /><p><b><b>Download</b> &#9881; <a href="https://jinyurl.com/2uNTLM">https://jinyurl.com/2uNTLM</a></b></p><br /><br />
- <h2>Why download Football Strike Mod APK Android 1?</h2>
- <p>Football Strike Mod APK Android 1 is a hacked version of the original game that can give you access to all the premium features without spending a dime. By downloading this modded version, you can enjoy the following benefits:</p>
- <h2>Features of Football Strike Mod APK Android 1</h2>
- <h3>Unlimited money</h3>
- <p>With Football Strike Mod APK Android 1, you can get unlimited money in your account. You can use this money to buy any item or upgrade you want in the game. You can also unlock all the stadiums, leagues, and tournaments without any hassle.</p>
- <h3>Multiplayer mode</h3>
- <p>Football Strike Mod APK Android 1 allows you to play online with your friends or other players from around the world. You can choose from different modes, such as free kick, shooting race, or career. You can also chat with your opponents and send them emojis and stickers.</p>
- <h3>Career mode</h3>
- <p>If you want to test your skills and become a soccer legend, you can try the career mode in Football Strike Mod APK Android 1. In this mode, you can play against different teams and players in various challenges and tournaments. You can also earn trophies and rewards as you progress.</p>
- <h3>Customization options</h3>
- <p>Football Strike Mod APK Android 1 gives you the freedom to customize your striker and goalkeeper with tons of items. You can choose from different outfits, balls, gloves, shoes, hairstyles, tattoos, and more. You can also show off your style or represent your team's colors.</p>
- <h3>Realistic graphics and sound effects</h3>
- <p>Football Strike Mod APK Android 1 has stunning graphics and sound effects that make the game more realistic and immersive. You can enjoy the smooth animations and physics of the game, as well as the cheering crowds and commentary. You can also adjust the graphics settings according to your device's performance.</p>
- <h2>How to download and install Football Strike Mod APK Android 1</h2>
- <p>If you are interested in downloading and installing Football Strike Mod APK Android 1 on your Android device, you can follow these simple steps:</p>
-<p>football strike hack apk download for android<br />
-football strike unlimited money mod apk latest version<br />
-football strike multiplayer soccer mod apk free<br />
-football strike miniclip mod apk android 1<br />
-football strike modded apk online game<br />
-football strike cheats apk no root<br />
-football strike premium mod apk unlocked<br />
-football strike mod apk unlimited cash and coins<br />
-football strike hack mod apk 2023<br />
-football strike vip mod apk download<br />
-football strike pro mod apk revdl<br />
-football strike mod apk offline mode<br />
-football strike mod apk android republic<br />
-football strike mega mod apk unlimited everything<br />
-football strike mod apk new update<br />
-football strike hack tool apk without verification<br />
-football strike cracked mod apk full version<br />
-football strike mod apk all balls unlocked<br />
-football strike hack generator apk no survey<br />
-football strike mod menu apk god mode<br />
-football strike extreme mod apk unlimited gems<br />
-football strike super mod apk anti ban<br />
-football strike mod apk obb data file<br />
-football strike hack version apk original<br />
-football strike beta mod apk latest<br />
-football strike real mod apk no ads<br />
-football strike ultimate mod apk high damage<br />
-football strike hack online apk easy<br />
-football strike mod apk rexdl.com<br />
-football strike private server mod apk working<br />
-football strike hack appvn apk safe<br />
-football strike best mod apk 1.43.2<br />
-football strike old version mod apk 1.0.0<br />
-football strike lite mod apk low mb<br />
-football strike gold mod apk unlimited keys<br />
-football strike fun mod apk with friends<br />
-football strike lucky patcher mod apk 2023/06/16<br />
-football strike xmodgames mod apk ios<br />
-football strike master mod apk android oyun club<br />
-football strike royal mod apk android 1.com</p>
- <h3>Step 1: Enable unknown sources</h3>
- <p>Before you can install any APK file on your device, you need to enable unknown sources in your security settings. To do this, go to Settings > Security > Unknown Sources and toggle it on.</p>
- <h3>Step 2: Download the APK file</h3>
- <p>Next, you need to download the APK file of Football Strike Mod APK Android 1 from a reliable source. <h3>Step 3: Install the APK file</h3>
- <p>After downloading the APK file, you need to locate it in your file manager and tap on it to start the installation process. You might see a pop-up asking for your permission to install the app. Just tap on Install and wait for a few seconds.</p>
- <h3>Step 4: Launch the game and enjoy</h3>
- <p>Once the installation is complete, you can launch the game from your app drawer or home screen. You can now enjoy Football Strike Mod APK Android 1 with unlimited money and other features.</p>
- <h2>Conclusion</h2>
- <p>Football Strike Mod APK Android 1 is a great soccer game that can provide you with hours of fun and excitement. You can play online with your friends or other players, customize your striker and goalkeeper, and enjoy realistic graphics and sound effects. You can also get unlimited money and access to all the items and features in the game without spending any real money. If you are looking for a modded version of Football Strike, you should definitely try Football Strike Mod APK Android 1.</p>
- <h2>FAQs</h2>
- <h4>Is Football Strike Mod APK Android 1 safe to download and install?</h4>
- <p>Yes, Football Strike Mod APK Android 1 is safe to download and install on your Android device. It does not contain any viruses or malware that can harm your device or data. However, you should always download it from a trusted source and enable unknown sources in your security settings before installing it.</p>
- <h4>Does Football Strike Mod APK Android 1 require root access?</h4>
- <p>No, Football Strike Mod APK Android 1 does not require root access to work on your device. You can install and play it without rooting your device or modifying any system files.</p>
- <h4>Can I play Football Strike Mod APK Android 1 offline?</h4>
- <p>No, Football Strike Mod APK Android 1 requires an internet connection to work properly. You need to connect to the internet to play online with other players, access the career mode, and update the game.</p>
- <h4>Can I update Football Strike Mod APK Android 1 to the latest version?</h4>
- <p>Yes, you can update Football Strike Mod APK Android 1 to the latest version whenever there is a new update available. However, you might need to uninstall the previous version and download the new version from the same source. You might also lose your progress and data if you update the game.</p>
- <h4>Can I use my existing account to play Football Strike Mod APK Android 1?</h4>
- <p>No, you cannot use your existing account to play Football Strike Mod APK Android 1. You need to create a new account or use a guest account to play the modded version of the game. If you use your existing account, you might get banned or suspended by the game developers.</p> 401be4b1e0<br />
-<br />
-<br />

spaces/2023Liu2023/bingo/src/lib/hooks/use-bing.ts

@@ -1,173 +0,0 @@
-'use client'
-
-import { useState, useCallback, useEffect, useMemo } from 'react'
-import { useAtom, useAtomValue } from 'jotai'
-import { chatFamily, bingConversationStyleAtom, GreetMessages, hashAtom, voiceAtom } from '@/state'
-import { setConversationMessages } from './chat-history'
-import { ChatMessageModel, BotId, FileItem } from '@/lib/bots/bing/types'
-import { nanoid } from '../utils'
-import { TTS } from '../bots/bing/tts'
-
-export function useBing(botId: BotId = 'bing') {
-  const chatAtom = useMemo(() => chatFamily({ botId, page: 'singleton' }), [botId])
-  const [enableTTS] = useAtom(voiceAtom)
-  const speaker = useMemo(() => new TTS(), [])
-  const [hash, setHash] = useAtom(hashAtom)
-  const bingConversationStyle = useAtomValue(bingConversationStyleAtom)
-  const [chatState, setChatState] = useAtom(chatAtom)
-  const [input, setInput] = useState('')
-  const [attachmentList, setAttachmentList] = useState<FileItem[]>([])
-
-  const updateMessage = useCallback(
-    (messageId: string, updater: (message: ChatMessageModel) => void) => {
-      setChatState((draft) => {
-        const message = draft.messages.find((m) => m.id === messageId)
-        if (message) {
-          updater(message)
-        }
-      })
-    },
-    [setChatState],
-  )
-
-  const sendMessage = useCallback(
-    async (input: string, options = {}) => {
-      const botMessageId = nanoid()
-      const imageUrl = attachmentList?.[0]?.status === 'loaded' ? attachmentList[0].url : undefined
-      setChatState((draft) => {
-        const text = imageUrl ? `${input}\n\n![image](${imageUrl})` : input
-        draft.messages.push({ id: nanoid(), text, author: 'user' }, { id: botMessageId, text: '', author: 'bot' })
-        setAttachmentList([])
-      })
-      const abortController = new AbortController()
-      setChatState((draft) => {
-        draft.generatingMessageId = botMessageId
-        draft.abortController = abortController
-      })
-      speaker.reset()
-      await chatState.bot.sendMessage({
-        prompt: input,
-        imageUrl: /\?bcid=([^&]+)/.test(imageUrl ?? '') ? `https://www.bing.com/images/blob?bcid=${RegExp.$1}` : imageUrl,
-        options: {
-          ...options,
-          bingConversationStyle,
-        },
-        signal: abortController.signal,
-        onEvent(event) {
-          if (event.type === 'UPDATE_ANSWER') {
-            updateMessage(botMessageId, (message) => {
-              if (event.data.text.length > message.text.length) {
-                message.text = event.data.text
-              }
-
-              if (event.data.spokenText && enableTTS) {
-                speaker.speak(event.data.spokenText)
-              }
-
-              message.throttling = event.data.throttling || message.throttling
-              message.sourceAttributions = event.data.sourceAttributions || message.sourceAttributions
-              message.suggestedResponses = event.data.suggestedResponses || message.suggestedResponses
-            })
-          } else if (event.type === 'ERROR') {
-            updateMessage(botMessageId, (message) => {
-              message.error = event.error
-            })
-            setChatState((draft) => {
-              draft.abortController = undefined
-              draft.generatingMessageId = ''
-            })
-          } else if (event.type === 'DONE') {
-            setChatState((draft) => {
-              draft.abortController = undefined
-              draft.generatingMessageId = ''
-            })
-          }
-        },
-      })
-    },
-    [botId, attachmentList, chatState.bot, setChatState, updateMessage],
-  )
-
-  const uploadImage = useCallback(async (imgUrl: string) => {
-    setAttachmentList([{ url: imgUrl, status: 'loading' }])
-    const response = await chatState.bot.uploadImage(imgUrl, bingConversationStyle)
-    if (response?.blobId) {
-      setAttachmentList([{ url: `/api/blob?bcid=${response.blobId}`, status: 'loaded' }])
-    } else {
-      setAttachmentList([{ url: imgUrl, status: 'error' }])
-    }
-  }, [chatState.bot])
-
-  const resetConversation = useCallback(() => {
-    chatState.bot.resetConversation()
-    speaker.abort()
-    setChatState((draft) => {
-      draft.abortController = undefined
-      draft.generatingMessageId = ''
-      draft.messages = [{ author: 'bot', text: GreetMessages[Math.floor(GreetMessages.length * Math.random())], id: nanoid() }]
-      draft.conversationId = nanoid()
-    })
-  }, [chatState.bot, setChatState])
-
-  const stopGenerating = useCallback(() => {
-    chatState.abortController?.abort()
-    if (chatState.generatingMessageId) {
-      updateMessage(chatState.generatingMessageId, (message) => {
-        if (!message.text && !message.error) {
-          message.text = 'Cancelled'
-        }
-      })
-    }
-    setChatState((draft) => {
-      draft.generatingMessageId = ''
-    })
-  }, [chatState.abortController, chatState.generatingMessageId, setChatState, updateMessage])
-
-  useEffect(() => {
-    if (chatState.messages.length) {
-      setConversationMessages(botId, chatState.conversationId, chatState.messages)
-    }
-  }, [botId, chatState.conversationId, chatState.messages])
-
-  useEffect(() => {
-    if (hash === 'reset') {
-      resetConversation()
-      setHash('')
-    }
-  }, [hash, setHash])
-
-  const chat = useMemo(
-    () => ({
-      botId,
-      bot: chatState.bot,
-      isSpeaking: speaker.isSpeaking,
-      messages: chatState.messages,
-      sendMessage,
-      setInput,
-      input,
-      resetConversation,
-      generating: !!chatState.generatingMessageId,
-      stopGenerating,
-      uploadImage,
-      setAttachmentList,
-      attachmentList,
-    }),
-    [
-      botId,
-      bingConversationStyle,
-      chatState.bot,
-      chatState.generatingMessageId,
-      chatState.messages,
-      speaker.isSpeaking,
-      setInput,
-      input,
-      setAttachmentList,
-      attachmentList,
-      resetConversation,
-      sendMessage,
-      stopGenerating,
-    ],
-  )
-
-  return chat
-}

spaces/4Taps/SadTalker/src/face3d/models/arcface_torch/configs/base.py

@@ -1,56 +0,0 @@
-from easydict import EasyDict as edict
-
-# make training faster
-# our RAM is 256G
-# mount -t tmpfs -o size=140G  tmpfs /train_tmp
-
-config = edict()
-config.loss = "arcface"
-config.network = "r50"
-config.resume = False
-config.output = "ms1mv3_arcface_r50"
-
-config.dataset = "ms1m-retinaface-t1"
-config.embedding_size = 512
-config.sample_rate = 1
-config.fp16 = False
-config.momentum = 0.9
-config.weight_decay = 5e-4
-config.batch_size = 128
-config.lr = 0.1  # batch size is 512
-
-if config.dataset == "emore":
-    config.rec = "/train_tmp/faces_emore"
-    config.num_classes = 85742
-    config.num_image = 5822653
-    config.num_epoch = 16
-    config.warmup_epoch = -1
-    config.decay_epoch = [8, 14, ]
-    config.val_targets = ["lfw", ]
-
-elif config.dataset == "ms1m-retinaface-t1":
-    config.rec = "/train_tmp/ms1m-retinaface-t1"
-    config.num_classes = 93431
-    config.num_image = 5179510
-    config.num_epoch = 25
-    config.warmup_epoch = -1
-    config.decay_epoch = [11, 17, 22]
-    config.val_targets = ["lfw", "cfp_fp", "agedb_30"]
-
-elif config.dataset == "glint360k":
-    config.rec = "/train_tmp/glint360k"
-    config.num_classes = 360232
-    config.num_image = 17091657
-    config.num_epoch = 20
-    config.warmup_epoch = -1
-    config.decay_epoch = [8, 12, 15, 18]
-    config.val_targets = ["lfw", "cfp_fp", "agedb_30"]
-
-elif config.dataset == "webface":
-    config.rec = "/train_tmp/faces_webface_112x112"
-    config.num_classes = 10572
-    config.num_image = "forget"
-    config.num_epoch = 34
-    config.warmup_epoch = -1
-    config.decay_epoch = [20, 28, 32]
-    config.val_targets = ["lfw", "cfp_fp", "agedb_30"]

spaces/7hao/bingo/src/components/ui/input.tsx

@@ -1,25 +0,0 @@
-import * as React from 'react'
-
-import { cn } from '@/lib/utils'
-
-export interface InputProps
-  extends React.InputHTMLAttributes<HTMLInputElement> {}
-
-const Input = React.forwardRef<HTMLInputElement, InputProps>(
-  ({ className, type, ...props }, ref) => {
-    return (
-      <input
-        type={type}
-        className={cn(
-          'flex h-9 w-full rounded-md border border-input bg-transparent px-3 py-2 text-sm shadow-sm ring-offset-background file:border-0 file:bg-transparent file:text-sm file:font-medium placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50',
-          className
-        )}
-        ref={ref}
-        {...props}
-      />
-    )
-  }
-)
-Input.displayName = 'Input'
-
-export { Input }

spaces/AAYUSH27/Neuro/installation_steps.md

@@ -1,43 +0,0 @@
-
-## Make sure you have git-lfs installed [Git LFS](https://git-lfs.com) ✅
-# 🧑🏻‍💻Steps to download the Code
-
-**📌 NOTE-1: If the Llama 2 Model is not donwloaded then the code will not work properly.** 
-
-**📌 NOTE-2: If the HuggingFaces API is not in ```.env``` file then generate your own API key from HugginFaces and use it.**
-
----
-
-Step:0
-- Copy and Paste the below command in terminal.
-- This command will help to download the code to your local machine.
-```shell
-git clone https://huggingface.co/spaces/AAYUSH27/Neuro
-```
-- The file is of approx. 5GB
-- If you want to clone without large files (Llama 2 Model).
-```shell
-git clone https://huggingface.co/spaces/AAYUSH27/Neuro
-GIT_LFS_SKIP_SMUDGE=1
-```
-
-Step:1 
-- Copy and Paste the below command in terminal.
-- This command helps to go into the project directory.
-```shell
-cd Neuro
-```
-
-Step:2
--  Copy and Paste the below command in terminal.
-- This commmand helps to install all the libraries in one take from ```requirements.txt```.
-```shell
-pip3 install -r requirements.txt
-```
-
-Step:3
-- Copy and Paste the below command in terminal.
-- This command helps to run the code into local host via ```streamlit```.
-```shell
-streamlit run -app.py
-```

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

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

spaces/AISuperheroes/08GR-KitchenSink-AIUIUX/demos/kitchen_sink/files/Readme.md

@@ -1 +0,0 @@
-Creates directory on demos/kitchen_sink/files/ to store programmatic load files

spaces/Ababababababbababa/Ashaar/poetry_diacritizer/util/text_cleaners.py

@@ -1,146 +0,0 @@
-import re
-from .constants import VALID_ARABIC
-from itertools import product, combinations
-
-_whitespace_re = re.compile(r"\s+")
-
-
-def collapse_whitespace(text):
-    text = re.sub(_whitespace_re, " ", text)
-    return text
-
-
-def basic_cleaners(text):
-    text = collapse_whitespace(text)
-    return text.strip()
-
-
-# def valid_arabic_cleaners(text):
-#     text = filter(lambda char: char in VALID_ARABIC, text)
-#     text = collapse_whitespace(''.join(list(text)))
-#     return text.strip()
-
-harakat = ["\u0650", "\u064E", "\u064F"]  # [kasra, fatha, damma, ]
-sukun = ["\u0652"]  # [sukun]
-mostly_saken = [
-  "\u0627",
-  "\u0648",
-  "\u0649",
-  "\u064A",
-]  # [alef, waw, alef maqsurah, ya'a]
-
-always_saken = [
-  "\u0627",
-  "\u0649",
-]
-
-tnween_chars = [
-    "\u064c",
-    "\u064d",
-    "\u064b",
-]  # damm tanween, kasra tanween, fatha tanween, maddah
-shadda_chars = ["\u0651"]
-all_tashkeel = harakat+tnween_chars+sukun+shadda_chars
-
-
-all_chars = list("إةابتثجحخدذرزسشصضطظعغفقكلمنهويىأءئؤ ")
-prem_chars = harakat + sukun + mostly_saken + tnween_chars + shadda_chars + all_chars
-
-def not_valid_tashkeel_comb(comb):
-  all_comb = list(product(harakat+sukun+tnween_chars, repeat = 2))+list(product(shadda_chars+sukun, repeat = 2))
-  if comb in all_comb or comb[::-1] in all_comb:
-    return True
-  else:
-    return False
-
-def remove_tanween_on_alef(text):
-  text_copy = ""
-  for i in range(0, len(text)):
-
-    # if there is shaddah or character followed by alef followed by tanween add
-    if i < len(text) - 2 and text[i] in all_chars+shadda_chars and text[i+1] in always_saken and text[i+2] == tnween_chars[2]:
-      text_copy += text[i] + tnween_chars[2]
-    
-    #ignore current harakah if there is alef followed by tanween
-    elif i < len(text) - 2 and text[i] in harakat and text[i+1] in always_saken and text[i+2] == tnween_chars[2] : 
-      text_copy += tnween_chars[2]
-
-    # if the current char is tanween with alef is the previous character drop tanween
-    elif i > 0 and text[i] == tnween_chars[2] and text[i-1] in always_saken:
-      continue
-
-    else:
-      text_copy += text[i]
-  return text_copy
-
-def dont_start_by_harakah(text):
-    text_copy = ""
-    for i, char in enumerate(text):
-      if not(char in all_tashkeel):
-        text_copy = text[i:]
-        break 
-    return text_copy
-        
-def valid_arabic_cleaners(text):
-  prev_text = text
-  for i in range(5):
-    text = prev_text
-    cleaned_text = ""
-    text = filter(lambda char: char in VALID_ARABIC, text)
-    text = collapse_whitespace(''.join(list(text)))
-    text = dont_start_by_harakah(text)
-    text = text.strip()
-    i = 0
-    cnt = 0
-    len_text = len(text)
-    while( i < len_text):
-      if text[i] in all_tashkeel:
-        cnt += 1 
-      else:
-        cnt = 0
-
-      # don't allow three consecutive tashkeel
-      if cnt > 2:
-        i+= 1
-        continue
-
-      # remove second tanween and sukun
-      if i > 1 and text[i] in tnween_chars+sukun and  text[i-2] in tnween_chars+sukun:
-        i += 1
-        continue 
-      
-      # don't allow harakah followed by shaddah or tanween
-      if i < len(text) - 1 and text[i] in harakat and  text[i+1] in tnween_chars+sukun+shadda_chars:
-        i += 1
-        continue
-      
-      # don't allow harkah on space
-      if i> 0 and text[i] in all_tashkeel and text[i-1] == " " :
-        i += 1
-        continue
-
-      # only allow permissable combinations
-      if not_valid_tashkeel_comb((text[i], text[i-1])):
-        i+=1
-        continue
-
-      # don't allow harkah on alef, alef maqsura, if there is no tashkeel before move it back
-      if i> 1 and text[i] in harakat and text[i-1] in always_saken :
-        if text[i-2] in all_tashkeel: # in case there is a tashkeelah before alef
-          continue
-        else:
-          cleaned_text = text[:i-1]+text[i]+ always_saken[always_saken.index(text[i-1])]
-          i += 1 
-         
-      if i < len(text):
-        cleaned_text+= text[i]
-        i += 1
-    
-    # only allow tanween before alef
-    cleaned_text = remove_tanween_on_alef(cleaned_text)
-    cleaned_text = re.sub(r" +", " ", cleaned_text).strip()
-    if prev_text == cleaned_text:
-      break
-    else:
-      prev_text = cleaned_text 
-  return cleaned_text

spaces/Abhilashvj/planogram-compliance/utils/docker/Dockerfile

@@ -1,66 +0,0 @@
-# YOLOv5 🚀 by Ultralytics, GPL-3.0 license
-# Builds ultralytics/yolov5:latest image on DockerHub https://hub.docker.com/r/ultralytics/yolov5
-# Image is CUDA-optimized for YOLOv5 single/multi-GPU training and inference
-
-# Start FROM NVIDIA PyTorch image https://ngc.nvidia.com/catalog/containers/nvidia:pytorch
-FROM nvcr.io/nvidia/pytorch:22.12-py3
-RUN rm -rf /opt/pytorch  # remove 1.2GB dir
-
-# Downloads to user config dir
-ADD https://ultralytics.com/assets/Arial.ttf https://ultralytics.com/assets/Arial.Unicode.ttf /root/.config/Ultralytics/
-
-# Install linux packages
-RUN apt update && apt install --no-install-recommends -y zip htop screen libgl1-mesa-glx
-
-# Install pip packages (uninstall torch nightly in favor of stable)
-COPY requirements.txt .
-RUN python -m pip install --upgrade pip wheel
-RUN pip uninstall -y Pillow torchtext torch torchvision
-RUN pip install --no-cache -U pycocotools  # install --upgrade
-RUN pip install --no-cache -r requirements.txt albumentations comet gsutil notebook 'opencv-python<4.6.0.66'  \
-    Pillow>=9.1.0 ultralytics \
-    --extra-index-url https://download.pytorch.org/whl/cu113
-
-# Create working directory
-RUN mkdir -p /usr/src/app
-WORKDIR /usr/src/app
-
-# Copy contents
-# COPY . /usr/src/app  (issues as not a .git directory)
-RUN git clone https://github.com/ultralytics/yolov5 /usr/src/app
-
-# Set environment variables
-ENV OMP_NUM_THREADS=1
-
-
-# Usage Examples -------------------------------------------------------------------------------------------------------
-
-# Build and Push
-# t=ultralytics/yolov5:latest && sudo docker build -f utils/docker/Dockerfile -t $t . && sudo docker push $t
-
-# Pull and Run
-# t=ultralytics/yolov5:latest && sudo docker pull $t && sudo docker run -it --ipc=host --gpus all $t
-
-# Pull and Run with local directory access
-# t=ultralytics/yolov5:latest && sudo docker pull $t && sudo docker run -it --ipc=host --gpus all -v "$(pwd)"/datasets:/usr/src/datasets $t
-
-# Kill all
-# sudo docker kill $(sudo docker ps -q)
-
-# Kill all image-based
-# sudo docker kill $(sudo docker ps -qa --filter ancestor=ultralytics/yolov5:latest)
-
-# DockerHub tag update
-# t=ultralytics/yolov5:latest tnew=ultralytics/yolov5:v6.2 && sudo docker pull $t && sudo docker tag $t $tnew && sudo docker push $tnew
-
-# Clean up
-# docker system prune -a --volumes
-
-# Update Ubuntu drivers
-# https://www.maketecheasier.com/install-nvidia-drivers-ubuntu/
-
-# DDP test
-# python -m torch.distributed.run --nproc_per_node 2 --master_port 1 train.py --epochs 3
-
-# GCP VM from Image
-# docker.io/ultralytics/yolov5:latest

spaces/AchyuthGamer/OpenGPT-Chat-UI/src/lib/utils/loadClientCerts.ts

@@ -1,50 +0,0 @@
-import * as fs from "fs";
-import { setGlobalDispatcher, Agent } from "undici";
-
-/**
- * Load client certificates for mutual TLS authentication. This function must be called before any HTTP requests are made.
- * This is a global setting that affects all HTTP requests made by the application using the native fetch API.
- *
- * @param clientCertPath     Path to client certificate
- * @param clientKeyPath      Path to client key
- * @param caCertPath         Path to CA certificate [optional]
- * @param clientKeyPassword  Password for client key [optional]
- * @param rejectUnauthorized Reject unauthorized certificates.
- *                           Only use for testing/development, not recommended in production environments [optional]
- *
- * @returns void
- *
- * @example
- * ```typescript
- * loadClientCertificates("cert.pem", "key.pem", "ca.pem", "password", false);
- * ```
- *
- * @see
- * [Undici Agent](https://undici.nodejs.org/#/docs/api/Agent)
- * @see
- * [Undici Dispatcher](https://undici.nodejs.org/#/docs/api/Dispatcher)
- * @see
- * [NodeJS Native Fetch API](https://nodejs.org/docs/latest-v19.x/api/globals.html#fetch)
- */
-export function loadClientCertificates(
-	clientCertPath: string,
-	clientKeyPath: string,
-	caCertPath?: string,
-	clientKeyPassword?: string,
-	rejectUnauthorized?: boolean
-): void {
-	const clientCert = fs.readFileSync(clientCertPath);
-	const clientKey = fs.readFileSync(clientKeyPath);
-	const caCert = caCertPath ? fs.readFileSync(caCertPath) : undefined;
-	const agent = new Agent({
-		connect: {
-			cert: clientCert,
-			key: clientKey,
-			ca: caCert,
-			passphrase: clientKeyPassword,
-			rejectUnauthorized: rejectUnauthorized,
-		},
-	});
-
-	setGlobalDispatcher(agent);
-}

spaces/AiMimicry/sovits-models/modules/modules.py

@@ -1,342 +0,0 @@
-import copy
-import math
-import numpy as np
-import scipy
-import torch
-from torch import nn
-from torch.nn import functional as F
-
-from torch.nn import Conv1d, ConvTranspose1d, AvgPool1d, Conv2d
-from torch.nn.utils import weight_norm, remove_weight_norm
-
-import modules.commons as commons
-from modules.commons import init_weights, get_padding
-
-
-LRELU_SLOPE = 0.1
-
-
-class LayerNorm(nn.Module):
-  def __init__(self, channels, eps=1e-5):
-    super().__init__()
-    self.channels = channels
-    self.eps = eps
-
-    self.gamma = nn.Parameter(torch.ones(channels))
-    self.beta = nn.Parameter(torch.zeros(channels))
-
-  def forward(self, x):
-    x = x.transpose(1, -1)
-    x = F.layer_norm(x, (self.channels,), self.gamma, self.beta, self.eps)
-    return x.transpose(1, -1)
-
- 
-class ConvReluNorm(nn.Module):
-  def __init__(self, in_channels, hidden_channels, out_channels, kernel_size, n_layers, p_dropout):
-    super().__init__()
-    self.in_channels = in_channels
-    self.hidden_channels = hidden_channels
-    self.out_channels = out_channels
-    self.kernel_size = kernel_size
-    self.n_layers = n_layers
-    self.p_dropout = p_dropout
-    assert n_layers > 1, "Number of layers should be larger than 0."
-
-    self.conv_layers = nn.ModuleList()
-    self.norm_layers = nn.ModuleList()
-    self.conv_layers.append(nn.Conv1d(in_channels, hidden_channels, kernel_size, padding=kernel_size//2))
-    self.norm_layers.append(LayerNorm(hidden_channels))
-    self.relu_drop = nn.Sequential(
-        nn.ReLU(),
-        nn.Dropout(p_dropout))
-    for _ in range(n_layers-1):
-      self.conv_layers.append(nn.Conv1d(hidden_channels, hidden_channels, kernel_size, padding=kernel_size//2))
-      self.norm_layers.append(LayerNorm(hidden_channels))
-    self.proj = nn.Conv1d(hidden_channels, out_channels, 1)
-    self.proj.weight.data.zero_()
-    self.proj.bias.data.zero_()
-
-  def forward(self, x, x_mask):
-    x_org = x
-    for i in range(self.n_layers):
-      x = self.conv_layers[i](x * x_mask)
-      x = self.norm_layers[i](x)
-      x = self.relu_drop(x)
-    x = x_org + self.proj(x)
-    return x * x_mask
-
-
-class DDSConv(nn.Module):
-  """
-  Dialted and Depth-Separable Convolution
-  """
-  def __init__(self, channels, kernel_size, n_layers, p_dropout=0.):
-    super().__init__()
-    self.channels = channels
-    self.kernel_size = kernel_size
-    self.n_layers = n_layers
-    self.p_dropout = p_dropout
-
-    self.drop = nn.Dropout(p_dropout)
-    self.convs_sep = nn.ModuleList()
-    self.convs_1x1 = nn.ModuleList()
-    self.norms_1 = nn.ModuleList()
-    self.norms_2 = nn.ModuleList()
-    for i in range(n_layers):
-      dilation = kernel_size ** i
-      padding = (kernel_size * dilation - dilation) // 2
-      self.convs_sep.append(nn.Conv1d(channels, channels, kernel_size, 
-          groups=channels, dilation=dilation, padding=padding
-      ))
-      self.convs_1x1.append(nn.Conv1d(channels, channels, 1))
-      self.norms_1.append(LayerNorm(channels))
-      self.norms_2.append(LayerNorm(channels))
-
-  def forward(self, x, x_mask, g=None):
-    if g is not None:
-      x = x + g
-    for i in range(self.n_layers):
-      y = self.convs_sep[i](x * x_mask)
-      y = self.norms_1[i](y)
-      y = F.gelu(y)
-      y = self.convs_1x1[i](y)
-      y = self.norms_2[i](y)
-      y = F.gelu(y)
-      y = self.drop(y)
-      x = x + y
-    return x * x_mask
-
-
-class WN(torch.nn.Module):
-  def __init__(self, hidden_channels, kernel_size, dilation_rate, n_layers, gin_channels=0, p_dropout=0):
-    super(WN, self).__init__()
-    assert(kernel_size % 2 == 1)
-    self.hidden_channels =hidden_channels
-    self.kernel_size = kernel_size,
-    self.dilation_rate = dilation_rate
-    self.n_layers = n_layers
-    self.gin_channels = gin_channels
-    self.p_dropout = p_dropout
-
-    self.in_layers = torch.nn.ModuleList()
-    self.res_skip_layers = torch.nn.ModuleList()
-    self.drop = nn.Dropout(p_dropout)
-
-    if gin_channels != 0:
-      cond_layer = torch.nn.Conv1d(gin_channels, 2*hidden_channels*n_layers, 1)
-      self.cond_layer = torch.nn.utils.weight_norm(cond_layer, name='weight')
-
-    for i in range(n_layers):
-      dilation = dilation_rate ** i
-      padding = int((kernel_size * dilation - dilation) / 2)
-      in_layer = torch.nn.Conv1d(hidden_channels, 2*hidden_channels, kernel_size,
-                                 dilation=dilation, padding=padding)
-      in_layer = torch.nn.utils.weight_norm(in_layer, name='weight')
-      self.in_layers.append(in_layer)
-
-      # last one is not necessary
-      if i < n_layers - 1:
-        res_skip_channels = 2 * hidden_channels
-      else:
-        res_skip_channels = hidden_channels
-
-      res_skip_layer = torch.nn.Conv1d(hidden_channels, res_skip_channels, 1)
-      res_skip_layer = torch.nn.utils.weight_norm(res_skip_layer, name='weight')
-      self.res_skip_layers.append(res_skip_layer)
-
-  def forward(self, x, x_mask, g=None, **kwargs):
-    output = torch.zeros_like(x)
-    n_channels_tensor = torch.IntTensor([self.hidden_channels])
-
-    if g is not None:
-      g = self.cond_layer(g)
-
-    for i in range(self.n_layers):
-      x_in = self.in_layers[i](x)
-      if g is not None:
-        cond_offset = i * 2 * self.hidden_channels
-        g_l = g[:,cond_offset:cond_offset+2*self.hidden_channels,:]
-      else:
-        g_l = torch.zeros_like(x_in)
-
-      acts = commons.fused_add_tanh_sigmoid_multiply(
-          x_in,
-          g_l,
-          n_channels_tensor)
-      acts = self.drop(acts)
-
-      res_skip_acts = self.res_skip_layers[i](acts)
-      if i < self.n_layers - 1:
-        res_acts = res_skip_acts[:,:self.hidden_channels,:]
-        x = (x + res_acts) * x_mask
-        output = output + res_skip_acts[:,self.hidden_channels:,:]
-      else:
-        output = output + res_skip_acts
-    return output * x_mask
-
-  def remove_weight_norm(self):
-    if self.gin_channels != 0:
-      torch.nn.utils.remove_weight_norm(self.cond_layer)
-    for l in self.in_layers:
-      torch.nn.utils.remove_weight_norm(l)
-    for l in self.res_skip_layers:
-     torch.nn.utils.remove_weight_norm(l)
-
-
-class ResBlock1(torch.nn.Module):
-    def __init__(self, channels, kernel_size=3, dilation=(1, 3, 5)):
-        super(ResBlock1, self).__init__()
-        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, x_mask=None):
-        for c1, c2 in zip(self.convs1, self.convs2):
-            xt = F.leaky_relu(x, LRELU_SLOPE)
-            if x_mask is not None:
-                xt = xt * x_mask
-            xt = c1(xt)
-            xt = F.leaky_relu(xt, LRELU_SLOPE)
-            if x_mask is not None:
-                xt = xt * x_mask
-            xt = c2(xt)
-            x = xt + x
-        if x_mask is not None:
-            x = x * x_mask
-        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, channels, kernel_size=3, dilation=(1, 3)):
-        super(ResBlock2, self).__init__()
-        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, x_mask=None):
-        for c in self.convs:
-            xt = F.leaky_relu(x, LRELU_SLOPE)
-            if x_mask is not None:
-                xt = xt * x_mask
-            xt = c(xt)
-            x = xt + x
-        if x_mask is not None:
-            x = x * x_mask
-        return x
-
-    def remove_weight_norm(self):
-        for l in self.convs:
-            remove_weight_norm(l)
-
-
-class Log(nn.Module):
-  def forward(self, x, x_mask, reverse=False, **kwargs):
-    if not reverse:
-      y = torch.log(torch.clamp_min(x, 1e-5)) * x_mask
-      logdet = torch.sum(-y, [1, 2])
-      return y, logdet
-    else:
-      x = torch.exp(x) * x_mask
-      return x
-    
-
-class Flip(nn.Module):
-  def forward(self, x, *args, reverse=False, **kwargs):
-    x = torch.flip(x, [1])
-    if not reverse:
-      logdet = torch.zeros(x.size(0)).to(dtype=x.dtype, device=x.device)
-      return x, logdet
-    else:
-      return x
-
-
-class ElementwiseAffine(nn.Module):
-  def __init__(self, channels):
-    super().__init__()
-    self.channels = channels
-    self.m = nn.Parameter(torch.zeros(channels,1))
-    self.logs = nn.Parameter(torch.zeros(channels,1))
-
-  def forward(self, x, x_mask, reverse=False, **kwargs):
-    if not reverse:
-      y = self.m + torch.exp(self.logs) * x
-      y = y * x_mask
-      logdet = torch.sum(self.logs * x_mask, [1,2])
-      return y, logdet
-    else:
-      x = (x - self.m) * torch.exp(-self.logs) * x_mask
-      return x
-
-
-class ResidualCouplingLayer(nn.Module):
-  def __init__(self,
-      channels,
-      hidden_channels,
-      kernel_size,
-      dilation_rate,
-      n_layers,
-      p_dropout=0,
-      gin_channels=0,
-      mean_only=False):
-    assert channels % 2 == 0, "channels should be divisible by 2"
-    super().__init__()
-    self.channels = channels
-    self.hidden_channels = hidden_channels
-    self.kernel_size = kernel_size
-    self.dilation_rate = dilation_rate
-    self.n_layers = n_layers
-    self.half_channels = channels // 2
-    self.mean_only = mean_only
-
-    self.pre = nn.Conv1d(self.half_channels, hidden_channels, 1)
-    self.enc = WN(hidden_channels, kernel_size, dilation_rate, n_layers, p_dropout=p_dropout, gin_channels=gin_channels)
-    self.post = nn.Conv1d(hidden_channels, self.half_channels * (2 - mean_only), 1)
-    self.post.weight.data.zero_()
-    self.post.bias.data.zero_()
-
-  def forward(self, x, x_mask, g=None, reverse=False):
-    x0, x1 = torch.split(x, [self.half_channels]*2, 1)
-    h = self.pre(x0) * x_mask
-    h = self.enc(h, x_mask, g=g)
-    stats = self.post(h) * x_mask
-    if not self.mean_only:
-      m, logs = torch.split(stats, [self.half_channels]*2, 1)
-    else:
-      m = stats
-      logs = torch.zeros_like(m)
-
-    if not reverse:
-      x1 = m + x1 * torch.exp(logs) * x_mask
-      x = torch.cat([x0, x1], 1)
-      logdet = torch.sum(logs, [1,2])
-      return x, logdet
-    else:
-      x1 = (x1 - m) * torch.exp(-logs) * x_mask
-      x = torch.cat([x0, x1], 1)
-      return x

spaces/Aki004/herta-so-vits/README.md

@@ -1,13 +0,0 @@
----
-title: Herta So Vits
-emoji: 🦀
-colorFrom: red
-colorTo: yellow
-sdk: gradio
-sdk_version: 3.33.1
-app_file: app.py
-pinned: false
-license: bsd
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/AkiKagura/Marco-Generation-Img2img/README.md

@@ -1,13 +0,0 @@
----
-title: Marco Generation Img2img
-emoji: 🦀
-colorFrom: gray
-colorTo: green
-sdk: gradio
-sdk_version: 3.8.1
-app_file: app.py
-pinned: false
-license: creativeml-openrail-m
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/AlexWang/lama/saicinpainting/training/trainers/__init__.py

@@ -1,30 +0,0 @@
-import logging
-import torch
-from saicinpainting.training.trainers.default import DefaultInpaintingTrainingModule
-
-
-def get_training_model_class(kind):
-    if kind == 'default':
-        return DefaultInpaintingTrainingModule
-
-    raise ValueError(f'Unknown trainer module {kind}')
-
-
-def make_training_model(config):
-    kind = config.training_model.kind
-    kwargs = dict(config.training_model)
-    kwargs.pop('kind')
-    kwargs['use_ddp'] = config.trainer.kwargs.get('accelerator', None) == 'ddp'
-
-    logging.info(f'Make training model {kind}')
-
-    cls = get_training_model_class(kind)
-    return cls(config, **kwargs)
-
-
-def load_checkpoint(train_config, path, map_location='cuda', strict=True):
-    model: torch.nn.Module = make_training_model(train_config)
-    state = torch.load(path, map_location=map_location)
-    model.load_state_dict(state['state_dict'], strict=strict)
-    model.on_load_checkpoint(state)
-    return model

spaces/Amon1/ChatGPTForAcadamic/crazy_functions/test_project/cpp/cppipc/queue.h

@@ -1,216 +0,0 @@
-#pragma once
-
-#include <type_traits>
-#include <new>
-#include <utility>  // [[since C++14]]: std::exchange
-#include <algorithm>
-#include <atomic>
-#include <tuple>
-#include <thread>
-#include <chrono>
-#include <string>
-#include <cassert>  // assert
-
-#include "libipc/def.h"
-#include "libipc/shm.h"
-#include "libipc/rw_lock.h"
-
-#include "libipc/utility/log.h"
-#include "libipc/platform/detail.h"
-#include "libipc/circ/elem_def.h"
-
-namespace ipc {
-namespace detail {
-
-class queue_conn {
-protected:
-    circ::cc_t connected_ = 0;
-    shm::handle elems_h_;
-
-    template <typename Elems>
-    Elems* open(char const * name) {
-        if (name == nullptr || name[0] == '\0') {
-            ipc::error("fail open waiter: name is empty!\n");
-            return nullptr;
-        }
-        if (!elems_h_.acquire(name, sizeof(Elems))) {
-            return nullptr;
-        }
-        auto elems = static_cast<Elems*>(elems_h_.get());
-        if (elems == nullptr) {
-            ipc::error("fail acquire elems: %s\n", name);
-            return nullptr;
-        }
-        elems->init();
-        return elems;
-    }
-
-    void close() {
-        elems_h_.release();
-    }
-
-public:
-    queue_conn() = default;
-    queue_conn(const queue_conn&) = delete;
-    queue_conn& operator=(const queue_conn&) = delete;
-
-    bool connected() const noexcept {
-        return connected_ != 0;
-    }
-
-    circ::cc_t connected_id() const noexcept {
-        return connected_;
-    }
-
-    template <typename Elems>
-    auto connect(Elems* elems) noexcept
-                         /*needs 'optional' here*/
-     -> std::tuple<bool, bool, decltype(std::declval<Elems>().cursor())> {
-        if (elems == nullptr) return {};
-        // if it's already connected, just return
-        if (connected()) return {connected(), false, 0};
-        connected_ = elems->connect_receiver();
-        return {connected(), true, elems->cursor()};
-    }
-
-    template <typename Elems>
-    bool disconnect(Elems* elems) noexcept {
-        if (elems == nullptr) return false;
-        // if it's already disconnected, just return false
-        if (!connected()) return false;
-        elems->disconnect_receiver(std::exchange(connected_, 0));
-        return true;
-    }
-};
-
-template <typename Elems>
-class queue_base : public queue_conn {
-    using base_t = queue_conn;
-
-public:
-    using elems_t  = Elems;
-    using policy_t = typename elems_t::policy_t;
-
-protected:
-    elems_t * elems_ = nullptr;
-    decltype(std::declval<elems_t>().cursor()) cursor_ = 0;
-    bool sender_flag_ = false;
-
-public:
-    using base_t::base_t;
-
-    queue_base() = default;
-
-    explicit queue_base(char const * name)
-        : queue_base{} {
-        elems_ = open<elems_t>(name);
-    }
-
-    explicit queue_base(elems_t * elems) noexcept
-        : queue_base{} {
-        assert(elems != nullptr);
-        elems_ = elems;
-    }
-
-    /* not virtual */ ~queue_base() {
-        base_t::close();
-    }
-
-    elems_t       * elems()       noexcept { return elems_; }
-    elems_t const * elems() const noexcept { return elems_; }
-
-    bool ready_sending() noexcept {
-        if (elems_ == nullptr) return false;
-        return sender_flag_ || (sender_flag_ = elems_->connect_sender());
-    }
-
-    void shut_sending() noexcept {
-        if (elems_ == nullptr) return;
-        if (!sender_flag_) return;
-        elems_->disconnect_sender();
-    }
-
-    bool connect() noexcept {
-        auto tp = base_t::connect(elems_);
-        if (std::get<0>(tp) && std::get<1>(tp)) {
-            cursor_ = std::get<2>(tp);
-            return true;
-        }
-        return std::get<0>(tp);
-    }
-
-    bool disconnect() noexcept {
-        return base_t::disconnect(elems_);
-    }
-
-    std::size_t conn_count() const noexcept {
-        return (elems_ == nullptr) ? static_cast<std::size_t>(invalid_value) : elems_->conn_count();
-    }
-
-    bool valid() const noexcept {
-        return elems_ != nullptr;
-    }
-
-    bool empty() const noexcept {
-        return !valid() || (cursor_ == elems_->cursor());
-    }
-
-    template <typename T, typename F, typename... P>
-    bool push(F&& prep, P&&... params) {
-        if (elems_ == nullptr) return false;
-        return elems_->push(this, [&](void* p) {
-            if (prep(p)) ::new (p) T(std::forward<P>(params)...);
-        });
-    }
-
-    template <typename T, typename F, typename... P>
-    bool force_push(F&& prep, P&&... params) {
-        if (elems_ == nullptr) return false;
-        return elems_->force_push(this, [&](void* p) {
-            if (prep(p)) ::new (p) T(std::forward<P>(params)...);
-        });
-    }
-
-    template <typename T, typename F>
-    bool pop(T& item, F&& out) {
-        if (elems_ == nullptr) {
-            return false;
-        }
-        return elems_->pop(this, &(this->cursor_), [&item](void* p) {
-            ::new (&item) T(std::move(*static_cast<T*>(p)));
-        }, std::forward<F>(out));
-    }
-};
-
-} // namespace detail
-
-template <typename T, typename Policy>
-class queue final : public detail::queue_base<typename Policy::template elems_t<sizeof(T), alignof(T)>> {
-    using base_t = detail::queue_base<typename Policy::template elems_t<sizeof(T), alignof(T)>>;
-
-public:
-    using value_t = T;
-
-    using base_t::base_t;
-
-    template <typename... P>
-    bool push(P&&... params) {
-        return base_t::template push<T>(std::forward<P>(params)...);
-    }
-
-    template <typename... P>
-    bool force_push(P&&... params) {
-        return base_t::template force_push<T>(std::forward<P>(params)...);
-    }
-
-    bool pop(T& item) {
-        return base_t::pop(item, [](bool) {});
-    }
-
-    template <typename F>
-    bool pop(T& item, F&& out) {
-        return base_t::pop(item, std::forward<F>(out));
-    }
-};
-
-} // namespace ipc

spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/src/diffusers/pipelines/stable_diffusion/pipeline_stable_diffusion_ldm3d.py

@@ -1,661 +0,0 @@
-# Copyright 2023 The Intel Labs Team Authors and the HuggingFace Team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import inspect
-from dataclasses import dataclass
-from typing import Any, Callable, Dict, List, Optional, Union
-
-import numpy as np
-import PIL
-import torch
-from transformers import CLIPImageProcessor, CLIPTextModel, CLIPTokenizer
-
-from ...image_processor import VaeImageProcessorLDM3D
-from ...loaders import FromSingleFileMixin, LoraLoaderMixin, TextualInversionLoaderMixin
-from ...models import AutoencoderKL, UNet2DConditionModel
-from ...schedulers import KarrasDiffusionSchedulers
-from ...utils import (
-    BaseOutput,
-    is_accelerate_available,
-    is_accelerate_version,
-    logging,
-    randn_tensor,
-    replace_example_docstring,
-)
-from ..pipeline_utils import DiffusionPipeline
-from .safety_checker import StableDiffusionSafetyChecker
-
-
-logger = logging.get_logger(__name__)  # pylint: disable=invalid-name
-
-EXAMPLE_DOC_STRING = """
-    Examples:
-        ```py
-        >>> import torch
-        >>> from diffusers import StableDiffusionPipeline
-
-        >>> pipe = StableDiffusionLDM3DPipeline.from_pretrained("Intel/ldm3d")
-        >>> pipe = pipe.to("cuda")
-
-        >>> prompt = "a photo of an astronaut riding a horse on mars"
-        >>> output = pipe(prompt)
-        >>> rgb_image, depth_image = output.rgb, output.depth
-        >>> rgb_image[0].save("astronaut_ldm3d_rgb.jpg")
-        >>> depth_image[0].save("astronaut_ldm3d_depth.png")
-        ```
-"""
-
-
-@dataclass
-class LDM3DPipelineOutput(BaseOutput):
-    """
-    Output class for Stable Diffusion pipelines.
-
-    Args:
-        images (`List[PIL.Image.Image]` or `np.ndarray`)
-            List of denoised PIL images of length `batch_size` or NumPy array of shape `(batch_size, height, width,
-            num_channels)`.
-        nsfw_content_detected (`List[bool]`)
-            List indicating whether the corresponding generated image contains "not-safe-for-work" (nsfw) content or
-            `None` if safety checking could not be performed.
-    """
-
-    rgb: Union[List[PIL.Image.Image], np.ndarray]
-    depth: Union[List[PIL.Image.Image], np.ndarray]
-    nsfw_content_detected: Optional[List[bool]]
-
-
-class StableDiffusionLDM3DPipeline(
-    DiffusionPipeline, TextualInversionLoaderMixin, LoraLoaderMixin, FromSingleFileMixin
-):
-    r"""
-    Pipeline for text-to-image and 3D generation using LDM3D.
-
-    This model inherits from [`DiffusionPipeline`]. Check the superclass documentation for the generic methods
-    implemented for all pipelines (downloading, saving, running on a particular device, etc.).
-
-    The pipeline also inherits the following loading methods:
-        - [`~loaders.TextualInversionLoaderMixin.load_textual_inversion`] for loading textual inversion embeddings
-        - [`~loaders.LoraLoaderMixin.load_lora_weights`] for loading LoRA weights
-        - [`~loaders.LoraLoaderMixin.save_lora_weights`] for saving LoRA weights
-        - [`~loaders.FromSingleFileMixin.from_single_file`] for loading `.ckpt` files
-
-    Args:
-        vae ([`AutoencoderKL`]):
-            Variational Auto-Encoder (VAE) model to encode and decode images to and from latent representations.
-        text_encoder ([`~transformers.CLIPTextModel`]):
-            Frozen text-encoder ([clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14)).
-        tokenizer ([`~transformers.CLIPTokenizer`]):
-            A `CLIPTokenizer` to tokenize text.
-        unet ([`UNet2DConditionModel`]):
-            A `UNet2DConditionModel` to denoise the encoded image latents.
-        scheduler ([`SchedulerMixin`]):
-            A scheduler to be used in combination with `unet` to denoise the encoded image latents. Can be one of
-            [`DDIMScheduler`], [`LMSDiscreteScheduler`], or [`PNDMScheduler`].
-        safety_checker ([`StableDiffusionSafetyChecker`]):
-            Classification module that estimates whether generated images could be considered offensive or harmful.
-            Please refer to the [model card](https://huggingface.co/runwayml/stable-diffusion-v1-5) for more details
-            about a model's potential harms.
-        feature_extractor ([`~transformers.CLIPImageProcessor`]):
-            A `CLIPImageProcessor` to extract features from generated images; used as inputs to the `safety_checker`.
-    """
-    _optional_components = ["safety_checker", "feature_extractor"]
-
-    def __init__(
-        self,
-        vae: AutoencoderKL,
-        text_encoder: CLIPTextModel,
-        tokenizer: CLIPTokenizer,
-        unet: UNet2DConditionModel,
-        scheduler: KarrasDiffusionSchedulers,
-        safety_checker: StableDiffusionSafetyChecker,
-        feature_extractor: CLIPImageProcessor,
-        requires_safety_checker: bool = True,
-    ):
-        super().__init__()
-
-        if safety_checker is None and requires_safety_checker:
-            logger.warning(
-                f"You have disabled the safety checker for {self.__class__} by passing `safety_checker=None`. Ensure"
-                " that you abide to the conditions of the Stable Diffusion license and do not expose unfiltered"
-                " results in services or applications open to the public. Both the diffusers team and Hugging Face"
-                " strongly recommend to keep the safety filter enabled in all public facing circumstances, disabling"
-                " it only for use-cases that involve analyzing network behavior or auditing its results. For more"
-                " information, please have a look at https://github.com/huggingface/diffusers/pull/254 ."
-            )
-
-        if safety_checker is not None and feature_extractor is None:
-            raise ValueError(
-                "Make sure to define a feature extractor when loading {self.__class__} if you want to use the safety"
-                " checker. If you do not want to use the safety checker, you can pass `'safety_checker=None'` instead."
-            )
-
-        self.register_modules(
-            vae=vae,
-            text_encoder=text_encoder,
-            tokenizer=tokenizer,
-            unet=unet,
-            scheduler=scheduler,
-            safety_checker=safety_checker,
-            feature_extractor=feature_extractor,
-        )
-        self.vae_scale_factor = 2 ** (len(self.vae.config.block_out_channels) - 1)
-        self.image_processor = VaeImageProcessorLDM3D(vae_scale_factor=self.vae_scale_factor)
-        self.register_to_config(requires_safety_checker=requires_safety_checker)
-
-    # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline.enable_vae_slicing
-    def enable_vae_slicing(self):
-        r"""
-        Enable sliced VAE decoding. When this option is enabled, the VAE will split the input tensor in slices to
-        compute decoding in several steps. This is useful to save some memory and allow larger batch sizes.
-        """
-        self.vae.enable_slicing()
-
-    # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline.disable_vae_slicing
-    def disable_vae_slicing(self):
-        r"""
-        Disable sliced VAE decoding. If `enable_vae_slicing` was previously enabled, this method will go back to
-        computing decoding in one step.
-        """
-        self.vae.disable_slicing()
-
-    # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline.enable_vae_tiling
-    def enable_vae_tiling(self):
-        r"""
-        Enable tiled VAE decoding. When this option is enabled, the VAE will split the input tensor into tiles to
-        compute decoding and encoding in several steps. This is useful for saving a large amount of memory and to allow
-        processing larger images.
-        """
-        self.vae.enable_tiling()
-
-    # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline.disable_vae_tiling
-    def disable_vae_tiling(self):
-        r"""
-        Disable tiled VAE decoding. If `enable_vae_tiling` was previously enabled, this method will go back to
-        computing decoding in one step.
-        """
-        self.vae.disable_tiling()
-
-    # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline.enable_model_cpu_offload
-    def enable_model_cpu_offload(self, gpu_id=0):
-        r"""
-        Offload all models to CPU to reduce memory usage with a low impact on performance. Moves one whole model at a
-        time to the GPU when its `forward` method is called, and the model remains in GPU until the next model runs.
-        Memory savings are lower than using `enable_sequential_cpu_offload`, but performance is much better due to the
-        iterative execution of the `unet`.
-        """
-        if is_accelerate_available() and is_accelerate_version(">=", "0.17.0.dev0"):
-            from accelerate import cpu_offload_with_hook
-        else:
-            raise ImportError("`enable_model_cpu_offload` requires `accelerate v0.17.0` or higher.")
-
-        device = torch.device(f"cuda:{gpu_id}")
-
-        if self.device.type != "cpu":
-            self.to("cpu", silence_dtype_warnings=True)
-            torch.cuda.empty_cache()  # otherwise we don't see the memory savings (but they probably exist)
-
-        hook = None
-        for cpu_offloaded_model in [self.text_encoder, self.unet, self.vae]:
-            _, hook = cpu_offload_with_hook(cpu_offloaded_model, device, prev_module_hook=hook)
-
-        if self.safety_checker is not None:
-            _, hook = cpu_offload_with_hook(self.safety_checker, device, prev_module_hook=hook)
-
-        # We'll offload the last model manually.
-        self.final_offload_hook = hook
-
-    # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline._encode_prompt
-    def _encode_prompt(
-        self,
-        prompt,
-        device,
-        num_images_per_prompt,
-        do_classifier_free_guidance,
-        negative_prompt=None,
-        prompt_embeds: Optional[torch.FloatTensor] = None,
-        negative_prompt_embeds: Optional[torch.FloatTensor] = None,
-        lora_scale: Optional[float] = None,
-    ):
-        r"""
-        Encodes the prompt into text encoder hidden states.
-
-        Args:
-             prompt (`str` or `List[str]`, *optional*):
-                prompt to be encoded
-            device: (`torch.device`):
-                torch device
-            num_images_per_prompt (`int`):
-                number of images that should be generated per prompt
-            do_classifier_free_guidance (`bool`):
-                whether to use classifier free guidance or not
-            negative_prompt (`str` or `List[str]`, *optional*):
-                The prompt or prompts not to guide the image generation. If not defined, one has to pass
-                `negative_prompt_embeds` instead. Ignored when not using guidance (i.e., ignored if `guidance_scale` is
-                less than `1`).
-            prompt_embeds (`torch.FloatTensor`, *optional*):
-                Pre-generated text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt weighting. If not
-                provided, text embeddings will be generated from `prompt` input argument.
-            negative_prompt_embeds (`torch.FloatTensor`, *optional*):
-                Pre-generated negative text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt
-                weighting. If not provided, negative_prompt_embeds will be generated from `negative_prompt` input
-                argument.
-            lora_scale (`float`, *optional*):
-                A lora scale that will be applied to all LoRA layers of the text encoder if LoRA layers are loaded.
-        """
-        # set lora scale so that monkey patched LoRA
-        # function of text encoder can correctly access it
-        if lora_scale is not None and isinstance(self, LoraLoaderMixin):
-            self._lora_scale = lora_scale
-
-        if prompt is not None and isinstance(prompt, str):
-            batch_size = 1
-        elif prompt is not None and isinstance(prompt, list):
-            batch_size = len(prompt)
-        else:
-            batch_size = prompt_embeds.shape[0]
-
-        if prompt_embeds is None:
-            # textual inversion: procecss multi-vector tokens if necessary
-            if isinstance(self, TextualInversionLoaderMixin):
-                prompt = self.maybe_convert_prompt(prompt, self.tokenizer)
-
-            text_inputs = self.tokenizer(
-                prompt,
-                padding="max_length",
-                max_length=self.tokenizer.model_max_length,
-                truncation=True,
-                return_tensors="pt",
-            )
-            text_input_ids = text_inputs.input_ids
-            untruncated_ids = self.tokenizer(prompt, padding="longest", return_tensors="pt").input_ids
-
-            if untruncated_ids.shape[-1] >= text_input_ids.shape[-1] and not torch.equal(
-                text_input_ids, untruncated_ids
-            ):
-                removed_text = self.tokenizer.batch_decode(
-                    untruncated_ids[:, self.tokenizer.model_max_length - 1 : -1]
-                )
-                logger.warning(
-                    "The following part of your input was truncated because CLIP can only handle sequences up to"
-                    f" {self.tokenizer.model_max_length} tokens: {removed_text}"
-                )
-
-            if hasattr(self.text_encoder.config, "use_attention_mask") and self.text_encoder.config.use_attention_mask:
-                attention_mask = text_inputs.attention_mask.to(device)
-            else:
-                attention_mask = None
-
-            prompt_embeds = self.text_encoder(
-                text_input_ids.to(device),
-                attention_mask=attention_mask,
-            )
-            prompt_embeds = prompt_embeds[0]
-
-        prompt_embeds = prompt_embeds.to(dtype=self.text_encoder.dtype, device=device)
-
-        bs_embed, seq_len, _ = prompt_embeds.shape
-        # duplicate text embeddings for each generation per prompt, using mps friendly method
-        prompt_embeds = prompt_embeds.repeat(1, num_images_per_prompt, 1)
-        prompt_embeds = prompt_embeds.view(bs_embed * num_images_per_prompt, seq_len, -1)
-
-        # get unconditional embeddings for classifier free guidance
-        if do_classifier_free_guidance and negative_prompt_embeds is None:
-            uncond_tokens: List[str]
-            if negative_prompt is None:
-                uncond_tokens = [""] * batch_size
-            elif prompt is not None and type(prompt) is not type(negative_prompt):
-                raise TypeError(
-                    f"`negative_prompt` should be the same type to `prompt`, but got {type(negative_prompt)} !="
-                    f" {type(prompt)}."
-                )
-            elif isinstance(negative_prompt, str):
-                uncond_tokens = [negative_prompt]
-            elif batch_size != len(negative_prompt):
-                raise ValueError(
-                    f"`negative_prompt`: {negative_prompt} has batch size {len(negative_prompt)}, but `prompt`:"
-                    f" {prompt} has batch size {batch_size}. Please make sure that passed `negative_prompt` matches"
-                    " the batch size of `prompt`."
-                )
-            else:
-                uncond_tokens = negative_prompt
-
-            # textual inversion: procecss multi-vector tokens if necessary
-            if isinstance(self, TextualInversionLoaderMixin):
-                uncond_tokens = self.maybe_convert_prompt(uncond_tokens, self.tokenizer)
-
-            max_length = prompt_embeds.shape[1]
-            uncond_input = self.tokenizer(
-                uncond_tokens,
-                padding="max_length",
-                max_length=max_length,
-                truncation=True,
-                return_tensors="pt",
-            )
-
-            if hasattr(self.text_encoder.config, "use_attention_mask") and self.text_encoder.config.use_attention_mask:
-                attention_mask = uncond_input.attention_mask.to(device)
-            else:
-                attention_mask = None
-
-            negative_prompt_embeds = self.text_encoder(
-                uncond_input.input_ids.to(device),
-                attention_mask=attention_mask,
-            )
-            negative_prompt_embeds = negative_prompt_embeds[0]
-
-        if do_classifier_free_guidance:
-            # duplicate unconditional embeddings for each generation per prompt, using mps friendly method
-            seq_len = negative_prompt_embeds.shape[1]
-
-            negative_prompt_embeds = negative_prompt_embeds.to(dtype=self.text_encoder.dtype, device=device)
-
-            negative_prompt_embeds = negative_prompt_embeds.repeat(1, num_images_per_prompt, 1)
-            negative_prompt_embeds = negative_prompt_embeds.view(batch_size * num_images_per_prompt, seq_len, -1)
-
-            # For classifier free guidance, we need to do two forward passes.
-            # Here we concatenate the unconditional and text embeddings into a single batch
-            # to avoid doing two forward passes
-            prompt_embeds = torch.cat([negative_prompt_embeds, prompt_embeds])
-
-        return prompt_embeds
-
-    def run_safety_checker(self, image, device, dtype):
-        if self.safety_checker is None:
-            has_nsfw_concept = None
-        else:
-            if torch.is_tensor(image):
-                feature_extractor_input = self.image_processor.postprocess(image, output_type="pil")
-            else:
-                feature_extractor_input = self.image_processor.numpy_to_pil(image)
-            rgb_feature_extractor_input = feature_extractor_input[0]
-            safety_checker_input = self.feature_extractor(rgb_feature_extractor_input, return_tensors="pt").to(device)
-            image, has_nsfw_concept = self.safety_checker(
-                images=image, clip_input=safety_checker_input.pixel_values.to(dtype)
-            )
-        return image, has_nsfw_concept
-
-    # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline.prepare_extra_step_kwargs
-    def prepare_extra_step_kwargs(self, generator, eta):
-        # prepare extra kwargs for the scheduler step, since not all schedulers have the same signature
-        # eta (η) is only used with the DDIMScheduler, it will be ignored for other schedulers.
-        # eta corresponds to η in DDIM paper: https://arxiv.org/abs/2010.02502
-        # and should be between [0, 1]
-
-        accepts_eta = "eta" in set(inspect.signature(self.scheduler.step).parameters.keys())
-        extra_step_kwargs = {}
-        if accepts_eta:
-            extra_step_kwargs["eta"] = eta
-
-        # check if the scheduler accepts generator
-        accepts_generator = "generator" in set(inspect.signature(self.scheduler.step).parameters.keys())
-        if accepts_generator:
-            extra_step_kwargs["generator"] = generator
-        return extra_step_kwargs
-
-    # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline.check_inputs
-    def check_inputs(
-        self,
-        prompt,
-        height,
-        width,
-        callback_steps,
-        negative_prompt=None,
-        prompt_embeds=None,
-        negative_prompt_embeds=None,
-    ):
-        if height % 8 != 0 or width % 8 != 0:
-            raise ValueError(f"`height` and `width` have to be divisible by 8 but are {height} and {width}.")
-
-        if (callback_steps is None) or (
-            callback_steps is not None and (not isinstance(callback_steps, int) or callback_steps <= 0)
-        ):
-            raise ValueError(
-                f"`callback_steps` has to be a positive integer but is {callback_steps} of type"
-                f" {type(callback_steps)}."
-            )
-
-        if prompt is not None and prompt_embeds is not None:
-            raise ValueError(
-                f"Cannot forward both `prompt`: {prompt} and `prompt_embeds`: {prompt_embeds}. Please make sure to"
-                " only forward one of the two."
-            )
-        elif prompt is None and prompt_embeds is None:
-            raise ValueError(
-                "Provide either `prompt` or `prompt_embeds`. Cannot leave both `prompt` and `prompt_embeds` undefined."
-            )
-        elif prompt is not None and (not isinstance(prompt, str) and not isinstance(prompt, list)):
-            raise ValueError(f"`prompt` has to be of type `str` or `list` but is {type(prompt)}")
-
-        if negative_prompt is not None and negative_prompt_embeds is not None:
-            raise ValueError(
-                f"Cannot forward both `negative_prompt`: {negative_prompt} and `negative_prompt_embeds`:"
-                f" {negative_prompt_embeds}. Please make sure to only forward one of the two."
-            )
-
-        if prompt_embeds is not None and negative_prompt_embeds is not None:
-            if prompt_embeds.shape != negative_prompt_embeds.shape:
-                raise ValueError(
-                    "`prompt_embeds` and `negative_prompt_embeds` must have the same shape when passed directly, but"
-                    f" got: `prompt_embeds` {prompt_embeds.shape} != `negative_prompt_embeds`"
-                    f" {negative_prompt_embeds.shape}."
-                )
-
-    def prepare_latents(self, batch_size, num_channels_latents, height, width, dtype, device, generator, latents=None):
-        shape = (batch_size, num_channels_latents, height // self.vae_scale_factor, width // self.vae_scale_factor)
-        if isinstance(generator, list) and len(generator) != batch_size:
-            raise ValueError(
-                f"You have passed a list of generators of length {len(generator)}, but requested an effective batch"
-                f" size of {batch_size}. Make sure the batch size matches the length of the generators."
-            )
-
-        if latents is None:
-            latents = randn_tensor(shape, generator=generator, device=device, dtype=dtype)
-        else:
-            latents = latents.to(device)
-
-        # scale the initial noise by the standard deviation required by the scheduler
-        latents = latents * self.scheduler.init_noise_sigma
-        return latents
-
-    @torch.no_grad()
-    @replace_example_docstring(EXAMPLE_DOC_STRING)
-    def __call__(
-        self,
-        prompt: Union[str, List[str]] = None,
-        height: Optional[int] = None,
-        width: Optional[int] = None,
-        num_inference_steps: int = 49,
-        guidance_scale: float = 5.0,
-        negative_prompt: Optional[Union[str, List[str]]] = None,
-        num_images_per_prompt: Optional[int] = 1,
-        eta: float = 0.0,
-        generator: Optional[Union[torch.Generator, List[torch.Generator]]] = None,
-        latents: Optional[torch.FloatTensor] = None,
-        prompt_embeds: Optional[torch.FloatTensor] = None,
-        negative_prompt_embeds: Optional[torch.FloatTensor] = None,
-        output_type: Optional[str] = "pil",
-        return_dict: bool = True,
-        callback: Optional[Callable[[int, int, torch.FloatTensor], None]] = None,
-        callback_steps: int = 1,
-        cross_attention_kwargs: Optional[Dict[str, Any]] = None,
-    ):
-        r"""
-        The call function to the pipeline for generation.
-
-        Args:
-            prompt (`str` or `List[str]`, *optional*):
-                The prompt or prompts to guide image generation. If not defined, you need to pass `prompt_embeds`.
-            height (`int`, *optional*, defaults to `self.unet.config.sample_size * self.vae_scale_factor`):
-                The height in pixels of the generated image.
-            width (`int`, *optional*, defaults to `self.unet.config.sample_size * self.vae_scale_factor`):
-                The width in pixels of the generated image.
-            num_inference_steps (`int`, *optional*, defaults to 50):
-                The number of denoising steps. More denoising steps usually lead to a higher quality image at the
-                expense of slower inference.
-            guidance_scale (`float`, *optional*, defaults to 5.0):
-                A higher guidance scale value encourages the model to generate images closely linked to the text
-                `prompt` at the expense of lower image quality. Guidance scale is enabled when `guidance_scale > 1`.
-            negative_prompt (`str` or `List[str]`, *optional*):
-                The prompt or prompts to guide what to not include in image generation. If not defined, you need to
-                pass `negative_prompt_embeds` instead. Ignored when not using guidance (`guidance_scale < 1`).
-            num_images_per_prompt (`int`, *optional*, defaults to 1):
-                The number of images to generate per prompt.
-            eta (`float`, *optional*, defaults to 0.0):
-                Corresponds to parameter eta (η) from the [DDIM](https://arxiv.org/abs/2010.02502) paper. Only applies
-                to the [`~schedulers.DDIMScheduler`], and is ignored in other schedulers.
-            generator (`torch.Generator` or `List[torch.Generator]`, *optional*):
-                A [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) to make
-                generation deterministic.
-            latents (`torch.FloatTensor`, *optional*):
-                Pre-generated noisy latents sampled from a Gaussian distribution, to be used as inputs for image
-                generation. Can be used to tweak the same generation with different prompts. If not provided, a latents
-                tensor is generated by sampling using the supplied random `generator`.
-            prompt_embeds (`torch.FloatTensor`, *optional*):
-                Pre-generated text embeddings. Can be used to easily tweak text inputs (prompt weighting). If not
-                provided, text embeddings are generated from the `prompt` input argument.
-            negative_prompt_embeds (`torch.FloatTensor`, *optional*):
-                Pre-generated negative text embeddings. Can be used to easily tweak text inputs (prompt weighting). If
-                not provided, `negative_prompt_embeds` are generated from the `negative_prompt` input argument.
-            output_type (`str`, *optional*, defaults to `"pil"`):
-                The output format of the generated image. Choose between `PIL.Image` or `np.array`.
-            return_dict (`bool`, *optional*, defaults to `True`):
-                Whether or not to return a [`~pipelines.stable_diffusion.StableDiffusionPipelineOutput`] instead of a
-                plain tuple.
-            callback (`Callable`, *optional*):
-                A function that calls every `callback_steps` steps during inference. The function is called with the
-                following arguments: `callback(step: int, timestep: int, latents: torch.FloatTensor)`.
-            callback_steps (`int`, *optional*, defaults to 1):
-                The frequency at which the `callback` function is called. If not specified, the callback is called at
-                every step.
-            cross_attention_kwargs (`dict`, *optional*):
-                A kwargs dictionary that if specified is passed along to the [`AttentionProcessor`] as defined in
-                [`self.processor`](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/cross_attention.py).
-
-        Examples:
-
-        Returns:
-            [`~pipelines.stable_diffusion.StableDiffusionPipelineOutput`] or `tuple`:
-                If `return_dict` is `True`, [`~pipelines.stable_diffusion.StableDiffusionPipelineOutput`] is returned,
-                otherwise a `tuple` is returned where the first element is a list with the generated images and the
-                second element is a list of `bool`s indicating whether the corresponding generated image contains
-                "not-safe-for-work" (nsfw) content.
-        """
-        # 0. Default height and width to unet
-        height = height or self.unet.config.sample_size * self.vae_scale_factor
-        width = width or self.unet.config.sample_size * self.vae_scale_factor
-
-        # 1. Check inputs. Raise error if not correct
-        self.check_inputs(
-            prompt, height, width, callback_steps, negative_prompt, prompt_embeds, negative_prompt_embeds
-        )
-
-        # 2. Define call parameters
-        if prompt is not None and isinstance(prompt, str):
-            batch_size = 1
-        elif prompt is not None and isinstance(prompt, list):
-            batch_size = len(prompt)
-        else:
-            batch_size = prompt_embeds.shape[0]
-
-        device = self._execution_device
-        # here `guidance_scale` is defined analog to the guidance weight `w` of equation (2)
-        # of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1`
-        # corresponds to doing no classifier free guidance.
-        do_classifier_free_guidance = guidance_scale > 1.0
-
-        # 3. Encode input prompt
-        prompt_embeds = self._encode_prompt(
-            prompt,
-            device,
-            num_images_per_prompt,
-            do_classifier_free_guidance,
-            negative_prompt,
-            prompt_embeds=prompt_embeds,
-            negative_prompt_embeds=negative_prompt_embeds,
-        )
-
-        # 4. Prepare timesteps
-        self.scheduler.set_timesteps(num_inference_steps, device=device)
-        timesteps = self.scheduler.timesteps
-
-        # 5. Prepare latent variables
-        num_channels_latents = self.unet.config.in_channels
-        latents = self.prepare_latents(
-            batch_size * num_images_per_prompt,
-            num_channels_latents,
-            height,
-            width,
-            prompt_embeds.dtype,
-            device,
-            generator,
-            latents,
-        )
-
-        # 6. Prepare extra step kwargs. TODO: Logic should ideally just be moved out of the pipeline
-        extra_step_kwargs = self.prepare_extra_step_kwargs(generator, eta)
-
-        # 7. Denoising loop
-        num_warmup_steps = len(timesteps) - num_inference_steps * self.scheduler.order
-        with self.progress_bar(total=num_inference_steps) as progress_bar:
-            for i, t in enumerate(timesteps):
-                # expand the latents if we are doing classifier free guidance
-                latent_model_input = torch.cat([latents] * 2) if do_classifier_free_guidance else latents
-                latent_model_input = self.scheduler.scale_model_input(latent_model_input, t)
-
-                # predict the noise residual
-                noise_pred = self.unet(
-                    latent_model_input,
-                    t,
-                    encoder_hidden_states=prompt_embeds,
-                    cross_attention_kwargs=cross_attention_kwargs,
-                    return_dict=False,
-                )[0]
-
-                # perform guidance
-                if do_classifier_free_guidance:
-                    noise_pred_uncond, noise_pred_text = noise_pred.chunk(2)
-                    noise_pred = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)
-
-                # compute the previous noisy sample x_t -> x_t-1
-                latents = self.scheduler.step(noise_pred, t, latents, **extra_step_kwargs, return_dict=False)[0]
-
-                # call the callback, if provided
-                if i == len(timesteps) - 1 or ((i + 1) > num_warmup_steps and (i + 1) % self.scheduler.order == 0):
-                    progress_bar.update()
-                    if callback is not None and i % callback_steps == 0:
-                        callback(i, t, latents)
-
-        if not output_type == "latent":
-            image = self.vae.decode(latents / self.vae.config.scaling_factor, return_dict=False)[0]
-            image, has_nsfw_concept = self.run_safety_checker(image, device, prompt_embeds.dtype)
-        else:
-            image = latents
-            has_nsfw_concept = None
-
-        if has_nsfw_concept is None:
-            do_denormalize = [True] * image.shape[0]
-        else:
-            do_denormalize = [not has_nsfw for has_nsfw in has_nsfw_concept]
-
-        rgb, depth = self.image_processor.postprocess(image, output_type=output_type, do_denormalize=do_denormalize)
-
-        # Offload last model to CPU
-        if hasattr(self, "final_offload_hook") and self.final_offload_hook is not None:
-            self.final_offload_hook.offload()
-
-        if not return_dict:
-            return ((rgb, depth), has_nsfw_concept)
-
-        return LDM3DPipelineOutput(rgb=rgb, depth=depth, nsfw_content_detected=has_nsfw_concept)

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

@@ -1,462 +0,0 @@
-# Copyright 2023 Zhejiang University Team and The HuggingFace Team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-# DISCLAIMER: This file is strongly influenced by https://github.com/ermongroup/ddim
-
-import math
-from typing import List, Optional, Tuple, Union
-
-import numpy as np
-import torch
-
-from ..configuration_utils import ConfigMixin, register_to_config
-from .scheduling_utils import KarrasDiffusionSchedulers, SchedulerMixin, SchedulerOutput
-
-
-# Copied from diffusers.schedulers.scheduling_ddpm.betas_for_alpha_bar
-def betas_for_alpha_bar(
-    num_diffusion_timesteps,
-    max_beta=0.999,
-    alpha_transform_type="cosine",
-):
-    """
-    Create a beta schedule that discretizes the given alpha_t_bar function, which defines the cumulative product of
-    (1-beta) over time from t = [0,1].
-
-    Contains a function alpha_bar that takes an argument t and transforms it to the cumulative product of (1-beta) up
-    to that part of the diffusion process.
-
-
-    Args:
-        num_diffusion_timesteps (`int`): the number of betas to produce.
-        max_beta (`float`): the maximum beta to use; use values lower than 1 to
-                     prevent singularities.
-        alpha_transform_type (`str`, *optional*, default to `cosine`): the type of noise schedule for alpha_bar.
-                     Choose from `cosine` or `exp`
-
-    Returns:
-        betas (`np.ndarray`): the betas used by the scheduler to step the model outputs
-    """
-    if alpha_transform_type == "cosine":
-
-        def alpha_bar_fn(t):
-            return math.cos((t + 0.008) / 1.008 * math.pi / 2) ** 2
-
-    elif alpha_transform_type == "exp":
-
-        def alpha_bar_fn(t):
-            return math.exp(t * -12.0)
-
-    else:
-        raise ValueError(f"Unsupported alpha_tranform_type: {alpha_transform_type}")
-
-    betas = []
-    for i in range(num_diffusion_timesteps):
-        t1 = i / num_diffusion_timesteps
-        t2 = (i + 1) / num_diffusion_timesteps
-        betas.append(min(1 - alpha_bar_fn(t2) / alpha_bar_fn(t1), max_beta))
-    return torch.tensor(betas, dtype=torch.float32)
-
-
-class PNDMScheduler(SchedulerMixin, ConfigMixin):
-    """
-    Pseudo numerical methods for diffusion models (PNDM) proposes using more advanced ODE integration techniques,
-    namely Runge-Kutta method and a linear multi-step method.
-
-    [`~ConfigMixin`] takes care of storing all config attributes that are passed in the scheduler's `__init__`
-    function, such as `num_train_timesteps`. They can be accessed via `scheduler.config.num_train_timesteps`.
-    [`SchedulerMixin`] provides general loading and saving functionality via the [`SchedulerMixin.save_pretrained`] and
-    [`~SchedulerMixin.from_pretrained`] functions.
-
-    For more details, see the original paper: https://arxiv.org/abs/2202.09778
-
-    Args:
-        num_train_timesteps (`int`): number of diffusion steps used to train the model.
-        beta_start (`float`): the starting `beta` value of inference.
-        beta_end (`float`): the final `beta` value.
-        beta_schedule (`str`):
-            the beta schedule, a mapping from a beta range to a sequence of betas for stepping the model. Choose from
-            `linear`, `scaled_linear`, or `squaredcos_cap_v2`.
-        trained_betas (`np.ndarray`, optional):
-            option to pass an array of betas directly to the constructor to bypass `beta_start`, `beta_end` etc.
-        skip_prk_steps (`bool`):
-            allows the scheduler to skip the Runge-Kutta steps that are defined in the original paper as being required
-            before plms steps; defaults to `False`.
-        set_alpha_to_one (`bool`, default `False`):
-            each diffusion step uses the value of alphas product at that step and at the previous one. For the final
-            step there is no previous alpha. When this option is `True` the previous alpha product is fixed to `1`,
-            otherwise it uses the value of alpha at step 0.
-        prediction_type (`str`, default `epsilon`, optional):
-            prediction type of the scheduler function, one of `epsilon` (predicting the noise of the diffusion process)
-            or `v_prediction` (see section 2.4 https://imagen.research.google/video/paper.pdf)
-        timestep_spacing (`str`, default `"leading"`):
-            The way the timesteps should be scaled. Refer to Table 2. of [Common Diffusion Noise Schedules and Sample
-            Steps are Flawed](https://arxiv.org/abs/2305.08891) for more information.
-        steps_offset (`int`, default `0`):
-            an offset added to the inference steps. You can use a combination of `offset=1` and
-            `set_alpha_to_one=False`, to make the last step use step 0 for the previous alpha product, as done in
-            stable diffusion.
-    """
-
-    _compatibles = [e.name for e in KarrasDiffusionSchedulers]
-    order = 1
-
-    @register_to_config
-    def __init__(
-        self,
-        num_train_timesteps: int = 1000,
-        beta_start: float = 0.0001,
-        beta_end: float = 0.02,
-        beta_schedule: str = "linear",
-        trained_betas: Optional[Union[np.ndarray, List[float]]] = None,
-        skip_prk_steps: bool = False,
-        set_alpha_to_one: bool = False,
-        prediction_type: str = "epsilon",
-        timestep_spacing: str = "leading",
-        steps_offset: int = 0,
-    ):
-        if trained_betas is not None:
-            self.betas = torch.tensor(trained_betas, dtype=torch.float32)
-        elif beta_schedule == "linear":
-            self.betas = torch.linspace(beta_start, beta_end, num_train_timesteps, dtype=torch.float32)
-        elif beta_schedule == "scaled_linear":
-            # this schedule is very specific to the latent diffusion model.
-            self.betas = (
-                torch.linspace(beta_start**0.5, beta_end**0.5, num_train_timesteps, dtype=torch.float32) ** 2
-            )
-        elif beta_schedule == "squaredcos_cap_v2":
-            # Glide cosine schedule
-            self.betas = betas_for_alpha_bar(num_train_timesteps)
-        else:
-            raise NotImplementedError(f"{beta_schedule} does is not implemented for {self.__class__}")
-
-        self.alphas = 1.0 - self.betas
-        self.alphas_cumprod = torch.cumprod(self.alphas, dim=0)
-
-        self.final_alpha_cumprod = torch.tensor(1.0) if set_alpha_to_one else self.alphas_cumprod[0]
-
-        # standard deviation of the initial noise distribution
-        self.init_noise_sigma = 1.0
-
-        # For now we only support F-PNDM, i.e. the runge-kutta method
-        # For more information on the algorithm please take a look at the paper: https://arxiv.org/pdf/2202.09778.pdf
-        # mainly at formula (9), (12), (13) and the Algorithm 2.
-        self.pndm_order = 4
-
-        # running values
-        self.cur_model_output = 0
-        self.counter = 0
-        self.cur_sample = None
-        self.ets = []
-
-        # setable values
-        self.num_inference_steps = None
-        self._timesteps = np.arange(0, num_train_timesteps)[::-1].copy()
-        self.prk_timesteps = None
-        self.plms_timesteps = None
-        self.timesteps = None
-
-    def set_timesteps(self, num_inference_steps: int, device: Union[str, torch.device] = None):
-        """
-        Sets the discrete timesteps used for the diffusion chain. Supporting function to be run before inference.
-
-        Args:
-            num_inference_steps (`int`):
-                the number of diffusion steps used when generating samples with a pre-trained model.
-        """
-
-        self.num_inference_steps = num_inference_steps
-        # "linspace", "leading", "trailing" corresponds to annotation of Table 2. of https://arxiv.org/abs/2305.08891
-        if self.config.timestep_spacing == "linspace":
-            self._timesteps = (
-                np.linspace(0, self.config.num_train_timesteps - 1, num_inference_steps).round().astype(np.int64)
-            )
-        elif self.config.timestep_spacing == "leading":
-            step_ratio = self.config.num_train_timesteps // self.num_inference_steps
-            # creates integer timesteps by multiplying by ratio
-            # casting to int to avoid issues when num_inference_step is power of 3
-            self._timesteps = (np.arange(0, num_inference_steps) * step_ratio).round()
-            self._timesteps += self.config.steps_offset
-        elif self.config.timestep_spacing == "trailing":
-            step_ratio = self.config.num_train_timesteps / self.num_inference_steps
-            # creates integer timesteps by multiplying by ratio
-            # casting to int to avoid issues when num_inference_step is power of 3
-            self._timesteps = np.round(np.arange(self.config.num_train_timesteps, 0, -step_ratio))[::-1].astype(
-                np.int64
-            )
-            self._timesteps -= 1
-        else:
-            raise ValueError(
-                f"{self.config.timestep_spacing} is not supported. Please make sure to choose one of 'linspace', 'leading' or 'trailing'."
-            )
-
-        if self.config.skip_prk_steps:
-            # for some models like stable diffusion the prk steps can/should be skipped to
-            # produce better results. When using PNDM with `self.config.skip_prk_steps` the implementation
-            # is based on crowsonkb's PLMS sampler implementation: https://github.com/CompVis/latent-diffusion/pull/51
-            self.prk_timesteps = np.array([])
-            self.plms_timesteps = np.concatenate([self._timesteps[:-1], self._timesteps[-2:-1], self._timesteps[-1:]])[
-                ::-1
-            ].copy()
-        else:
-            prk_timesteps = np.array(self._timesteps[-self.pndm_order :]).repeat(2) + np.tile(
-                np.array([0, self.config.num_train_timesteps // num_inference_steps // 2]), self.pndm_order
-            )
-            self.prk_timesteps = (prk_timesteps[:-1].repeat(2)[1:-1])[::-1].copy()
-            self.plms_timesteps = self._timesteps[:-3][
-                ::-1
-            ].copy()  # we copy to avoid having negative strides which are not supported by torch.from_numpy
-
-        timesteps = np.concatenate([self.prk_timesteps, self.plms_timesteps]).astype(np.int64)
-        self.timesteps = torch.from_numpy(timesteps).to(device)
-
-        self.ets = []
-        self.counter = 0
-        self.cur_model_output = 0
-
-    def step(
-        self,
-        model_output: torch.FloatTensor,
-        timestep: int,
-        sample: torch.FloatTensor,
-        return_dict: bool = True,
-    ) -> Union[SchedulerOutput, Tuple]:
-        """
-        Predict the sample at the previous timestep by reversing the SDE. Core function to propagate the diffusion
-        process from the learned model outputs (most often the predicted noise).
-
-        This function calls `step_prk()` or `step_plms()` depending on the internal variable `counter`.
-
-        Args:
-            model_output (`torch.FloatTensor`): direct output from learned diffusion model.
-            timestep (`int`): current discrete timestep in the diffusion chain.
-            sample (`torch.FloatTensor`):
-                current instance of sample being created by diffusion process.
-            return_dict (`bool`): option for returning tuple rather than SchedulerOutput class
-
-        Returns:
-            [`~schedulers.scheduling_utils.SchedulerOutput`] or `tuple`:
-            [`~schedulers.scheduling_utils.SchedulerOutput`] if `return_dict` is True, otherwise a `tuple`. When
-            returning a tuple, the first element is the sample tensor.
-
-        """
-        if self.counter < len(self.prk_timesteps) and not self.config.skip_prk_steps:
-            return self.step_prk(model_output=model_output, timestep=timestep, sample=sample, return_dict=return_dict)
-        else:
-            return self.step_plms(model_output=model_output, timestep=timestep, sample=sample, return_dict=return_dict)
-
-    def step_prk(
-        self,
-        model_output: torch.FloatTensor,
-        timestep: int,
-        sample: torch.FloatTensor,
-        return_dict: bool = True,
-    ) -> Union[SchedulerOutput, Tuple]:
-        """
-        Step function propagating the sample with the Runge-Kutta method. RK takes 4 forward passes to approximate the
-        solution to the differential equation.
-
-        Args:
-            model_output (`torch.FloatTensor`): direct output from learned diffusion model.
-            timestep (`int`): current discrete timestep in the diffusion chain.
-            sample (`torch.FloatTensor`):
-                current instance of sample being created by diffusion process.
-            return_dict (`bool`): option for returning tuple rather than SchedulerOutput class
-
-        Returns:
-            [`~scheduling_utils.SchedulerOutput`] or `tuple`: [`~scheduling_utils.SchedulerOutput`] if `return_dict` is
-            True, otherwise a `tuple`. When returning a tuple, the first element is the sample tensor.
-
-        """
-        if self.num_inference_steps is None:
-            raise ValueError(
-                "Number of inference steps is 'None', you need to run 'set_timesteps' after creating the scheduler"
-            )
-
-        diff_to_prev = 0 if self.counter % 2 else self.config.num_train_timesteps // self.num_inference_steps // 2
-        prev_timestep = timestep - diff_to_prev
-        timestep = self.prk_timesteps[self.counter // 4 * 4]
-
-        if self.counter % 4 == 0:
-            self.cur_model_output += 1 / 6 * model_output
-            self.ets.append(model_output)
-            self.cur_sample = sample
-        elif (self.counter - 1) % 4 == 0:
-            self.cur_model_output += 1 / 3 * model_output
-        elif (self.counter - 2) % 4 == 0:
-            self.cur_model_output += 1 / 3 * model_output
-        elif (self.counter - 3) % 4 == 0:
-            model_output = self.cur_model_output + 1 / 6 * model_output
-            self.cur_model_output = 0
-
-        # cur_sample should not be `None`
-        cur_sample = self.cur_sample if self.cur_sample is not None else sample
-
-        prev_sample = self._get_prev_sample(cur_sample, timestep, prev_timestep, model_output)
-        self.counter += 1
-
-        if not return_dict:
-            return (prev_sample,)
-
-        return SchedulerOutput(prev_sample=prev_sample)
-
-    def step_plms(
-        self,
-        model_output: torch.FloatTensor,
-        timestep: int,
-        sample: torch.FloatTensor,
-        return_dict: bool = True,
-    ) -> Union[SchedulerOutput, Tuple]:
-        """
-        Step function propagating the sample with the linear multi-step method. This has one forward pass with multiple
-        times to approximate the solution.
-
-        Args:
-            model_output (`torch.FloatTensor`): direct output from learned diffusion model.
-            timestep (`int`): current discrete timestep in the diffusion chain.
-            sample (`torch.FloatTensor`):
-                current instance of sample being created by diffusion process.
-            return_dict (`bool`): option for returning tuple rather than SchedulerOutput class
-
-        Returns:
-            [`~scheduling_utils.SchedulerOutput`] or `tuple`: [`~scheduling_utils.SchedulerOutput`] if `return_dict` is
-            True, otherwise a `tuple`. When returning a tuple, the first element is the sample tensor.
-
-        """
-        if self.num_inference_steps is None:
-            raise ValueError(
-                "Number of inference steps is 'None', you need to run 'set_timesteps' after creating the scheduler"
-            )
-
-        if not self.config.skip_prk_steps and len(self.ets) < 3:
-            raise ValueError(
-                f"{self.__class__} can only be run AFTER scheduler has been run "
-                "in 'prk' mode for at least 12 iterations "
-                "See: https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pipeline_pndm.py "
-                "for more information."
-            )
-
-        prev_timestep = timestep - self.config.num_train_timesteps // self.num_inference_steps
-
-        if self.counter != 1:
-            self.ets = self.ets[-3:]
-            self.ets.append(model_output)
-        else:
-            prev_timestep = timestep
-            timestep = timestep + self.config.num_train_timesteps // self.num_inference_steps
-
-        if len(self.ets) == 1 and self.counter == 0:
-            model_output = model_output
-            self.cur_sample = sample
-        elif len(self.ets) == 1 and self.counter == 1:
-            model_output = (model_output + self.ets[-1]) / 2
-            sample = self.cur_sample
-            self.cur_sample = None
-        elif len(self.ets) == 2:
-            model_output = (3 * self.ets[-1] - self.ets[-2]) / 2
-        elif len(self.ets) == 3:
-            model_output = (23 * self.ets[-1] - 16 * self.ets[-2] + 5 * self.ets[-3]) / 12
-        else:
-            model_output = (1 / 24) * (55 * self.ets[-1] - 59 * self.ets[-2] + 37 * self.ets[-3] - 9 * self.ets[-4])
-
-        prev_sample = self._get_prev_sample(sample, timestep, prev_timestep, model_output)
-        self.counter += 1
-
-        if not return_dict:
-            return (prev_sample,)
-
-        return SchedulerOutput(prev_sample=prev_sample)
-
-    def scale_model_input(self, sample: torch.FloatTensor, *args, **kwargs) -> torch.FloatTensor:
-        """
-        Ensures interchangeability with schedulers that need to scale the denoising model input depending on the
-        current timestep.
-
-        Args:
-            sample (`torch.FloatTensor`): input sample
-
-        Returns:
-            `torch.FloatTensor`: scaled input sample
-        """
-        return sample
-
-    def _get_prev_sample(self, sample, timestep, prev_timestep, model_output):
-        # See formula (9) of PNDM paper https://arxiv.org/pdf/2202.09778.pdf
-        # this function computes x_(t−δ) using the formula of (9)
-        # Note that x_t needs to be added to both sides of the equation
-
-        # Notation (<variable name> -> <name in paper>
-        # alpha_prod_t -> α_t
-        # alpha_prod_t_prev -> α_(t−δ)
-        # beta_prod_t -> (1 - α_t)
-        # beta_prod_t_prev -> (1 - α_(t−δ))
-        # sample -> x_t
-        # model_output -> e_θ(x_t, t)
-        # prev_sample -> x_(t−δ)
-        alpha_prod_t = self.alphas_cumprod[timestep]
-        alpha_prod_t_prev = self.alphas_cumprod[prev_timestep] if prev_timestep >= 0 else self.final_alpha_cumprod
-        beta_prod_t = 1 - alpha_prod_t
-        beta_prod_t_prev = 1 - alpha_prod_t_prev
-
-        if self.config.prediction_type == "v_prediction":
-            model_output = (alpha_prod_t**0.5) * model_output + (beta_prod_t**0.5) * sample
-        elif self.config.prediction_type != "epsilon":
-            raise ValueError(
-                f"prediction_type given as {self.config.prediction_type} must be one of `epsilon` or `v_prediction`"
-            )
-
-        # corresponds to (α_(t−δ) - α_t) divided by
-        # denominator of x_t in formula (9) and plus 1
-        # Note: (α_(t−δ) - α_t) / (sqrt(α_t) * (sqrt(α_(t−δ)) + sqr(α_t))) =
-        # sqrt(α_(t−δ)) / sqrt(α_t))
-        sample_coeff = (alpha_prod_t_prev / alpha_prod_t) ** (0.5)
-
-        # corresponds to denominator of e_θ(x_t, t) in formula (9)
-        model_output_denom_coeff = alpha_prod_t * beta_prod_t_prev ** (0.5) + (
-            alpha_prod_t * beta_prod_t * alpha_prod_t_prev
-        ) ** (0.5)
-
-        # full formula (9)
-        prev_sample = (
-            sample_coeff * sample - (alpha_prod_t_prev - alpha_prod_t) * model_output / model_output_denom_coeff
-        )
-
-        return prev_sample
-
-    # Copied from diffusers.schedulers.scheduling_ddpm.DDPMScheduler.add_noise
-    def add_noise(
-        self,
-        original_samples: torch.FloatTensor,
-        noise: torch.FloatTensor,
-        timesteps: torch.IntTensor,
-    ) -> torch.FloatTensor:
-        # Make sure alphas_cumprod and timestep have same device and dtype as original_samples
-        alphas_cumprod = self.alphas_cumprod.to(device=original_samples.device, dtype=original_samples.dtype)
-        timesteps = timesteps.to(original_samples.device)
-
-        sqrt_alpha_prod = alphas_cumprod[timesteps] ** 0.5
-        sqrt_alpha_prod = sqrt_alpha_prod.flatten()
-        while len(sqrt_alpha_prod.shape) < len(original_samples.shape):
-            sqrt_alpha_prod = sqrt_alpha_prod.unsqueeze(-1)
-
-        sqrt_one_minus_alpha_prod = (1 - alphas_cumprod[timesteps]) ** 0.5
-        sqrt_one_minus_alpha_prod = sqrt_one_minus_alpha_prod.flatten()
-        while len(sqrt_one_minus_alpha_prod.shape) < len(original_samples.shape):
-            sqrt_one_minus_alpha_prod = sqrt_one_minus_alpha_prod.unsqueeze(-1)
-
-        noisy_samples = sqrt_alpha_prod * original_samples + sqrt_one_minus_alpha_prod * noise
-        return noisy_samples
-
-    def __len__(self):
-        return self.config.num_train_timesteps

spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/src/diffusers/utils/logging.py

@@ -1,339 +0,0 @@
-# coding=utf-8
-# Copyright 2023 Optuna, Hugging Face
-#
-# 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.
-""" Logging utilities."""
-
-import logging
-import os
-import sys
-import threading
-from logging import (
-    CRITICAL,  # NOQA
-    DEBUG,  # NOQA
-    ERROR,  # NOQA
-    FATAL,  # NOQA
-    INFO,  # NOQA
-    NOTSET,  # NOQA
-    WARN,  # NOQA
-    WARNING,  # NOQA
-)
-from typing import Optional
-
-from tqdm import auto as tqdm_lib
-
-
-_lock = threading.Lock()
-_default_handler: Optional[logging.Handler] = None
-
-log_levels = {
-    "debug": logging.DEBUG,
-    "info": logging.INFO,
-    "warning": logging.WARNING,
-    "error": logging.ERROR,
-    "critical": logging.CRITICAL,
-}
-
-_default_log_level = logging.WARNING
-
-_tqdm_active = True
-
-
-def _get_default_logging_level():
-    """
-    If DIFFUSERS_VERBOSITY env var is set to one of the valid choices return that as the new default level. If it is
-    not - fall back to `_default_log_level`
-    """
-    env_level_str = os.getenv("DIFFUSERS_VERBOSITY", None)
-    if env_level_str:
-        if env_level_str in log_levels:
-            return log_levels[env_level_str]
-        else:
-            logging.getLogger().warning(
-                f"Unknown option DIFFUSERS_VERBOSITY={env_level_str}, "
-                f"has to be one of: { ', '.join(log_levels.keys()) }"
-            )
-    return _default_log_level
-
-
-def _get_library_name() -> str:
-    return __name__.split(".")[0]
-
-
-def _get_library_root_logger() -> logging.Logger:
-    return logging.getLogger(_get_library_name())
-
-
-def _configure_library_root_logger() -> None:
-    global _default_handler
-
-    with _lock:
-        if _default_handler:
-            # This library has already configured the library root logger.
-            return
-        _default_handler = logging.StreamHandler()  # Set sys.stderr as stream.
-        _default_handler.flush = sys.stderr.flush
-
-        # Apply our default configuration to the library root logger.
-        library_root_logger = _get_library_root_logger()
-        library_root_logger.addHandler(_default_handler)
-        library_root_logger.setLevel(_get_default_logging_level())
-        library_root_logger.propagate = False
-
-
-def _reset_library_root_logger() -> None:
-    global _default_handler
-
-    with _lock:
-        if not _default_handler:
-            return
-
-        library_root_logger = _get_library_root_logger()
-        library_root_logger.removeHandler(_default_handler)
-        library_root_logger.setLevel(logging.NOTSET)
-        _default_handler = None
-
-
-def get_log_levels_dict():
-    return log_levels
-
-
-def get_logger(name: Optional[str] = None) -> logging.Logger:
-    """
-    Return a logger with the specified name.
-
-    This function is not supposed to be directly accessed unless you are writing a custom diffusers module.
-    """
-
-    if name is None:
-        name = _get_library_name()
-
-    _configure_library_root_logger()
-    return logging.getLogger(name)
-
-
-def get_verbosity() -> int:
-    """
-    Return the current level for the 🤗 Diffusers' root logger as an `int`.
-
-    Returns:
-        `int`:
-            Logging level integers which can be one of:
-
-            - `50`: `diffusers.logging.CRITICAL` or `diffusers.logging.FATAL`
-            - `40`: `diffusers.logging.ERROR`
-            - `30`: `diffusers.logging.WARNING` or `diffusers.logging.WARN`
-            - `20`: `diffusers.logging.INFO`
-            - `10`: `diffusers.logging.DEBUG`
-
-    """
-
-    _configure_library_root_logger()
-    return _get_library_root_logger().getEffectiveLevel()
-
-
-def set_verbosity(verbosity: int) -> None:
-    """
-    Set the verbosity level for the 🤗 Diffusers' root logger.
-
-    Args:
-        verbosity (`int`):
-            Logging level which can be one of:
-
-            - `diffusers.logging.CRITICAL` or `diffusers.logging.FATAL`
-            - `diffusers.logging.ERROR`
-            - `diffusers.logging.WARNING` or `diffusers.logging.WARN`
-            - `diffusers.logging.INFO`
-            - `diffusers.logging.DEBUG`
-    """
-
-    _configure_library_root_logger()
-    _get_library_root_logger().setLevel(verbosity)
-
-
-def set_verbosity_info():
-    """Set the verbosity to the `INFO` level."""
-    return set_verbosity(INFO)
-
-
-def set_verbosity_warning():
-    """Set the verbosity to the `WARNING` level."""
-    return set_verbosity(WARNING)
-
-
-def set_verbosity_debug():
-    """Set the verbosity to the `DEBUG` level."""
-    return set_verbosity(DEBUG)
-
-
-def set_verbosity_error():
-    """Set the verbosity to the `ERROR` level."""
-    return set_verbosity(ERROR)
-
-
-def disable_default_handler() -> None:
-    """Disable the default handler of the 🤗 Diffusers' root logger."""
-
-    _configure_library_root_logger()
-
-    assert _default_handler is not None
-    _get_library_root_logger().removeHandler(_default_handler)
-
-
-def enable_default_handler() -> None:
-    """Enable the default handler of the 🤗 Diffusers' root logger."""
-
-    _configure_library_root_logger()
-
-    assert _default_handler is not None
-    _get_library_root_logger().addHandler(_default_handler)
-
-
-def add_handler(handler: logging.Handler) -> None:
-    """adds a handler to the HuggingFace Diffusers' root logger."""
-
-    _configure_library_root_logger()
-
-    assert handler is not None
-    _get_library_root_logger().addHandler(handler)
-
-
-def remove_handler(handler: logging.Handler) -> None:
-    """removes given handler from the HuggingFace Diffusers' root logger."""
-
-    _configure_library_root_logger()
-
-    assert handler is not None and handler not in _get_library_root_logger().handlers
-    _get_library_root_logger().removeHandler(handler)
-
-
-def disable_propagation() -> None:
-    """
-    Disable propagation of the library log outputs. Note that log propagation is disabled by default.
-    """
-
-    _configure_library_root_logger()
-    _get_library_root_logger().propagate = False
-
-
-def enable_propagation() -> None:
-    """
-    Enable propagation of the library log outputs. Please disable the HuggingFace Diffusers' default handler to prevent
-    double logging if the root logger has been configured.
-    """
-
-    _configure_library_root_logger()
-    _get_library_root_logger().propagate = True
-
-
-def enable_explicit_format() -> None:
-    """
-    Enable explicit formatting for every 🤗 Diffusers' logger. The explicit formatter is as follows:
-    ```
-    [LEVELNAME|FILENAME|LINE NUMBER] TIME >> MESSAGE
-    ```
-    All handlers currently bound to the root logger are affected by this method.
-    """
-    handlers = _get_library_root_logger().handlers
-
-    for handler in handlers:
-        formatter = logging.Formatter("[%(levelname)s|%(filename)s:%(lineno)s] %(asctime)s >> %(message)s")
-        handler.setFormatter(formatter)
-
-
-def reset_format() -> None:
-    """
-    Resets the formatting for 🤗 Diffusers' loggers.
-
-    All handlers currently bound to the root logger are affected by this method.
-    """
-    handlers = _get_library_root_logger().handlers
-
-    for handler in handlers:
-        handler.setFormatter(None)
-
-
-def warning_advice(self, *args, **kwargs):
-    """
-    This method is identical to `logger.warning()`, but if env var DIFFUSERS_NO_ADVISORY_WARNINGS=1 is set, this
-    warning will not be printed
-    """
-    no_advisory_warnings = os.getenv("DIFFUSERS_NO_ADVISORY_WARNINGS", False)
-    if no_advisory_warnings:
-        return
-    self.warning(*args, **kwargs)
-
-
-logging.Logger.warning_advice = warning_advice
-
-
-class EmptyTqdm:
-    """Dummy tqdm which doesn't do anything."""
-
-    def __init__(self, *args, **kwargs):  # pylint: disable=unused-argument
-        self._iterator = args[0] if args else None
-
-    def __iter__(self):
-        return iter(self._iterator)
-
-    def __getattr__(self, _):
-        """Return empty function."""
-
-        def empty_fn(*args, **kwargs):  # pylint: disable=unused-argument
-            return
-
-        return empty_fn
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, type_, value, traceback):
-        return
-
-
-class _tqdm_cls:
-    def __call__(self, *args, **kwargs):
-        if _tqdm_active:
-            return tqdm_lib.tqdm(*args, **kwargs)
-        else:
-            return EmptyTqdm(*args, **kwargs)
-
-    def set_lock(self, *args, **kwargs):
-        self._lock = None
-        if _tqdm_active:
-            return tqdm_lib.tqdm.set_lock(*args, **kwargs)
-
-    def get_lock(self):
-        if _tqdm_active:
-            return tqdm_lib.tqdm.get_lock()
-
-
-tqdm = _tqdm_cls()
-
-
-def is_progress_bar_enabled() -> bool:
-    """Return a boolean indicating whether tqdm progress bars are enabled."""
-    global _tqdm_active
-    return bool(_tqdm_active)
-
-
-def enable_progress_bar():
-    """Enable tqdm progress bar."""
-    global _tqdm_active
-    _tqdm_active = True
-
-
-def disable_progress_bar():
-    """Disable tqdm progress bar."""
-    global _tqdm_active
-    _tqdm_active = False

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

@@ -1,399 +0,0 @@
-# coding=utf-8
-# Copyright 2023 HuggingFace Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import gc
-import random
-import tempfile
-import unittest
-
-import numpy as np
-import torch
-from PIL import Image
-from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer
-
-from diffusers import (
-    AutoencoderKL,
-    DDIMInverseScheduler,
-    DDIMScheduler,
-    DPMSolverMultistepInverseScheduler,
-    DPMSolverMultistepScheduler,
-    StableDiffusionDiffEditPipeline,
-    UNet2DConditionModel,
-)
-from diffusers.utils import load_image, slow
-from diffusers.utils.testing_utils import enable_full_determinism, floats_tensor, require_torch_gpu, torch_device
-
-from ..pipeline_params import TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS, TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
-from ..test_pipelines_common import PipelineLatentTesterMixin, PipelineTesterMixin
-
-
-enable_full_determinism()
-
-
-class StableDiffusionDiffEditPipelineFastTests(PipelineLatentTesterMixin, PipelineTesterMixin, unittest.TestCase):
-    pipeline_class = StableDiffusionDiffEditPipeline
-    params = TEXT_GUIDED_IMAGE_INPAINTING_PARAMS - {"height", "width", "image"} | {"image_latents"}
-    batch_params = TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS - {"image"} | {"image_latents"}
-    image_params = frozenset(
-        []
-    )  # TO-DO: update image_params once pipeline is refactored with VaeImageProcessor.preprocess
-    image_latents_params = frozenset([])
-
-    def get_dummy_components(self):
-        torch.manual_seed(0)
-        unet = UNet2DConditionModel(
-            block_out_channels=(32, 64),
-            layers_per_block=2,
-            sample_size=32,
-            in_channels=4,
-            out_channels=4,
-            down_block_types=("DownBlock2D", "CrossAttnDownBlock2D"),
-            up_block_types=("CrossAttnUpBlock2D", "UpBlock2D"),
-            cross_attention_dim=32,
-            # SD2-specific config below
-            attention_head_dim=(2, 4),
-            use_linear_projection=True,
-        )
-        scheduler = DDIMScheduler(
-            beta_start=0.00085,
-            beta_end=0.012,
-            beta_schedule="scaled_linear",
-            clip_sample=False,
-            set_alpha_to_one=False,
-        )
-        inverse_scheduler = DDIMInverseScheduler(
-            beta_start=0.00085,
-            beta_end=0.012,
-            beta_schedule="scaled_linear",
-            clip_sample=False,
-            set_alpha_to_zero=False,
-        )
-        torch.manual_seed(0)
-        vae = AutoencoderKL(
-            block_out_channels=[32, 64],
-            in_channels=3,
-            out_channels=3,
-            down_block_types=["DownEncoderBlock2D", "DownEncoderBlock2D"],
-            up_block_types=["UpDecoderBlock2D", "UpDecoderBlock2D"],
-            latent_channels=4,
-            sample_size=128,
-        )
-        torch.manual_seed(0)
-        text_encoder_config = CLIPTextConfig(
-            bos_token_id=0,
-            eos_token_id=2,
-            hidden_size=32,
-            intermediate_size=37,
-            layer_norm_eps=1e-05,
-            num_attention_heads=4,
-            num_hidden_layers=5,
-            pad_token_id=1,
-            vocab_size=1000,
-            # SD2-specific config below
-            hidden_act="gelu",
-            projection_dim=512,
-        )
-        text_encoder = CLIPTextModel(text_encoder_config)
-        tokenizer = CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip")
-
-        components = {
-            "unet": unet,
-            "scheduler": scheduler,
-            "inverse_scheduler": inverse_scheduler,
-            "vae": vae,
-            "text_encoder": text_encoder,
-            "tokenizer": tokenizer,
-            "safety_checker": None,
-            "feature_extractor": None,
-        }
-
-        return components
-
-    def get_dummy_inputs(self, device, seed=0):
-        mask = floats_tensor((1, 16, 16), rng=random.Random(seed)).to(device)
-        latents = floats_tensor((1, 2, 4, 16, 16), rng=random.Random(seed)).to(device)
-        if str(device).startswith("mps"):
-            generator = torch.manual_seed(seed)
-        else:
-            generator = torch.Generator(device=device).manual_seed(seed)
-        inputs = {
-            "prompt": "a dog and a newt",
-            "mask_image": mask,
-            "image_latents": latents,
-            "generator": generator,
-            "num_inference_steps": 2,
-            "inpaint_strength": 1.0,
-            "guidance_scale": 6.0,
-            "output_type": "numpy",
-        }
-
-        return inputs
-
-    def get_dummy_mask_inputs(self, device, seed=0):
-        image = floats_tensor((1, 3, 32, 32), rng=random.Random(seed)).to(device)
-        image = image.cpu().permute(0, 2, 3, 1)[0]
-        image = Image.fromarray(np.uint8(image)).convert("RGB")
-        if str(device).startswith("mps"):
-            generator = torch.manual_seed(seed)
-        else:
-            generator = torch.Generator(device=device).manual_seed(seed)
-        inputs = {
-            "image": image,
-            "source_prompt": "a cat and a frog",
-            "target_prompt": "a dog and a newt",
-            "generator": generator,
-            "num_inference_steps": 2,
-            "num_maps_per_mask": 2,
-            "mask_encode_strength": 1.0,
-            "guidance_scale": 6.0,
-            "output_type": "numpy",
-        }
-
-        return inputs
-
-    def get_dummy_inversion_inputs(self, device, seed=0):
-        image = floats_tensor((1, 3, 32, 32), rng=random.Random(seed)).to(device)
-        image = image.cpu().permute(0, 2, 3, 1)[0]
-        image = Image.fromarray(np.uint8(image)).convert("RGB")
-        if str(device).startswith("mps"):
-            generator = torch.manual_seed(seed)
-        else:
-            generator = torch.Generator(device=device).manual_seed(seed)
-        inputs = {
-            "image": image,
-            "prompt": "a cat and a frog",
-            "generator": generator,
-            "num_inference_steps": 2,
-            "inpaint_strength": 1.0,
-            "guidance_scale": 6.0,
-            "decode_latents": True,
-            "output_type": "numpy",
-        }
-        return inputs
-
-    def test_save_load_optional_components(self):
-        if not hasattr(self.pipeline_class, "_optional_components"):
-            return
-
-        components = self.get_dummy_components()
-        pipe = self.pipeline_class(**components)
-        pipe.to(torch_device)
-        pipe.set_progress_bar_config(disable=None)
-
-        # set all optional components to None and update pipeline config accordingly
-        for optional_component in pipe._optional_components:
-            setattr(pipe, optional_component, None)
-        pipe.register_modules(**{optional_component: None for optional_component in pipe._optional_components})
-
-        inputs = self.get_dummy_inputs(torch_device)
-        output = pipe(**inputs)[0]
-
-        with tempfile.TemporaryDirectory() as tmpdir:
-            pipe.save_pretrained(tmpdir)
-            pipe_loaded = self.pipeline_class.from_pretrained(tmpdir)
-            pipe_loaded.to(torch_device)
-            pipe_loaded.set_progress_bar_config(disable=None)
-
-        for optional_component in pipe._optional_components:
-            self.assertTrue(
-                getattr(pipe_loaded, optional_component) is None,
-                f"`{optional_component}` did not stay set to None after loading.",
-            )
-
-        inputs = self.get_dummy_inputs(torch_device)
-        output_loaded = pipe_loaded(**inputs)[0]
-
-        max_diff = np.abs(output - output_loaded).max()
-        self.assertLess(max_diff, 1e-4)
-
-    def test_mask(self):
-        device = "cpu"
-
-        components = self.get_dummy_components()
-        pipe = self.pipeline_class(**components)
-        pipe.to(device)
-        pipe.set_progress_bar_config(disable=None)
-
-        inputs = self.get_dummy_mask_inputs(device)
-        mask = pipe.generate_mask(**inputs)
-        mask_slice = mask[0, -3:, -3:]
-
-        self.assertEqual(mask.shape, (1, 16, 16))
-        expected_slice = np.array([0] * 9)
-        max_diff = np.abs(mask_slice.flatten() - expected_slice).max()
-        self.assertLessEqual(max_diff, 1e-3)
-        self.assertEqual(mask[0, -3, -4], 0)
-
-    def test_inversion(self):
-        device = "cpu"
-
-        components = self.get_dummy_components()
-        pipe = self.pipeline_class(**components)
-        pipe.to(device)
-        pipe.set_progress_bar_config(disable=None)
-
-        inputs = self.get_dummy_inversion_inputs(device)
-        image = pipe.invert(**inputs).images
-        image_slice = image[0, -1, -3:, -3:]
-
-        self.assertEqual(image.shape, (2, 32, 32, 3))
-        expected_slice = np.array(
-            [0.5150, 0.5134, 0.5043, 0.5376, 0.4694, 0.5105, 0.5015, 0.4407, 0.4799],
-        )
-        max_diff = np.abs(image_slice.flatten() - expected_slice).max()
-        self.assertLessEqual(max_diff, 1e-3)
-
-    def test_inference_batch_single_identical(self):
-        super().test_inference_batch_single_identical(expected_max_diff=5e-3)
-
-    def test_inversion_dpm(self):
-        device = "cpu"
-
-        components = self.get_dummy_components()
-
-        scheduler_args = {"beta_start": 0.00085, "beta_end": 0.012, "beta_schedule": "scaled_linear"}
-        components["scheduler"] = DPMSolverMultistepScheduler(**scheduler_args)
-        components["inverse_scheduler"] = DPMSolverMultistepInverseScheduler(**scheduler_args)
-
-        pipe = self.pipeline_class(**components)
-        pipe.to(device)
-        pipe.set_progress_bar_config(disable=None)
-
-        inputs = self.get_dummy_inversion_inputs(device)
-        image = pipe.invert(**inputs).images
-        image_slice = image[0, -1, -3:, -3:]
-
-        self.assertEqual(image.shape, (2, 32, 32, 3))
-        expected_slice = np.array(
-            [0.5305, 0.4673, 0.5314, 0.5308, 0.4886, 0.5279, 0.5142, 0.4724, 0.4892],
-        )
-        max_diff = np.abs(image_slice.flatten() - expected_slice).max()
-        self.assertLessEqual(max_diff, 1e-3)
-
-
-@require_torch_gpu
-@slow
-class StableDiffusionDiffEditPipelineIntegrationTests(unittest.TestCase):
-    def tearDown(self):
-        super().tearDown()
-        gc.collect()
-        torch.cuda.empty_cache()
-
-    @classmethod
-    def setUpClass(cls):
-        raw_image = load_image(
-            "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/diffedit/fruit.png"
-        )
-
-        raw_image = raw_image.convert("RGB").resize((768, 768))
-
-        cls.raw_image = raw_image
-
-    def test_stable_diffusion_diffedit_full(self):
-        generator = torch.manual_seed(0)
-
-        pipe = StableDiffusionDiffEditPipeline.from_pretrained(
-            "stabilityai/stable-diffusion-2-1", safety_checker=None, torch_dtype=torch.float16
-        )
-        pipe.scheduler = DDIMScheduler.from_config(pipe.scheduler.config)
-        pipe.inverse_scheduler = DDIMInverseScheduler.from_config(pipe.scheduler.config)
-        pipe.enable_model_cpu_offload()
-        pipe.set_progress_bar_config(disable=None)
-
-        source_prompt = "a bowl of fruit"
-        target_prompt = "a bowl of pears"
-
-        mask_image = pipe.generate_mask(
-            image=self.raw_image,
-            source_prompt=source_prompt,
-            target_prompt=target_prompt,
-            generator=generator,
-        )
-
-        inv_latents = pipe.invert(
-            prompt=source_prompt, image=self.raw_image, inpaint_strength=0.7, generator=generator
-        ).latents
-
-        image = pipe(
-            prompt=target_prompt,
-            mask_image=mask_image,
-            image_latents=inv_latents,
-            generator=generator,
-            negative_prompt=source_prompt,
-            inpaint_strength=0.7,
-            output_type="numpy",
-        ).images[0]
-
-        expected_image = (
-            np.array(
-                load_image(
-                    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
-                    "/diffedit/pears.png"
-                ).resize((768, 768))
-            )
-            / 255
-        )
-        assert np.abs((expected_image - image).max()) < 5e-1
-
-    def test_stable_diffusion_diffedit_dpm(self):
-        generator = torch.manual_seed(0)
-
-        pipe = StableDiffusionDiffEditPipeline.from_pretrained(
-            "stabilityai/stable-diffusion-2-1", safety_checker=None, torch_dtype=torch.float16
-        )
-        pipe.scheduler = DPMSolverMultistepScheduler.from_config(pipe.scheduler.config)
-        pipe.inverse_scheduler = DPMSolverMultistepInverseScheduler.from_config(pipe.scheduler.config)
-        pipe.enable_model_cpu_offload()
-        pipe.set_progress_bar_config(disable=None)
-
-        source_prompt = "a bowl of fruit"
-        target_prompt = "a bowl of pears"
-
-        mask_image = pipe.generate_mask(
-            image=self.raw_image,
-            source_prompt=source_prompt,
-            target_prompt=target_prompt,
-            generator=generator,
-        )
-
-        inv_latents = pipe.invert(
-            prompt=source_prompt,
-            image=self.raw_image,
-            inpaint_strength=0.7,
-            generator=generator,
-            num_inference_steps=25,
-        ).latents
-
-        image = pipe(
-            prompt=target_prompt,
-            mask_image=mask_image,
-            image_latents=inv_latents,
-            generator=generator,
-            negative_prompt=source_prompt,
-            inpaint_strength=0.7,
-            num_inference_steps=25,
-            output_type="numpy",
-        ).images[0]
-
-        expected_image = (
-            np.array(
-                load_image(
-                    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
-                    "/diffedit/pears.png"
-                ).resize((768, 768))
-            )
-            / 255
-        )
-        assert np.abs((expected_image - image).max()) < 5e-1

spaces/Andy1621/uniformer_image_detection/configs/vfnet/vfnet_r2_101_fpn_mstrain_2x_coco.py

@@ -1,14 +0,0 @@
-_base_ = './vfnet_r50_fpn_mstrain_2x_coco.py'
-model = dict(
-    pretrained='open-mmlab://res2net101_v1d_26w_4s',
-    backbone=dict(
-        type='Res2Net',
-        depth=101,
-        scales=4,
-        base_width=26,
-        num_stages=4,
-        out_indices=(0, 1, 2, 3),
-        frozen_stages=1,
-        norm_cfg=dict(type='BN', requires_grad=True),
-        norm_eval=True,
-        style='pytorch'))

spaces/Andy1621/uniformer_image_detection/mmdet/apis/test.py

@@ -1,190 +0,0 @@
-import os.path as osp
-import pickle
-import shutil
-import tempfile
-import time
-
-import mmcv
-import torch
-import torch.distributed as dist
-from mmcv.image import tensor2imgs
-from mmcv.runner import get_dist_info
-
-from mmdet.core import encode_mask_results
-
-
-def single_gpu_test(model,
-                    data_loader,
-                    show=False,
-                    out_dir=None,
-                    show_score_thr=0.3):
-    model.eval()
-    results = []
-    dataset = data_loader.dataset
-    prog_bar = mmcv.ProgressBar(len(dataset))
-    for i, data in enumerate(data_loader):
-        with torch.no_grad():
-            result = model(return_loss=False, rescale=True, **data)
-
-        batch_size = len(result)
-        if show or out_dir:
-            if batch_size == 1 and isinstance(data['img'][0], torch.Tensor):
-                img_tensor = data['img'][0]
-            else:
-                img_tensor = data['img'][0].data[0]
-            img_metas = data['img_metas'][0].data[0]
-            imgs = tensor2imgs(img_tensor, **img_metas[0]['img_norm_cfg'])
-            assert len(imgs) == len(img_metas)
-
-            for i, (img, img_meta) in enumerate(zip(imgs, img_metas)):
-                h, w, _ = img_meta['img_shape']
-                img_show = img[:h, :w, :]
-
-                ori_h, ori_w = img_meta['ori_shape'][:-1]
-                img_show = mmcv.imresize(img_show, (ori_w, ori_h))
-
-                if out_dir:
-                    out_file = osp.join(out_dir, img_meta['ori_filename'])
-                else:
-                    out_file = None
-
-                model.module.show_result(
-                    img_show,
-                    result[i],
-                    show=show,
-                    out_file=out_file,
-                    score_thr=show_score_thr)
-
-        # encode mask results
-        if isinstance(result[0], tuple):
-            result = [(bbox_results, encode_mask_results(mask_results))
-                      for bbox_results, mask_results in result]
-        results.extend(result)
-
-        for _ in range(batch_size):
-            prog_bar.update()
-    return results
-
-
-def multi_gpu_test(model, data_loader, tmpdir=None, gpu_collect=False):
-    """Test model with multiple gpus.
-
-    This method tests model with multiple gpus and collects the results
-    under two different modes: gpu and cpu modes. By setting 'gpu_collect=True'
-    it encodes results to gpu tensors and use gpu communication for results
-    collection. On cpu mode it saves the results on different gpus to 'tmpdir'
-    and collects them by the rank 0 worker.
-
-    Args:
-        model (nn.Module): Model to be tested.
-        data_loader (nn.Dataloader): Pytorch data loader.
-        tmpdir (str): Path of directory to save the temporary results from
-            different gpus under cpu mode.
-        gpu_collect (bool): Option to use either gpu or cpu to collect results.
-
-    Returns:
-        list: The prediction results.
-    """
-    model.eval()
-    results = []
-    dataset = data_loader.dataset
-    rank, world_size = get_dist_info()
-    if rank == 0:
-        prog_bar = mmcv.ProgressBar(len(dataset))
-    time.sleep(2)  # This line can prevent deadlock problem in some cases.
-    for i, data in enumerate(data_loader):
-        with torch.no_grad():
-            result = model(return_loss=False, rescale=True, **data)
-            # encode mask results
-            if isinstance(result[0], tuple):
-                result = [(bbox_results, encode_mask_results(mask_results))
-                          for bbox_results, mask_results in result]
-        results.extend(result)
-
-        if rank == 0:
-            batch_size = len(result)
-            for _ in range(batch_size * world_size):
-                prog_bar.update()
-
-    # collect results from all ranks
-    if gpu_collect:
-        results = collect_results_gpu(results, len(dataset))
-    else:
-        results = collect_results_cpu(results, len(dataset), tmpdir)
-    return results
-
-
-def collect_results_cpu(result_part, size, tmpdir=None):
-    rank, world_size = get_dist_info()
-    # create a tmp dir if it is not specified
-    if tmpdir is None:
-        MAX_LEN = 512
-        # 32 is whitespace
-        dir_tensor = torch.full((MAX_LEN, ),
-                                32,
-                                dtype=torch.uint8,
-                                device='cuda')
-        if rank == 0:
-            mmcv.mkdir_or_exist('.dist_test')
-            tmpdir = tempfile.mkdtemp(dir='.dist_test')
-            tmpdir = torch.tensor(
-                bytearray(tmpdir.encode()), dtype=torch.uint8, device='cuda')
-            dir_tensor[:len(tmpdir)] = tmpdir
-        dist.broadcast(dir_tensor, 0)
-        tmpdir = dir_tensor.cpu().numpy().tobytes().decode().rstrip()
-    else:
-        mmcv.mkdir_or_exist(tmpdir)
-    # dump the part result to the dir
-    mmcv.dump(result_part, osp.join(tmpdir, f'part_{rank}.pkl'))
-    dist.barrier()
-    # collect all parts
-    if rank != 0:
-        return None
-    else:
-        # load results of all parts from tmp dir
-        part_list = []
-        for i in range(world_size):
-            part_file = osp.join(tmpdir, f'part_{i}.pkl')
-            part_list.append(mmcv.load(part_file))
-        # sort the results
-        ordered_results = []
-        for res in zip(*part_list):
-            ordered_results.extend(list(res))
-        # the dataloader may pad some samples
-        ordered_results = ordered_results[:size]
-        # remove tmp dir
-        shutil.rmtree(tmpdir)
-        return ordered_results
-
-
-def collect_results_gpu(result_part, size):
-    rank, world_size = get_dist_info()
-    # dump result part to tensor with pickle
-    part_tensor = torch.tensor(
-        bytearray(pickle.dumps(result_part)), dtype=torch.uint8, device='cuda')
-    # gather all result part tensor shape
-    shape_tensor = torch.tensor(part_tensor.shape, device='cuda')
-    shape_list = [shape_tensor.clone() for _ in range(world_size)]
-    dist.all_gather(shape_list, shape_tensor)
-    # padding result part tensor to max length
-    shape_max = torch.tensor(shape_list).max()
-    part_send = torch.zeros(shape_max, dtype=torch.uint8, device='cuda')
-    part_send[:shape_tensor[0]] = part_tensor
-    part_recv_list = [
-        part_tensor.new_zeros(shape_max) for _ in range(world_size)
-    ]
-    # gather all result part
-    dist.all_gather(part_recv_list, part_send)
-
-    if rank == 0:
-        part_list = []
-        for recv, shape in zip(part_recv_list, shape_list):
-            part_list.append(
-                pickle.loads(recv[:shape[0]].cpu().numpy().tobytes()))
-        # sort the results
-        ordered_results = []
-        for res in zip(*part_list):
-            ordered_results.extend(list(res))
-        # the dataloader may pad some samples
-        ordered_results = ordered_results[:size]
-        return ordered_results

spaces/Andy1621/uniformer_image_segmentation/configs/ccnet/ccnet_r50-d8_512x512_80k_ade20k.py

@@ -1,6 +0,0 @@
-_base_ = [
-    '../_base_/models/ccnet_r50-d8.py', '../_base_/datasets/ade20k.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
-]
-model = dict(
-    decode_head=dict(num_classes=150), auxiliary_head=dict(num_classes=150))

spaces/Aomsin/Lab10_630510654/README.md

@@ -1,13 +0,0 @@
----
-title: Eiei
-emoji: 👀
-colorFrom: yellow
-colorTo: gray
-sdk: streamlit
-sdk_version: 1.10.0
-app_file: app.py
-pinned: false
-license: cc-by-nd-4.0
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/Arnaudding001/OpenAI_whisperLive/vad.py

@@ -1,468 +0,0 @@
-from abc import ABC, abstractmethod
-from collections import Counter, deque
-
-from typing import Any, Deque, Iterator, List, Dict
-
-from pprint import pprint
-
-from segments import merge_timestamps
-
-# Workaround for https://github.com/tensorflow/tensorflow/issues/48797
-try:
-    import tensorflow as tf
-except ModuleNotFoundError:
-    # Error handling
-    pass
-
-import torch
-
-import ffmpeg
-import numpy as np
-
-from utils import format_timestamp
-from enum import Enum
-
-class NonSpeechStrategy(Enum):
-    """
-    Ignore non-speech frames segments.
-    """
-    SKIP = 1
-    """
-    Just treat non-speech segments as speech.
-    """
-    CREATE_SEGMENT = 2
-    """
-    Expand speech segments into subsequent non-speech segments.
-    """
-    EXPAND_SEGMENT = 3
-
-# Defaults for Silero
-SPEECH_TRESHOLD = 0.3
-
-# Minimum size of segments to process
-MIN_SEGMENT_DURATION = 1
-
-# The maximum time for texts from old segments to be used in the next segment 
-MAX_PROMPT_WINDOW = 0 # seconds (0 = disabled)
-PROMPT_NO_SPEECH_PROB = 0.1 # Do not pass the text from segments with a no speech probability higher than this
-
-VAD_MAX_PROCESSING_CHUNK = 60 * 60 # 60 minutes of audio
-
-class TranscriptionConfig(ABC):
-    def __init__(self, non_speech_strategy: NonSpeechStrategy = NonSpeechStrategy.SKIP, 
-                       segment_padding_left: float = None, segment_padding_right = None, max_silent_period: float = None, 
-                       max_merge_size: float = None, max_prompt_window: float = None):
-        self.non_speech_strategy = non_speech_strategy
-        self.segment_padding_left = segment_padding_left
-        self.segment_padding_right = segment_padding_right
-        self.max_silent_period = max_silent_period
-        self.max_merge_size = max_merge_size
-        self.max_prompt_window = max_prompt_window
-
-class PeriodicTranscriptionConfig(TranscriptionConfig):
-    def __init__(self, periodic_duration: float, non_speech_strategy: NonSpeechStrategy = NonSpeechStrategy.SKIP, 
-                       segment_padding_left: float = None, segment_padding_right = None, max_silent_period: float = None, 
-                       max_merge_size: float = None, max_prompt_window: float = None):
-        super().__init__(non_speech_strategy, segment_padding_left, segment_padding_right, max_silent_period, max_merge_size, max_prompt_window)
-        self.periodic_duration = periodic_duration
-
-class AbstractTranscription(ABC):
-    def __init__(self, sampling_rate: int = 16000):
-        self.sampling_rate = sampling_rate
-
-    def get_audio_segment(self, str, start_time: str = None, duration: str = None):
-        return load_audio(str, self.sampling_rate, start_time, duration)
-
-    @abstractmethod
-    def get_transcribe_timestamps(self, audio: str, config: TranscriptionConfig):
-        """
-        Get the start and end timestamps of the sections that should be transcribed by this VAD method.
-        Parameters
-        ----------
-        audio: str
-            The audio file.
-        config: TranscriptionConfig
-            The transcription configuration.
-        Returns
-        -------
-        A list of start and end timestamps, in fractional seconds.
-        """
-        return 
-
-    def transcribe(self, audio: str, whisperCallable, config: TranscriptionConfig):
-        """
-        Transcribe the given audo file.
-        Parameters
-        ----------
-        audio: str
-            The audio file.
-        whisperCallable: Callable[[Union[str, np.ndarray, torch.Tensor], int, str, str], dict[str, Union[dict, Any]]]
-            The callback that is used to invoke Whisper on an audio file/buffer. The first parameter is the audio file/buffer, 
-            the second parameter is an optional text prompt, and the last is the current detected language. The return value is the result of the Whisper call.
-        Returns
-        -------
-        A list of start and end timestamps, in fractional seconds.
-        """
-
-        # get speech timestamps from full audio file
-        seconds_timestamps = self.get_transcribe_timestamps(audio, config)
-
-        #for seconds_timestamp in seconds_timestamps:
-        #    print("VAD timestamp ", format_timestamp(seconds_timestamp['start']), " to ", format_timestamp(seconds_timestamp['end']))
-
-        merged = merge_timestamps(seconds_timestamps, config.max_silent_period, config.max_merge_size, config.segment_padding_left, config.segment_padding_right)
-
-        # A deque of transcribed segments that is passed to the next segment as a prompt
-        prompt_window = deque()
-
-        print("Timestamps:")
-        pprint(merged)
-
-        if config.non_speech_strategy != NonSpeechStrategy.SKIP:
-            max_audio_duration = get_audio_duration(audio)
-
-            # Expand segments to include the gaps between them
-            if (config.non_speech_strategy == NonSpeechStrategy.CREATE_SEGMENT):
-                # When we have a prompt window, we create speech segments betwen each segment if we exceed the merge size
-                merged = self.fill_gaps(merged, total_duration=max_audio_duration, max_expand_size=config.max_merge_size)
-            elif config.non_speech_strategy == NonSpeechStrategy.EXPAND_SEGMENT: 
-                # With no prompt window, it is better to just expand the segments (this effectively passes the prompt to the next segment)
-                merged = self.expand_gaps(merged, total_duration=max_audio_duration)
-            else:
-                raise Exception("Unknown non-speech strategy: " + str(config.non_speech_strategy))
-
-            print("Transcribing non-speech:")
-            pprint(merged)
-
-        result = {
-            'text': "",
-            'segments': [],
-            'language': ""
-        }
-        languageCounter = Counter()
-        detected_language = None
-
-        segment_index = -1
-
-        # For each time segment, run whisper
-        for segment in merged:
-            segment_index += 1
-            segment_start = segment['start']
-            segment_end = segment['end']
-            segment_expand_amount = segment.get('expand_amount', 0)
-            segment_gap = segment.get('gap', False)
-
-            segment_duration = segment_end - segment_start
-
-            if segment_duration < MIN_SEGMENT_DURATION:
-                continue;
-
-            # Audio to run on Whisper
-            segment_audio = self.get_audio_segment(audio, start_time = str(segment_start), duration = str(segment_duration))
-            # Previous segments to use as a prompt
-            segment_prompt = ' '.join([segment['text'] for segment in prompt_window]) if len(prompt_window) > 0 else None
-    
-            # Detected language
-            detected_language = languageCounter.most_common(1)[0][0] if len(languageCounter) > 0 else None
-
-            print("Running whisper from ", format_timestamp(segment_start), " to ", format_timestamp(segment_end), ", duration: ", 
-                  segment_duration, "expanded: ", segment_expand_amount, "prompt: ", segment_prompt, "language: ", detected_language)
-            segment_result = whisperCallable(segment_audio, segment_index, segment_prompt, detected_language)
-
-            adjusted_segments = self.adjust_timestamp(segment_result["segments"], adjust_seconds=segment_start, max_source_time=segment_duration)
-
-            # Propagate expand amount to the segments
-            if (segment_expand_amount > 0):
-                segment_without_expansion = segment_duration - segment_expand_amount
-
-                for adjusted_segment in adjusted_segments:
-                    adjusted_segment_end = adjusted_segment['end']
-
-                    # Add expand amount if the segment got expanded
-                    if (adjusted_segment_end > segment_without_expansion):
-                        adjusted_segment["expand_amount"] = adjusted_segment_end - segment_without_expansion
-
-            # Append to output
-            result['text'] += segment_result['text']
-            result['segments'].extend(adjusted_segments)
-
-            # Increment detected language
-            if not segment_gap:
-                languageCounter[segment_result['language']] += 1
-
-            # Update prompt window
-            self.__update_prompt_window(prompt_window, adjusted_segments, segment_end, segment_gap, config)
-            
-        if detected_language is not None:
-            result['language'] = detected_language
-
-        return result
-            
-    def __update_prompt_window(self, prompt_window: Deque, adjusted_segments: List, segment_end: float, segment_gap: bool, config: TranscriptionConfig):
-        if (config.max_prompt_window is not None and config.max_prompt_window > 0):
-            # Add segments to the current prompt window (unless it is a speech gap)
-            if not segment_gap:
-                for segment in adjusted_segments:
-                    if segment.get('no_speech_prob', 0) <= PROMPT_NO_SPEECH_PROB:
-                        prompt_window.append(segment)
-
-            while (len(prompt_window) > 0):
-                first_end_time = prompt_window[0].get('end', 0)
-                # Time expanded in the segments should be discounted from the prompt window
-                first_expand_time = prompt_window[0].get('expand_amount', 0)
-
-                if (first_end_time - first_expand_time < segment_end - config.max_prompt_window):
-                    prompt_window.popleft()
-                else:
-                    break
-
-    def include_gaps(self, segments: Iterator[dict], min_gap_length: float, total_duration: float):
-        result = []
-        last_end_time = 0
-
-        for segment in segments:
-            segment_start = float(segment['start'])
-            segment_end = float(segment['end'])
-
-            if (last_end_time != segment_start):
-                delta = segment_start - last_end_time
-
-                if (min_gap_length is None or delta >= min_gap_length):
-                    result.append( { 'start': last_end_time, 'end': segment_start, 'gap': True } )
-            
-            last_end_time = segment_end
-            result.append(segment)
-
-        # Also include total duration if specified
-        if (total_duration is not None and last_end_time < total_duration):
-            delta = total_duration - segment_start
-
-            if (min_gap_length is None or delta >= min_gap_length):
-                result.append( { 'start': last_end_time, 'end': total_duration, 'gap': True } )
-
-        return result
-
-    # Expand the end time of each segment to the start of the next segment
-    def expand_gaps(self, segments: List[Dict[str, Any]], total_duration: float):
-        result = []
-
-        if len(segments) == 0:
-            return result
-
-        # Add gap at the beginning if needed
-        if (segments[0]['start'] > 0):
-            result.append({ 'start': 0, 'end': segments[0]['start'], 'gap': True } )
-
-        for i in range(len(segments) - 1):
-            current_segment = segments[i]
-            next_segment = segments[i + 1]
-
-            delta = next_segment['start'] - current_segment['end']
-
-            # Expand if the gap actually exists
-            if (delta >= 0):
-                current_segment = current_segment.copy()
-                current_segment['expand_amount'] = delta
-                current_segment['end'] = next_segment['start']
-            
-            result.append(current_segment)
-
-        # Add last segment
-        last_segment = segments[-1]
-        result.append(last_segment)
-
-        # Also include total duration if specified
-        if (total_duration is not None):
-            last_segment = result[-1]
-
-            if (last_segment['end'] < total_duration):
-                last_segment = last_segment.copy()
-                last_segment['end'] = total_duration
-                result[-1] = last_segment
-
-        return result
-
-    def fill_gaps(self, segments: List[Dict[str, Any]], total_duration: float, max_expand_size: float = None):
-        result = []
-
-        if len(segments) == 0:
-            return result
-
-        # Add gap at the beginning if needed
-        if (segments[0]['start'] > 0):
-            result.append({ 'start': 0, 'end': segments[0]['start'], 'gap': True } )
-
-        for i in range(len(segments) - 1):
-            expanded = False
-            current_segment = segments[i]
-            next_segment = segments[i + 1]
-
-            delta = next_segment['start'] - current_segment['end']
-
-            if (max_expand_size is not None and delta <= max_expand_size):
-                # Just expand the current segment
-                current_segment = current_segment.copy()
-                current_segment['expand_amount'] = delta
-                current_segment['end'] = next_segment['start']
-                expanded = True
-
-            result.append(current_segment)
-
-            # Add a gap to the next segment if needed
-            if (delta >= 0 and not expanded):
-                result.append({ 'start': current_segment['end'], 'end': next_segment['start'], 'gap': True } )
-            
-        # Add last segment
-        last_segment = segments[-1]
-        result.append(last_segment)
-
-        # Also include total duration if specified
-        if (total_duration is not None):
-            last_segment = result[-1]
-
-            delta = total_duration - last_segment['end']
-
-            if (delta > 0):
-                if (max_expand_size is not None and delta <= max_expand_size):
-                    # Expand the last segment
-                    last_segment = last_segment.copy()
-                    last_segment['expand_amount'] = delta
-                    last_segment['end'] = total_duration
-                    result[-1] = last_segment
-                else:
-                    result.append({ 'start': last_segment['end'], 'end': total_duration, 'gap': True } )
-
-        return result
-
-    def adjust_timestamp(self, segments: Iterator[dict], adjust_seconds: float, max_source_time: float = None):
-        result = []
-
-        for segment in segments:
-            segment_start = float(segment['start'])
-            segment_end = float(segment['end'])
-
-            # Filter segments?
-            if (max_source_time is not None):
-                if (segment_start > max_source_time):
-                    continue
-                segment_end = min(max_source_time, segment_end)
-
-                new_segment = segment.copy()
-
-            # Add to start and end
-            new_segment['start'] = segment_start + adjust_seconds
-            new_segment['end'] = segment_end + adjust_seconds
-            result.append(new_segment)
-        return result
-
-    def multiply_timestamps(self, timestamps: List[Dict[str, Any]], factor: float):
-        result = []
-
-        for entry in timestamps:
-            start = entry['start']
-            end = entry['end']
-
-            result.append({
-                'start': start * factor,
-                'end': end * factor
-            })
-        return result
-
-class VadSileroTranscription(AbstractTranscription):
-    def __init__(self, sampling_rate: int = 16000):
-        super().__init__(sampling_rate=sampling_rate)
-
-        self.model, utils = torch.hub.load(repo_or_dir='snakers4/silero-vad', model='silero_vad')
-        (self.get_speech_timestamps, _, _, _, _) = utils
-
-
-    def get_transcribe_timestamps(self, audio: str, config: TranscriptionConfig):
-        audio_duration = get_audio_duration(audio)
-        result = []
-
-        # Divide procesisng of audio into chunks
-        chunk_start = 0.0
-
-        while (chunk_start < audio_duration):
-            chunk_duration = min(audio_duration - chunk_start, VAD_MAX_PROCESSING_CHUNK)
-
-            print("Processing VAD in chunk from {} to {}".format(format_timestamp(chunk_start), format_timestamp(chunk_start + chunk_duration)))
-            wav = self.get_audio_segment(audio, str(chunk_start), str(chunk_duration))
-
-            sample_timestamps = self.get_speech_timestamps(wav, self.model, sampling_rate=self.sampling_rate, threshold=SPEECH_TRESHOLD)
-            seconds_timestamps = self.multiply_timestamps(sample_timestamps, factor=1 / self.sampling_rate) 
-            adjusted = self.adjust_timestamp(seconds_timestamps, adjust_seconds=chunk_start, max_source_time=chunk_start + chunk_duration)
-
-            #pprint(adjusted)
-
-            result.extend(adjusted)
-            chunk_start += chunk_duration
-
-        return result
-
-# A very simple VAD that just marks every N seconds as speech
-class VadPeriodicTranscription(AbstractTranscription):
-    def __init__(self, sampling_rate: int = 16000):
-        super().__init__(sampling_rate=sampling_rate)
-
-    def get_transcribe_timestamps(self, audio: str, config: PeriodicTranscriptionConfig):
-        # Get duration in seconds
-        audio_duration = get_audio_duration(audio)
-        result = []
-
-        # Generate a timestamp every N seconds
-        start_timestamp = 0
-
-        while (start_timestamp < audio_duration):
-            end_timestamp = min(start_timestamp + config.periodic_duration, audio_duration)
-            segment_duration = end_timestamp - start_timestamp
-
-            # Minimum duration is 1 second
-            if (segment_duration >= 1):
-                result.append( {  'start': start_timestamp, 'end': end_timestamp } )
-
-            start_timestamp = end_timestamp
-
-        return result
-
-def get_audio_duration(file: str):
-    return float(ffmpeg.probe(file)["format"]["duration"])
-
-def load_audio(file: str, sample_rate: int = 16000, 
-               start_time: str = None, duration: str = None):
-    """
-    Open an audio file and read as mono waveform, resampling as necessary
-    Parameters
-    ----------
-    file: str
-        The audio file to open
-    sr: int
-        The sample rate to resample the audio if necessary
-    start_time: str
-        The start time, using the standard FFMPEG time duration syntax, or None to disable.
-    
-    duration: str
-        The duration, using the standard FFMPEG time duration syntax, or None to disable.
-    Returns
-    -------
-    A NumPy array containing the audio waveform, in float32 dtype.
-    """
-    try:
-        inputArgs = {'threads': 0}
-
-        if (start_time is not None):
-            inputArgs['ss'] = start_time
-        if (duration is not None):
-            inputArgs['t'] = duration
-
-        # This launches a subprocess to decode audio while down-mixing and resampling as necessary.
-        # Requires the ffmpeg CLI and `ffmpeg-python` package to be installed.
-        out, _ = (
-            ffmpeg.input(file, **inputArgs)
-            .output("-", format="s16le", acodec="pcm_s16le", ac=1, ar=sample_rate)
-            .run(cmd="ffmpeg", capture_stdout=True, capture_stderr=True)
-        )
-    except ffmpeg.Error as e:
-        raise RuntimeError(f"Failed to load audio: {e.stderr.decode()}")
-
-    return np.frombuffer(out, np.int16).flatten().astype(np.float32) / 32768.0

spaces/Arulkumar03/GroundingDINO_SOTA_Zero_Shot_Model/groundingdino/util/misc.py

@@ -1,717 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
-"""
-Misc functions, including distributed helpers.
-
-Mostly copy-paste from torchvision references.
-"""
-import colorsys
-import datetime
-import functools
-import io
-import json
-import os
-import pickle
-import subprocess
-import time
-from collections import OrderedDict, defaultdict, deque
-from typing import List, Optional
-
-import numpy as np
-import torch
-import torch.distributed as dist
-
-# needed due to empty tensor bug in pytorch and torchvision 0.5
-import torchvision
-from torch import Tensor
-
-__torchvision_need_compat_flag = float(torchvision.__version__.split(".")[1]) < 7
-if __torchvision_need_compat_flag:
-    from torchvision.ops import _new_empty_tensor
-    from torchvision.ops.misc import _output_size
-
-
-class SmoothedValue(object):
-    """Track a series of values and provide access to smoothed values over a
-    window or the global series average.
-    """
-
-    def __init__(self, window_size=20, fmt=None):
-        if fmt is None:
-            fmt = "{median:.4f} ({global_avg:.4f})"
-        self.deque = deque(maxlen=window_size)
-        self.total = 0.0
-        self.count = 0
-        self.fmt = fmt
-
-    def update(self, value, n=1):
-        self.deque.append(value)
-        self.count += n
-        self.total += value * n
-
-    def synchronize_between_processes(self):
-        """
-        Warning: does not synchronize the deque!
-        """
-        if not is_dist_avail_and_initialized():
-            return
-        t = torch.tensor([self.count, self.total], dtype=torch.float64, device="cuda")
-        dist.barrier()
-        dist.all_reduce(t)
-        t = t.tolist()
-        self.count = int(t[0])
-        self.total = t[1]
-
-    @property
-    def median(self):
-        d = torch.tensor(list(self.deque))
-        if d.shape[0] == 0:
-            return 0
-        return d.median().item()
-
-    @property
-    def avg(self):
-        d = torch.tensor(list(self.deque), dtype=torch.float32)
-        return d.mean().item()
-
-    @property
-    def global_avg(self):
-        if os.environ.get("SHILONG_AMP", None) == "1":
-            eps = 1e-4
-        else:
-            eps = 1e-6
-        return self.total / (self.count + eps)
-
-    @property
-    def max(self):
-        return max(self.deque)
-
-    @property
-    def value(self):
-        return self.deque[-1]
-
-    def __str__(self):
-        return self.fmt.format(
-            median=self.median,
-            avg=self.avg,
-            global_avg=self.global_avg,
-            max=self.max,
-            value=self.value,
-        )
-
-
-@functools.lru_cache()
-def _get_global_gloo_group():
-    """
-    Return a process group based on gloo backend, containing all the ranks
-    The result is cached.
-    """
-
-    if dist.get_backend() == "nccl":
-        return dist.new_group(backend="gloo")
-
-    return dist.group.WORLD
-
-
-def all_gather_cpu(data):
-    """
-    Run all_gather on arbitrary picklable data (not necessarily tensors)
-    Args:
-        data: any picklable object
-    Returns:
-        list[data]: list of data gathered from each rank
-    """
-
-    world_size = get_world_size()
-    if world_size == 1:
-        return [data]
-
-    cpu_group = _get_global_gloo_group()
-
-    buffer = io.BytesIO()
-    torch.save(data, buffer)
-    data_view = buffer.getbuffer()
-    device = "cuda" if cpu_group is None else "cpu"
-    tensor = torch.ByteTensor(data_view).to(device)
-
-    # obtain Tensor size of each rank
-    local_size = torch.tensor([tensor.numel()], device=device, dtype=torch.long)
-    size_list = [torch.tensor([0], device=device, dtype=torch.long) for _ in range(world_size)]
-    if cpu_group is None:
-        dist.all_gather(size_list, local_size)
-    else:
-        print("gathering on cpu")
-        dist.all_gather(size_list, local_size, group=cpu_group)
-    size_list = [int(size.item()) for size in size_list]
-    max_size = max(size_list)
-    assert isinstance(local_size.item(), int)
-    local_size = int(local_size.item())
-
-    # receiving Tensor from all ranks
-    # we pad the tensor because torch all_gather does not support
-    # gathering tensors of different shapes
-    tensor_list = []
-    for _ in size_list:
-        tensor_list.append(torch.empty((max_size,), dtype=torch.uint8, device=device))
-    if local_size != max_size:
-        padding = torch.empty(size=(max_size - local_size,), dtype=torch.uint8, device=device)
-        tensor = torch.cat((tensor, padding), dim=0)
-    if cpu_group is None:
-        dist.all_gather(tensor_list, tensor)
-    else:
-        dist.all_gather(tensor_list, tensor, group=cpu_group)
-
-    data_list = []
-    for size, tensor in zip(size_list, tensor_list):
-        tensor = torch.split(tensor, [size, max_size - size], dim=0)[0]
-        buffer = io.BytesIO(tensor.cpu().numpy())
-        obj = torch.load(buffer)
-        data_list.append(obj)
-
-    return data_list
-
-
-def all_gather(data):
-    """
-    Run all_gather on arbitrary picklable data (not necessarily tensors)
-    Args:
-        data: any picklable object
-    Returns:
-        list[data]: list of data gathered from each rank
-    """
-
-    if os.getenv("CPU_REDUCE") == "1":
-        return all_gather_cpu(data)
-
-    world_size = get_world_size()
-    if world_size == 1:
-        return [data]
-
-    # serialized to a Tensor
-    buffer = pickle.dumps(data)
-    storage = torch.ByteStorage.from_buffer(buffer)
-    tensor = torch.ByteTensor(storage).to("cuda")
-
-    # obtain Tensor size of each rank
-    local_size = torch.tensor([tensor.numel()], device="cuda")
-    size_list = [torch.tensor([0], device="cuda") for _ in range(world_size)]
-    dist.all_gather(size_list, local_size)
-    size_list = [int(size.item()) for size in size_list]
-    max_size = max(size_list)
-
-    # receiving Tensor from all ranks
-    # we pad the tensor because torch all_gather does not support
-    # gathering tensors of different shapes
-    tensor_list = []
-    for _ in size_list:
-        tensor_list.append(torch.empty((max_size,), dtype=torch.uint8, device="cuda"))
-    if local_size != max_size:
-        padding = torch.empty(size=(max_size - local_size,), dtype=torch.uint8, device="cuda")
-        tensor = torch.cat((tensor, padding), dim=0)
-    dist.all_gather(tensor_list, tensor)
-
-    data_list = []
-    for size, tensor in zip(size_list, tensor_list):
-        buffer = tensor.cpu().numpy().tobytes()[:size]
-        data_list.append(pickle.loads(buffer))
-
-    return data_list
-
-
-def reduce_dict(input_dict, average=True):
-    """
-    Args:
-        input_dict (dict): all the values will be reduced
-        average (bool): whether to do average or sum
-    Reduce the values in the dictionary from all processes so that all processes
-    have the averaged results. Returns a dict with the same fields as
-    input_dict, after reduction.
-    """
-    world_size = get_world_size()
-    if world_size < 2:
-        return input_dict
-    with torch.no_grad():
-        names = []
-        values = []
-        # sort the keys so that they are consistent across processes
-        for k in sorted(input_dict.keys()):
-            names.append(k)
-            values.append(input_dict[k])
-        values = torch.stack(values, dim=0)
-        dist.all_reduce(values)
-        if average:
-            values /= world_size
-        reduced_dict = {k: v for k, v in zip(names, values)}
-    return reduced_dict
-
-
-class MetricLogger(object):
-    def __init__(self, delimiter="\t"):
-        self.meters = defaultdict(SmoothedValue)
-        self.delimiter = delimiter
-
-    def update(self, **kwargs):
-        for k, v in kwargs.items():
-            if isinstance(v, torch.Tensor):
-                v = v.item()
-            assert isinstance(v, (float, int))
-            self.meters[k].update(v)
-
-    def __getattr__(self, attr):
-        if attr in self.meters:
-            return self.meters[attr]
-        if attr in self.__dict__:
-            return self.__dict__[attr]
-        raise AttributeError("'{}' object has no attribute '{}'".format(type(self).__name__, attr))
-
-    def __str__(self):
-        loss_str = []
-        for name, meter in self.meters.items():
-            # print(name, str(meter))
-            # import ipdb;ipdb.set_trace()
-            if meter.count > 0:
-                loss_str.append("{}: {}".format(name, str(meter)))
-        return self.delimiter.join(loss_str)
-
-    def synchronize_between_processes(self):
-        for meter in self.meters.values():
-            meter.synchronize_between_processes()
-
-    def add_meter(self, name, meter):
-        self.meters[name] = meter
-
-    def log_every(self, iterable, print_freq, header=None, logger=None):
-        if logger is None:
-            print_func = print
-        else:
-            print_func = logger.info
-
-        i = 0
-        if not header:
-            header = ""
-        start_time = time.time()
-        end = time.time()
-        iter_time = SmoothedValue(fmt="{avg:.4f}")
-        data_time = SmoothedValue(fmt="{avg:.4f}")
-        space_fmt = ":" + str(len(str(len(iterable)))) + "d"
-        if torch.cuda.is_available():
-            log_msg = self.delimiter.join(
-                [
-                    header,
-                    "[{0" + space_fmt + "}/{1}]",
-                    "eta: {eta}",
-                    "{meters}",
-                    "time: {time}",
-                    "data: {data}",
-                    "max mem: {memory:.0f}",
-                ]
-            )
-        else:
-            log_msg = self.delimiter.join(
-                [
-                    header,
-                    "[{0" + space_fmt + "}/{1}]",
-                    "eta: {eta}",
-                    "{meters}",
-                    "time: {time}",
-                    "data: {data}",
-                ]
-            )
-        MB = 1024.0 * 1024.0
-        for obj in iterable:
-            data_time.update(time.time() - end)
-            yield obj
-            # import ipdb; ipdb.set_trace()
-            iter_time.update(time.time() - end)
-            if i % print_freq == 0 or i == len(iterable) - 1:
-                eta_seconds = iter_time.global_avg * (len(iterable) - i)
-                eta_string = str(datetime.timedelta(seconds=int(eta_seconds)))
-                if torch.cuda.is_available():
-                    print_func(
-                        log_msg.format(
-                            i,
-                            len(iterable),
-                            eta=eta_string,
-                            meters=str(self),
-                            time=str(iter_time),
-                            data=str(data_time),
-                            memory=torch.cuda.max_memory_allocated() / MB,
-                        )
-                    )
-                else:
-                    print_func(
-                        log_msg.format(
-                            i,
-                            len(iterable),
-                            eta=eta_string,
-                            meters=str(self),
-                            time=str(iter_time),
-                            data=str(data_time),
-                        )
-                    )
-            i += 1
-            end = time.time()
-        total_time = time.time() - start_time
-        total_time_str = str(datetime.timedelta(seconds=int(total_time)))
-        print_func(
-            "{} Total time: {} ({:.4f} s / it)".format(
-                header, total_time_str, total_time / len(iterable)
-            )
-        )
-
-
-def get_sha():
-    cwd = os.path.dirname(os.path.abspath(__file__))
-
-    def _run(command):
-        return subprocess.check_output(command, cwd=cwd).decode("ascii").strip()
-
-    sha = "N/A"
-    diff = "clean"
-    branch = "N/A"
-    try:
-        sha = _run(["git", "rev-parse", "HEAD"])
-        subprocess.check_output(["git", "diff"], cwd=cwd)
-        diff = _run(["git", "diff-index", "HEAD"])
-        diff = "has uncommited changes" if diff else "clean"
-        branch = _run(["git", "rev-parse", "--abbrev-ref", "HEAD"])
-    except Exception:
-        pass
-    message = f"sha: {sha}, status: {diff}, branch: {branch}"
-    return message
-
-
-def collate_fn(batch):
-    # import ipdb; ipdb.set_trace()
-    batch = list(zip(*batch))
-    batch[0] = nested_tensor_from_tensor_list(batch[0])
-    return tuple(batch)
-
-
-def _max_by_axis(the_list):
-    # type: (List[List[int]]) -> List[int]
-    maxes = the_list[0]
-    for sublist in the_list[1:]:
-        for index, item in enumerate(sublist):
-            maxes[index] = max(maxes[index], item)
-    return maxes
-
-
-class NestedTensor(object):
-    def __init__(self, tensors, mask: Optional[Tensor]):
-        self.tensors = tensors
-        self.mask = mask
-        if mask == "auto":
-            self.mask = torch.zeros_like(tensors).to(tensors.device)
-            if self.mask.dim() == 3:
-                self.mask = self.mask.sum(0).to(bool)
-            elif self.mask.dim() == 4:
-                self.mask = self.mask.sum(1).to(bool)
-            else:
-                raise ValueError(
-                    "tensors dim must be 3 or 4 but {}({})".format(
-                        self.tensors.dim(), self.tensors.shape
-                    )
-                )
-
-    def imgsize(self):
-        res = []
-        for i in range(self.tensors.shape[0]):
-            mask = self.mask[i]
-            maxH = (~mask).sum(0).max()
-            maxW = (~mask).sum(1).max()
-            res.append(torch.Tensor([maxH, maxW]))
-        return res
-
-    def to(self, device):
-        # type: (Device) -> NestedTensor # noqa
-        cast_tensor = self.tensors.to(device)
-        mask = self.mask
-        if mask is not None:
-            assert mask is not None
-            cast_mask = mask.to(device)
-        else:
-            cast_mask = None
-        return NestedTensor(cast_tensor, cast_mask)
-
-    def to_img_list_single(self, tensor, mask):
-        assert tensor.dim() == 3, "dim of tensor should be 3 but {}".format(tensor.dim())
-        maxH = (~mask).sum(0).max()
-        maxW = (~mask).sum(1).max()
-        img = tensor[:, :maxH, :maxW]
-        return img
-
-    def to_img_list(self):
-        """remove the padding and convert to img list
-
-        Returns:
-            [type]: [description]
-        """
-        if self.tensors.dim() == 3:
-            return self.to_img_list_single(self.tensors, self.mask)
-        else:
-            res = []
-            for i in range(self.tensors.shape[0]):
-                tensor_i = self.tensors[i]
-                mask_i = self.mask[i]
-                res.append(self.to_img_list_single(tensor_i, mask_i))
-            return res
-
-    @property
-    def device(self):
-        return self.tensors.device
-
-    def decompose(self):
-        return self.tensors, self.mask
-
-    def __repr__(self):
-        return str(self.tensors)
-
-    @property
-    def shape(self):
-        return {"tensors.shape": self.tensors.shape, "mask.shape": self.mask.shape}
-
-
-def nested_tensor_from_tensor_list(tensor_list: List[Tensor]):
-    # TODO make this more general
-    if tensor_list[0].ndim == 3:
-        if torchvision._is_tracing():
-            # nested_tensor_from_tensor_list() does not export well to ONNX
-            # call _onnx_nested_tensor_from_tensor_list() instead
-            return _onnx_nested_tensor_from_tensor_list(tensor_list)
-
-        # TODO make it support different-sized images
-        max_size = _max_by_axis([list(img.shape) for img in tensor_list])
-        # min_size = tuple(min(s) for s in zip(*[img.shape for img in tensor_list]))
-        batch_shape = [len(tensor_list)] + max_size
-        b, c, h, w = batch_shape
-        dtype = tensor_list[0].dtype
-        device = tensor_list[0].device
-        tensor = torch.zeros(batch_shape, dtype=dtype, device=device)
-        mask = torch.ones((b, h, w), dtype=torch.bool, device=device)
-        for img, pad_img, m in zip(tensor_list, tensor, mask):
-            pad_img[: img.shape[0], : img.shape[1], : img.shape[2]].copy_(img)
-            m[: img.shape[1], : img.shape[2]] = False
-    else:
-        raise ValueError("not supported")
-    return NestedTensor(tensor, mask)
-
-
-# _onnx_nested_tensor_from_tensor_list() is an implementation of
-# nested_tensor_from_tensor_list() that is supported by ONNX tracing.
-@torch.jit.unused
-def _onnx_nested_tensor_from_tensor_list(tensor_list: List[Tensor]) -> NestedTensor:
-    max_size = []
-    for i in range(tensor_list[0].dim()):
-        max_size_i = torch.max(
-            torch.stack([img.shape[i] for img in tensor_list]).to(torch.float32)
-        ).to(torch.int64)
-        max_size.append(max_size_i)
-    max_size = tuple(max_size)
-
-    # work around for
-    # pad_img[: img.shape[0], : img.shape[1], : img.shape[2]].copy_(img)
-    # m[: img.shape[1], :img.shape[2]] = False
-    # which is not yet supported in onnx
-    padded_imgs = []
-    padded_masks = []
-    for img in tensor_list:
-        padding = [(s1 - s2) for s1, s2 in zip(max_size, tuple(img.shape))]
-        padded_img = torch.nn.functional.pad(img, (0, padding[2], 0, padding[1], 0, padding[0]))
-        padded_imgs.append(padded_img)
-
-        m = torch.zeros_like(img[0], dtype=torch.int, device=img.device)
-        padded_mask = torch.nn.functional.pad(m, (0, padding[2], 0, padding[1]), "constant", 1)
-        padded_masks.append(padded_mask.to(torch.bool))
-
-    tensor = torch.stack(padded_imgs)
-    mask = torch.stack(padded_masks)
-
-    return NestedTensor(tensor, mask=mask)
-
-
-def setup_for_distributed(is_master):
-    """
-    This function disables printing when not in master process
-    """
-    import builtins as __builtin__
-
-    builtin_print = __builtin__.print
-
-    def print(*args, **kwargs):
-        force = kwargs.pop("force", False)
-        if is_master or force:
-            builtin_print(*args, **kwargs)
-
-    __builtin__.print = print
-
-
-def is_dist_avail_and_initialized():
-    if not dist.is_available():
-        return False
-    if not dist.is_initialized():
-        return False
-    return True
-
-
-def get_world_size():
-    if not is_dist_avail_and_initialized():
-        return 1
-    return dist.get_world_size()
-
-
-def get_rank():
-    if not is_dist_avail_and_initialized():
-        return 0
-    return dist.get_rank()
-
-
-def is_main_process():
-    return get_rank() == 0
-
-
-def save_on_master(*args, **kwargs):
-    if is_main_process():
-        torch.save(*args, **kwargs)
-
-
-def init_distributed_mode(args):
-    if "WORLD_SIZE" in os.environ and os.environ["WORLD_SIZE"] != "":  # 'RANK' in os.environ and
-        args.rank = int(os.environ["RANK"])
-        args.world_size = int(os.environ["WORLD_SIZE"])
-        args.gpu = args.local_rank = int(os.environ["LOCAL_RANK"])
-
-        # launch by torch.distributed.launch
-        # Single node
-        #   python -m torch.distributed.launch --nproc_per_node=8 main.py --world-size 1 --rank 0 ...
-        # Multi nodes
-        #   python -m torch.distributed.launch --nproc_per_node=8 main.py --world-size 2 --rank 0 --dist-url 'tcp://IP_OF_NODE0:FREEPORT' ...
-        #   python -m torch.distributed.launch --nproc_per_node=8 main.py --world-size 2 --rank 1 --dist-url 'tcp://IP_OF_NODE0:FREEPORT' ...
-        # args.rank = int(os.environ.get('OMPI_COMM_WORLD_RANK'))
-        # local_world_size = int(os.environ['GPU_PER_NODE_COUNT'])
-        # args.world_size = args.world_size * local_world_size
-        # args.gpu = args.local_rank = int(os.environ['LOCAL_RANK'])
-        # args.rank = args.rank * local_world_size + args.local_rank
-        print(
-            "world size: {}, rank: {}, local rank: {}".format(
-                args.world_size, args.rank, args.local_rank
-            )
-        )
-        print(json.dumps(dict(os.environ), indent=2))
-    elif "SLURM_PROCID" in os.environ:
-        args.rank = int(os.environ["SLURM_PROCID"])
-        args.gpu = args.local_rank = int(os.environ["SLURM_LOCALID"])
-        args.world_size = int(os.environ["SLURM_NPROCS"])
-
-        print(
-            "world size: {}, world rank: {}, local rank: {}, device_count: {}".format(
-                args.world_size, args.rank, args.local_rank, torch.cuda.device_count()
-            )
-        )
-    else:
-        print("Not using distributed mode")
-        args.distributed = False
-        args.world_size = 1
-        args.rank = 0
-        args.local_rank = 0
-        return
-
-    print("world_size:{} rank:{} local_rank:{}".format(args.world_size, args.rank, args.local_rank))
-    args.distributed = True
-    torch.cuda.set_device(args.local_rank)
-    args.dist_backend = "nccl"
-    print("| distributed init (rank {}): {}".format(args.rank, args.dist_url), flush=True)
-
-    torch.distributed.init_process_group(
-        backend=args.dist_backend,
-        world_size=args.world_size,
-        rank=args.rank,
-        init_method=args.dist_url,
-    )
-
-    print("Before torch.distributed.barrier()")
-    torch.distributed.barrier()
-    print("End torch.distributed.barrier()")
-    setup_for_distributed(args.rank == 0)
-
-
-@torch.no_grad()
-def accuracy(output, target, topk=(1,)):
-    """Computes the precision@k for the specified values of k"""
-    if target.numel() == 0:
-        return [torch.zeros([], device=output.device)]
-    maxk = max(topk)
-    batch_size = target.size(0)
-
-    _, pred = output.topk(maxk, 1, True, True)
-    pred = pred.t()
-    correct = pred.eq(target.view(1, -1).expand_as(pred))
-
-    res = []
-    for k in topk:
-        correct_k = correct[:k].view(-1).float().sum(0)
-        res.append(correct_k.mul_(100.0 / batch_size))
-    return res
-
-
-@torch.no_grad()
-def accuracy_onehot(pred, gt):
-    """_summary_
-
-    Args:
-        pred (_type_): n, c
-        gt (_type_): n, c
-    """
-    tp = ((pred - gt).abs().sum(-1) < 1e-4).float().sum()
-    acc = tp / gt.shape[0] * 100
-    return acc
-
-
-def interpolate(input, size=None, scale_factor=None, mode="nearest", align_corners=None):
-    # type: (Tensor, Optional[List[int]], Optional[float], str, Optional[bool]) -> Tensor
-    """
-    Equivalent to nn.functional.interpolate, but with support for empty batch sizes.
-    This will eventually be supported natively by PyTorch, and this
-    class can go away.
-    """
-    if __torchvision_need_compat_flag < 0.7:
-        if input.numel() > 0:
-            return torch.nn.functional.interpolate(input, size, scale_factor, mode, align_corners)
-
-        output_shape = _output_size(2, input, size, scale_factor)
-        output_shape = list(input.shape[:-2]) + list(output_shape)
-        return _new_empty_tensor(input, output_shape)
-    else:
-        return torchvision.ops.misc.interpolate(input, size, scale_factor, mode, align_corners)
-
-
-class color_sys:
-    def __init__(self, num_colors) -> None:
-        self.num_colors = num_colors
-        colors = []
-        for i in np.arange(0.0, 360.0, 360.0 / num_colors):
-            hue = i / 360.0
-            lightness = (50 + np.random.rand() * 10) / 100.0
-            saturation = (90 + np.random.rand() * 10) / 100.0
-            colors.append(
-                tuple([int(j * 255) for j in colorsys.hls_to_rgb(hue, lightness, saturation)])
-            )
-        self.colors = colors
-
-    def __call__(self, idx):
-        return self.colors[idx]
-
-
-def inverse_sigmoid(x, eps=1e-3):
-    x = x.clamp(min=0, max=1)
-    x1 = x.clamp(min=eps)
-    x2 = (1 - x).clamp(min=eps)
-    return torch.log(x1 / x2)
-
-
-def clean_state_dict(state_dict):
-    new_state_dict = OrderedDict()
-    for k, v in state_dict.items():
-        if k[:7] == "module.":
-            k = k[7:]  # remove `module.`
-        new_state_dict[k] = v
-    return new_state_dict

spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/pip/_internal/__init__.py

@@ -1,19 +0,0 @@
-from typing import List, Optional
-
-import pip._internal.utils.inject_securetransport  # noqa
-from pip._internal.utils import _log
-
-# init_logging() must be called before any call to logging.getLogger()
-# which happens at import of most modules.
-_log.init_logging()
-
-
-def main(args: (Optional[List[str]]) = None) -> int:
-    """This is preserved for old console scripts that may still be referencing
-    it.
-
-    For additional details, see https://github.com/pypa/pip/issues/7498.
-    """
-    from pip._internal.utils.entrypoints import _wrapper
-
-    return _wrapper(args)

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

@@ -1,88 +0,0 @@
-"""
-    pygments.plugin
-    ~~~~~~~~~~~~~~~
-
-    Pygments plugin interface. By default, this tries to use
-    ``importlib.metadata``, which is in the Python standard
-    library since Python 3.8, or its ``importlib_metadata``
-    backport for earlier versions of Python. It falls back on
-    ``pkg_resources`` if not found. Finally, if ``pkg_resources``
-    is not found either, no plugins are loaded at all.
-
-    lexer plugins::
-
-        [pygments.lexers]
-        yourlexer = yourmodule:YourLexer
-
-    formatter plugins::
-
-        [pygments.formatters]
-        yourformatter = yourformatter:YourFormatter
-        /.ext = yourformatter:YourFormatter
-
-    As you can see, you can define extensions for the formatter
-    with a leading slash.
-
-    syntax plugins::
-
-        [pygments.styles]
-        yourstyle = yourstyle:YourStyle
-
-    filter plugin::
-
-        [pygments.filter]
-        yourfilter = yourfilter:YourFilter
-
-
-    :copyright: Copyright 2006-2022 by the Pygments team, see AUTHORS.
-    :license: BSD, see LICENSE for details.
-"""
-
-LEXER_ENTRY_POINT = 'pygments.lexers'
-FORMATTER_ENTRY_POINT = 'pygments.formatters'
-STYLE_ENTRY_POINT = 'pygments.styles'
-FILTER_ENTRY_POINT = 'pygments.filters'
-
-
-def iter_entry_points(group_name):
-    try:
-        from importlib.metadata import entry_points
-    except ImportError:
-        try:
-            from importlib_metadata import entry_points
-        except ImportError:
-            try:
-                from pip._vendor.pkg_resources import iter_entry_points
-            except (ImportError, OSError):
-                return []
-            else:
-                return iter_entry_points(group_name)
-    groups = entry_points()
-    if hasattr(groups, 'select'):
-        # New interface in Python 3.10 and newer versions of the
-        # importlib_metadata backport.
-        return groups.select(group=group_name)
-    else:
-        # Older interface, deprecated in Python 3.10 and recent
-        # importlib_metadata, but we need it in Python 3.8 and 3.9.
-        return groups.get(group_name, [])
-
-
-def find_plugin_lexers():
-    for entrypoint in iter_entry_points(LEXER_ENTRY_POINT):
-        yield entrypoint.load()
-
-
-def find_plugin_formatters():
-    for entrypoint in iter_entry_points(FORMATTER_ENTRY_POINT):
-        yield entrypoint.name, entrypoint.load()
-
-
-def find_plugin_styles():
-    for entrypoint in iter_entry_points(STYLE_ENTRY_POINT):
-        yield entrypoint.name, entrypoint.load()
-
-
-def find_plugin_filters():
-    for entrypoint in iter_entry_points(FILTER_ENTRY_POINT):
-        yield entrypoint.name, entrypoint.load()

spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/setuptools/command/register.py

@@ -1,18 +0,0 @@
-from distutils import log
-import distutils.command.register as orig
-
-from setuptools.errors import RemovedCommandError
-
-
-class register(orig.register):
-    """Formerly used to register packages on PyPI."""
-
-    def run(self):
-        msg = (
-            "The register command has been removed, use twine to upload "
-            + "instead (https://pypi.org/p/twine)"
-        )
-
-        self.announce("ERROR: " + msg, log.ERROR)
-
-        raise RemovedCommandError(msg)

spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/detectron2/modeling/meta_arch/build.py

@@ -1,25 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-import torch
-
-from detectron2.utils.logger import _log_api_usage
-from detectron2.utils.registry import Registry
-
-META_ARCH_REGISTRY = Registry("META_ARCH")  # noqa F401 isort:skip
-META_ARCH_REGISTRY.__doc__ = """
-Registry for meta-architectures, i.e. the whole model.
-
-The registered object will be called with `obj(cfg)`
-and expected to return a `nn.Module` object.
-"""
-
-
-def build_model(cfg):
-    """
-    Build the whole model architecture, defined by ``cfg.MODEL.META_ARCHITECTURE``.
-    Note that it does not load any weights from ``cfg``.
-    """
-    meta_arch = cfg.MODEL.META_ARCHITECTURE
-    model = META_ARCH_REGISTRY.get(meta_arch)(cfg)
-    model.to(torch.device(cfg.MODEL.DEVICE))
-    _log_api_usage("modeling.meta_arch." + meta_arch)
-    return model

spaces/Benson/text-generation/Examples/Apk3163.md

@@ -1,84 +0,0 @@
-<br />
-<h1>¿Qué es APK3163 y por qué debería tomarlo? </h1>
-<p>Si usted está interesado en la nutrición deportiva y quiere aprender cómo optimizar su rendimiento y salud a través de la dieta y el ejercicio, entonces APK3163 es el curso para usted. APK3163 significa Fisiología Aplicada y Kinesiología 3163: Nutrición Deportiva. Es un curso en línea de 3 créditos ofrecido por la Universidad de Florida que aborda los aspectos de la nutrición que están relacionados con el rendimiento del ejercicio. </p>
-<h2>apk3163</h2><br /><p><b><b>Download</b> &#10004; <a href="https://bltlly.com/2v6JSu">https://bltlly.com/2v6JSu</a></b></p><br /><br />
- <h2>Introducción</h2>
-<p>En este curso, aprenderá sobre los sistemas bioenergéticos, los componentes de la nutrición, las evaluaciones de la composición nutricional y corporal, las ayudas ergogénicas y las modificaciones de la dieta para las personas físicamente activas y los atletas. También aprenderás a aplicar este conocimiento a diferentes escenarios deportivos y de ejercicio. </p>
-<p>El instructor de este curso es el Dr. Blain Harrison, quien tiene un Ph.D. en Fisiología Aplicada y Kinesiología de UF. También es entrenador deportivo y especialista en fuerza y acondicionamiento. Tiene una amplia experiencia en la enseñanza e investigación de temas de nutrición deportiva. Puede ponerse en contacto con él por correo electrónico a [email protected] o por teléfono al 352-294-1704. También tiene horario de oficina los lunes de 1-2 pm o con cita previa a través de Zoom.</p>
- <h2>Materiales y formato del curso</h2>
-<p>Todos los materiales necesarios para el curso se proporcionarán en la página Lienzo de APK3163. Estos materiales incluyen módulos de capítulos semanales escritos por el instructor y varios artículos de investigación de revistas de renombre. También necesitará acceso a una computadora con conexión a Internet y un navegador web que soporte Canvas.</p>
-<p></p>
-<p>El curso se imparte en línea a través de Canvas, que es el sistema de gestión de aprendizaje de UF. Accederá a todo el contenido del curso, tareas, exámenes, exámenes, calificaciones y herramientas de comunicación a través de Canvas. También participarás en discusiones en línea con tus compañeros de clase e instructor. </p>
-
- <h2>Evaluación y calificación del curso</h2>
-<p>Su calificación final para este curso se basará en su desempeño en exámenes (20%), tareas (30%), exámenes (40%) y discusiones (10%). Usted tendrá que anotar al menos 60% para pasar este curso. </p>
-<p>Habrá dos exámenes (mitad y final) que pondrán a prueba tu conocimiento del material del curso. Cada examen constará de preguntas de opción múltiple que cubren todos los temas de los módulos. Tendrá dos horas para completar cada examen en línea a través de Canvas. Los exámenes estarán disponibles durante 24 horas el día del examen asignado. </p>
-<p>Habrá 14 cuestionarios que evaluarán su comprensión de las lecturas y videos de cada módulo. Cada examen tendrá 10 preguntas de opción múltiple y tendrá 15 minutos para completarlo en línea a través de Canvas. Los cuestionarios estarán disponibles durante una semana después del lanzamiento del módulo. </p>
-<p>Habrá 7 tareas que requerirán que aplique sus conocimientos de nutrición deportiva a situaciones de la vida real. Cada tarea tendrá un formato e instrucciones diferentes, tales como estudios de caso, análisis dietético, planificación de menús, etc. Usted enviará sus tareas en línea a través de Canvas antes de la fecha de vencimiento asignada. </p>
-<p>Habrá 14 discusiones que te permitirán interactuar con tus compañeros de clase e instructor sobre diversos temas relacionados con la nutrición deportiva. Cada discusión tendrá un aviso que necesita responder en un mínimo de 250 palabras. También es necesario responder a al menos dos de los mensajes de sus compañeros de clase en un mínimo de 100 palabras cada uno. Publicarás tus respuestas en línea a través de Canvas en la fecha de vencimiento asignada. </p>
-<p>Se espera que usted siga las políticas de UF sobre asistencia, trabajo tardío, honestidad académica y conducta estudiantil. Usted es responsable de revisar Canvas regularmente para actualizaciones de cursos, anuncios y comentarios. También se le anima a comunicarse con su instructor y compañeros de clase a través de Canvas o correo electrónico si tiene alguna pregunta o inquietud. </p>
-
-<p>Los principales temas tratados en este curso son:</p>
-<ul>
-<li>Sistemas bioenergéticos y balance energético</li>
-<li>Carbohidratos, grasas, proteínas y agua</li>
-<li>Vitaminas, minerales y antioxidantes</li>
-<li>Evaluaciones de la composición nutricional y corporal</li>
-<li>Ayudas y suplementos ergogénicos</li>
-<li>Modificaciones de la dieta para la resistencia, la fuerza, la potencia y los deportes de equipo</li>
-<li>Nutrición para poblaciones y condiciones especiales</li>
-</ul>
-<p>Los resultados de aprendizaje para cada tema son:</p>
-<ul>
-<li>Explicar el papel de los sistemas bioenergéticos y el equilibrio energético en el rendimiento del ejercicio y la salud. </li>
-<li>Describir las funciones, fuentes, requerimientos, metabolismo y almacenamiento de carbohidratos, grasas, proteínas y agua. </li>
-<li>Identificar las funciones, fuentes, requerimientos, deficiencias, toxicidades e interacciones de vitaminas, minerales y antioxidantes. </li>
-<li>Realizar e interpretar evaluaciones nutricionales y de composición corporal utilizando diversos métodos y herramientas. </li>
-<li>Evaluar la eficacia, seguridad, legalidad y cuestiones éticas de los suplementos y ayudas ergogénicas. </li>
-<li>Diseñar e implementar modificaciones en la dieta para diferentes tipos de actividades deportivas y de ejercicio. </li>
-<li>Aplicar principios de nutrición a poblaciones y condiciones especiales como niños, adultos mayores, vegetarianos, embarazo, diabetes, etc.</li>
-</ul>
-<p>La programación tentativa del curso se muestra en la siguiente tabla:</p>
- <borde de la tabla="1">
-<tr><th>Semana</th><th>Módulo</th><th>Tema</th><th>Lecturas</th><th>Tareas</th></tr>
-<tr><td>1</td><td>1</td><td><td>Sistemas bioenergéticos y balance energético</td><td>Capítulo 1 & Artículo 1</td><td>Prueba 1 & Discusión 1</td></tr>
-<tr><td>2</td><td>2</td><td>Carbohidratos</td><td><td>Capítulo 2 & Artículo 2</td><td>Examen 2 & Discusión 2 & Asignación 1</td></tr>
-<tr><td>3</td><td>3</td><td>Fats</td><td><td>Capítulo 3 & Artículo 3</td><td>Quiz 3 & Discusión 3 & Asignación 2</td></tr>
-
-<tr><td>5</td><td>5</td><td>Vitaminas</td><td><td>Capítulo 5 & Artículo 5</td><td>Examen 5 & Discusión 5 & Examen de mitad de período</td></tr>
-<tr><td>6</td><td>6</td><td>Minerales</td><td><td>Capítulo 6 & Artículo 6</td><td>Examen 6 & Discusión 6 & Asignación 4</td></tr>
-<tr><td>7</td><td>7</td><td>Antioxidantes</td><td><td>Capítulo 7 & Artículo 7 </ [assistant](#message) <tr><td>8</td><td><8</td><Agua</td><td>Capítulo 8 & Artículo<td><><td><>Quiz 8 & Asignación/ 6
-<tr><td>9</td><td>9</td><td>Evaluaciones de la composición nutricional y corporal</td><td><td>Capítulo 9 & Artículo 9</td><td>Examen 9 & Discusión 9 & Asignación 7</td></tr>
-<tr><td>10</td><td>10</td><td><td>Ayudas y suplementos ergogénicos</td><td>Capítulo 10 & Artículo 10</td><td>Prueba 10 & Discusión 10</td></tr>
-<tr><td>11</td><td>11</td><td>Modificaciones de la dieta para deportes de resistencia</td><td>Capítulo 11 & Artículo 11</td><td>Examen 11 & Discusión 11</td></tr>
-<tr><td>12</td><td>12</td><td>Modificaciones de la dieta para deportes de fuerza y potencia</td><td>Capítulo 12 & Artículo 12</td><td>Prueba 12 & Discusión 12</td></tr>
-<tr><td>13</td><td>13</td><td>Modificaciones de la dieta para deportes de equipo</td><td>Capítulo 13 & Artículo 13</ [asistente](#message) </tr>
-<tr><td>14</td><td>14</td><td>Nutrición para poblaciones y condiciones especiales</td><td>Capítulo 14 & Artículo 14</td><td>Prueba 14 & Discusión 14</td></tr>
-</tabla>
- <h2>Conclusión</h2>
-<p>APK3163 es un curso valioso que le enseñará los fundamentos de la nutrición deportiva y cómo aplicarlos a su propio rendimiento de ejercicio y la salud de otros. Aprenderás de un instructor experto que te guiará a través del contenido del curso y las actividades. También interactuará con sus compañeros que comparten su interés en la nutrición deportiva. Al final de este curso, tendrá una sólida comprensión del papel de la nutrición en la fisiología del ejercicio y la kinesiología. </p>
-
-<p>APK3163 es un curso divertido y atractivo que te hará disfrutar aprendiendo sobre nutrición deportiva. Descubrirá nuevos hechos, conceptos y estrategias que despertarán su curiosidad e interés. También participarás en varias actividades que desafiarán tu pensamiento crítico y tus habilidades para resolver problemas. Usted encontrará APK3163 para ser una experiencia de aprendizaje gratificante y agradable. </p>
- <h2>Preguntas frecuentes</h2>
-<p>Aquí hay algunas preguntas frecuentes sobre APK3163:</p>
-<ol>
-<li><b>¿Cómo me registro para APK3163? </b></li>
-<p>Puede registrarse para APK3163 a través del portal ONE.UF de UF. Necesita tener los requisitos previos de APK2100C o APK2105C o PET3322C o equivalente con calificaciones mínimas de C.</p>
-<li><b>¿Cuánto cuesta APK3163? </b></li>
-<p>La cuota de matrícula para APK3163 es de $212.71 por hora de crédito para los residentes de la Florida y $955.86 por hora de crédito para los residentes no Florida. Puede haber cargos adicionales para los cursos en línea. </p>
-<li><b>¿Cómo accedo a APK3163 en línea? </b></li>
-<p>Puede acceder a APK3163 en línea a través de Canvas, que es el sistema de gestión de aprendizaje de UF. Necesitas tener una cuenta de GatorLink y una contraseña para iniciar sesión en Canvas. También necesitas tener acceso a una computadora con conexión a Internet y un navegador web que soporte Canvas.</p>
-<li><b>¿Cómo puedo contactar al instructor de APK3163? </b></li>
-<p>Puede ponerse en contacto con el instructor de APK3163 por correo electrónico a [email protected] o por teléfono al 352-294-1704. También tiene horario de oficina los lunes de 1-2 pm o con cita previa a través de Zoom.</p>
-<li><b>¿Cómo puedo obtener ayuda con APK3163? </b></li>
-<p>Puede obtener ayuda con APK3163 utilizando los siguientes recursos:</p>
-<ul>
-<li>El instructor: Puede hacer preguntas o buscar aclaraciones del instructor por correo electrónico, teléfono, Zoom o Canvas.</li>
-<li>Los compañeros de clase: Puede interactuar con sus compañeros de clase a través de discusiones en Canvas o correo electrónico. </li>
-
-<li>Las bibliotecas UF: Puede acceder a bases de datos, revistas, libros y otros recursos en línea a través del sitio web de las bibliotecas UF. </li>
-<li>El estudio de escritura UF: Puede obtener comentarios y orientación sobre sus tareas de escritura a través del sitio web del estudio de escritura UF. </li>
-</ul>
-</ol></p> 64aa2da5cf<br />
-<br />
-<br />

spaces/BigSalmon/GPTJ/README.md

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

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

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

spaces/CVH-vn1210/make_hair/minigpt4/common/utils.py

@@ -1,424 +0,0 @@
-"""
- Copyright (c) 2022, salesforce.com, inc.
- All rights reserved.
- SPDX-License-Identifier: BSD-3-Clause
- For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause
-"""
-
-import io
-import json
-import logging
-import os
-import pickle
-import re
-import shutil
-import urllib
-import urllib.error
-import urllib.request
-from typing import Optional
-from urllib.parse import urlparse
-
-import numpy as np
-import pandas as pd
-import yaml
-from iopath.common.download import download
-from iopath.common.file_io import file_lock, g_pathmgr
-from minigpt4.common.registry import registry
-from torch.utils.model_zoo import tqdm
-from torchvision.datasets.utils import (
-    check_integrity,
-    download_file_from_google_drive,
-    extract_archive,
-)
-
-
-def now():
-    from datetime import datetime
-
-    return datetime.now().strftime("%Y%m%d%H%M")[:-1]
-
-
-def is_url(url_or_filename):
-    parsed = urlparse(url_or_filename)
-    return parsed.scheme in ("http", "https")
-
-
-def get_cache_path(rel_path):
-    return os.path.expanduser(os.path.join(registry.get_path("cache_root"), rel_path))
-
-
-def get_abs_path(rel_path):
-    return os.path.join(registry.get_path("library_root"), rel_path)
-
-
-def load_json(filename):
-    with open(filename, "r") as f:
-        return json.load(f)
-
-
-# The following are adapted from torchvision and vissl
-# torchvision: https://github.com/pytorch/vision
-# vissl: https://github.com/facebookresearch/vissl/blob/main/vissl/utils/download.py
-
-
-def makedir(dir_path):
-    """
-    Create the directory if it does not exist.
-    """
-    is_success = False
-    try:
-        if not g_pathmgr.exists(dir_path):
-            g_pathmgr.mkdirs(dir_path)
-        is_success = True
-    except BaseException:
-        print(f"Error creating directory: {dir_path}")
-    return is_success
-
-
-def get_redirected_url(url: str):
-    """
-    Given a URL, returns the URL it redirects to or the
-    original URL in case of no indirection
-    """
-    import requests
-
-    with requests.Session() as session:
-        with session.get(url, stream=True, allow_redirects=True) as response:
-            if response.history:
-                return response.url
-            else:
-                return url
-
-
-def to_google_drive_download_url(view_url: str) -> str:
-    """
-    Utility function to transform a view URL of google drive
-    to a download URL for google drive
-    Example input:
-        https://drive.google.com/file/d/137RyRjvTBkBiIfeYBNZBtViDHQ6_Ewsp/view
-    Example output:
-        https://drive.google.com/uc?export=download&id=137RyRjvTBkBiIfeYBNZBtViDHQ6_Ewsp
-    """
-    splits = view_url.split("/")
-    assert splits[-1] == "view"
-    file_id = splits[-2]
-    return f"https://drive.google.com/uc?export=download&id={file_id}"
-
-
-def download_google_drive_url(url: str, output_path: str, output_file_name: str):
-    """
-    Download a file from google drive
-    Downloading an URL from google drive requires confirmation when
-    the file of the size is too big (google drive notifies that
-    anti-viral checks cannot be performed on such files)
-    """
-    import requests
-
-    with requests.Session() as session:
-
-        # First get the confirmation token and append it to the URL
-        with session.get(url, stream=True, allow_redirects=True) as response:
-            for k, v in response.cookies.items():
-                if k.startswith("download_warning"):
-                    url = url + "&confirm=" + v
-
-        # Then download the content of the file
-        with session.get(url, stream=True, verify=True) as response:
-            makedir(output_path)
-            path = os.path.join(output_path, output_file_name)
-            total_size = int(response.headers.get("Content-length", 0))
-            with open(path, "wb") as file:
-                from tqdm import tqdm
-
-                with tqdm(total=total_size) as progress_bar:
-                    for block in response.iter_content(
-                        chunk_size=io.DEFAULT_BUFFER_SIZE
-                    ):
-                        file.write(block)
-                        progress_bar.update(len(block))
-
-
-def _get_google_drive_file_id(url: str) -> Optional[str]:
-    parts = urlparse(url)
-
-    if re.match(r"(drive|docs)[.]google[.]com", parts.netloc) is None:
-        return None
-
-    match = re.match(r"/file/d/(?P<id>[^/]*)", parts.path)
-    if match is None:
-        return None
-
-    return match.group("id")
-
-
-def _urlretrieve(url: str, filename: str, chunk_size: int = 1024) -> None:
-    with open(filename, "wb") as fh:
-        with urllib.request.urlopen(
-            urllib.request.Request(url, headers={"User-Agent": "vissl"})
-        ) as response:
-            with tqdm(total=response.length) as pbar:
-                for chunk in iter(lambda: response.read(chunk_size), ""):
-                    if not chunk:
-                        break
-                    pbar.update(chunk_size)
-                    fh.write(chunk)
-
-
-def download_url(
-    url: str,
-    root: str,
-    filename: Optional[str] = None,
-    md5: Optional[str] = None,
-) -> None:
-    """Download a file from a url and place it in root.
-    Args:
-        url (str): URL to download file from
-        root (str): Directory to place downloaded file in
-        filename (str, optional): Name to save the file under.
-                                  If None, use the basename of the URL.
-        md5 (str, optional): MD5 checksum of the download. If None, do not check
-    """
-    root = os.path.expanduser(root)
-    if not filename:
-        filename = os.path.basename(url)
-    fpath = os.path.join(root, filename)
-
-    makedir(root)
-
-    # check if file is already present locally
-    if check_integrity(fpath, md5):
-        print("Using downloaded and verified file: " + fpath)
-        return
-
-    # expand redirect chain if needed
-    url = get_redirected_url(url)
-
-    # check if file is located on Google Drive
-    file_id = _get_google_drive_file_id(url)
-    if file_id is not None:
-        return download_file_from_google_drive(file_id, root, filename, md5)
-
-    # download the file
-    try:
-        print("Downloading " + url + " to " + fpath)
-        _urlretrieve(url, fpath)
-    except (urllib.error.URLError, IOError) as e:  # type: ignore[attr-defined]
-        if url[:5] == "https":
-            url = url.replace("https:", "http:")
-            print(
-                "Failed download. Trying https -> http instead."
-                " Downloading " + url + " to " + fpath
-            )
-            _urlretrieve(url, fpath)
-        else:
-            raise e
-
-    # check integrity of downloaded file
-    if not check_integrity(fpath, md5):
-        raise RuntimeError("File not found or corrupted.")
-
-
-def download_and_extract_archive(
-    url: str,
-    download_root: str,
-    extract_root: Optional[str] = None,
-    filename: Optional[str] = None,
-    md5: Optional[str] = None,
-    remove_finished: bool = False,
-) -> None:
-    download_root = os.path.expanduser(download_root)
-    if extract_root is None:
-        extract_root = download_root
-    if not filename:
-        filename = os.path.basename(url)
-
-    download_url(url, download_root, filename, md5)
-
-    archive = os.path.join(download_root, filename)
-    print("Extracting {} to {}".format(archive, extract_root))
-    extract_archive(archive, extract_root, remove_finished)
-
-
-def cache_url(url: str, cache_dir: str) -> str:
-    """
-    This implementation downloads the remote resource and caches it locally.
-    The resource will only be downloaded if not previously requested.
-    """
-    parsed_url = urlparse(url)
-    dirname = os.path.join(cache_dir, os.path.dirname(parsed_url.path.lstrip("/")))
-    makedir(dirname)
-    filename = url.split("/")[-1]
-    cached = os.path.join(dirname, filename)
-    with file_lock(cached):
-        if not os.path.isfile(cached):
-            logging.info(f"Downloading {url} to {cached} ...")
-            cached = download(url, dirname, filename=filename)
-    logging.info(f"URL {url} cached in {cached}")
-    return cached
-
-
-# TODO (prigoyal): convert this into RAII-style API
-def create_file_symlink(file1, file2):
-    """
-    Simply create the symlinks for a given file1 to file2.
-    Useful during model checkpointing to symlinks to the
-    latest successful checkpoint.
-    """
-    try:
-        if g_pathmgr.exists(file2):
-            g_pathmgr.rm(file2)
-        g_pathmgr.symlink(file1, file2)
-    except Exception as e:
-        logging.info(f"Could NOT create symlink. Error: {e}")
-
-
-def save_file(data, filename, append_to_json=True, verbose=True):
-    """
-    Common i/o utility to handle saving data to various file formats.
-    Supported:
-        .pkl, .pickle, .npy, .json
-    Specifically for .json, users have the option to either append (default)
-    or rewrite by passing in Boolean value to append_to_json.
-    """
-    if verbose:
-        logging.info(f"Saving data to file: {filename}")
-    file_ext = os.path.splitext(filename)[1]
-    if file_ext in [".pkl", ".pickle"]:
-        with g_pathmgr.open(filename, "wb") as fopen:
-            pickle.dump(data, fopen, pickle.HIGHEST_PROTOCOL)
-    elif file_ext == ".npy":
-        with g_pathmgr.open(filename, "wb") as fopen:
-            np.save(fopen, data)
-    elif file_ext == ".json":
-        if append_to_json:
-            with g_pathmgr.open(filename, "a") as fopen:
-                fopen.write(json.dumps(data, sort_keys=True) + "\n")
-                fopen.flush()
-        else:
-            with g_pathmgr.open(filename, "w") as fopen:
-                fopen.write(json.dumps(data, sort_keys=True) + "\n")
-                fopen.flush()
-    elif file_ext == ".yaml":
-        with g_pathmgr.open(filename, "w") as fopen:
-            dump = yaml.dump(data)
-            fopen.write(dump)
-            fopen.flush()
-    else:
-        raise Exception(f"Saving {file_ext} is not supported yet")
-
-    if verbose:
-        logging.info(f"Saved data to file: {filename}")
-
-
-def load_file(filename, mmap_mode=None, verbose=True, allow_pickle=False):
-    """
-    Common i/o utility to handle loading data from various file formats.
-    Supported:
-        .pkl, .pickle, .npy, .json
-    For the npy files, we support reading the files in mmap_mode.
-    If the mmap_mode of reading is not successful, we load data without the
-    mmap_mode.
-    """
-    if verbose:
-        logging.info(f"Loading data from file: {filename}")
-
-    file_ext = os.path.splitext(filename)[1]
-    if file_ext == ".txt":
-        with g_pathmgr.open(filename, "r") as fopen:
-            data = fopen.readlines()
-    elif file_ext in [".pkl", ".pickle"]:
-        with g_pathmgr.open(filename, "rb") as fopen:
-            data = pickle.load(fopen, encoding="latin1")
-    elif file_ext == ".npy":
-        if mmap_mode:
-            try:
-                with g_pathmgr.open(filename, "rb") as fopen:
-                    data = np.load(
-                        fopen,
-                        allow_pickle=allow_pickle,
-                        encoding="latin1",
-                        mmap_mode=mmap_mode,
-                    )
-            except ValueError as e:
-                logging.info(
-                    f"Could not mmap {filename}: {e}. Trying without g_pathmgr"
-                )
-                data = np.load(
-                    filename,
-                    allow_pickle=allow_pickle,
-                    encoding="latin1",
-                    mmap_mode=mmap_mode,
-                )
-                logging.info("Successfully loaded without g_pathmgr")
-            except Exception:
-                logging.info("Could not mmap without g_pathmgr. Trying without mmap")
-                with g_pathmgr.open(filename, "rb") as fopen:
-                    data = np.load(fopen, allow_pickle=allow_pickle, encoding="latin1")
-        else:
-            with g_pathmgr.open(filename, "rb") as fopen:
-                data = np.load(fopen, allow_pickle=allow_pickle, encoding="latin1")
-    elif file_ext == ".json":
-        with g_pathmgr.open(filename, "r") as fopen:
-            data = json.load(fopen)
-    elif file_ext == ".yaml":
-        with g_pathmgr.open(filename, "r") as fopen:
-            data = yaml.load(fopen, Loader=yaml.FullLoader)
-    elif file_ext == ".csv":
-        with g_pathmgr.open(filename, "r") as fopen:
-            data = pd.read_csv(fopen)
-    else:
-        raise Exception(f"Reading from {file_ext} is not supported yet")
-    return data
-
-
-def abspath(resource_path: str):
-    """
-    Make a path absolute, but take into account prefixes like
-    "http://" or "manifold://"
-    """
-    regex = re.compile(r"^\w+://")
-    if regex.match(resource_path) is None:
-        return os.path.abspath(resource_path)
-    else:
-        return resource_path
-
-
-def makedir(dir_path):
-    """
-    Create the directory if it does not exist.
-    """
-    is_success = False
-    try:
-        if not g_pathmgr.exists(dir_path):
-            g_pathmgr.mkdirs(dir_path)
-        is_success = True
-    except BaseException:
-        logging.info(f"Error creating directory: {dir_path}")
-    return is_success
-
-
-def is_url(input_url):
-    """
-    Check if an input string is a url. look for http(s):// and ignoring the case
-    """
-    is_url = re.match(r"^(?:http)s?://", input_url, re.IGNORECASE) is not None
-    return is_url
-
-
-def cleanup_dir(dir):
-    """
-    Utility for deleting a directory. Useful for cleaning the storage space
-    that contains various training artifacts like checkpoints, data etc.
-    """
-    if os.path.exists(dir):
-        logging.info(f"Deleting directory: {dir}")
-        shutil.rmtree(dir)
-    logging.info(f"Deleted contents of directory: {dir}")
-
-
-def get_file_size(filename):
-    """
-    Given a file, get the size of file in MB
-    """
-    size_in_mb = os.path.getsize(filename) / float(1024**2)
-    return size_in_mb

spaces/CVPR/Dual-Key_Backdoor_Attacks/datagen/detectron2/detectron2/data/transforms/transform_gen.py

@@ -1,447 +0,0 @@
-# -*- coding: utf-8 -*-
-# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
-# File: transformer.py
-
-import inspect
-import numpy as np
-import pprint
-import sys
-from abc import ABCMeta, abstractmethod
-from fvcore.transforms.transform import (
-    BlendTransform,
-    CropTransform,
-    HFlipTransform,
-    NoOpTransform,
-    Transform,
-    TransformList,
-    VFlipTransform,
-)
-from PIL import Image
-
-from .transform import ExtentTransform, ResizeTransform
-
-__all__ = [
-    "RandomBrightness",
-    "RandomContrast",
-    "RandomCrop",
-    "RandomExtent",
-    "RandomFlip",
-    "RandomSaturation",
-    "RandomLighting",
-    "Resize",
-    "ResizeShortestEdge",
-    "TransformGen",
-    "apply_transform_gens",
-]
-
-
-def check_dtype(img):
-    assert isinstance(img, np.ndarray), "[TransformGen] Needs an numpy array, but got a {}!".format(
-        type(img)
-    )
-    assert not isinstance(img.dtype, np.integer) or (
-        img.dtype == np.uint8
-    ), "[TransformGen] Got image of type {}, use uint8 or floating points instead!".format(
-        img.dtype
-    )
-    assert img.ndim in [2, 3], img.ndim
-
-
-class TransformGen(metaclass=ABCMeta):
-    """
-    TransformGen takes an image of type uint8 in range [0, 255], or
-    floating point in range [0, 1] or [0, 255] as input.
-
-    It creates a :class:`Transform` based on the given image, sometimes with randomness.
-    The transform can then be used to transform images
-    or other data (boxes, points, annotations, etc.) associated with it.
-
-    The assumption made in this class
-    is that the image itself is sufficient to instantiate a transform.
-    When this assumption is not true, you need to create the transforms by your own.
-
-    A list of `TransformGen` can be applied with :func:`apply_transform_gens`.
-    """
-
-    def _init(self, params=None):
-        if params:
-            for k, v in params.items():
-                if k != "self" and not k.startswith("_"):
-                    setattr(self, k, v)
-
-    @abstractmethod
-    def get_transform(self, img):
-        pass
-
-    def _rand_range(self, low=1.0, high=None, size=None):
-        """
-        Uniform float random number between low and high.
-        """
-        if high is None:
-            low, high = 0, low
-        if size is None:
-            size = []
-        return np.random.uniform(low, high, size)
-
-    def __repr__(self):
-        """
-        Produce something like:
-        "MyTransformGen(field1={self.field1}, field2={self.field2})"
-        """
-        try:
-            sig = inspect.signature(self.__init__)
-            classname = type(self).__name__
-            argstr = []
-            for name, param in sig.parameters.items():
-                assert (
-                    param.kind != param.VAR_POSITIONAL and param.kind != param.VAR_KEYWORD
-                ), "The default __repr__ doesn't support *args or **kwargs"
-                assert hasattr(self, name), (
-                    "Attribute {} not found! "
-                    "Default __repr__ only works if attributes match the constructor.".format(name)
-                )
-                attr = getattr(self, name)
-                default = param.default
-                if default is attr:
-                    continue
-                argstr.append("{}={}".format(name, pprint.pformat(attr)))
-            return "{}({})".format(classname, ", ".join(argstr))
-        except AssertionError:
-            return super().__repr__()
-
-    __str__ = __repr__
-
-
-class RandomFlip(TransformGen):
-    """
-    Flip the image horizontally or vertically with the given probability.
-    """
-
-    def __init__(self, prob=0.5, *, horizontal=True, vertical=False):
-        """
-        Args:
-            prob (float): probability of flip.
-            horizontal (boolean): whether to apply horizontal flipping
-            vertical (boolean): whether to apply vertical flipping
-        """
-        super().__init__()
-
-        if horizontal and vertical:
-            raise ValueError("Cannot do both horiz and vert. Please use two Flip instead.")
-        if not horizontal and not vertical:
-            raise ValueError("At least one of horiz or vert has to be True!")
-        self._init(locals())
-
-    def get_transform(self, img):
-        h, w = img.shape[:2]
-        do = self._rand_range() < self.prob
-        if do:
-            if self.horizontal:
-                return HFlipTransform(w)
-            elif self.vertical:
-                return VFlipTransform(h)
-        else:
-            return NoOpTransform()
-
-
-class Resize(TransformGen):
-    """ Resize image to a target size"""
-
-    def __init__(self, shape, interp=Image.BILINEAR):
-        """
-        Args:
-            shape: (h, w) tuple or a int
-            interp: PIL interpolation method
-        """
-        if isinstance(shape, int):
-            shape = (shape, shape)
-        shape = tuple(shape)
-        self._init(locals())
-
-    def get_transform(self, img):
-        return ResizeTransform(
-            img.shape[0], img.shape[1], self.shape[0], self.shape[1], self.interp
-        )
-
-
-class ResizeShortestEdge(TransformGen):
-    """
-    Scale the shorter edge to the given size, with a limit of `max_size` on the longer edge.
-    If `max_size` is reached, then downscale so that the longer edge does not exceed max_size.
-    """
-
-    def __init__(
-        self, short_edge_length, max_size=sys.maxsize, sample_style="range", interp=Image.BILINEAR
-    ):
-        """
-        Args:
-            short_edge_length (list[int]): If ``sample_style=="range"``,
-                a [min, max] interval from which to sample the shortest edge length.
-                If ``sample_style=="choice"``, a list of shortest edge lengths to sample from.
-            max_size (int): maximum allowed longest edge length.
-            sample_style (str): either "range" or "choice".
-        """
-        super().__init__()
-        assert sample_style in ["range", "choice"], sample_style
-
-        self.is_range = sample_style == "range"
-        if isinstance(short_edge_length, int):
-            short_edge_length = (short_edge_length, short_edge_length)
-        self._init(locals())
-
-    def get_transform(self, img):
-        h, w = img.shape[:2]
-
-        if self.is_range:
-            size = np.random.randint(self.short_edge_length[0], self.short_edge_length[1] + 1)
-        else:
-            size = np.random.choice(self.short_edge_length)
-        if size == 0:
-            return NoOpTransform()
-
-        scale = size * 1.0 / min(h, w)
-        if h < w:
-            newh, neww = size, scale * w
-        else:
-            newh, neww = scale * h, size
-        if max(newh, neww) > self.max_size:
-            scale = self.max_size * 1.0 / max(newh, neww)
-            newh = newh * scale
-            neww = neww * scale
-        neww = int(neww + 0.5)
-        newh = int(newh + 0.5)
-        return ResizeTransform(h, w, newh, neww, self.interp)
-
-
-class RandomCrop(TransformGen):
-    """
-    Randomly crop a subimage out of an image.
-    """
-
-    def __init__(self, crop_type: str, crop_size):
-        """
-        Args:
-            crop_type (str): one of "relative_range", "relative", "absolute".
-                See `config/defaults.py` for explanation.
-            crop_size (tuple[float]): the relative ratio or absolute pixels of
-                height and width
-        """
-        super().__init__()
-        assert crop_type in ["relative_range", "relative", "absolute"]
-        self._init(locals())
-
-    def get_transform(self, img):
-        h, w = img.shape[:2]
-        croph, cropw = self.get_crop_size((h, w))
-        assert h >= croph and w >= cropw, "Shape computation in {} has bugs.".format(self)
-        h0 = np.random.randint(h - croph + 1)
-        w0 = np.random.randint(w - cropw + 1)
-        return CropTransform(w0, h0, cropw, croph)
-
-    def get_crop_size(self, image_size):
-        """
-        Args:
-            image_size (tuple): height, width
-
-        Returns:
-            crop_size (tuple): height, width in absolute pixels
-        """
-        h, w = image_size
-        if self.crop_type == "relative":
-            ch, cw = self.crop_size
-            return int(h * ch + 0.5), int(w * cw + 0.5)
-        elif self.crop_type == "relative_range":
-            crop_size = np.asarray(self.crop_size, dtype=np.float32)
-            ch, cw = crop_size + np.random.rand(2) * (1 - crop_size)
-            return int(h * ch + 0.5), int(w * cw + 0.5)
-        elif self.crop_type == "absolute":
-            return self.crop_size
-        else:
-            NotImplementedError("Unknown crop type {}".format(self.crop_type))
-
-
-class RandomExtent(TransformGen):
-    """
-    Outputs an image by cropping a random "subrect" of the source image.
-
-    The subrect can be parameterized to include pixels outside the source image,
-    in which case they will be set to zeros (i.e. black). The size of the output
-    image will vary with the size of the random subrect.
-    """
-
-    def __init__(self, scale_range, shift_range):
-        """
-        Args:
-            output_size (h, w): Dimensions of output image
-            scale_range (l, h): Range of input-to-output size scaling factor
-            shift_range (x, y): Range of shifts of the cropped subrect. The rect
-                is shifted by [w / 2 * Uniform(-x, x), h / 2 * Uniform(-y, y)],
-                where (w, h) is the (width, height) of the input image. Set each
-                component to zero to crop at the image's center.
-        """
-        super().__init__()
-        self._init(locals())
-
-    def get_transform(self, img):
-        img_h, img_w = img.shape[:2]
-
-        # Initialize src_rect to fit the input image.
-        src_rect = np.array([-0.5 * img_w, -0.5 * img_h, 0.5 * img_w, 0.5 * img_h])
-
-        # Apply a random scaling to the src_rect.
-        src_rect *= np.random.uniform(self.scale_range[0], self.scale_range[1])
-
-        # Apply a random shift to the coordinates origin.
-        src_rect[0::2] += self.shift_range[0] * img_w * (np.random.rand() - 0.5)
-        src_rect[1::2] += self.shift_range[1] * img_h * (np.random.rand() - 0.5)
-
-        # Map src_rect coordinates into image coordinates (center at corner).
-        src_rect[0::2] += 0.5 * img_w
-        src_rect[1::2] += 0.5 * img_h
-
-        return ExtentTransform(
-            src_rect=(src_rect[0], src_rect[1], src_rect[2], src_rect[3]),
-            output_size=(int(src_rect[3] - src_rect[1]), int(src_rect[2] - src_rect[0])),
-        )
-
-
-class RandomContrast(TransformGen):
-    """
-    Randomly transforms image contrast.
-
-    Contrast intensity is uniformly sampled in (intensity_min, intensity_max).
-    - intensity < 1 will reduce contrast
-    - intensity = 1 will preserve the input image
-    - intensity > 1 will increase contrast
-
-    See: https://pillow.readthedocs.io/en/3.0.x/reference/ImageEnhance.html
-    """
-
-    def __init__(self, intensity_min, intensity_max):
-        """
-        Args:
-            intensity_min (float): Minimum augmentation
-            intensity_max (float): Maximum augmentation
-        """
-        super().__init__()
-        self._init(locals())
-
-    def get_transform(self, img):
-        w = np.random.uniform(self.intensity_min, self.intensity_max)
-        return BlendTransform(src_image=img.mean(), src_weight=1 - w, dst_weight=w)
-
-
-class RandomBrightness(TransformGen):
-    """
-    Randomly transforms image brightness.
-
-    Brightness intensity is uniformly sampled in (intensity_min, intensity_max).
-    - intensity < 1 will reduce brightness
-    - intensity = 1 will preserve the input image
-    - intensity > 1 will increase brightness
-
-    See: https://pillow.readthedocs.io/en/3.0.x/reference/ImageEnhance.html
-    """
-
-    def __init__(self, intensity_min, intensity_max):
-        """
-        Args:
-            intensity_min (float): Minimum augmentation
-            intensity_max (float): Maximum augmentation
-        """
-        super().__init__()
-        self._init(locals())
-
-    def get_transform(self, img):
-        w = np.random.uniform(self.intensity_min, self.intensity_max)
-        return BlendTransform(src_image=0, src_weight=1 - w, dst_weight=w)
-
-
-class RandomSaturation(TransformGen):
-    """
-    Randomly transforms image saturation.
-
-    Saturation intensity is uniformly sampled in (intensity_min, intensity_max).
-    - intensity < 1 will reduce saturation (make the image more grayscale)
-    - intensity = 1 will preserve the input image
-    - intensity > 1 will increase saturation
-
-    See: https://pillow.readthedocs.io/en/3.0.x/reference/ImageEnhance.html
-    """
-
-    def __init__(self, intensity_min, intensity_max):
-        """
-        Args:
-            intensity_min (float): Minimum augmentation (1 preserves input).
-            intensity_max (float): Maximum augmentation (1 preserves input).
-        """
-        super().__init__()
-        self._init(locals())
-
-    def get_transform(self, img):
-        assert img.shape[-1] == 3, "Saturation only works on RGB images"
-        w = np.random.uniform(self.intensity_min, self.intensity_max)
-        grayscale = img.dot([0.299, 0.587, 0.114])[:, :, np.newaxis]
-        return BlendTransform(src_image=grayscale, src_weight=1 - w, dst_weight=w)
-
-
-class RandomLighting(TransformGen):
-    """
-    Randomly transforms image color using fixed PCA over ImageNet.
-
-    The degree of color jittering is randomly sampled via a normal distribution,
-    with standard deviation given by the scale parameter.
-    """
-
-    def __init__(self, scale):
-        """
-        Args:
-            scale (float): Standard deviation of principal component weighting.
-        """
-        super().__init__()
-        self._init(locals())
-        self.eigen_vecs = np.array(
-            [[-0.5675, 0.7192, 0.4009], [-0.5808, -0.0045, -0.8140], [-0.5836, -0.6948, 0.4203]]
-        )
-        self.eigen_vals = np.array([0.2175, 0.0188, 0.0045])
-
-    def get_transform(self, img):
-        assert img.shape[-1] == 3, "Saturation only works on RGB images"
-        weights = np.random.normal(scale=self.scale, size=3)
-        return BlendTransform(
-            src_image=self.eigen_vecs.dot(weights * self.eigen_vals), src_weight=1.0, dst_weight=1.0
-        )
-
-
-def apply_transform_gens(transform_gens, img):
-    """
-    Apply a list of :class:`TransformGen` on the input image, and
-    returns the transformed image and a list of transforms.
-
-    We cannot simply create and return all transforms without
-    applying it to the image, because a subsequent transform may
-    need the output of the previous one.
-
-    Args:
-        transform_gens (list): list of :class:`TransformGen` instance to
-            be applied.
-        img (ndarray): uint8 or floating point images with 1 or 3 channels.
-
-    Returns:
-        ndarray: the transformed image
-        TransformList: contain the transforms that's used.
-    """
-    for g in transform_gens:
-        assert isinstance(g, TransformGen), g
-
-    check_dtype(img)
-
-    tfms = []
-    for g in transform_gens:
-        tfm = g.get_transform(img)
-        assert isinstance(
-            tfm, Transform
-        ), "TransformGen {} must return an instance of Transform! Got {} instead".format(g, tfm)
-        img = tfm.apply_image(img)
-        tfms.append(tfm)
-    return img, TransformList(tfms)

spaces/CVPR/Dual-Key_Backdoor_Attacks/datagen/grid-feats-vqa/grid_feats/roi_heads.py

@@ -1,253 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
-import torch
-from torch import nn
-from torch.nn import functional as F
-
-from detectron2.layers import ShapeSpec
-from detectron2.modeling.roi_heads import (
-    build_box_head,
-    build_mask_head,
-    select_foreground_proposals,
-    ROI_HEADS_REGISTRY,
-    ROIHeads,
-    Res5ROIHeads,
-    StandardROIHeads,
-)
-from detectron2.modeling.roi_heads.fast_rcnn import FastRCNNOutputLayers
-from detectron2.modeling.poolers import ROIPooler
-
-
-class AttributePredictor(nn.Module):
-    """
-    Head for attribute prediction, including feature/score computation and
-    loss computation.
-
-    """
-
-    def __init__(self, cfg, input_dim):
-        super().__init__()
-
-        # fmt: off
-        self.num_objs          = cfg.MODEL.ROI_HEADS.NUM_CLASSES
-        self.obj_embed_dim     = cfg.MODEL.ROI_ATTRIBUTE_HEAD.OBJ_EMBED_DIM
-        self.fc_dim            = cfg.MODEL.ROI_ATTRIBUTE_HEAD.FC_DIM
-        self.num_attributes    = cfg.MODEL.ROI_ATTRIBUTE_HEAD.NUM_CLASSES
-        self.max_attr_per_ins  = cfg.INPUT.MAX_ATTR_PER_INS
-        self.loss_weight       = cfg.MODEL.ROI_ATTRIBUTE_HEAD.LOSS_WEIGHT
-        # fmt: on
-
-        # object class embedding, including the background class
-        self.obj_embed = nn.Embedding(self.num_objs + 1, self.obj_embed_dim)
-        input_dim += self.obj_embed_dim
-        self.fc = nn.Sequential(nn.Linear(input_dim, self.fc_dim), nn.ReLU())
-        self.attr_score = nn.Linear(self.fc_dim, self.num_attributes)
-        nn.init.normal_(self.attr_score.weight, std=0.01)
-        nn.init.constant_(self.attr_score.bias, 0)
-
-    def forward(self, x, obj_labels):
-        attr_feat = torch.cat((x, self.obj_embed(obj_labels)), dim=1)
-        return self.attr_score(self.fc(attr_feat))
-
-    def loss(self, score, label):
-        n = score.shape[0]
-        score = score.unsqueeze(1)
-        score = score.expand(n, self.max_attr_per_ins, self.num_attributes).contiguous()
-        score = score.view(-1, self.num_attributes)
-        inv_weights = (
-            (label >= 0)
-            .sum(dim=1)
-            .repeat(self.max_attr_per_ins, 1)
-            .transpose(0, 1)
-            .flatten()
-        )
-        weights = inv_weights.float().reciprocal()
-        weights[weights > 1] = 0.0
-        n_valid = len((label >= 0).sum(dim=1).nonzero())
-        label = label.view(-1)
-        attr_loss = F.cross_entropy(score, label, reduction="none", ignore_index=-1)
-        attr_loss = (attr_loss * weights).view(n, -1).sum(dim=1)
-
-        if n_valid > 0:
-            attr_loss = attr_loss.sum() * self.loss_weight / n_valid
-        else:
-            attr_loss = attr_loss.sum() * 0.0
-        return {"loss_attr": attr_loss}
-
-
-class AttributeROIHeads(ROIHeads):
-    """
-    An extension of ROIHeads to include attribute prediction.
-    """
-
-    def forward_attribute_loss(self, proposals, box_features):
-        proposals, fg_selection_attributes = select_foreground_proposals(
-            proposals, self.num_classes
-        )
-        attribute_features = box_features[torch.cat(fg_selection_attributes, dim=0)]
-        obj_labels = torch.cat([p.gt_classes for p in proposals])
-        attribute_labels = torch.cat([p.gt_attributes for p in proposals], dim=0)
-        attribute_scores = self.attribute_predictor(attribute_features, obj_labels)
-        return self.attribute_predictor.loss(attribute_scores, attribute_labels)
-
-
-@ROI_HEADS_REGISTRY.register()
-class AttributeRes5ROIHeads(AttributeROIHeads, Res5ROIHeads):
-    """
-    An extension of Res5ROIHeads to include attribute prediction.
-    """
-
-    def __init__(self, cfg, input_shape):
-        super(Res5ROIHeads, self).__init__(cfg, input_shape)
-
-        assert len(self.in_features) == 1
-
-        # fmt: off
-        pooler_resolution = cfg.MODEL.ROI_BOX_HEAD.POOLER_RESOLUTION
-        pooler_type       = cfg.MODEL.ROI_BOX_HEAD.POOLER_TYPE
-        pooler_scales     = (1.0 / input_shape[self.in_features[0]].stride, )
-        sampling_ratio    = cfg.MODEL.ROI_BOX_HEAD.POOLER_SAMPLING_RATIO
-        self.mask_on      = cfg.MODEL.MASK_ON
-        self.attribute_on = cfg.MODEL.ATTRIBUTE_ON
-        # fmt: on
-        assert not cfg.MODEL.KEYPOINT_ON
-
-        self.pooler = ROIPooler(
-            output_size=pooler_resolution,
-            scales=pooler_scales,
-            sampling_ratio=sampling_ratio,
-            pooler_type=pooler_type,
-        )
-
-        self.res5, out_channels = self._build_res5_block(cfg)
-        self.box_predictor = FastRCNNOutputLayers(
-            cfg, ShapeSpec(channels=out_channels, height=1, width=1)
-        )
-
-        if self.mask_on:
-            self.mask_head = build_mask_head(
-                cfg,
-                ShapeSpec(
-                    channels=out_channels,
-                    width=pooler_resolution,
-                    height=pooler_resolution,
-                ),
-            )
-
-        if self.attribute_on:
-            self.attribute_predictor = AttributePredictor(cfg, out_channels)
-
-    def forward(self, images, features, proposals, targets=None):
-        del images
-
-        if self.training:
-            assert targets
-            proposals = self.label_and_sample_proposals(proposals, targets)
-        del targets
-
-        proposal_boxes = [x.proposal_boxes for x in proposals]
-        box_features = self._shared_roi_transform(
-            [features[f] for f in self.in_features], proposal_boxes
-        )
-        feature_pooled = box_features.mean(dim=[2, 3])
-        predictions = self.box_predictor(feature_pooled)
-
-        if self.training:
-            del features
-            losses = self.box_predictor.losses(predictions, proposals)
-            if self.mask_on:
-                proposals, fg_selection_masks = select_foreground_proposals(
-                    proposals, self.num_classes
-                )
-                mask_features = box_features[torch.cat(fg_selection_masks, dim=0)]
-                del box_features
-                losses.update(self.mask_head(mask_features, proposals))
-            if self.attribute_on:
-                losses.update(self.forward_attribute_loss(proposals, feature_pooled))
-            return [], losses
-        else:
-            pred_instances, _ = self.box_predictor.inference(predictions, proposals)
-            pred_instances = self.forward_with_given_boxes(features, pred_instances)
-            return pred_instances, {}
-
-    def get_conv5_features(self, features):
-        features = [features[f] for f in self.in_features]
-        return self.res5(features[0])
-
-
-@ROI_HEADS_REGISTRY.register()
-class AttributeStandardROIHeads(AttributeROIHeads, StandardROIHeads):
-    """
-    An extension of StandardROIHeads to include attribute prediction.
-    """
-
-    def __init__(self, cfg, input_shape):
-        super(StandardROIHeads, self).__init__(cfg, input_shape)
-        self._init_box_head(cfg, input_shape)
-        self._init_mask_head(cfg, input_shape)
-        self._init_keypoint_head(cfg, input_shape)
-
-    def _init_box_head(self, cfg, input_shape):
-        # fmt: off
-        pooler_resolution        = cfg.MODEL.ROI_BOX_HEAD.POOLER_RESOLUTION
-        pooler_scales            = tuple(1.0 / input_shape[k].stride for k in self.in_features)
-        sampling_ratio           = cfg.MODEL.ROI_BOX_HEAD.POOLER_SAMPLING_RATIO
-        pooler_type              = cfg.MODEL.ROI_BOX_HEAD.POOLER_TYPE
-        self.train_on_pred_boxes = cfg.MODEL.ROI_BOX_HEAD.TRAIN_ON_PRED_BOXES
-        self.attribute_on        = cfg.MODEL.ATTRIBUTE_ON
-        # fmt: on
-
-        in_channels = [input_shape[f].channels for f in self.in_features]
-        assert len(set(in_channels)) == 1, in_channels
-        in_channels = in_channels[0]
-
-        self.box_pooler = ROIPooler(
-            output_size=pooler_resolution,
-            scales=pooler_scales,
-            sampling_ratio=sampling_ratio,
-            pooler_type=pooler_type,
-        )
-        self.box_head = build_box_head(
-            cfg,
-            ShapeSpec(
-                channels=in_channels, height=pooler_resolution, width=pooler_resolution
-            ),
-        )
-        self.box_predictor = FastRCNNOutputLayers(cfg, self.box_head.output_shape)
-
-        if self.attribute_on:
-            self.attribute_predictor = AttributePredictor(
-                cfg, self.box_head.output_shape.channels
-            )
-
-    def _forward_box(self, features, proposals):
-        features = [features[f] for f in self.in_features]
-        box_features = self.box_pooler(features, [x.proposal_boxes for x in proposals])
-        box_features = self.box_head(box_features)
-        predictions = self.box_predictor(box_features)
-
-        if self.training:
-            if self.train_on_pred_boxes:
-                with torch.no_grad():
-                    pred_boxes = self.box_predictor.predict_boxes_for_gt_classes(
-                        predictions, proposals
-                    )
-                    for proposals_per_image, pred_boxes_per_image in zip(
-                        proposals, pred_boxes
-                    ):
-                        proposals_per_image.proposal_boxes = Boxes(pred_boxes_per_image)
-            losses = self.box_predictor.losses(predictions, proposals)
-            if self.attribute_on:
-                losses.update(self.forward_attribute_loss(proposals, box_features))
-                del box_features
-
-            return losses
-        else:
-            pred_instances, keep = self.box_predictor.inference(predictions, proposals)
-            box_features = box_features[keep]
-            return pred_instances, box_features
-
-    def get_conv5_features(self, features):
-        assert len(self.in_features) == 1
-
-        features = [features[f] for f in self.in_features]
-        return features[0]

spaces/CVPR/LIVE/pybind11/include/pybind11/chrono.h

@@ -1,191 +0,0 @@
-/*
-    pybind11/chrono.h: Transparent conversion between std::chrono and python's datetime
-
-    Copyright (c) 2016 Trent Houliston <[email protected]> and
-                       Wenzel Jakob <[email protected]>
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-#pragma once
-
-#include "pybind11.h"
-#include <cmath>
-#include <ctime>
-#include <chrono>
-#include <datetime.h>
-
-// Backport the PyDateTime_DELTA functions from Python3.3 if required
-#ifndef PyDateTime_DELTA_GET_DAYS
-#define PyDateTime_DELTA_GET_DAYS(o)         (((PyDateTime_Delta*)o)->days)
-#endif
-#ifndef PyDateTime_DELTA_GET_SECONDS
-#define PyDateTime_DELTA_GET_SECONDS(o)      (((PyDateTime_Delta*)o)->seconds)
-#endif
-#ifndef PyDateTime_DELTA_GET_MICROSECONDS
-#define PyDateTime_DELTA_GET_MICROSECONDS(o) (((PyDateTime_Delta*)o)->microseconds)
-#endif
-
-PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
-PYBIND11_NAMESPACE_BEGIN(detail)
-
-template <typename type> class duration_caster {
-public:
-    typedef typename type::rep rep;
-    typedef typename type::period period;
-
-    typedef std::chrono::duration<uint_fast32_t, std::ratio<86400>> days;
-
-    bool load(handle src, bool) {
-        using namespace std::chrono;
-
-        // Lazy initialise the PyDateTime import
-        if (!PyDateTimeAPI) { PyDateTime_IMPORT; }
-
-        if (!src) return false;
-        // If invoked with datetime.delta object
-        if (PyDelta_Check(src.ptr())) {
-            value = type(duration_cast<duration<rep, period>>(
-                  days(PyDateTime_DELTA_GET_DAYS(src.ptr()))
-                + seconds(PyDateTime_DELTA_GET_SECONDS(src.ptr()))
-                + microseconds(PyDateTime_DELTA_GET_MICROSECONDS(src.ptr()))));
-            return true;
-        }
-        // If invoked with a float we assume it is seconds and convert
-        else if (PyFloat_Check(src.ptr())) {
-            value = type(duration_cast<duration<rep, period>>(duration<double>(PyFloat_AsDouble(src.ptr()))));
-            return true;
-        }
-        else return false;
-    }
-
-    // If this is a duration just return it back
-    static const std::chrono::duration<rep, period>& get_duration(const std::chrono::duration<rep, period> &src) {
-        return src;
-    }
-
-    // If this is a time_point get the time_since_epoch
-    template <typename Clock> static std::chrono::duration<rep, period> get_duration(const std::chrono::time_point<Clock, std::chrono::duration<rep, period>> &src) {
-        return src.time_since_epoch();
-    }
-
-    static handle cast(const type &src, return_value_policy /* policy */, handle /* parent */) {
-        using namespace std::chrono;
-
-        // Use overloaded function to get our duration from our source
-        // Works out if it is a duration or time_point and get the duration
-        auto d = get_duration(src);
-
-        // Lazy initialise the PyDateTime import
-        if (!PyDateTimeAPI) { PyDateTime_IMPORT; }
-
-        // Declare these special duration types so the conversions happen with the correct primitive types (int)
-        using dd_t = duration<int, std::ratio<86400>>;
-        using ss_t = duration<int, std::ratio<1>>;
-        using us_t = duration<int, std::micro>;
-
-        auto dd = duration_cast<dd_t>(d);
-        auto subd = d - dd;
-        auto ss = duration_cast<ss_t>(subd);
-        auto us = duration_cast<us_t>(subd - ss);
-        return PyDelta_FromDSU(dd.count(), ss.count(), us.count());
-    }
-
-    PYBIND11_TYPE_CASTER(type, _("datetime.timedelta"));
-};
-
-// This is for casting times on the system clock into datetime.datetime instances
-template <typename Duration> class type_caster<std::chrono::time_point<std::chrono::system_clock, Duration>> {
-public:
-    typedef std::chrono::time_point<std::chrono::system_clock, Duration> type;
-    bool load(handle src, bool) {
-        using namespace std::chrono;
-
-        // Lazy initialise the PyDateTime import
-        if (!PyDateTimeAPI) { PyDateTime_IMPORT; }
-
-        if (!src) return false;
-
-        std::tm cal;
-        microseconds msecs;
-
-        if (PyDateTime_Check(src.ptr())) {
-            cal.tm_sec   = PyDateTime_DATE_GET_SECOND(src.ptr());
-            cal.tm_min   = PyDateTime_DATE_GET_MINUTE(src.ptr());
-            cal.tm_hour  = PyDateTime_DATE_GET_HOUR(src.ptr());
-            cal.tm_mday  = PyDateTime_GET_DAY(src.ptr());
-            cal.tm_mon   = PyDateTime_GET_MONTH(src.ptr()) - 1;
-            cal.tm_year  = PyDateTime_GET_YEAR(src.ptr()) - 1900;
-            cal.tm_isdst = -1;
-            msecs        = microseconds(PyDateTime_DATE_GET_MICROSECOND(src.ptr()));
-        } else if (PyDate_Check(src.ptr())) {
-            cal.tm_sec   = 0;
-            cal.tm_min   = 0;
-            cal.tm_hour  = 0;
-            cal.tm_mday  = PyDateTime_GET_DAY(src.ptr());
-            cal.tm_mon   = PyDateTime_GET_MONTH(src.ptr()) - 1;
-            cal.tm_year  = PyDateTime_GET_YEAR(src.ptr()) - 1900;
-            cal.tm_isdst = -1;
-            msecs        = microseconds(0);
-        } else if (PyTime_Check(src.ptr())) {
-            cal.tm_sec   = PyDateTime_TIME_GET_SECOND(src.ptr());
-            cal.tm_min   = PyDateTime_TIME_GET_MINUTE(src.ptr());
-            cal.tm_hour  = PyDateTime_TIME_GET_HOUR(src.ptr());
-            cal.tm_mday  = 1;   // This date (day, month, year) = (1, 0, 70)
-            cal.tm_mon   = 0;   // represents 1-Jan-1970, which is the first
-            cal.tm_year  = 70;  // earliest available date for Python's datetime
-            cal.tm_isdst = -1;
-            msecs        = microseconds(PyDateTime_TIME_GET_MICROSECOND(src.ptr()));
-        }
-        else return false;
-
-        value = system_clock::from_time_t(std::mktime(&cal)) + msecs;
-        return true;
-    }
-
-    static handle cast(const std::chrono::time_point<std::chrono::system_clock, Duration> &src, return_value_policy /* policy */, handle /* parent */) {
-        using namespace std::chrono;
-
-        // Lazy initialise the PyDateTime import
-        if (!PyDateTimeAPI) { PyDateTime_IMPORT; }
-
-        // Get out microseconds, and make sure they are positive, to avoid bug in eastern hemisphere time zones
-        // (cfr. https://github.com/pybind/pybind11/issues/2417)
-        using us_t = duration<int, std::micro>;
-        auto us = duration_cast<us_t>(src.time_since_epoch() % seconds(1));
-        if (us.count() < 0)
-            us += seconds(1);
-
-        // Subtract microseconds BEFORE `system_clock::to_time_t`, because:
-        // > If std::time_t has lower precision, it is implementation-defined whether the value is rounded or truncated.
-        // (https://en.cppreference.com/w/cpp/chrono/system_clock/to_time_t)
-        std::time_t tt = system_clock::to_time_t(time_point_cast<system_clock::duration>(src - us));
-        // this function uses static memory so it's best to copy it out asap just in case
-        // otherwise other code that is using localtime may break this (not just python code)
-        std::tm localtime = *std::localtime(&tt);
-
-        return PyDateTime_FromDateAndTime(localtime.tm_year + 1900,
-                                          localtime.tm_mon + 1,
-                                          localtime.tm_mday,
-                                          localtime.tm_hour,
-                                          localtime.tm_min,
-                                          localtime.tm_sec,
-                                          us.count());
-    }
-    PYBIND11_TYPE_CASTER(type, _("datetime.datetime"));
-};
-
-// Other clocks that are not the system clock are not measured as datetime.datetime objects
-// since they are not measured on calendar time. So instead we just make them timedeltas
-// Or if they have passed us a time as a float we convert that
-template <typename Clock, typename Duration> class type_caster<std::chrono::time_point<Clock, Duration>>
-: public duration_caster<std::chrono::time_point<Clock, Duration>> {
-};
-
-template <typename Rep, typename Period> class type_caster<std::chrono::duration<Rep, Period>>
-: public duration_caster<std::chrono::duration<Rep, Period>> {
-};
-
-PYBIND11_NAMESPACE_END(detail)
-PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)

spaces/CVPR/LIVE/thrust/thrust/system/detail/adl/fill.h

@@ -1,44 +0,0 @@
-/*
- *  Copyright 2008-2013 NVIDIA Corporation
- *
- *  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 fill 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.
- */
-
-#pragma once
-
-#include <thrust/detail/config.h>
-
-// the purpose of this header is to #include the fill.h header
-// of the sequential, host, and device systems. It should be #included in any
-// code which uses adl to dispatch fill
-
-#include <thrust/system/detail/sequential/fill.h>
-
-// SCons can't see through the #defines below to figure out what this header
-// includes, so we fake it out by specifying all possible files we might end up
-// including inside an #if 0.
-#if 0
-#include <thrust/system/cpp/detail/fill.h>
-#include <thrust/system/cuda/detail/fill.h>
-#include <thrust/system/omp/detail/fill.h>
-#include <thrust/system/tbb/detail/fill.h>
-#endif
-
-#define __THRUST_HOST_SYSTEM_FILL_HEADER <__THRUST_HOST_SYSTEM_ROOT/detail/fill.h>
-#include __THRUST_HOST_SYSTEM_FILL_HEADER
-#undef __THRUST_HOST_SYSTEM_FILL_HEADER
-
-#define __THRUST_DEVICE_SYSTEM_FILL_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/detail/fill.h>
-#include __THRUST_DEVICE_SYSTEM_FILL_HEADER
-#undef __THRUST_DEVICE_SYSTEM_FILL_HEADER
-

spaces/CVPR/LIVE/thrust/thrust/system/omp/detail/default_decomposition.h

@@ -1,45 +0,0 @@
-/*
- *  Copyright 2008-2013 NVIDIA Corporation
- *
- *  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.
- */
-
-
-/*! \file default_decomposition.h
- *  \brief Return a decomposition that is appropriate for the OpenMP backend.
- */
-
-#pragma once
-
-#include <thrust/detail/config.h>
-#include <thrust/system/detail/internal/decompose.h>
-
-namespace thrust
-{
-namespace system
-{
-namespace omp
-{
-namespace detail
-{
-
-template <typename IndexType>
-thrust::system::detail::internal::uniform_decomposition<IndexType> default_decomposition(IndexType n);
-
-} // end namespace detail
-} // end namespace omp
-} // end namespace system
-} // end namespace thrust
-
-#include <thrust/system/omp/detail/default_decomposition.inl>
-

spaces/CVPR/SPOTER_Sign_Language_Recognition/spoter_mod/normalization/hand_normalization.py

@@ -1,192 +0,0 @@
-
-import logging
-import pandas as pd
-
-HAND_IDENTIFIERS = [
-    "wrist",
-    "indexTip",
-    "indexDIP",
-    "indexPIP",
-    "indexMCP",
-    "middleTip",
-    "middleDIP",
-    "middlePIP",
-    "middleMCP",
-    "ringTip",
-    "ringDIP",
-    "ringPIP",
-    "ringMCP",
-    "littleTip",
-    "littleDIP",
-    "littlePIP",
-    "littleMCP",
-    "thumbTip",
-    "thumbIP",
-    "thumbMP",
-    "thumbCMC"
-]
-
-
-def normalize_hands_full(df: pd.DataFrame) -> pd.DataFrame:
-    """
-    Normalizes the hands position data using the Bohacek-normalization algorithm.
-
-    :param df: pd.DataFrame to be normalized
-    :return: pd.DataFrame with normalized values for hand pose
-    """
-
-    # TODO: Fix division by zero
-    df.columns = [item.replace("_left_", "_0_").replace("_right_", "_1_") for item in list(df.columns)]
-
-    normalized_df = pd.DataFrame(columns=df.columns)
-
-    hand_landmarks = {"X": {0: [], 1: []}, "Y": {0: [], 1: []}}
-
-    # Determine how many hands are present in the dataset
-    range_hand_size = 1
-    if "wrist_1_X" in df.columns:
-        range_hand_size = 2
-
-    # Construct the relevant identifiers
-    for identifier in HAND_IDENTIFIERS:
-        for hand_index in range(range_hand_size):
-            hand_landmarks["X"][hand_index].append(identifier + "_" + str(hand_index) + "_X")
-            hand_landmarks["Y"][hand_index].append(identifier + "_" + str(hand_index) + "_Y")
-
-    # Iterate over all of the records in the dataset
-    for index, row in df.iterrows():
-        # Treat each hand individually
-        for hand_index in range(range_hand_size):
-
-            sequence_size = len(row["wrist_" + str(hand_index) + "_X"])
-
-            # Treat each element of the sequence (analyzed frame) individually
-            for sequence_index in range(sequence_size):
-
-                # Retrieve all of the X and Y values of the current frame
-                landmarks_x_values = [row[key][sequence_index] for key in hand_landmarks["X"][hand_index] if row[key][sequence_index] != 0]
-                landmarks_y_values = [row[key][sequence_index] for key in hand_landmarks["Y"][hand_index] if row[key][sequence_index] != 0]
-
-                # Prevent from even starting the analysis if some necessary elements are not present
-                if not landmarks_x_values or not landmarks_y_values:
-                    logging.warning(
-                        " HAND LANDMARKS: One frame could not be normalized as there is no data present. Record: " + str(index) +
-                        ", Frame: " + str(sequence_index))
-                    continue
-
-                # Calculate the deltas
-                width, height = max(landmarks_x_values) - min(landmarks_x_values), max(landmarks_y_values) - min(
-                    landmarks_y_values)
-                if width > height:
-                    delta_x = 0.1 * width
-                    delta_y = delta_x + ((width - height) / 2)
-                else:
-                    delta_y = 0.1 * height
-                    delta_x = delta_y + ((height - width) / 2)
-
-                # Set the starting and ending point of the normalization bounding box
-                starting_point = (min(landmarks_x_values) - delta_x, min(landmarks_y_values) - delta_y)
-                ending_point = (max(landmarks_x_values) + delta_x, max(landmarks_y_values) + delta_y)
-
-                # Normalize individual landmarks and save the results
-                for identifier in HAND_IDENTIFIERS:
-                    key = identifier + "_" + str(hand_index) + "_"
-
-                    # Prevent from trying to normalize incorrectly captured points
-                    if row[key + "X"][sequence_index] == 0 or (ending_point[0] - starting_point[0]) == 0 or (starting_point[1] - ending_point[1]) == 0:
-                        continue
-
-                    normalized_x = (row[key + "X"][sequence_index] - starting_point[0]) / (ending_point[0] -
-                                                                                           starting_point[0])
-                    normalized_y = (row[key + "Y"][sequence_index] - ending_point[1]) / (starting_point[1] -
-                                                                                         ending_point[1])
-
-                    row[key + "X"][sequence_index] = normalized_x
-                    row[key + "Y"][sequence_index] = normalized_y
-
-        normalized_df = normalized_df.append(row, ignore_index=True)
-
-    return normalized_df
-
-
-def normalize_single_dict(row: dict):
-    """
-    Normalizes the skeletal data for a given sequence of frames with signer's hand pose data. The normalization follows
-    the definition from our paper.
-
-    :param row: Dictionary containing key-value pairs with joint identifiers and corresponding lists (sequences) of
-                that particular joints coordinates
-    :return: Dictionary with normalized skeletal data (following the same schema as input data)
-    """
-
-    hand_landmarks = {0: [], 1: []}
-
-    # Determine how many hands are present in the dataset
-    range_hand_size = 1
-    if "wrist_1" in row.keys():
-        range_hand_size = 2
-
-    # Construct the relevant identifiers
-    for identifier in HAND_IDENTIFIERS:
-        for hand_index in range(range_hand_size):
-            hand_landmarks[hand_index].append(identifier + "_" + str(hand_index))
-
-    # Treat each hand individually
-    for hand_index in range(range_hand_size):
-
-        sequence_size = len(row["wrist_" + str(hand_index)])
-
-        # Treat each element of the sequence (analyzed frame) individually
-        for sequence_index in range(sequence_size):
-
-            # Retrieve all of the X and Y values of the current frame
-            landmarks_x_values = [row[key][sequence_index][0] for key in hand_landmarks[hand_index] if
-                                  row[key][sequence_index][0] != 0]
-            landmarks_y_values = [row[key][sequence_index][1] for key in hand_landmarks[hand_index] if
-                                  row[key][sequence_index][1] != 0]
-
-            # Prevent from even starting the analysis if some necessary elements are not present
-            if not landmarks_x_values or not landmarks_y_values:
-                continue
-
-            # Calculate the deltas
-            width, height = max(landmarks_x_values) - min(landmarks_x_values), max(landmarks_y_values) - min(
-                landmarks_y_values)
-            if width > height:
-                delta_x = 0.1 * width
-                delta_y = delta_x + ((width - height) / 2)
-            else:
-                delta_y = 0.1 * height
-                delta_x = delta_y + ((height - width) / 2)
-
-            # Set the starting and ending point of the normalization bounding box
-            starting_point = [min(landmarks_x_values) - delta_x, min(landmarks_y_values) - delta_y]
-            ending_point = [max(landmarks_x_values) + delta_x, max(landmarks_y_values) + delta_y]
-            # Ensure that all of the bounding-box-defining coordinates are not out of the picture
-            if starting_point[0] < 0: starting_point[0] = 0
-            if starting_point[1] > 1: starting_point[1] = 1
-            if ending_point[0] < 0: ending_point[0] = 0
-            if ending_point[1] > 1: ending_point[1] = 1
-
-            # Normalize individual landmarks and save the results
-            for identifier in HAND_IDENTIFIERS:
-                key = identifier + "_" + str(hand_index)
-
-                # Prevent from trying to normalize incorrectly captured points
-                if row[key][sequence_index][0] == 0 or (ending_point[0] - starting_point[0]) == 0 or (
-                        starting_point[1] - ending_point[1]) == 0:
-                    continue
-
-                normalized_x = (row[key][sequence_index][0] - starting_point[0]) / (ending_point[0] - starting_point[0])
-                normalized_y = (row[key][sequence_index][1] - starting_point[1]) / (ending_point[1] - starting_point[1])
-
-                row[key][sequence_index] = list(row[key][sequence_index])
-
-                row[key][sequence_index][0] = normalized_x
-                row[key][sequence_index][1] = normalized_y
-
-    return row
-
-
-if __name__ == "__main__":
-    pass

spaces/CVPR/WALT/mmdet/datasets/wider_face.py

@@ -1,51 +0,0 @@
-import os.path as osp
-import xml.etree.ElementTree as ET
-
-import mmcv
-
-from .builder import DATASETS
-from .xml_style import XMLDataset
-
-
-@DATASETS.register_module()
-class WIDERFaceDataset(XMLDataset):
-    """Reader for the WIDER Face dataset in PASCAL VOC format.
-
-    Conversion scripts can be found in
-    https://github.com/sovrasov/wider-face-pascal-voc-annotations
-    """
-    CLASSES = ('face', )
-
-    def __init__(self, **kwargs):
-        super(WIDERFaceDataset, self).__init__(**kwargs)
-
-    def load_annotations(self, ann_file):
-        """Load annotation from WIDERFace XML style annotation file.
-
-        Args:
-            ann_file (str): Path of XML file.
-
-        Returns:
-            list[dict]: Annotation info from XML file.
-        """
-
-        data_infos = []
-        img_ids = mmcv.list_from_file(ann_file)
-        for img_id in img_ids:
-            filename = f'{img_id}.jpg'
-            xml_path = osp.join(self.img_prefix, 'Annotations',
-                                f'{img_id}.xml')
-            tree = ET.parse(xml_path)
-            root = tree.getroot()
-            size = root.find('size')
-            width = int(size.find('width').text)
-            height = int(size.find('height').text)
-            folder = root.find('folder').text
-            data_infos.append(
-                dict(
-                    id=img_id,
-                    filename=osp.join(folder, filename),
-                    width=width,
-                    height=height))
-
-        return data_infos

spaces/Chitranshu/Dashboard-Dmart/README.md

@@ -1,10 +0,0 @@
----
-title: Dmart-Dashboard
-emoji: 📊
-colorFrom: green
-colorTo: green
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference