Datasets:

Weyaxi
/

huggingface-spaces-codes

@@ -1,22 +0,0 @@
-<br />
-<h1>How to Install Delphi 5 Enterprise on Windows 10 with a Crack</h1>
-<p>Delphi 5 Enterprise is a powerful and versatile software development tool that uses the Object Pascal programming language and provides an integrated development environment (IDE) for creating desktop, mobile, web, and console applications. It was originally released by Borland in 1999, but it is still used by many developers who need to maintain legacy code or prefer its features and performance.</p>
-<p>However, installing Delphi 5 Enterprise on Windows 10 can be challenging, as the installer may hang or fail due to compatibility issues, especially when trying to install the Borland Database Engine (BDE). Moreover, you may need a crack to bypass the license verification and use the software without restrictions.</p>
-<h2>Delphi 5 Enterprise.zip crack</h2><br /><p><b><b>Download</b> &#9999; <a href="https://byltly.com/2uKwfU">https://byltly.com/2uKwfU</a></b></p><br /><br />
-<p>In this article, we will show you how to install Delphi 5 Enterprise on Windows 10 with a crack, using a simple and effective method that does not require any special skills or tools. We will also provide you with a link to download the Delphi 5 Enterprise.zip file that contains the installer and the crack.</p>
-<h2>Step 1: Download the Delphi 5 Enterprise.zip file</h2>
-<p>The first step is to download the Delphi 5 Enterprise.zip file that contains the installer and the crack. You can find it on various websites that offer software downloads, such as <a href="https://archive.org/details/delphi-5-archive">Archive.org</a>, <a href="https://sourceforge.net/directory/?q=delphi%205">SourceForge.net</a>, or <a href="https://www.fileplanet.com/archive/p-16103/Delphi-5-Enterprise-Trial">FilePlanet.com</a>. Make sure you download the file from a reliable and trustworthy source, as some files may contain viruses or malware that can harm your computer.</p>
-<p>Once you have downloaded the Delphi 5 Enterprise.zip file, extract it to a folder of your choice using a program like WinZip or WinRAR. You should see two files inside the folder: setup.exe and crack.exe. The setup.exe file is the installer for Delphi 5 Enterprise, and the crack.exe file is the program that will patch the software and remove the license verification.</p>
-<h2>Step 2: Install Delphi 5 Enterprise</h2>
-<p>The next step is to install Delphi 5 Enterprise on your Windows 10 computer. Before you start, make sure you log in as an administrator and turn off User Account Control (UAC) from the Control Panel. This will prevent any errors or interruptions during the installation process.</p>
-<p>Then, double-click on the setup.exe file to launch the installer. Follow the instructions on the screen and choose the options that suit your preferences. When you reach the point where the installer asks you to install the BDE, uncheck the box and skip this step. The BDE is not compatible with Windows 10 and may cause problems if you try to install it.</p>
-<p></p>
-<p>After you finish installing Delphi 5 Enterprise, do not run it yet. You need to apply the crack first to activate it and use it without limitations.</p>
-<h2>Step 3: Apply the crack</h2>
-<p>The final step is to apply the crack to Delphi 5 Enterprise. To do this, double-click on the crack.exe file that you extracted from the Delphi 5 Enterprise.zip file. A window will open with a button that says "Crack". Click on it and wait for a few seconds until you see a message that says "Done". This means that the crack has successfully patched Delphi 5 Enterprise and removed the license verification.</p>
-<p>Now you can run Delphi 5 Enterprise from your Start menu or desktop shortcut. You should see a splash screen that says "Delphi 5 Enterprise - Cracked by [name of cracker]". You can ignore this message and proceed to use the software as normal. You can also turn on UAC again if you want.</p>
-<h2>Conclusion</h2>
-<p>In this article, we have shown you how to install Delphi 5 Enterprise on Windows 10 with a crack, using a simple and effective method that does not require any special skills or tools. We have also provided you with a link to download the Delphi 5 Enterprise.zip file that contains the installer and the crack.</p>
-<p>We hope this article has been helpful and informative for you. If you have any questions or comments, feel free to leave them below. Thank you for reading!</p> 81aa517590<br />
-<br />
-<br />

spaces/1acneusushi/gradio-2dmoleculeeditor/data/Free Crack the Code Worksheets The Best Kept Secret for Kids Education.md DELETED Viewed

@@ -1,25 +0,0 @@
-<h1>Free Crack the Code Worksheets for Kids</h1>
-<p>Do you want to challenge your kids' logic and problem-solving skills? Do you want to make learning fun and engaging? If yes, then you should try these free crack the code worksheets for kids!</p>
-<p>Crack the code worksheets are a type of puzzle where kids have to use a key to decode a secret message. The key can be a letter, a number, a symbol, or a pattern. The secret message can be a word, a phrase, a joke, or a fact. The worksheets can cover various topics, such as math, spelling, vocabulary, science, history, and more.</p>
-<h2>free crack the code worksheets</h2><br /><p><b><b>DOWNLOAD</b> - <a href="https://byltly.com/2uKvDk">https://byltly.com/2uKvDk</a></b></p><br /><br />
-<p>Crack the code worksheets are great for kids of all ages and abilities. They can help kids develop their critical thinking, reasoning, and deduction skills. They can also improve their literacy, numeracy, and general knowledge. Plus, they are fun and satisfying to solve!</p>
-<p>In this article, we will share some of the best free crack the code worksheets for kids that you can find online. You can download and print them for your personal or classroom use. You can also customize them to suit your kids' interests and needs.</p>
-<h2>Best Free Crack the Code Worksheets for Kids</h2>
-<p>Here are some of the best free crack the code worksheets for kids that we have found online:</p>
-<ul>
-<li><a href="https://www.math-salamanders.com/crack-the-code.html">Math Salamanders</a>: This website has a collection of math-themed crack the code worksheets for kids from kindergarten to fifth grade. The worksheets cover topics such as addition, subtraction, multiplication, division, fractions, decimals, and more. The kids have to use the key to find the answer to each math problem.</li>
-<li><a href="https://www.teacherspayteachers.com/Browse/Search:crack%20the%20code/Price-Range/Free">Teachers Pay Teachers</a>: This website has a variety of free crack the code worksheets for kids created by teachers. The worksheets cover topics such as sight words, spelling words, phonics, grammar, punctuation, and more. The kids have to use the key to reveal the hidden words or sentences.</li>
-<li><a href="https://www.activityvillage.co.uk/crack-the-code-puzzles">Activity Village</a>: This website has a selection of free crack the code puzzles for kids that are fun and colorful. The puzzles feature different themes, such as animals, sports, holidays, seasons, and more. The kids have to use the key to decode the secret messages or jokes.</li>
-<li><a href="https://www.education.com/worksheet/article/crack-the-code/">Education.com</a>: This website has a free crack the code worksheet for kids that is based on history. The worksheet features a secret message from Abraham Lincoln that he wrote in 1862. The kids have to use the key to decipher the message and learn about an important event in American history.</li>
-</ul>
-<h2>How to Create Your Own Crack the Code Worksheets</h2>
-<p>If you want to create your own crack the code worksheets for your kids or students, you can use online tools or software to generate them. Here are some of the options that you can try:</p>
-<ul>
-<li><a href="https://www.discoveryeducation.com/free-puzzlemaker/">Discovery Education's Puzzlemaker</a>: This is a free online tool that allows you to create various types of puzzles, including crack the code puzzles. You can choose from different types of keys, such as letters, numbers, symbols, or Morse code. You can also enter your own secret message and customize the font size and style.</li>
-<li><a href="https://worksheetgenius.com/codebreaker.php">Worksheet Genius</a>: This is another free online tool that lets you create crack the code worksheets. You can choose from different types of keys, such as letters or numbers. You can also enter your own secret message and adjust the difficulty level.</li>
-<li><a href="https://www.microsoft.com/en-us/microsoft-365/excel">Microsoft Excel</a>: This is a software that you can use to create crack the code worksheets using formulas and functions. You can create your own key using letters or numbers and assign them values using formulas. You can also enter your own secret message and encode it using functions. You can then format the worksheet using colors and fonts.</li>
-</ul>
-<h2>Conclusion</h2</p> ddb901b051<br />
-<br />
-<br />

spaces/1gistliPinn/ChatGPT4/Examples/Aqua Energizer Game Full Version Free Download HOT!.md DELETED Viewed

@@ -1,6 +0,0 @@
-<h2>aqua energizer game full version free download</h2><br /><p><b><b>DOWNLOAD</b> &mdash; <a href="https://imgfil.com/2uxXA8">https://imgfil.com/2uxXA8</a></b></p><br /><br />
-Musafir full movies 720p torrent Â· HD Online Player (Shimla Mirchi tamil full movie hd 1080p free download) Â· aqua energizer game full versionÂ ... 1fdad05405<br />
-<br />
-<br />
-<p></p>

spaces/1phancelerku/anime-remove-background/Bus Simulator Indonesia The Best Bus Simulator Game with APK Download.md DELETED Viewed

@@ -1,118 +0,0 @@
-<br />
-<h1>Bus Simulator Indonesia: A Fun and Authentic Game for Android</h1>
-<p>If you love driving games and want to experience what it's like to be a bus driver in Indonesia, then you should try Bus Simulator Indonesia. This is a free bus simulator game that lets you design your own livery, drive around authentic Indonesian cities and places, honk your horn, and enjoy the realistic 3D graphics. In this article, we will tell you more about this game, how to download it in APK format, and why you should play it.</p>
- <h2>What is Bus Simulator Indonesia?</h2>
-<p>Bus Simulator Indonesia (aka BUSSID) is a game developed by Maleo, an Indonesian game studio. It was released in 2017 and has been updated regularly since then. The game aims to replicate the experience of being a bus driver in Indonesia in a fun and authentic way. You can choose from a wide variety of customizable vehicles, pick up passengers, follow the traffic rules, and drive around different cities and places in Indonesia. You can also play online with other players and join convoys.</p>
-<h2>bus simulator indonesia game download in apk</h2><br /><p><b><b>DOWNLOAD</b> - <a href="https://jinyurl.com/2uNQT2">https://jinyurl.com/2uNQT2</a></b></p><br /><br />
- <h3>Features of Bus Simulator Indonesia</h3>
-<p>Bus Simulator Indonesia has many features that make it one of the best bus simulator games on Android. Here are some of them:</p>
- <h4>Design your own livery</h4>
-<p>You can customize your bus with your own design and colors. You can also use your own 3D model using the vehicle mod system. This way, you can express your creativity and personality with your bus.</p>
- <h4>Easy and intuitive control</h4>
-<p>The game has very easy and intuitive control options. You can use the tilt, steering wheel, or buttons to control your bus. You can also adjust the camera angle and zoom level to suit your preference.</p>
- <h4>Authentic Indonesian cities and places</h4>
-<p>The game features authentic Indonesian cities and places, such as Jakarta, Surabaya, Bali, Yogyakarta, and more. You can see the landmarks, buildings, roads, bridges, and scenery that are unique to each location. You can also experience the weather, traffic, and culture of each place.</p>
- <h4>Indonesian buses</h4>
-<p>The game has a variety of Indonesian buses that you can choose from. You can drive buses from different brands, models, sizes, and types. You can also see the interior and exterior details of each bus.</p>
- <h4>Cool and fun honks</h4>
-<p>The game has cool and fun honks that you can use to communicate with other drivers and pedestrians. You can also hear the famous "Om Telolet Om!" (Uncle, honk your horn, uncle!) phrase that became a viral sensation in Indonesia.</p>
-<p>Bus Simulator Indonesia APK free download for Android<br />
-How to install Bus Simulator Indonesia game on your phone<br />
-Bus Simulator Indonesia mod APK with unlimited money and fuel<br />
-Bus Simulator Indonesia game review and features<br />
-Bus Simulator Indonesia online multiplayer mode<br />
-Bus Simulator Indonesia latest version 3.7.1 update<br />
-Bus Simulator Indonesia vehicle mod system tutorial<br />
-Bus Simulator Indonesia authentic Indonesian cities and places<br />
-Bus Simulator Indonesia cool and fun honks<br />
-Bus Simulator Indonesia design your own livery<br />
-Bus Simulator Indonesia best buses and routes<br />
-Bus Simulator Indonesia realistic driving physics and graphics<br />
-Bus Simulator Indonesia tips and tricks for beginners<br />
-Bus Simulator Indonesia cheats and hacks<br />
-Bus Simulator Indonesia offline mode without internet<br />
-Bus Simulator Indonesia Maleo developer information<br />
-Bus Simulator Indonesia ratings and reviews from users<br />
-Bus Simulator Indonesia gameplay videos and screenshots<br />
-Bus Simulator Indonesia download size and requirements<br />
-Bus Simulator Indonesia data safety and privacy policy<br />
-Bus Simulator Indonesia support and feedback<br />
-Bus Simulator Indonesia leaderboards and achievements<br />
-Bus Simulator Indonesia data saved online feature<br />
-Bus Simulator Indonesia alternatives and similar games<br />
-Bus Simulator Indonesia problems and solutions<br />
-Bus Simulator Indonesia FAQs and guides<br />
-Bus Simulator Indonesia news and updates<br />
-Bus Simulator Indonesia no ads option<br />
-Bus Simulator Indonesia for PC and laptop<br />
-Bus Simulator Indonesia for iOS and iPhone<br />
-Bus Simulator Indonesia for Windows 10 and Mac OS<br />
-Bus Simulator Indonesia for tablet and iPad<br />
-Bus Simulator Indonesia for Chromebook and Kindle Fire<br />
-Bus Simulator Indonesia for Samsung and Huawei devices<br />
-Bus Simulator Indonesia for LG and Sony devices<br />
-Bus Simulator Indonesia for Xiaomi and Oppo devices<br />
-Bus Simulator Indonesia for Vivo and Realme devices<br />
-Bus Simulator Indonesia for Nokia and Motorola devices<br />
-Bus Simulator Indonesia for Asus and Lenovo devices<br />
-Bus Simulator Indonesia for ZTE and Alcatel devices<br />
-Bus Simulator Indonesia APK download link from Google Play Store <br />
-Bus Simulator Indonesia APK download link from APK Combo <br />
-Bus Simulator Indonesia APK download link from Softonic <br />
-Bus Simulator Indonesia APK download link from APK Pure <br />
-Bus Simulator Indonesia APK download link from Uptodown <br />
-Bus Simulator Indonesia APK download link from APK Mirror</p>
- <h4>High quality and detailed 3D graphics</h4>
-<p>The game has high quality and detailed 3D graphics that make it look realistic and immersive. You can see the shadows, reflections, textures, lighting, and animations of the game. You can also adjust the graphics settings to optimize the performance of your device.</p>
- <h4>No obstructive ads while driving</h4>
-<p>The game has no obstructive ads while driving. You can enjoy the game without being interrupted by annoying pop-ups or banners. The only ads you will see are on the billboards along the road, which add to the realism of the game.</p>
- <h4>Leaderboard and online multiplayer convoy</h4>
-<p>The game has a leaderboard system that ranks the players based on their score, distance, speed, fuel consumption, and other factors. <table>
-<tr>
-<th>Pros</th>
-<th>Cons</th>
-</tr>
-<tr>
-<td>Free to play and download</td>
-<td>Some bugs and glitches may occur</td>
-</tr>
-<tr>
-<td>Funny and realistic gameplay</td>
-<td>Some features may require in-app purchases</td>
-</tr>
-<tr>
-<td>Creative and customizable options</td>
-<td>Some devices may not support the game well</td>
-</tr>
-<tr>
-<td>Cultural and educational value</td>
-<td>Some content may not be suitable for children</td>
-</tr>
-<tr>
-<td>Social and competitive aspects</td>
-<td>Some players may be rude or abusive online</td>
-</tr>
-</table>
- <h3>User reviews and ratings</h3>
-<p>Bus Simulator Indonesia has received mostly positive reviews and ratings from users. On Google Play Store, it has a rating of 4.4 out of 5 stars, based on over 1.5 million reviews. On App Store, it has a rating of 4.6 out of 5 stars, based on over 16 thousand reviews. Here are some of the user comments:</p>
- <blockquote>"This game is awesome. I love the graphics, the sounds, the controls, and the customization. I feel like I'm really driving a bus in Indonesia. The online mode is also fun and exciting. I recommend this game to anyone who likes driving games."</blockquote>
- <blockquote>"This game is very good and realistic. I like the Indonesian culture and scenery in this game. The buses are also very nice and detailed. The only problem is that sometimes the game crashes or freezes. I hope the developers can fix this issue."</blockquote>
- <blockquote>"This game is very bad and boring. I hate the graphics, the sounds, the controls, and the customization. I feel like I'm wasting my time playing this game. The online mode is also laggy and annoying. I don't recommend this game to anyone who likes driving games."</blockquote>
- <h2>Conclusion</h2>
-<p>Bus Simulator Indonesia is a fun and authentic game for Android that lets you drive a bus in Indonesia. You can design your own livery, drive around different cities and places, honk your horn, and enjoy the realistic 3D graphics. You can also play online with other players and join convoys. To download the game in APK format, you can follow the steps we provided above. You can also check the pros and cons and user reviews and ratings of the game before you play it.</p>
- <p>We hope you enjoyed this article and learned something new about Bus Simulator Indonesia. If you have any questions or feedback, please let us know in the comments below. Thank you for reading!</p>
- <h3>Frequently Asked Questions (FAQs)</h3>
- <ol>
-<li><b>What is the difference between APK and normal download?</b></li>
-<p>An APK file is an Android Package file that contains all the files and data needed to install an app on an Android device. A normal download is a file that can be downloaded from an official app store or website.</p>
- <li><b>Is Bus Simulator Indonesia safe to download?</b></li>
-<p>Yes, Bus Simulator Indonesia is safe to download as long as you download it from a trusted source, such as the official website or app store. You should also scan the file with an antivirus software before installing it.</p>
- <li><b>How can I update Bus Simulator Indonesia?</b></li>
-<p>You can update Bus Simulator Indonesia by downloading the latest version from the official website or app store. You can also enable the automatic update option in your device settings to get notified when a new version is available.</p>
- <li><b>How can I contact the developers of Bus Simulator Indonesia?</b></li>
-<p>You can contact the developers of Bus Simulator Indonesia by sending them an email at <a href="mailto:[email protected]">[email protected]</a> or by visiting their Facebook page at <a href="https://www.facebook.com/bussimulatorid/">https://www.facebook.com/bussimulatorid/</a>.</p>
- <li><b>How can I support Bus Simulator Indonesia?</b></li>
-<p>You can support Bus Simulator Indonesia by giving it a positive review and rating on the app store or website, by sharing it with your friends and family, by making in-app purchases, or by donating to the developers via PayPal or bank transfer.</p>
-</ol></p> 401be4b1e0<br />
-<br />
-<br />

spaces/4Taps/SadTalker/src/face3d/models/arcface_torch/inference.py DELETED Viewed

@@ -1,35 +0,0 @@
-import argparse
-import cv2
-import numpy as np
-import torch
-from backbones import get_model
-@torch.no_grad()
-def inference(weight, name, img):
-    if img is None:
-        img = np.random.randint(0, 255, size=(112, 112, 3), dtype=np.uint8)
-    else:
-        img = cv2.imread(img)
-        img = cv2.resize(img, (112, 112))
-    img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
-    img = np.transpose(img, (2, 0, 1))
-    img = torch.from_numpy(img).unsqueeze(0).float()
-    img.div_(255).sub_(0.5).div_(0.5)
-    net = get_model(name, fp16=False)
-    net.load_state_dict(torch.load(weight))
-    net.eval()
-    feat = net(img).numpy()
-    print(feat)
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser(description='PyTorch ArcFace Training')
-    parser.add_argument('--network', type=str, default='r50', help='backbone network')
-    parser.add_argument('--weight', type=str, default='')
-    parser.add_argument('--img', type=str, default=None)
-    args = parser.parse_args()
-    inference(args.weight, args.network, args.img)

spaces/801artistry/RVC801/go-tensorboard.bat DELETED Viewed

	@@ -1,2 +0,0 @@
1	- python fixes/tensor-launch.py
2	- pause

spaces/AFischer1985/German-Flan-T5/app.py DELETED Viewed

@@ -1,40 +0,0 @@
-import gradio as gr
-from transformers import pipeline
-title= "German Flan-T5"
-desc="Kommunikation mit flan-t5-large auf Deutsch wird intern ins Englische (opus-mt-de-en) und vom Englischen (opus-mt-en-de) übersetzt."
-examples = [
-  ["Erzähl mit eine Geschichte!",50,2,3,1,"Deutsch"],
-  ["Welche Blumen sollte man jemandem zum Valentinstag schenken?",50,1,0,1,"Deutsch"],
-  ["Please write a step by step recipe to make bolognese pasta!",50,2,3,2,"Englisch"]
-]
-tDeEn = pipeline(model="Helsinki-NLP/opus-mt-de-en")
-tEnDe = pipeline(model="Helsinki-NLP/opus-mt-en-de")
-bot = pipeline(model="google/flan-t5-large")
-def solve(text,max_length,length_penalty,no_repeat_ngram_size,num_beams,language):
-  if(language=="Deutsch"):
-      text=tDeEn(text)[0]["translation_text"]
-  out=bot(text,max_length=max_length, length_penalty=length_penalty, no_repeat_ngram_size=no_repeat_ngram_size, num_beams=num_beams, early_stopping=True)[0]["generated_text"]
-  if(language=="Deutsch"):
-      out=tEnDe(out)[0]["translation_text"]
-  return out
-task = gr.Interface(
-  fn=solve,
-  inputs=[
-      gr.Textbox(lines=5,max_lines=6,label="Frage"),
-      gr.Slider(minimum=1.0,maximum=200.0,value=50.0,step=1,interactive=True,label="max_length"),
-      gr.Slider(minimum=1.0,maximum=20.0,value=1.0,step=1,interactive=True,label="length_penalty"),
-      gr.Slider(minimum=0.0,maximum=5.0,value=3.0,step=1,interactive=True,label="no_repeat_ngram_size"),
-      gr.Slider(minimum=1.0,maximum=20.0,value=1.0,step=1,interactive=True,label="num_beams"),
-      gr.Dropdown(["Deutsch", "Englisch"],value="Deutsch"),
-  ],
-  outputs="text",
-  title=title,
-  description=desc,
-  examples=examples
-)
-if __name__ == "__main__":
-  task.launch()

spaces/AILab-CVC/EvalCrafter/src/utils_display.py DELETED Viewed

@@ -1,99 +0,0 @@
-from dataclasses import dataclass
-# These classes are for user facing column names, to avoid having to change them
-# all around the code when a modif is needed
-@dataclass
-class ColumnContent:
-    name: str
-    type: str
-    displayed_by_default: bool
-    hidden: bool = False
-def fields(raw_class):
-    return [v for k, v in raw_class.__dict__.items() if k[:2] != "__" and k[-2:] != "__"]
-@dataclass(frozen=True)
-class AutoEvalColumn: # Auto evals column
-    model_type_symbol = ColumnContent("T", "str", True)
-    model = ColumnContent("Model", "markdown", True)
-    average = ColumnContent("Average ⬆️", "number", True)
-    arc = ColumnContent("ARC", "number", True)
-    hellaswag = ColumnContent("HellaSwag", "number", True)
-    mmlu = ColumnContent("MMLU", "number", True)
-    truthfulqa = ColumnContent("TruthfulQA", "number", True)
-    model_type = ColumnContent("Type", "str", False)
-    precision = ColumnContent("Precision", "str", False, True)
-    license = ColumnContent("Hub License", "str", False)
-    params = ColumnContent("#Params (B)", "number", False)
-    likes = ColumnContent("Hub ❤️", "number", False)
-    revision = ColumnContent("Model sha", "str", False, False)
-    dummy = ColumnContent("model_name_for_query", "str", True) # dummy col to implement search bar (hidden by custom CSS)
-@dataclass(frozen=True)
-class EloEvalColumn: # Elo evals column
-    model = ColumnContent("Model", "markdown", True)
-    gpt4 = ColumnContent("GPT-4 (all)", "number", True)
-    human_all = ColumnContent("Human (all)", "number", True)
-    human_instruct = ColumnContent("Human (instruct)", "number", True)
-    human_code_instruct = ColumnContent("Human (code-instruct)", "number", True)
-@dataclass(frozen=True)
-class EvalQueueColumn: # Queue column
-    model = ColumnContent("model", "markdown", True)
-    revision = ColumnContent("revision", "str", True)
-    private = ColumnContent("private", "bool", True)
-    precision = ColumnContent("precision", "bool", True)
-    weight_type = ColumnContent("weight_type", "str", "Original")
-    status = ColumnContent("status", "str", True)
-LLAMAS = ["huggingface/llama-7b", "huggingface/llama-13b", "huggingface/llama-30b", "huggingface/llama-65b"]
-KOALA_LINK = "https://huggingface.co/TheBloke/koala-13B-HF"
-VICUNA_LINK = "https://huggingface.co/lmsys/vicuna-13b-delta-v1.1"
-OASST_LINK = "https://huggingface.co/OpenAssistant/oasst-sft-4-pythia-12b-epoch-3.5"
-DOLLY_LINK = "https://huggingface.co/databricks/dolly-v2-12b"
-MODEL_PAGE = "https://huggingface.co/models"
-LLAMA_LINK = "https://ai.facebook.com/blog/large-language-model-llama-meta-ai/"
-VICUNA_LINK = "https://huggingface.co/CarperAI/stable-vicuna-13b-delta"
-ALPACA_LINK = "https://crfm.stanford.edu/2023/03/13/alpaca.html"
-def model_hyperlink(link, model_name):
-    return f'<a target="_blank" href="{link}" style="color: var(--link-text-color); text-decoration: underline;text-decoration-style: dotted;">{model_name}</a>'
-def make_clickable_model(model_name):
-    link = f"https://huggingface.co/{model_name}"
-    if model_name in LLAMAS:
-        link = LLAMA_LINK
-        model_name = model_name.split("/")[1]
-    elif model_name == "HuggingFaceH4/stable-vicuna-13b-2904":
-        link = VICUNA_LINK
-        model_name = "stable-vicuna-13b"
-    elif model_name == "HuggingFaceH4/llama-7b-ift-alpaca":
-        link = ALPACA_LINK
-        model_name = "alpaca-13b"
-    if model_name == "dolly-12b":
-        link = DOLLY_LINK
-    elif model_name == "vicuna-13b":
-        link = VICUNA_LINK
-    elif model_name == "koala-13b":
-        link = KOALA_LINK
-    elif model_name == "oasst-12b":
-        link = OASST_LINK
-    #else:
-    #    link = MODEL_PAGE
-    return model_hyperlink(link, model_name)
-def styled_error(error):
-    return f"<p style='color: red; font-size: 20px; text-align: center;'>{error}</p>"
-def styled_warning(warn):
-    return f"<p style='color: orange; font-size: 20px; text-align: center;'>{warn}</p>"
-def styled_message(message):
-    return f"<p style='color: green; font-size: 20px; text-align: center;'>{message}</p>"

spaces/AISuperheroes/01ST-CSV-Dataset-Analyzer/README.md DELETED Viewed

@@ -1,13 +0,0 @@
----
-title: 01ST CSV Dataset Analyzer
-emoji: 🔥
-colorFrom: red
-colorTo: purple
-sdk: streamlit
-sdk_version: 1.10.0
-app_file: app.py
-pinned: false
-license: mit
----
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/AchyuthGamer/OpenGPT-Chat-UI/src/routes/r/[id]/+page.server.ts DELETED Viewed

@@ -1,34 +0,0 @@
-import type { PageServerLoad } from "./$types";
-import { collections } from "$lib/server/database";
-import { error } from "@sveltejs/kit";
-import type { WebSearchMessageResult } from "$lib/types/WebSearch";
-export const load: PageServerLoad = async ({ params }) => {
-	/*const conversation = await collections.sharedConversations.findOne({
-		_id: params.id,
-	});
-	if (!conversation) {
-		throw error(404, "Conversation not found");
-	}
-	const webSearchesId = conversation.messages
-		.filter((message) => message.webSearchId)
-		.map((message) => new ObjectId(message.webSearchId));
-	const results = await collections.webSearches.find({ _id: { $in: webSearchesId } }).toArray();
-	const searches = Object.fromEntries(
-		results.map((x) => [
-			x._id.toString(),
-			[...x.messages, { type: "result", id: x._id.toString() } satisfies WebSearchMessageResult],
-		])
-	);
-	return {
-		messages: conversation.messages,
-		title: conversation.title,
-		model: conversation.model,
-		searches,
-	};*/
-};

spaces/AgentVerse/agentVerse/agentverse/tasks/simulation/sde_team/readme.md DELETED Viewed

@@ -1,98 +0,0 @@
-# SDE team
-In this task, LLMs work as a software development team to solve code implementation problem. We have simulated two scenarios *sde_team/sde_team_2players* and *sde_team/sde_team_3players*.
-The performance on [HumanEval](https://github.com/openai/human-eval) is shown below.
-| Methods                         | Pass@1 HumanEval |
-|---------------------------------|-----------|
-| Codex (175B)*                   | 0.47      |
-| &nbsp;&nbsp;&nbsp;&nbsp;+ CodeT*                      | 0.658     |
-| PaLM Coder (540B)*              | 0.36      |
-| GPT-4*                          | 0.67      |
-| ChatGPT (gpt-3.5-turbo)*        | 0.573     |
-| &nbsp;&nbsp;&nbsp;&nbsp;+ Self-collaboration*         | 0.744     |
-| &nbsp;&nbsp;&nbsp;&nbsp;+ Our *sde_team/sde_team_2players* | **0.799**     |
-*: Results are from [Self-collaboration](https://arxiv.org/abs/2304.07590). The methods in the table all employed the provided unit tests.
-Our *sde_team/sde_team_2players* shares the similar spirit as Self-collaboration at the moment. We are working to introduce more features in this repo!
-## *sde_team/sde_team_2players*
-In this case, we are simulating a code generation problem that a python function body is required to be generated given function signature, doc string and unit tests. In the following, we will elaborate the details.
-### Roles
-Detailed role description and prompts can be found in `config.yaml`
-#### *code writer*
-Code writer writes the code to satisfy the given requirement. The requirement is given in the \<problem\> field of the prompt. The code writer first thinks about the task (the thoughts written in \<thoughts\>) and then write the code in \<code\>.
-The submitted code will be tested automatically on a series of unit tests. Then the feedback (in \<unit test feedback\>) together with a professional code review (in \<code review\>) will be returned. Then code writer will leverage this information to refine the previously submitted code. The refinement will take multiple iterations.
-#### *code reviewer*
-Code reviewer will write professional review for the submitted code. The submitted code will be given in \<submitted code\>, the execution feedback of unit tests will be given in \<unit tests feedback\> and the review will be composed in \<code review\>.
-#### dummy *code tester*
-Code tester is a dummy agent. In the current implementation, unit tests are executed via the local python code `agentverse/environments/rules/selector/code_api.py`. We will integrate the execution tools to BMTools soon.
-### How to run the simulation
-#### Provide problem and unit tests
-The code problem and unit tests should be given in `agentverse/tasks/sde_team/sde_team_2players/code_problem.json`. Here is an example.
-```json
-{
-    "problem": "from typing import List\n\n\ndef separate_paren_groups(paren_string: str) -> List[str]:\n    \"\"\" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to\n    separate those group into separate strings and return the list of those.\n    Separate groups are balanced (each open brace is properly closed) and not nested within each other\n    Ignore any spaces in the input string.\n    >>> separate_paren_groups('( ) (( )) (( )( ))')\n    ['()', '(())', '(()())']\n    \"\"\"\n",
-    "unit_tests": [
-        "assert separate_paren_groups('(()()) ((())) () ((())()())') == ['(()())', '((()))', '()', '((())()())']",
-        "assert separate_paren_groups('() (()) ((())) (((())))') == ['()', '(())', '((()))', '(((())))']",
-        "assert separate_paren_groups('(()(())((())))') == ['(()(())((())))']",
-        "assert separate_paren_groups('( ) (( )) (( )( ))') == ['()', '(())', '(()())']"
-    ]
-}
-```
-#### Build the configuration file
-Run `agentverse/tasks/sde_team/sde_team_2players/build_config.py` to generate `config.yaml`.
-```bash
-cd agentverse/tasks/sde_team/sde_team_2players/
-python build_config.py
-```
-#### Run the session
-After generating `config.yaml`, run the `main.py` to start the task.
-```python
-import os
-from agentverse.agentverse import AgentVerse
-from argparse import ArgumentParser
-parser = ArgumentParser()
-parser.add_argument("--task", type=str, default="sde_team/sde_team_2players")
-parser.add_argument("--tasks_dir", type=str, default=os.path.join(
-    os.path.dirname(__file__), "agentverse", "tasks"))
-args = parser.parse_args()
-agentverse = AgentVerse.from_task(args.task, args.tasks_dir)
-agentverse.run()
-```
-## *sde_team/sde_team_3players*
-Different from *sde_team/sde_team_2players*, we additionally introduce a role to automatically generate unit tests.
-- *unit test generator*: generate a series of unit test cases for the coding problem.
-### Stay tuned
-The generated unit tests are not always perfect, as they may not be correct. We plan to incorporate tools to raise the correctness of the generated cases.

spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/plugins/ymlachievements-plugin.d.ts DELETED Viewed

@@ -1,6 +0,0 @@
-import Achievements from './ymlachievements';
-export default class AchievementsPlugin extends Phaser.Plugins.BasePlugin {
-    add(): Achievements;
-}

spaces/AlanMars/QYL-AI-Space/assets/external-scripts.js DELETED Viewed

	@@ -1,2 +0,0 @@
1	-
2	- // external javascript here

spaces/Amrrs/DragGan-Inversion/PTI/criteria/l2_loss.py DELETED Viewed

@@ -1,8 +0,0 @@
-import torch
-l2_criterion = torch.nn.MSELoss(reduction='mean')
-def l2_loss(real_images, generated_images):
-    loss = l2_criterion(real_images, generated_images)
-    return loss

spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/docs/source/en/training/adapt_a_model.md DELETED Viewed

@@ -1,42 +0,0 @@
-# Adapt a model to a new task
-Many diffusion systems share the same components, allowing you to adapt a pretrained model for one task to an entirely different task.
-This guide will show you how to adapt a pretrained text-to-image model for inpainting by initializing and modifying the architecture of a pretrained [`UNet2DConditionModel`].
-## Configure UNet2DConditionModel parameters
-A [`UNet2DConditionModel`] by default accepts 4 channels in the [input sample](https://huggingface.co/docs/diffusers/v0.16.0/en/api/models#diffusers.UNet2DConditionModel.in_channels). For example, load a pretrained text-to-image model like [`runwayml/stable-diffusion-v1-5`](https://huggingface.co/runwayml/stable-diffusion-v1-5) and take a look at the number of `in_channels`:
-```py
-from diffusers import StableDiffusionPipeline
-pipeline = StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5")
-pipeline.unet.config["in_channels"]
-4
-```
-Inpainting requires 9 channels in the input sample. You can check this value in a pretrained inpainting model like [`runwayml/stable-diffusion-inpainting`](https://huggingface.co/runwayml/stable-diffusion-inpainting):
-```py
-from diffusers import StableDiffusionPipeline
-pipeline = StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-inpainting")
-pipeline.unet.config["in_channels"]
-9
-```
-To adapt your text-to-image model for inpainting, you'll need to change the number of `in_channels` from 4 to 9.
-Initialize a [`UNet2DConditionModel`] with the pretrained text-to-image model weights, and change `in_channels` to 9. Changing the number of `in_channels` means you need to set `ignore_mismatched_sizes=True` and `low_cpu_mem_usage=False` to avoid a size mismatch error because the shape is different now.
-```py
-from diffusers import UNet2DConditionModel
-model_id = "runwayml/stable-diffusion-v1-5"
-unet = UNet2DConditionModel.from_pretrained(
-    model_id, subfolder="unet", in_channels=9, low_cpu_mem_usage=False, ignore_mismatched_sizes=True
-)
-```
-The pretrained weights of the other components from the text-to-image model are initialized from their checkpoints, but the input channel weights (`conv_in.weight`) of the `unet` are randomly initialized. It is important to finetune the model for inpainting because otherwise the model returns noise.

spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/src/diffusers/pipelines/onnx_utils.py DELETED Viewed

@@ -1,212 +0,0 @@
-# coding=utf-8
-# Copyright 2023 The HuggingFace Inc. team.
-# Copyright (c) 2022, NVIDIA CORPORATION.  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 os
-import shutil
-from pathlib import Path
-from typing import Optional, Union
-import numpy as np
-from huggingface_hub import hf_hub_download
-from ..utils import ONNX_EXTERNAL_WEIGHTS_NAME, ONNX_WEIGHTS_NAME, is_onnx_available, logging
-if is_onnx_available():
-    import onnxruntime as ort
-logger = logging.get_logger(__name__)
-ORT_TO_NP_TYPE = {
-    "tensor(bool)": np.bool_,
-    "tensor(int8)": np.int8,
-    "tensor(uint8)": np.uint8,
-    "tensor(int16)": np.int16,
-    "tensor(uint16)": np.uint16,
-    "tensor(int32)": np.int32,
-    "tensor(uint32)": np.uint32,
-    "tensor(int64)": np.int64,
-    "tensor(uint64)": np.uint64,
-    "tensor(float16)": np.float16,
-    "tensor(float)": np.float32,
-    "tensor(double)": np.float64,
-}
-class OnnxRuntimeModel:
-    def __init__(self, model=None, **kwargs):
-        logger.info("`diffusers.OnnxRuntimeModel` is experimental and might change in the future.")
-        self.model = model
-        self.model_save_dir = kwargs.get("model_save_dir", None)
-        self.latest_model_name = kwargs.get("latest_model_name", ONNX_WEIGHTS_NAME)
-    def __call__(self, **kwargs):
-        inputs = {k: np.array(v) for k, v in kwargs.items()}
-        return self.model.run(None, inputs)
-    @staticmethod
-    def load_model(path: Union[str, Path], provider=None, sess_options=None):
-        """
-        Loads an ONNX Inference session with an ExecutionProvider. Default provider is `CPUExecutionProvider`
-        Arguments:
-            path (`str` or `Path`):
-                Directory from which to load
-            provider(`str`, *optional*):
-                Onnxruntime execution provider to use for loading the model, defaults to `CPUExecutionProvider`
-        """
-        if provider is None:
-            logger.info("No onnxruntime provider specified, using CPUExecutionProvider")
-            provider = "CPUExecutionProvider"
-        return ort.InferenceSession(path, providers=[provider], sess_options=sess_options)
-    def _save_pretrained(self, save_directory: Union[str, Path], file_name: Optional[str] = None, **kwargs):
-        """
-        Save a model and its configuration file to a directory, so that it can be re-loaded using the
-        [`~optimum.onnxruntime.modeling_ort.ORTModel.from_pretrained`] class method. It will always save the
-        latest_model_name.
-        Arguments:
-            save_directory (`str` or `Path`):
-                Directory where to save the model file.
-            file_name(`str`, *optional*):
-                Overwrites the default model file name from `"model.onnx"` to `file_name`. This allows you to save the
-                model with a different name.
-        """
-        model_file_name = file_name if file_name is not None else ONNX_WEIGHTS_NAME
-        src_path = self.model_save_dir.joinpath(self.latest_model_name)
-        dst_path = Path(save_directory).joinpath(model_file_name)
-        try:
-            shutil.copyfile(src_path, dst_path)
-        except shutil.SameFileError:
-            pass
-        # copy external weights (for models >2GB)
-        src_path = self.model_save_dir.joinpath(ONNX_EXTERNAL_WEIGHTS_NAME)
-        if src_path.exists():
-            dst_path = Path(save_directory).joinpath(ONNX_EXTERNAL_WEIGHTS_NAME)
-            try:
-                shutil.copyfile(src_path, dst_path)
-            except shutil.SameFileError:
-                pass
-    def save_pretrained(
-        self,
-        save_directory: Union[str, os.PathLike],
-        **kwargs,
-    ):
-        """
-        Save a model to a directory, so that it can be re-loaded using the [`~OnnxModel.from_pretrained`] class
-        method.:
-        Arguments:
-            save_directory (`str` or `os.PathLike`):
-                Directory to which to save. Will be created if it doesn't exist.
-        """
-        if os.path.isfile(save_directory):
-            logger.error(f"Provided path ({save_directory}) should be a directory, not a file")
-            return
-        os.makedirs(save_directory, exist_ok=True)
-        # saving model weights/files
-        self._save_pretrained(save_directory, **kwargs)
-    @classmethod
-    def _from_pretrained(
-        cls,
-        model_id: Union[str, Path],
-        use_auth_token: Optional[Union[bool, str, None]] = None,
-        revision: Optional[Union[str, None]] = None,
-        force_download: bool = False,
-        cache_dir: Optional[str] = None,
-        file_name: Optional[str] = None,
-        provider: Optional[str] = None,
-        sess_options: Optional["ort.SessionOptions"] = None,
-        **kwargs,
-    ):
-        """
-        Load a model from a directory or the HF Hub.
-        Arguments:
-            model_id (`str` or `Path`):
-                Directory from which to load
-            use_auth_token (`str` or `bool`):
-                Is needed to load models from a private or gated repository
-            revision (`str`):
-                Revision is the specific model version to use. It can be a branch name, a tag name, or a commit id
-            cache_dir (`Union[str, Path]`, *optional*):
-                Path to a directory in which a downloaded pretrained model configuration should be cached if the
-                standard cache should not be used.
-            force_download (`bool`, *optional*, defaults to `False`):
-                Whether or not to force the (re-)download of the model weights and configuration files, overriding the
-                cached versions if they exist.
-            file_name(`str`):
-                Overwrites the default model file name from `"model.onnx"` to `file_name`. This allows you to load
-                different model files from the same repository or directory.
-            provider(`str`):
-                The ONNX runtime provider, e.g. `CPUExecutionProvider` or `CUDAExecutionProvider`.
-            kwargs (`Dict`, *optional*):
-                kwargs will be passed to the model during initialization
-        """
-        model_file_name = file_name if file_name is not None else ONNX_WEIGHTS_NAME
-        # load model from local directory
-        if os.path.isdir(model_id):
-            model = OnnxRuntimeModel.load_model(
-                os.path.join(model_id, model_file_name), provider=provider, sess_options=sess_options
-            )
-            kwargs["model_save_dir"] = Path(model_id)
-        # load model from hub
-        else:
-            # download model
-            model_cache_path = hf_hub_download(
-                repo_id=model_id,
-                filename=model_file_name,
-                use_auth_token=use_auth_token,
-                revision=revision,
-                cache_dir=cache_dir,
-                force_download=force_download,
-            )
-            kwargs["model_save_dir"] = Path(model_cache_path).parent
-            kwargs["latest_model_name"] = Path(model_cache_path).name
-            model = OnnxRuntimeModel.load_model(model_cache_path, provider=provider, sess_options=sess_options)
-        return cls(model=model, **kwargs)
-    @classmethod
-    def from_pretrained(
-        cls,
-        model_id: Union[str, Path],
-        force_download: bool = True,
-        use_auth_token: Optional[str] = None,
-        cache_dir: Optional[str] = None,
-        **model_kwargs,
-    ):
-        revision = None
-        if len(str(model_id).split("@")) == 2:
-            model_id, revision = model_id.split("@")
-        return cls._from_pretrained(
-            model_id=model_id,
-            revision=revision,
-            cache_dir=cache_dir,
-            force_download=force_download,
-            use_auth_token=use_auth_token,
-            **model_kwargs,
-        )

spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/tests/pipelines/altdiffusion/test_alt_diffusion_img2img.py DELETED Viewed

@@ -1,300 +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 unittest
-import numpy as np
-import torch
-from transformers import XLMRobertaTokenizer
-from diffusers import (
-    AltDiffusionImg2ImgPipeline,
-    AutoencoderKL,
-    PNDMScheduler,
-    UNet2DConditionModel,
-)
-from diffusers.image_processor import VaeImageProcessor
-from diffusers.pipelines.alt_diffusion.modeling_roberta_series import (
-    RobertaSeriesConfig,
-    RobertaSeriesModelWithTransformation,
-)
-from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device
-from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu
-enable_full_determinism()
-class AltDiffusionImg2ImgPipelineFastTests(unittest.TestCase):
-    def tearDown(self):
-        # clean up the VRAM after each test
-        super().tearDown()
-        gc.collect()
-        torch.cuda.empty_cache()
-    @property
-    def dummy_image(self):
-        batch_size = 1
-        num_channels = 3
-        sizes = (32, 32)
-        image = floats_tensor((batch_size, num_channels) + sizes, rng=random.Random(0)).to(torch_device)
-        return image
-    @property
-    def dummy_cond_unet(self):
-        torch.manual_seed(0)
-        model = 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,
-        )
-        return model
-    @property
-    def dummy_vae(self):
-        torch.manual_seed(0)
-        model = 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,
-        )
-        return model
-    @property
-    def dummy_text_encoder(self):
-        torch.manual_seed(0)
-        config = RobertaSeriesConfig(
-            hidden_size=32,
-            project_dim=32,
-            intermediate_size=37,
-            layer_norm_eps=1e-05,
-            num_attention_heads=4,
-            num_hidden_layers=5,
-            pad_token_id=1,
-            vocab_size=5006,
-        )
-        return RobertaSeriesModelWithTransformation(config)
-    @property
-    def dummy_extractor(self):
-        def extract(*args, **kwargs):
-            class Out:
-                def __init__(self):
-                    self.pixel_values = torch.ones([0])
-                def to(self, device):
-                    self.pixel_values.to(device)
-                    return self
-            return Out()
-        return extract
-    def test_stable_diffusion_img2img_default_case(self):
-        device = "cpu"  # ensure determinism for the device-dependent torch.Generator
-        unet = self.dummy_cond_unet
-        scheduler = PNDMScheduler(skip_prk_steps=True)
-        vae = self.dummy_vae
-        bert = self.dummy_text_encoder
-        tokenizer = XLMRobertaTokenizer.from_pretrained("hf-internal-testing/tiny-xlm-roberta")
-        tokenizer.model_max_length = 77
-        init_image = self.dummy_image.to(device)
-        init_image = init_image / 2 + 0.5
-        # make sure here that pndm scheduler skips prk
-        alt_pipe = AltDiffusionImg2ImgPipeline(
-            unet=unet,
-            scheduler=scheduler,
-            vae=vae,
-            text_encoder=bert,
-            tokenizer=tokenizer,
-            safety_checker=None,
-            feature_extractor=self.dummy_extractor,
-        )
-        alt_pipe.image_processor = VaeImageProcessor(vae_scale_factor=alt_pipe.vae_scale_factor, do_normalize=True)
-        alt_pipe = alt_pipe.to(device)
-        alt_pipe.set_progress_bar_config(disable=None)
-        prompt = "A painting of a squirrel eating a burger"
-        generator = torch.Generator(device=device).manual_seed(0)
-        output = alt_pipe(
-            [prompt],
-            generator=generator,
-            guidance_scale=6.0,
-            num_inference_steps=2,
-            output_type="np",
-            image=init_image,
-        )
-        image = output.images
-        generator = torch.Generator(device=device).manual_seed(0)
-        image_from_tuple = alt_pipe(
-            [prompt],
-            generator=generator,
-            guidance_scale=6.0,
-            num_inference_steps=2,
-            output_type="np",
-            image=init_image,
-            return_dict=False,
-        )[0]
-        image_slice = image[0, -3:, -3:, -1]
-        image_from_tuple_slice = image_from_tuple[0, -3:, -3:, -1]
-        assert image.shape == (1, 32, 32, 3)
-        expected_slice = np.array([0.4427, 0.3731, 0.4249, 0.4941, 0.4546, 0.4148, 0.4193, 0.4666, 0.4499])
-        assert np.abs(image_slice.flatten() - expected_slice).max() < 5e-3
-        assert np.abs(image_from_tuple_slice.flatten() - expected_slice).max() < 5e-3
-    @unittest.skipIf(torch_device != "cuda", "This test requires a GPU")
-    def test_stable_diffusion_img2img_fp16(self):
-        """Test that stable diffusion img2img works with fp16"""
-        unet = self.dummy_cond_unet
-        scheduler = PNDMScheduler(skip_prk_steps=True)
-        vae = self.dummy_vae
-        bert = self.dummy_text_encoder
-        tokenizer = XLMRobertaTokenizer.from_pretrained("hf-internal-testing/tiny-xlm-roberta")
-        tokenizer.model_max_length = 77
-        init_image = self.dummy_image.to(torch_device)
-        # put models in fp16
-        unet = unet.half()
-        vae = vae.half()
-        bert = bert.half()
-        # make sure here that pndm scheduler skips prk
-        alt_pipe = AltDiffusionImg2ImgPipeline(
-            unet=unet,
-            scheduler=scheduler,
-            vae=vae,
-            text_encoder=bert,
-            tokenizer=tokenizer,
-            safety_checker=None,
-            feature_extractor=self.dummy_extractor,
-        )
-        alt_pipe.image_processor = VaeImageProcessor(vae_scale_factor=alt_pipe.vae_scale_factor, do_normalize=False)
-        alt_pipe = alt_pipe.to(torch_device)
-        alt_pipe.set_progress_bar_config(disable=None)
-        prompt = "A painting of a squirrel eating a burger"
-        generator = torch.manual_seed(0)
-        image = alt_pipe(
-            [prompt],
-            generator=generator,
-            num_inference_steps=2,
-            output_type="np",
-            image=init_image,
-        ).images
-        assert image.shape == (1, 32, 32, 3)
-    @unittest.skipIf(torch_device != "cuda", "This test requires a GPU")
-    def test_stable_diffusion_img2img_pipeline_multiple_of_8(self):
-        init_image = load_image(
-            "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
-            "/img2img/sketch-mountains-input.jpg"
-        )
-        # resize to resolution that is divisible by 8 but not 16 or 32
-        init_image = init_image.resize((760, 504))
-        model_id = "BAAI/AltDiffusion"
-        pipe = AltDiffusionImg2ImgPipeline.from_pretrained(
-            model_id,
-            safety_checker=None,
-        )
-        pipe.to(torch_device)
-        pipe.set_progress_bar_config(disable=None)
-        pipe.enable_attention_slicing()
-        prompt = "A fantasy landscape, trending on artstation"
-        generator = torch.manual_seed(0)
-        output = pipe(
-            prompt=prompt,
-            image=init_image,
-            strength=0.75,
-            guidance_scale=7.5,
-            generator=generator,
-            output_type="np",
-        )
-        image = output.images[0]
-        image_slice = image[255:258, 383:386, -1]
-        assert image.shape == (504, 760, 3)
-        expected_slice = np.array([0.9358, 0.9397, 0.9599, 0.9901, 1.0000, 1.0000, 0.9882, 1.0000, 1.0000])
-        assert np.abs(image_slice.flatten() - expected_slice).max() < 1e-2
-@slow
-@require_torch_gpu
-class AltDiffusionImg2ImgPipelineIntegrationTests(unittest.TestCase):
-    def tearDown(self):
-        # clean up the VRAM after each test
-        super().tearDown()
-        gc.collect()
-        torch.cuda.empty_cache()
-    def test_stable_diffusion_img2img_pipeline_default(self):
-        init_image = load_image(
-            "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
-            "/img2img/sketch-mountains-input.jpg"
-        )
-        init_image = init_image.resize((768, 512))
-        expected_image = load_numpy(
-            "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/img2img/fantasy_landscape_alt.npy"
-        )
-        model_id = "BAAI/AltDiffusion"
-        pipe = AltDiffusionImg2ImgPipeline.from_pretrained(
-            model_id,
-            safety_checker=None,
-        )
-        pipe.to(torch_device)
-        pipe.set_progress_bar_config(disable=None)
-        pipe.enable_attention_slicing()
-        prompt = "A fantasy landscape, trending on artstation"
-        generator = torch.manual_seed(0)
-        output = pipe(
-            prompt=prompt,
-            image=init_image,
-            strength=0.75,
-            guidance_scale=7.5,
-            generator=generator,
-            output_type="np",
-        )
-        image = output.images[0]
-        assert image.shape == (512, 768, 3)
-        # img2img is flaky across GPUs even in fp32, so using MAE here
-        assert np.abs(expected_image - image).max() < 1e-2

spaces/Andy1621/uniformer_image_detection/mmdet/models/backbones/resnest.py DELETED Viewed

@@ -1,317 +0,0 @@
-import math
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-import torch.utils.checkpoint as cp
-from mmcv.cnn import build_conv_layer, build_norm_layer
-from ..builder import BACKBONES
-from ..utils import ResLayer
-from .resnet import Bottleneck as _Bottleneck
-from .resnet import ResNetV1d
-class RSoftmax(nn.Module):
-    """Radix Softmax module in ``SplitAttentionConv2d``.
-    Args:
-        radix (int): Radix of input.
-        groups (int): Groups of input.
-    """
-    def __init__(self, radix, groups):
-        super().__init__()
-        self.radix = radix
-        self.groups = groups
-    def forward(self, x):
-        batch = x.size(0)
-        if self.radix > 1:
-            x = x.view(batch, self.groups, self.radix, -1).transpose(1, 2)
-            x = F.softmax(x, dim=1)
-            x = x.reshape(batch, -1)
-        else:
-            x = torch.sigmoid(x)
-        return x
-class SplitAttentionConv2d(nn.Module):
-    """Split-Attention Conv2d in ResNeSt.
-    Args:
-        in_channels (int): Number of channels in the input feature map.
-        channels (int): Number of intermediate channels.
-        kernel_size (int | tuple[int]): Size of the convolution kernel.
-        stride (int | tuple[int]): Stride of the convolution.
-        padding (int | tuple[int]): Zero-padding added to both sides of
-        dilation (int | tuple[int]): Spacing between kernel elements.
-        groups (int): Number of blocked connections from input channels to
-            output channels.
-        groups (int): Same as nn.Conv2d.
-        radix (int): Radix of SpltAtConv2d. Default: 2
-        reduction_factor (int): Reduction factor of inter_channels. Default: 4.
-        conv_cfg (dict): Config dict for convolution layer. Default: None,
-            which means using conv2d.
-        norm_cfg (dict): Config dict for normalization layer. Default: None.
-        dcn (dict): Config dict for DCN. Default: None.
-    """
-    def __init__(self,
-                 in_channels,
-                 channels,
-                 kernel_size,
-                 stride=1,
-                 padding=0,
-                 dilation=1,
-                 groups=1,
-                 radix=2,
-                 reduction_factor=4,
-                 conv_cfg=None,
-                 norm_cfg=dict(type='BN'),
-                 dcn=None):
-        super(SplitAttentionConv2d, self).__init__()
-        inter_channels = max(in_channels * radix // reduction_factor, 32)
-        self.radix = radix
-        self.groups = groups
-        self.channels = channels
-        self.with_dcn = dcn is not None
-        self.dcn = dcn
-        fallback_on_stride = False
-        if self.with_dcn:
-            fallback_on_stride = self.dcn.pop('fallback_on_stride', False)
-        if self.with_dcn and not fallback_on_stride:
-            assert conv_cfg is None, 'conv_cfg must be None for DCN'
-            conv_cfg = dcn
-        self.conv = build_conv_layer(
-            conv_cfg,
-            in_channels,
-            channels * radix,
-            kernel_size,
-            stride=stride,
-            padding=padding,
-            dilation=dilation,
-            groups=groups * radix,
-            bias=False)
-        # To be consistent with original implementation, starting from 0
-        self.norm0_name, norm0 = build_norm_layer(
-            norm_cfg, channels * radix, postfix=0)
-        self.add_module(self.norm0_name, norm0)
-        self.relu = nn.ReLU(inplace=True)
-        self.fc1 = build_conv_layer(
-            None, channels, inter_channels, 1, groups=self.groups)
-        self.norm1_name, norm1 = build_norm_layer(
-            norm_cfg, inter_channels, postfix=1)
-        self.add_module(self.norm1_name, norm1)
-        self.fc2 = build_conv_layer(
-            None, inter_channels, channels * radix, 1, groups=self.groups)
-        self.rsoftmax = RSoftmax(radix, groups)
-    @property
-    def norm0(self):
-        """nn.Module: the normalization layer named "norm0" """
-        return getattr(self, self.norm0_name)
-    @property
-    def norm1(self):
-        """nn.Module: the normalization layer named "norm1" """
-        return getattr(self, self.norm1_name)
-    def forward(self, x):
-        x = self.conv(x)
-        x = self.norm0(x)
-        x = self.relu(x)
-        batch, rchannel = x.shape[:2]
-        batch = x.size(0)
-        if self.radix > 1:
-            splits = x.view(batch, self.radix, -1, *x.shape[2:])
-            gap = splits.sum(dim=1)
-        else:
-            gap = x
-        gap = F.adaptive_avg_pool2d(gap, 1)
-        gap = self.fc1(gap)
-        gap = self.norm1(gap)
-        gap = self.relu(gap)
-        atten = self.fc2(gap)
-        atten = self.rsoftmax(atten).view(batch, -1, 1, 1)
-        if self.radix > 1:
-            attens = atten.view(batch, self.radix, -1, *atten.shape[2:])
-            out = torch.sum(attens * splits, dim=1)
-        else:
-            out = atten * x
-        return out.contiguous()
-class Bottleneck(_Bottleneck):
-    """Bottleneck block for ResNeSt.
-    Args:
-        inplane (int): Input planes of this block.
-        planes (int): Middle planes of this block.
-        groups (int): Groups of conv2.
-        base_width (int): Base of width in terms of base channels. Default: 4.
-        base_channels (int): Base of channels for calculating width.
-            Default: 64.
-        radix (int): Radix of SpltAtConv2d. Default: 2
-        reduction_factor (int): Reduction factor of inter_channels in
-            SplitAttentionConv2d. Default: 4.
-        avg_down_stride (bool): Whether to use average pool for stride in
-            Bottleneck. Default: True.
-        kwargs (dict): Key word arguments for base class.
-    """
-    expansion = 4
-    def __init__(self,
-                 inplanes,
-                 planes,
-                 groups=1,
-                 base_width=4,
-                 base_channels=64,
-                 radix=2,
-                 reduction_factor=4,
-                 avg_down_stride=True,
-                 **kwargs):
-        """Bottleneck block for ResNeSt."""
-        super(Bottleneck, self).__init__(inplanes, planes, **kwargs)
-        if groups == 1:
-            width = self.planes
-        else:
-            width = math.floor(self.planes *
-                               (base_width / base_channels)) * groups
-        self.avg_down_stride = avg_down_stride and self.conv2_stride > 1
-        self.norm1_name, norm1 = build_norm_layer(
-            self.norm_cfg, width, postfix=1)
-        self.norm3_name, norm3 = build_norm_layer(
-            self.norm_cfg, self.planes * self.expansion, postfix=3)
-        self.conv1 = build_conv_layer(
-            self.conv_cfg,
-            self.inplanes,
-            width,
-            kernel_size=1,
-            stride=self.conv1_stride,
-            bias=False)
-        self.add_module(self.norm1_name, norm1)
-        self.with_modulated_dcn = False
-        self.conv2 = SplitAttentionConv2d(
-            width,
-            width,
-            kernel_size=3,
-            stride=1 if self.avg_down_stride else self.conv2_stride,
-            padding=self.dilation,
-            dilation=self.dilation,
-            groups=groups,
-            radix=radix,
-            reduction_factor=reduction_factor,
-            conv_cfg=self.conv_cfg,
-            norm_cfg=self.norm_cfg,
-            dcn=self.dcn)
-        delattr(self, self.norm2_name)
-        if self.avg_down_stride:
-            self.avd_layer = nn.AvgPool2d(3, self.conv2_stride, padding=1)
-        self.conv3 = build_conv_layer(
-            self.conv_cfg,
-            width,
-            self.planes * self.expansion,
-            kernel_size=1,
-            bias=False)
-        self.add_module(self.norm3_name, norm3)
-    def forward(self, x):
-        def _inner_forward(x):
-            identity = x
-            out = self.conv1(x)
-            out = self.norm1(out)
-            out = self.relu(out)
-            if self.with_plugins:
-                out = self.forward_plugin(out, self.after_conv1_plugin_names)
-            out = self.conv2(out)
-            if self.avg_down_stride:
-                out = self.avd_layer(out)
-            if self.with_plugins:
-                out = self.forward_plugin(out, self.after_conv2_plugin_names)
-            out = self.conv3(out)
-            out = self.norm3(out)
-            if self.with_plugins:
-                out = self.forward_plugin(out, self.after_conv3_plugin_names)
-            if self.downsample is not None:
-                identity = self.downsample(x)
-            out += identity
-            return out
-        if self.with_cp and x.requires_grad:
-            out = cp.checkpoint(_inner_forward, x)
-        else:
-            out = _inner_forward(x)
-        out = self.relu(out)
-        return out
-@BACKBONES.register_module()
-class ResNeSt(ResNetV1d):
-    """ResNeSt backbone.
-    Args:
-        groups (int): Number of groups of Bottleneck. Default: 1
-        base_width (int): Base width of Bottleneck. Default: 4
-        radix (int): Radix of SplitAttentionConv2d. Default: 2
-        reduction_factor (int): Reduction factor of inter_channels in
-            SplitAttentionConv2d. Default: 4.
-        avg_down_stride (bool): Whether to use average pool for stride in
-            Bottleneck. Default: True.
-        kwargs (dict): Keyword arguments for ResNet.
-    """
-    arch_settings = {
-        50: (Bottleneck, (3, 4, 6, 3)),
-        101: (Bottleneck, (3, 4, 23, 3)),
-        152: (Bottleneck, (3, 8, 36, 3)),
-        200: (Bottleneck, (3, 24, 36, 3))
-    }
-    def __init__(self,
-                 groups=1,
-                 base_width=4,
-                 radix=2,
-                 reduction_factor=4,
-                 avg_down_stride=True,
-                 **kwargs):
-        self.groups = groups
-        self.base_width = base_width
-        self.radix = radix
-        self.reduction_factor = reduction_factor
-        self.avg_down_stride = avg_down_stride
-        super(ResNeSt, self).__init__(**kwargs)
-    def make_res_layer(self, **kwargs):
-        """Pack all blocks in a stage into a ``ResLayer``."""
-        return ResLayer(
-            groups=self.groups,
-            base_width=self.base_width,
-            base_channels=self.base_channels,
-            radix=self.radix,
-            reduction_factor=self.reduction_factor,
-            avg_down_stride=self.avg_down_stride,
-            **kwargs)

spaces/Andy1621/uniformer_image_detection/mmdet/models/detectors/fovea.py DELETED Viewed

@@ -1,17 +0,0 @@
-from ..builder import DETECTORS
-from .single_stage import SingleStageDetector
-@DETECTORS.register_module()
-class FOVEA(SingleStageDetector):
-    """Implementation of `FoveaBox <https://arxiv.org/abs/1904.03797>`_"""
-    def __init__(self,
-                 backbone,
-                 neck,
-                 bbox_head,
-                 train_cfg=None,
-                 test_cfg=None,
-                 pretrained=None):
-        super(FOVEA, self).__init__(backbone, neck, bbox_head, train_cfg,
-                                    test_cfg, pretrained)

spaces/AnnaPalatkina/fine_grained_SA/sentiment_wrapper.py DELETED Viewed

@@ -1,100 +0,0 @@
-from transformers import BertModel, BertTokenizer, AdamW, get_linear_schedule_with_warmup
-from sklearn.metrics import  classification_report, f1_score
-from torch.utils.data import Dataset, DataLoader
-from tqdm.auto import tqdm
-from config import params
-from torch import nn
-import pandas as pd
-import numpy as np
-import warnings
-import random
-import torch
-import os
-device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
-class Dataset(Dataset):
-  def __init__(self, texts, max_len):
-    self.texts = texts
-    self.tokenizer = BertTokenizer.from_pretrained(params['pretrained_model_name'])
-    self.max_len = max_len
-  def __len__(self):
-    return len(self.texts)
-  def __getitem__(self, item):
-    text = str(self.texts[item])
-    encoding = self.tokenizer.encode_plus(
-      text,
-      add_special_tokens=True,
-      max_length=self.max_len,
-      return_token_type_ids=False,
-      pad_to_max_length=True,
-      return_attention_mask=True,
-      truncation=True,
-      return_tensors='pt',
-    )
-    return {
-      'text': text,
-      'input_ids': encoding['input_ids'].flatten(),
-      'attention_mask': encoding['attention_mask'].flatten(),
-    }
-class SentimentClassifier(nn.Module):
-  def __init__(self, n_classes):
-    super(SentimentClassifier, self).__init__()
-    self.bert = BertModel.from_pretrained(params['pretrained_model_name'])
-    self.drop = nn.Dropout(params['dropout'])
-    self.out = nn.Linear(self.bert.config.hidden_size, n_classes)
-  def forward(self, input_ids, attention_mask):
-    bert_output = self.bert(
-      input_ids=input_ids,
-      attention_mask=attention_mask,
-      return_dict=False
-    )
-    last_hidden_state, pooled_output = bert_output
-    output = self.drop(pooled_output)
-    return self.out(output)
-class PredictionModel:
-    def __init__(self):
-        self.model = SentimentClassifier(n_classes = 6)
-        self.loss_fn = nn.CrossEntropyLoss().to(device)
-    def create_data_loader(self, X_test, max_len, batch_size):
-        ds = Dataset(
-            texts= np.array(X_test),
-            max_len=max_len
-        )
-        return DataLoader(
-            ds,
-            batch_size=batch_size
-        )
-    def predict(self, X_test: list):
-        data_loader = self.create_data_loader(X_test, params['max_length'], params['batch_size'])
-        self.model.load_state_dict(torch.load(params['path_to_model_bin']))
-        self.model.eval()
-        losses = []
-        y_pred = []
-        with torch.no_grad():
-            for d in data_loader:
-                input_ids = d["input_ids"].to(device)
-                attention_mask = d["attention_mask"].to(device)
-                outputs = self.model(
-                    input_ids=input_ids,
-                    attention_mask=attention_mask
-                )
-                _, preds = torch.max(outputs, dim=1)
-                y_pred += preds.tolist()
-        return y_pred

spaces/Anonymous-123/ImageNet-Editing/object_removal/TFill/model/tc_model.py DELETED Viewed

@@ -1,247 +0,0 @@
-import torch
-import torch.nn.functional as F
-from .base_model import BaseModel
-from . import networks, losses
-class TC(BaseModel):
-    """This class implements the transformer for image completion"""
-    def name(self):
-        return "Transformer Image Completion"
-    @staticmethod
-    def modify_options(parser, is_train=True):
-        """Add new options and rewrite default values for existing options"""
-        parser.add_argument('--coarse_or_refine', type=str, default='refine', help='train the transform or refined network')
-        parser.add_argument('--down_layers', type=int, default=4, help='# times down sampling for refine generator')
-        parser.add_argument('--mid_layers', type=int, default=6, help='# times middle layers for refine generator')
-        if is_train:
-            parser.add_argument('--lambda_rec', type=float, default=10.0, help='weight for image reconstruction loss')
-            parser.add_argument('--lambda_g', type=float, default=1.0, help='weight for discriminator loss')
-            parser.add_argument('--lambda_lp', type=float, default=10.0, help='weight for the perceptual loss')
-            parser.add_argument('--lambda_gradient', type=float, default=0.0, help='weight for the gradient penalty')
-        return parser
-    def __init__(self, opt):
-        """inital the Transformer model"""
-        BaseModel.__init__(self, opt)
-        self.visual_names = ['img_org', 'img_m', 'img_g', 'img_out']
-        self.model_names = ['E', 'G', 'D', 'T']
-        self.loss_names = ['G_rec', 'G_lp', 'G_GAN', 'D_real', 'D_fake']
-        self.netE = networks.define_E(opt)
-        self.netT = networks.define_T(opt)
-        self.netG = networks.define_G(opt)
-        self.netD = networks.define_D(opt, opt.fixed_size)
-        if 'refine' in self.opt.coarse_or_refine:
-            opt = self._refine_opt(opt)
-            self.netG_Ref = networks.define_G(opt)
-            self.netD_Ref = networks.define_D(opt, opt.fine_size)
-            self.visual_names += ['img_ref', 'img_ref_out']
-            self.model_names += ['G_Ref', 'D_Ref']
-        if self.isTrain:
-            # define the loss function
-            self.L1loss = torch.nn.L1Loss()
-            self.GANloss = losses.GANLoss(opt.gan_mode).to(self.device)
-            self.NormalVGG = losses.Normalization(self.device)
-            self.LPIPSloss = losses.LPIPSLoss(ckpt_path=opt.lipip_path).to(self.device)
-            if len(self.opt.gpu_ids) > 0:
-                self.LPIPSloss = torch.nn.parallel.DataParallel(self.LPIPSloss, self.opt.gpu_ids)
-            # define the optimizer
-            if 'coarse' in self.opt.coarse_or_refine:
-                self.optimizerG = torch.optim.Adam(list(self.netE.parameters()) + list(self.netG.parameters())
-                                                   + list(self.netT.parameters()), lr=opt.lr, betas=(opt.beta1, opt.beta2))
-                self.optimizerD = torch.optim.Adam(self.netD.parameters(), lr=opt.lr * 4, betas=(opt.beta1, opt.beta2))
-                self.optimizers.append(self.optimizerG)
-                self.optimizers.append(self.optimizerD)
-            if 'refine' in self.opt.coarse_or_refine:
-                self.optimizerGRef = torch.optim.Adam(self.netG_Ref.parameters(), lr=opt.lr, betas=(opt.beta1, opt.beta2))
-                self.optimizerDRef = torch.optim.Adam(self.netD_Ref.parameters(), lr=opt.lr * 4, betas=(opt.beta1, opt.beta2))
-                self.optimizers.append(self.optimizerGRef)
-                self.optimizers.append(self.optimizerDRef)
-        else:
-            self.visual_names = ['img_org', 'img_m', 'img_out']
-            if 'refine' in self.opt.coarse_or_refine:
-                self.visual_names += ['img_ref_out']
-    def set_input(self, input):
-        """Unpack input data from the data loader and perform necessary pre-process steps"""
-        self.input = input
-        self.image_paths = self.input['img_path']
-        self.img_org = input['img_org'].to(self.device) * 2 - 1
-        self.img = input['img'].to(self.device) * 2 - 1
-        self.mask = input['mask'].to(self.device)
-        # get I_m and I_c for image with mask and complement regions for training
-        self.img_m = self.mask * self.img_org
-    @torch.no_grad()
-    def test(self):
-        """Run forward processing for testing"""
-        fixed_img = F.interpolate(self.img_m, size=[self.opt.fixed_size, self.opt.fixed_size], mode='bicubic', align_corners=True).clamp(-1, 1)
-        fixed_mask = (F.interpolate(self.mask, size=[self.opt.fixed_size, self.opt.fixed_size], mode='bicubic', align_corners=True) > 0.9).type_as(fixed_img)
-        out, mask = self.netE(fixed_img, mask=fixed_mask, return_mask=True)
-        out = self.netT(out, mask, bool_mask=False)
-        # sample result
-        for i in range(self.opt.nsampling):
-            img_g = self.netG(out, mask=self.mask)
-            img_g_org = F.interpolate(img_g, size=self.img_org.size()[2:], mode='bicubic', align_corners=True).clamp(-1, 1)
-            self.img_out = self.mask * self.img_org + (1 - self.mask) * img_g_org
-            # save for multiple results
-            self.save_results(self.img_out, path=self.opt.save_dir + '/img_out', data_name=i)
-            if 'refine' in self.opt.coarse_or_refine:
-                img_ref = self.netG_Ref(self.img_out, mask=self.mask)
-                self.img_ref_out = self.mask * self.img_org + (1 - self.mask) * img_ref
-                # save for multiple results
-                self.save_results(self.img_ref_out, path=self.opt.save_dir + '/img_ref_out', data_name=i)
-    def forward(self):
-        """Run forward processing to get the outputs"""
-        fixed_img = F.interpolate(self.img_m, size=[self.opt.fixed_size, self.opt.fixed_size], mode='bicubic', align_corners=True).clamp(-1, 1)
-        self.fixed_mask = (F.interpolate(self.mask, size=[self.opt.fixed_size, self.opt.fixed_size], mode='bicubic', align_corners=True) > 0.9).type_as(fixed_img)
-        out, mask = self.netE(fixed_img, mask=self.fixed_mask, return_mask=True)
-        out = self.netT(out, mask, bool_mask=False)
-        self.img_g = self.netG(out, mask=self.mask)
-        img_g_org = F.interpolate(self.img_g, size=self.img_org.size()[2:], mode='bicubic', align_corners=True).clamp(-1, 1)
-        self.img_out = self.mask * self.img_org + (1 - self.mask) * img_g_org
-        if 'refine' in self.opt.coarse_or_refine:
-            self.img_ref = self.netG_Ref(self.img_out, self.mask)
-            self.img_ref_out = self.mask * self.img_org + (1 - self.mask) * self.img_ref
-    def backward_D_basic(self, netD, real, fake):
-        """
-        Calculate GAN loss for the discriminator
-        :param netD: the discriminator D
-        :param real: real examples
-        :param fake: examples generated by a generator
-        :return: discriminator loss
-        """
-        self.loss_D_real = self.GANloss(netD(real), True, is_dis=True)
-        self.loss_D_fake = self.GANloss(netD(fake), False, is_dis=True)
-        loss_D = self.loss_D_real + self.loss_D_fake
-        if self.opt.lambda_gradient > 0:
-            self.loss_D_Gradient, _ = losses.cal_gradient_penalty(netD, real, fake, real.device, lambda_gp=self.opt.lambda_gradient)
-            loss_D += self.loss_D_Gradient
-        loss_D.backward()
-        return loss_D
-    def backward_D(self):
-        """Calculate the GAN loss for discriminator"""
-        self.loss_D = 0
-        if 'coarse' in self.opt.coarse_or_refine:
-            self.set_requires_grad([self.netD], True)
-            self.optimizerD.zero_grad()
-            real = self.img.detach()
-            fake = self.img_g.detach()
-            self.loss_D += self.backward_D_basic(self.netD, real, fake) if self.opt.lambda_g > 0 else 0
-        if 'refine' in self.opt.coarse_or_refine:
-            self.set_requires_grad([self.netD_Ref], True)
-            self.optimizerDRef.zero_grad()
-            real = self.img_org.detach()
-            fake = self.img_ref.detach()
-            self.loss_D += self.backward_D_basic(self.netD_Ref, real, fake) if self.opt.lambda_g > 0 else 0
-    def backward_G(self):
-        """Calculate the loss for generator"""
-        self.loss_G_GAN = 0
-        self.loss_G_rec = 0
-        self.loss_G_lp =0
-        if 'coarse' in self.opt.coarse_or_refine:
-            self.set_requires_grad([self.netD], False)
-            self.optimizerG.zero_grad()
-            self.loss_G_GAN += self.GANloss(self.netD(self.img_g), True) * self.opt.lambda_g if self.opt.lambda_g > 0 else 0
-            self.loss_G_rec += (self.L1loss(self.img_g * (1 - self.fixed_mask), self.img * (1 - self.fixed_mask)) * 3 +
-                                self.L1loss(self.img_g * self.fixed_mask, self.img_g * self.fixed_mask)) * self.opt.lambda_rec
-            norm_real = self.NormalVGG((self.img + 1) * 0.5)
-            norm_fake = self.NormalVGG((self.img_g + 1) * 0.5)
-            self.loss_G_lp += (self.LPIPSloss(norm_real, norm_fake).mean()) * self.opt.lambda_lp if self.opt.lambda_lp > 0 else 0
-        if 'refine' in self.opt.coarse_or_refine:
-            self.set_requires_grad([self.netD_Ref], False)
-            self.optimizerGRef.zero_grad()
-            self.loss_G_GAN += self.GANloss(self.netD_Ref(self.img_ref), True) * self.opt.lambda_g if self.opt.lambda_g > 0 else 0
-            self.loss_G_rec += (self.L1loss(self.img_ref * (1 - self.mask), self.img_org * (1 - self.mask)) * 3 +
-                                self.L1loss(self.img_ref * self.mask, self.img_org * self.mask)) * self.opt.lambda_rec
-            norm_real = self.NormalVGG((self.img_org + 1) * 0.5)
-            norm_fake = self.NormalVGG((self.img_ref + 1) * 0.5)
-            self.loss_G_lp += (self.LPIPSloss(norm_real, norm_fake).mean()) * self.opt.lambda_lp if self.opt.lambda_lp > 0 else 0
-        self.loss_G = self.loss_G_GAN + self.loss_G_rec + self.loss_G_lp
-        self.loss_G.backward()
-    def optimize_parameters(self):
-        """update network weights"""
-        # forward
-        self.set_requires_grad([self.netE, self.netT, self.netG], 'coarse' in self.opt.coarse_or_refine)
-        self.forward()
-        # update D
-        self.backward_D()
-        if 'coarse' in self.opt.coarse_or_refine:
-            self.optimizerD.step()
-        if 'refine' in self.opt.coarse_or_refine:
-            self.optimizerDRef.step()
-        # update G
-        self.backward_G()
-        if 'coarse' in self.opt.coarse_or_refine:
-            self.optimizerG.step()
-        if 'refine' in self.opt.coarse_or_refine:
-            self.optimizerGRef.step()
-    def configure_optimizers(self):
-        """
-        Following minGPT:
-        This long function is unfortunately doing something very simple and is being very defensive:
-        We are separating out all parameters of the model into two buckets: those that will experience
-        weight decay for regularization and those that won't (biases, and layernorm/embedding weights).
-        We are then returning the PyTorch optimizer object.
-        """
-        # separate out all parameters to those that will and won't experience regularizing weight decay
-        decay = set()
-        no_decay = set()
-        whitelist_weight_modules = (torch.nn.Linear, torch.nn.Conv2d)
-        blacklist_weight_modules = (torch.nn.LayerNorm, torch.nn.Embedding)
-        for mn, m in self.netT.named_modules():
-            for pn, p in m.named_parameters():
-                fpn = '%s.%s' % (mn, pn) if mn else pn  # full param name
-                if pn.endswith('bias') or pn.endswith('alpha'):
-                    # all biases will not be decayed
-                    no_decay.add(fpn)
-                elif pn.endswith('weight') and isinstance(m, whitelist_weight_modules):
-                    # weights of whitelist modules will be weight decayed
-                    decay.add(fpn)
-                elif pn.endswith('weight') and isinstance(m, blacklist_weight_modules):
-                    # weights of blacklist modules will NOT be weight decayed
-                    no_decay.add(fpn)
-        # validate that we considered every parameter
-        param_dict = {pn: p for pn, p in self.netT.named_parameters()}
-        inter_params = decay & no_decay
-        union_params = decay | no_decay
-        assert len(inter_params) == 0, "parameters %s made it into both decay/no_decay sets!" % (str(inter_params),)
-        assert len(param_dict.keys() - union_params) == 0, "parameters %s were not separated into either decay/no_decay set!" \
-                                                                % (str(param_dict.keys() - union_params),)
-        # create the pytorch optimizer object
-        optim_groups = [
-            {"params": [param_dict[pn] for pn in sorted(list(decay))], "weight_decay": 0.01, "betas":(0.9, 0.95)},
-            {"params": [param_dict[pn] for pn in sorted(list(no_decay))], "weight_decay": 0.0, "betas":(0.9, 0.95)},
-            {"params": list(filter(lambda p: p.requires_grad, self.netE.parameters()))},
-            {"params": list(filter(lambda p: p.requires_grad, self.netG.parameters()))}
-        ]
-        optimizer = torch.optim.Adam(optim_groups, lr=self.opt.lr, betas=(self.opt.beta1, self.opt.beta2))
-        return optimizer
-    def _refine_opt(self, opt):
-        """modify the opt for refine generator and discriminator"""
-        opt.netG = 'refine'
-        opt.netD = 'style'
-        return opt

spaces/Ariharasudhan/YoloV5/utils/segment/dataloaders.py DELETED Viewed

@@ -1,331 +0,0 @@
-# YOLOv5 🚀 by Ultralytics, GPL-3.0 license
-"""
-Dataloaders
-"""
-import os
-import random
-import cv2
-import numpy as np
-import torch
-from torch.utils.data import DataLoader, distributed
-from ..augmentations import augment_hsv, copy_paste, letterbox
-from ..dataloaders import InfiniteDataLoader, LoadImagesAndLabels, seed_worker
-from ..general import LOGGER, xyn2xy, xywhn2xyxy, xyxy2xywhn
-from ..torch_utils import torch_distributed_zero_first
-from .augmentations import mixup, random_perspective
-RANK = int(os.getenv('RANK', -1))
-def create_dataloader(path,
-                      imgsz,
-                      batch_size,
-                      stride,
-                      single_cls=False,
-                      hyp=None,
-                      augment=False,
-                      cache=False,
-                      pad=0.0,
-                      rect=False,
-                      rank=-1,
-                      workers=8,
-                      image_weights=False,
-                      quad=False,
-                      prefix='',
-                      shuffle=False,
-                      mask_downsample_ratio=1,
-                      overlap_mask=False):
-    if rect and shuffle:
-        LOGGER.warning('WARNING ⚠️ --rect is incompatible with DataLoader shuffle, setting shuffle=False')
-        shuffle = False
-    with torch_distributed_zero_first(rank):  # init dataset *.cache only once if DDP
-        dataset = LoadImagesAndLabelsAndMasks(
-            path,
-            imgsz,
-            batch_size,
-            augment=augment,  # augmentation
-            hyp=hyp,  # hyperparameters
-            rect=rect,  # rectangular batches
-            cache_images=cache,
-            single_cls=single_cls,
-            stride=int(stride),
-            pad=pad,
-            image_weights=image_weights,
-            prefix=prefix,
-            downsample_ratio=mask_downsample_ratio,
-            overlap=overlap_mask)
-    batch_size = min(batch_size, len(dataset))
-    nd = torch.cuda.device_count()  # number of CUDA devices
-    nw = min([os.cpu_count() // max(nd, 1), batch_size if batch_size > 1 else 0, workers])  # number of workers
-    sampler = None if rank == -1 else distributed.DistributedSampler(dataset, shuffle=shuffle)
-    loader = DataLoader if image_weights else InfiniteDataLoader  # only DataLoader allows for attribute updates
-    generator = torch.Generator()
-    generator.manual_seed(6148914691236517205 + RANK)
-    return loader(
-        dataset,
-        batch_size=batch_size,
-        shuffle=shuffle and sampler is None,
-        num_workers=nw,
-        sampler=sampler,
-        pin_memory=True,
-        collate_fn=LoadImagesAndLabelsAndMasks.collate_fn4 if quad else LoadImagesAndLabelsAndMasks.collate_fn,
-        worker_init_fn=seed_worker,
-        generator=generator,
-    ), dataset
-class LoadImagesAndLabelsAndMasks(LoadImagesAndLabels):  # for training/testing
-    def __init__(
-        self,
-        path,
-        img_size=640,
-        batch_size=16,
-        augment=False,
-        hyp=None,
-        rect=False,
-        image_weights=False,
-        cache_images=False,
-        single_cls=False,
-        stride=32,
-        pad=0,
-        min_items=0,
-        prefix="",
-        downsample_ratio=1,
-        overlap=False,
-    ):
-        super().__init__(path, img_size, batch_size, augment, hyp, rect, image_weights, cache_images, single_cls,
-                         stride, pad, min_items, prefix)
-        self.downsample_ratio = downsample_ratio
-        self.overlap = overlap
-    def __getitem__(self, index):
-        index = self.indices[index]  # linear, shuffled, or image_weights
-        hyp = self.hyp
-        mosaic = self.mosaic and random.random() < hyp['mosaic']
-        masks = []
-        if mosaic:
-            # Load mosaic
-            img, labels, segments = self.load_mosaic(index)
-            shapes = None
-            # MixUp augmentation
-            if random.random() < hyp["mixup"]:
-                img, labels, segments = mixup(img, labels, segments, *self.load_mosaic(random.randint(0, self.n - 1)))
-        else:
-            # Load image
-            img, (h0, w0), (h, w) = self.load_image(index)
-            # Letterbox
-            shape = self.batch_shapes[self.batch[index]] if self.rect else self.img_size  # final letterboxed shape
-            img, ratio, pad = letterbox(img, shape, auto=False, scaleup=self.augment)
-            shapes = (h0, w0), ((h / h0, w / w0), pad)  # for COCO mAP rescaling
-            labels = self.labels[index].copy()
-            # [array, array, ....], array.shape=(num_points, 2), xyxyxyxy
-            segments = self.segments[index].copy()
-            if len(segments):
-                for i_s in range(len(segments)):
-                    segments[i_s] = xyn2xy(
-                        segments[i_s],
-                        ratio[0] * w,
-                        ratio[1] * h,
-                        padw=pad[0],
-                        padh=pad[1],
-                    )
-            if labels.size:  # normalized xywh to pixel xyxy format
-                labels[:, 1:] = xywhn2xyxy(labels[:, 1:], ratio[0] * w, ratio[1] * h, padw=pad[0], padh=pad[1])
-            if self.augment:
-                img, labels, segments = random_perspective(img,
-                                                           labels,
-                                                           segments=segments,
-                                                           degrees=hyp["degrees"],
-                                                           translate=hyp["translate"],
-                                                           scale=hyp["scale"],
-                                                           shear=hyp["shear"],
-                                                           perspective=hyp["perspective"])
-        nl = len(labels)  # number of labels
-        if nl:
-            labels[:, 1:5] = xyxy2xywhn(labels[:, 1:5], w=img.shape[1], h=img.shape[0], clip=True, eps=1e-3)
-            if self.overlap:
-                masks, sorted_idx = polygons2masks_overlap(img.shape[:2],
-                                                           segments,
-                                                           downsample_ratio=self.downsample_ratio)
-                masks = masks[None]  # (640, 640) -> (1, 640, 640)
-                labels = labels[sorted_idx]
-            else:
-                masks = polygons2masks(img.shape[:2], segments, color=1, downsample_ratio=self.downsample_ratio)
-        masks = (torch.from_numpy(masks) if len(masks) else torch.zeros(1 if self.overlap else nl, img.shape[0] //
-                                                                        self.downsample_ratio, img.shape[1] //
-                                                                        self.downsample_ratio))
-        # TODO: albumentations support
-        if self.augment:
-            # Albumentations
-            # there are some augmentation that won't change boxes and masks,
-            # so just be it for now.
-            img, labels = self.albumentations(img, labels)
-            nl = len(labels)  # update after albumentations
-            # HSV color-space
-            augment_hsv(img, hgain=hyp["hsv_h"], sgain=hyp["hsv_s"], vgain=hyp["hsv_v"])
-            # Flip up-down
-            if random.random() < hyp["flipud"]:
-                img = np.flipud(img)
-                if nl:
-                    labels[:, 2] = 1 - labels[:, 2]
-                    masks = torch.flip(masks, dims=[1])
-            # Flip left-right
-            if random.random() < hyp["fliplr"]:
-                img = np.fliplr(img)
-                if nl:
-                    labels[:, 1] = 1 - labels[:, 1]
-                    masks = torch.flip(masks, dims=[2])
-            # Cutouts  # labels = cutout(img, labels, p=0.5)
-        labels_out = torch.zeros((nl, 6))
-        if nl:
-            labels_out[:, 1:] = torch.from_numpy(labels)
-        # Convert
-        img = img.transpose((2, 0, 1))[::-1]  # HWC to CHW, BGR to RGB
-        img = np.ascontiguousarray(img)
-        return (torch.from_numpy(img), labels_out, self.im_files[index], shapes, masks)
-    def load_mosaic(self, index):
-        # YOLOv5 4-mosaic loader. Loads 1 image + 3 random images into a 4-image mosaic
-        labels4, segments4 = [], []
-        s = self.img_size
-        yc, xc = (int(random.uniform(-x, 2 * s + x)) for x in self.mosaic_border)  # mosaic center x, y
-        # 3 additional image indices
-        indices = [index] + random.choices(self.indices, k=3)  # 3 additional image indices
-        for i, index in enumerate(indices):
-            # Load image
-            img, _, (h, w) = self.load_image(index)
-            # place img in img4
-            if i == 0:  # top left
-                img4 = np.full((s * 2, s * 2, img.shape[2]), 114, dtype=np.uint8)  # base image with 4 tiles
-                x1a, y1a, x2a, y2a = max(xc - w, 0), max(yc - h, 0), xc, yc  # xmin, ymin, xmax, ymax (large image)
-                x1b, y1b, x2b, y2b = w - (x2a - x1a), h - (y2a - y1a), w, h  # xmin, ymin, xmax, ymax (small image)
-            elif i == 1:  # top right
-                x1a, y1a, x2a, y2a = xc, max(yc - h, 0), min(xc + w, s * 2), yc
-                x1b, y1b, x2b, y2b = 0, h - (y2a - y1a), min(w, x2a - x1a), h
-            elif i == 2:  # bottom left
-                x1a, y1a, x2a, y2a = max(xc - w, 0), yc, xc, min(s * 2, yc + h)
-                x1b, y1b, x2b, y2b = w - (x2a - x1a), 0, w, min(y2a - y1a, h)
-            elif i == 3:  # bottom right
-                x1a, y1a, x2a, y2a = xc, yc, min(xc + w, s * 2), min(s * 2, yc + h)
-                x1b, y1b, x2b, y2b = 0, 0, min(w, x2a - x1a), min(y2a - y1a, h)
-            img4[y1a:y2a, x1a:x2a] = img[y1b:y2b, x1b:x2b]  # img4[ymin:ymax, xmin:xmax]
-            padw = x1a - x1b
-            padh = y1a - y1b
-            labels, segments = self.labels[index].copy(), self.segments[index].copy()
-            if labels.size:
-                labels[:, 1:] = xywhn2xyxy(labels[:, 1:], w, h, padw, padh)  # normalized xywh to pixel xyxy format
-                segments = [xyn2xy(x, w, h, padw, padh) for x in segments]
-            labels4.append(labels)
-            segments4.extend(segments)
-        # Concat/clip labels
-        labels4 = np.concatenate(labels4, 0)
-        for x in (labels4[:, 1:], *segments4):
-            np.clip(x, 0, 2 * s, out=x)  # clip when using random_perspective()
-        # img4, labels4 = replicate(img4, labels4)  # replicate
-        # Augment
-        img4, labels4, segments4 = copy_paste(img4, labels4, segments4, p=self.hyp["copy_paste"])
-        img4, labels4, segments4 = random_perspective(img4,
-                                                      labels4,
-                                                      segments4,
-                                                      degrees=self.hyp["degrees"],
-                                                      translate=self.hyp["translate"],
-                                                      scale=self.hyp["scale"],
-                                                      shear=self.hyp["shear"],
-                                                      perspective=self.hyp["perspective"],
-                                                      border=self.mosaic_border)  # border to remove
-        return img4, labels4, segments4
-    @staticmethod
-    def collate_fn(batch):
-        img, label, path, shapes, masks = zip(*batch)  # transposed
-        batched_masks = torch.cat(masks, 0)
-        for i, l in enumerate(label):
-            l[:, 0] = i  # add target image index for build_targets()
-        return torch.stack(img, 0), torch.cat(label, 0), path, shapes, batched_masks
-def polygon2mask(img_size, polygons, color=1, downsample_ratio=1):
-    """
-    Args:
-        img_size (tuple): The image size.
-        polygons (np.ndarray): [N, M], N is the number of polygons,
-            M is the number of points(Be divided by 2).
-    """
-    mask = np.zeros(img_size, dtype=np.uint8)
-    polygons = np.asarray(polygons)
-    polygons = polygons.astype(np.int32)
-    shape = polygons.shape
-    polygons = polygons.reshape(shape[0], -1, 2)
-    cv2.fillPoly(mask, polygons, color=color)
-    nh, nw = (img_size[0] // downsample_ratio, img_size[1] // downsample_ratio)
-    # NOTE: fillPoly firstly then resize is trying the keep the same way
-    # of loss calculation when mask-ratio=1.
-    mask = cv2.resize(mask, (nw, nh))
-    return mask
-def polygons2masks(img_size, polygons, color, downsample_ratio=1):
-    """
-    Args:
-        img_size (tuple): The image size.
-        polygons (list[np.ndarray]): each polygon is [N, M],
-            N is the number of polygons,
-            M is the number of points(Be divided by 2).
-    """
-    masks = []
-    for si in range(len(polygons)):
-        mask = polygon2mask(img_size, [polygons[si].reshape(-1)], color, downsample_ratio)
-        masks.append(mask)
-    return np.array(masks)
-def polygons2masks_overlap(img_size, segments, downsample_ratio=1):
-    """Return a (640, 640) overlap mask."""
-    masks = np.zeros((img_size[0] // downsample_ratio, img_size[1] // downsample_ratio),
-                     dtype=np.int32 if len(segments) > 255 else np.uint8)
-    areas = []
-    ms = []
-    for si in range(len(segments)):
-        mask = polygon2mask(
-            img_size,
-            [segments[si].reshape(-1)],
-            downsample_ratio=downsample_ratio,
-            color=1,
-        )
-        ms.append(mask)
-        areas.append(mask.sum())
-    areas = np.asarray(areas)
-    index = np.argsort(-areas)
-    ms = np.array(ms)[index]
-    for i in range(len(segments)):
-        mask = ms[i] * (i + 1)
-        masks = masks + mask
-        masks = np.clip(masks, a_min=0, a_max=i + 1)
-    return masks, index

spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/pip/_internal/operations/build/metadata_editable.py DELETED Viewed

@@ -1,41 +0,0 @@
-"""Metadata generation logic for source distributions.
-"""
-import os
-from pip._vendor.pyproject_hooks import BuildBackendHookCaller
-from pip._internal.build_env import BuildEnvironment
-from pip._internal.exceptions import (
-    InstallationSubprocessError,
-    MetadataGenerationFailed,
-)
-from pip._internal.utils.subprocess import runner_with_spinner_message
-from pip._internal.utils.temp_dir import TempDirectory
-def generate_editable_metadata(
-    build_env: BuildEnvironment, backend: BuildBackendHookCaller, details: str
-) -> str:
-    """Generate metadata using mechanisms described in PEP 660.
-    Returns the generated metadata directory.
-    """
-    metadata_tmpdir = TempDirectory(kind="modern-metadata", globally_managed=True)
-    metadata_dir = metadata_tmpdir.path
-    with build_env:
-        # Note that BuildBackendHookCaller implements a fallback for
-        # prepare_metadata_for_build_wheel/editable, so we don't have to
-        # consider the possibility that this hook doesn't exist.
-        runner = runner_with_spinner_message(
-            "Preparing editable metadata (pyproject.toml)"
-        )
-        with backend.subprocess_runner(runner):
-            try:
-                distinfo_dir = backend.prepare_metadata_for_build_editable(metadata_dir)
-            except InstallationSubprocessError as error:
-                raise MetadataGenerationFailed(package_details=details) from error
-    return os.path.join(metadata_dir, distinfo_dir)

spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/pip/_vendor/urllib3/exceptions.py DELETED Viewed

@@ -1,323 +0,0 @@
-from __future__ import absolute_import
-from .packages.six.moves.http_client import IncompleteRead as httplib_IncompleteRead
-# Base Exceptions
-class HTTPError(Exception):
-    """Base exception used by this module."""
-    pass
-class HTTPWarning(Warning):
-    """Base warning used by this module."""
-    pass
-class PoolError(HTTPError):
-    """Base exception for errors caused within a pool."""
-    def __init__(self, pool, message):
-        self.pool = pool
-        HTTPError.__init__(self, "%s: %s" % (pool, message))
-    def __reduce__(self):
-        # For pickling purposes.
-        return self.__class__, (None, None)
-class RequestError(PoolError):
-    """Base exception for PoolErrors that have associated URLs."""
-    def __init__(self, pool, url, message):
-        self.url = url
-        PoolError.__init__(self, pool, message)
-    def __reduce__(self):
-        # For pickling purposes.
-        return self.__class__, (None, self.url, None)
-class SSLError(HTTPError):
-    """Raised when SSL certificate fails in an HTTPS connection."""
-    pass
-class ProxyError(HTTPError):
-    """Raised when the connection to a proxy fails."""
-    def __init__(self, message, error, *args):
-        super(ProxyError, self).__init__(message, error, *args)
-        self.original_error = error
-class DecodeError(HTTPError):
-    """Raised when automatic decoding based on Content-Type fails."""
-    pass
-class ProtocolError(HTTPError):
-    """Raised when something unexpected happens mid-request/response."""
-    pass
-#: Renamed to ProtocolError but aliased for backwards compatibility.
-ConnectionError = ProtocolError
-# Leaf Exceptions
-class MaxRetryError(RequestError):
-    """Raised when the maximum number of retries is exceeded.
-    :param pool: The connection pool
-    :type pool: :class:`~urllib3.connectionpool.HTTPConnectionPool`
-    :param string url: The requested Url
-    :param exceptions.Exception reason: The underlying error
-    """
-    def __init__(self, pool, url, reason=None):
-        self.reason = reason
-        message = "Max retries exceeded with url: %s (Caused by %r)" % (url, reason)
-        RequestError.__init__(self, pool, url, message)
-class HostChangedError(RequestError):
-    """Raised when an existing pool gets a request for a foreign host."""
-    def __init__(self, pool, url, retries=3):
-        message = "Tried to open a foreign host with url: %s" % url
-        RequestError.__init__(self, pool, url, message)
-        self.retries = retries
-class TimeoutStateError(HTTPError):
-    """Raised when passing an invalid state to a timeout"""
-    pass
-class TimeoutError(HTTPError):
-    """Raised when a socket timeout error occurs.
-    Catching this error will catch both :exc:`ReadTimeoutErrors
-    <ReadTimeoutError>` and :exc:`ConnectTimeoutErrors <ConnectTimeoutError>`.
-    """
-    pass
-class ReadTimeoutError(TimeoutError, RequestError):
-    """Raised when a socket timeout occurs while receiving data from a server"""
-    pass
-# This timeout error does not have a URL attached and needs to inherit from the
-# base HTTPError
-class ConnectTimeoutError(TimeoutError):
-    """Raised when a socket timeout occurs while connecting to a server"""
-    pass
-class NewConnectionError(ConnectTimeoutError, PoolError):
-    """Raised when we fail to establish a new connection. Usually ECONNREFUSED."""
-    pass
-class EmptyPoolError(PoolError):
-    """Raised when a pool runs out of connections and no more are allowed."""
-    pass
-class ClosedPoolError(PoolError):
-    """Raised when a request enters a pool after the pool has been closed."""
-    pass
-class LocationValueError(ValueError, HTTPError):
-    """Raised when there is something wrong with a given URL input."""
-    pass
-class LocationParseError(LocationValueError):
-    """Raised when get_host or similar fails to parse the URL input."""
-    def __init__(self, location):
-        message = "Failed to parse: %s" % location
-        HTTPError.__init__(self, message)
-        self.location = location
-class URLSchemeUnknown(LocationValueError):
-    """Raised when a URL input has an unsupported scheme."""
-    def __init__(self, scheme):
-        message = "Not supported URL scheme %s" % scheme
-        super(URLSchemeUnknown, self).__init__(message)
-        self.scheme = scheme
-class ResponseError(HTTPError):
-    """Used as a container for an error reason supplied in a MaxRetryError."""
-    GENERIC_ERROR = "too many error responses"
-    SPECIFIC_ERROR = "too many {status_code} error responses"
-class SecurityWarning(HTTPWarning):
-    """Warned when performing security reducing actions"""
-    pass
-class SubjectAltNameWarning(SecurityWarning):
-    """Warned when connecting to a host with a certificate missing a SAN."""
-    pass
-class InsecureRequestWarning(SecurityWarning):
-    """Warned when making an unverified HTTPS request."""
-    pass
-class SystemTimeWarning(SecurityWarning):
-    """Warned when system time is suspected to be wrong"""
-    pass
-class InsecurePlatformWarning(SecurityWarning):
-    """Warned when certain TLS/SSL configuration is not available on a platform."""
-    pass
-class SNIMissingWarning(HTTPWarning):
-    """Warned when making a HTTPS request without SNI available."""
-    pass
-class DependencyWarning(HTTPWarning):
-    """
-    Warned when an attempt is made to import a module with missing optional
-    dependencies.
-    """
-    pass
-class ResponseNotChunked(ProtocolError, ValueError):
-    """Response needs to be chunked in order to read it as chunks."""
-    pass
-class BodyNotHttplibCompatible(HTTPError):
-    """
-    Body should be :class:`http.client.HTTPResponse` like
-    (have an fp attribute which returns raw chunks) for read_chunked().
-    """
-    pass
-class IncompleteRead(HTTPError, httplib_IncompleteRead):
-    """
-    Response length doesn't match expected Content-Length
-    Subclass of :class:`http.client.IncompleteRead` to allow int value
-    for ``partial`` to avoid creating large objects on streamed reads.
-    """
-    def __init__(self, partial, expected):
-        super(IncompleteRead, self).__init__(partial, expected)
-    def __repr__(self):
-        return "IncompleteRead(%i bytes read, %i more expected)" % (
-            self.partial,
-            self.expected,
-        )
-class InvalidChunkLength(HTTPError, httplib_IncompleteRead):
-    """Invalid chunk length in a chunked response."""
-    def __init__(self, response, length):
-        super(InvalidChunkLength, self).__init__(
-            response.tell(), response.length_remaining
-        )
-        self.response = response
-        self.length = length
-    def __repr__(self):
-        return "InvalidChunkLength(got length %r, %i bytes read)" % (
-            self.length,
-            self.partial,
-        )
-class InvalidHeader(HTTPError):
-    """The header provided was somehow invalid."""
-    pass
-class ProxySchemeUnknown(AssertionError, URLSchemeUnknown):
-    """ProxyManager does not support the supplied scheme"""
-    # TODO(t-8ch): Stop inheriting from AssertionError in v2.0.
-    def __init__(self, scheme):
-        # 'localhost' is here because our URL parser parses
-        # localhost:8080 -> scheme=localhost, remove if we fix this.
-        if scheme == "localhost":
-            scheme = None
-        if scheme is None:
-            message = "Proxy URL had no scheme, should start with http:// or https://"
-        else:
-            message = (
-                "Proxy URL had unsupported scheme %s, should use http:// or https://"
-                % scheme
-            )
-        super(ProxySchemeUnknown, self).__init__(message)
-class ProxySchemeUnsupported(ValueError):
-    """Fetching HTTPS resources through HTTPS proxies is unsupported"""
-    pass
-class HeaderParsingError(HTTPError):
-    """Raised by assert_header_parsing, but we convert it to a log.warning statement."""
-    def __init__(self, defects, unparsed_data):
-        message = "%s, unparsed data: %r" % (defects or "Unknown", unparsed_data)
-        super(HeaderParsingError, self).__init__(message)
-class UnrewindableBodyError(HTTPError):
-    """urllib3 encountered an error when trying to rewind a body"""
-    pass

spaces/Bart92/RVC_HF/infer/lib/audio.py DELETED Viewed

@@ -1,197 +0,0 @@
-import librosa
-import numpy as np
-import av
-from io import BytesIO
-import ffmpeg
-import os
-import sys
-import random
-from infer.lib.csvutil import CSVutil
-#import csv
-platform_stft_mapping = {
-    'linux': 'stftpitchshift',
-    'darwin': 'stftpitchshift',
-    'win32': 'stftpitchshift.exe',
-}
-stft = platform_stft_mapping.get(sys.platform)
-def wav2(i, o, format):
-    inp = av.open(i, 'rb')
-    if format == "m4a": format = "mp4"
-    out = av.open(o, 'wb', format=format)
-    if format == "ogg": format = "libvorbis"
-    if format == "mp4": format = "aac"
-    ostream = out.add_stream(format)
-    for frame in inp.decode(audio=0):
-        for p in ostream.encode(frame): out.mux(p)
-    for p in ostream.encode(None): out.mux(p)
-    out.close()
-    inp.close()
-def audio2(i, o, format, sr):
-    inp = av.open(i, 'rb')
-    out = av.open(o, 'wb', format=format)
-    if format == "ogg": format = "libvorbis"
-    if format == "f32le": format = "pcm_f32le"
-    ostream = out.add_stream(format, channels=1)
-    ostream.sample_rate = sr
-    for frame in inp.decode(audio=0):
-        for p in ostream.encode(frame): out.mux(p)
-    out.close()
-    inp.close()
-def load_audion(file, sr):
-    try:
-        file = (
-            file.strip(" ").strip('"').strip("\n").strip('"').strip(" ")
-        )  # 防止小白拷路径头尾带了空格和"和回车
-        with open(file, "rb") as f:
-            with BytesIO() as out:
-                audio2(f, out, "f32le", sr)
-                return np.frombuffer(out.getvalue(), np.float32).flatten()
-    except AttributeError:
-        audio = file[1] / 32768.0
-        if len(audio.shape) == 2:
-            audio = np.mean(audio, -1)
-        return librosa.resample(audio, orig_sr=file[0], target_sr=16000)
-    except Exception as e:
-        raise RuntimeError(f"Failed to load audio: {e}")
-def load_audio(file, sr, DoFormant=False, Quefrency=1.0, Timbre=1.0):
-    converted = False
-    DoFormant, Quefrency, Timbre = CSVutil("csvdb/formanting.csv", "r", "formanting")
-    try:
-        # https://github.com/openai/whisper/blob/main/whisper/audio.py#L26
-        # 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.
-        file = (
-            file.strip(" ").strip('"').strip("\n").strip('"').strip(" ")
-        )  # 防止小白拷路径头尾带了空格和"和回车
-        file_formanted = file.strip(" ").strip('"').strip("\n").strip('"').strip(" ")
-        # print(f"dofor={bool(DoFormant)} timbr={Timbre} quef={Quefrency}\n")
-        if (
-            lambda DoFormant: True
-            if DoFormant.lower() == "true"
-            else (False if DoFormant.lower() == "false" else DoFormant)
-        )(DoFormant):
-            numerator = round(random.uniform(1, 4), 4)
-            # os.system(f"stftpitchshift -i {file} -q {Quefrency} -t {Timbre} -o {file_formanted}")
-            # print('stftpitchshift -i "%s" -p 1.0 --rms -w 128 -v 8 -q %s -t %s -o "%s"' % (file, Quefrency, Timbre, file_formanted))
-            if not file.endswith(".wav"):
-                if not os.path.isfile(f"{file_formanted}.wav"):
-                    converted = True
-                    # print(f"\nfile = {file}\n")
-                    # print(f"\nfile_formanted = {file_formanted}\n")
-                    converting = (
-                        ffmpeg.input(file_formanted, threads=0)
-                        .output(f"{file_formanted}.wav")
-                        .run(
-                            cmd=["ffmpeg", "-nostdin"],
-                            capture_stdout=True,
-                            capture_stderr=True,
-                        )
-                    )
-                else:
-                    pass
-            file_formanted = (
-                f"{file_formanted}.wav"
-                if not file_formanted.endswith(".wav")
-                else file_formanted
-            )
-            print(f" · Formanting {file_formanted}...\n")
-            os.system(
-                '%s -i "%s" -q "%s" -t "%s" -o "%sFORMANTED_%s.wav"'
-                % (
-                    stft,
-                    file_formanted,
-                    Quefrency,
-                    Timbre,
-                    file_formanted,
-                    str(numerator),
-                )
-            )
-            print(f" · Formanted {file_formanted}!\n")
-            # filepraat = (os.path.abspath(os.getcwd()) + '\\' + file).replace('/','\\')
-            # file_formantedpraat = ('"' + os.path.abspath(os.getcwd()) + '/' + 'formanted'.join(file_formanted) + '"').replace('/','\\')
-            # print("%sFORMANTED_%s.wav" % (file_formanted, str(numerator)))
-            out, _ = (
-                ffmpeg.input(
-                    "%sFORMANTED_%s.wav" % (file_formanted, str(numerator)), threads=0
-                )
-                .output("-", format="f32le", acodec="pcm_f32le", ac=1, ar=sr)
-                .run(
-                    cmd=["ffmpeg", "-nostdin"], capture_stdout=True, capture_stderr=True
-                )
-            )
-            try:
-                os.remove("%sFORMANTED_%s.wav" % (file_formanted, str(numerator)))
-            except Exception:
-                pass
-                print("couldn't remove formanted type of file")
-        else:
-            out, _ = (
-                ffmpeg.input(file, threads=0)
-                .output("-", format="f32le", acodec="pcm_f32le", ac=1, ar=sr)
-                .run(
-                    cmd=["ffmpeg", "-nostdin"], capture_stdout=True, capture_stderr=True
-                )
-            )
-    except Exception as e:
-        raise RuntimeError(f"Failed to load audio: {e}")
-    if converted:
-        try:
-            os.remove(file_formanted)
-        except Exception:
-            pass
-            print("couldn't remove converted type of file")
-        converted = False
-    return np.frombuffer(out, np.float32).flatten()
-def check_audio_duration(file):
-    try:
-        file = file.strip(" ").strip('"').strip("\n").strip('"').strip(" ")
-        probe = ffmpeg.probe(file)
-        duration = float(probe['streams'][0]['duration'])
-        if duration < 0.76:
-            print(
-                f"\n------------\n"
-                f"Audio file, {file.split('/')[-1]}, under ~0.76s detected - file is too short. Target at least 1-2s for best results."
-                f"\n------------\n\n"
-            )
-            return False
-        return True
-    except Exception as e:
-        raise RuntimeError(f"Failed to check audio duration: {e}")

spaces/Benson/text-generation/Examples/Bangla Mejor Tono De Llamada Que Me Encanta Descargar.md DELETED Viewed

@@ -1,113 +0,0 @@
-<br />
-<h1>Bangla mejor tono de llamada que me encanta descargar</h1>
-<p>¿Te encanta el sonido del bangla, el idioma hablado por más de 200 millones de personas en Bangladesh y la India? ¿Quieres expresar tu amor y afecto con un tono de llamada bangla romántico? Si es así, entonces estás de suerte. Hay muchas maneras de descargar y disfrutar de los mejores tonos de bangla para su teléfono. En este artículo, te mostraremos cómo encontrar, descargar y establecer un tono de llamada personalizado que diga "Te amo" de una manera dulce y melodiosa. </p>
-<h2>bangla mejor tono de llamada que me encanta descargar</h2><br /><p><b><b>Download</b> &bull; <a href="https://bltlly.com/2v6Lmw">https://bltlly.com/2v6Lmw</a></b></p><br /><br />
- <h2>Qué es el bangla y por qué es un lenguaje popular para tonos de llamada</h2>
-<p>El bangla, también conocido como bengalí, es una lengua indoaria que pertenece a la familia lingüística indoeuropea. Es el idioma oficial de Bangladesh y uno de los idiomas oficiales de la India. También es hablado por muchas personas en otros países, como Nepal, Pakistán, Sri Lanka, Malasia, Singapur y el Reino Unido.</p>
-<p>El bangla tiene una cultura rica y diversa que se refleja en su literatura, música, arte, cine y cocina. Los hablantes de bangla están orgullosos de su idioma y su herencia, y a menudo lo utilizan para expresar sus emociones y sentimientos. El bangla es también un lenguaje muy musical, con una variedad de tonos, ritmos y ritmos. Es por eso que muchas personas les encanta escuchar canciones de bangla y tonos de llamada. </p>
- <h2>Cómo descargar tonos de llamada bangla gratis desde sitios web</h2>
-<p>Una de las maneras más fáciles de obtener tonos de llamada bangla gratis es visitar algunos sitios web de renombre que ofrecen una amplia gama de tonos de llamada en diferentes géneros y categorías. Algunos de estos sitios web son:</p>
-<ul>
-<li><a href="( 1 )">Prokerala</a>: Este sitio web tiene una sección dedicada a los tonos de llamada bangla, donde puedes encontrar cientos de tonos de llamada en varios estilos, como romántico, triste, divertido, patriótico, devocional, etc. Puedes escucharlos en línea y descargarlos en formato MP3. </li>
-<li><a href="( 3 )">Tonos de llamada bengalíes</a>: Este sitio web es otra gran opción para encontrar tonos de llamada bangla gratis. Tiene una interfaz sencilla que le permite buscar tonos por nombre o por categoría. También puede previsualizar los tonos antes de descargarlos. </li>
-</ul>
-<p>Para descargar tonos de llamada bangla gratis de estos sitios web, debe seguir estos pasos:</p>
-<ol>
-<li>Visite el sitio web de su elección y busque el tono de llamada que desee. </li>
-<li> Seleccione el tono de llamada y haga clic en el botón de descarga o enlace. </li>
-<li>Guarde el archivo de tono de llamada en su computadora o transfiéralo a su teléfono a través de un cable USB o Bluetooth.</li>
-</ol>
- <h2>Cómo descargar tonos de llamada bangla pagados desde iTunes Store en el iPhone</h2>
-<p>Si tienes un iPhone y quieres comprar algunos tonos de llamada bangla premium que son clips de tus canciones favoritas, entonces puedes usar la aplicación iTunes Store en tu teléfono. El iTunes Store tiene una sección para tonos de llamada donde se pueden encontrar miles de tonos de llamada en diferentes idiomas, incluyendo el bangla. Algunos de estos tonos son:</p>
-<p></p>
-<ul>
-<li>Te amo por Ash King</li>
-<li>Tumi Amar por Habib Wahid</li>
-<li>Moner Manush por Anupam Roy</li>
-<li>Amaro Porano Jaha Chay por Arijit Singh</li>
-<li>Bolna por Arijit Singh y Asees Kaur</li>
-</ul>
-<p>Para descargar tonos de llamada bangla pagados desde el iTunes Store en tu iPhone, debes seguir estos pasos:</p>
-<ol>
-<li>Abra la aplicación iTunes Store en su teléfono y toque en el icono Más en la esquina inferior derecha. </li>
-<li>Toque en Tonos y luego toque en el icono de búsqueda en la esquina superior derecha. </li>
-<li>Escriba el nombre de la canción o del artista que desee y pulse en Buscar.</li>
-<li> Desplazarse por los resultados y encontrar el tono de llamada que desee. Puede tocar en el tono de llamada para escuchar una vista previa. </li>
-<li>Toque en el precio del tono de llamada y luego toque en Comprar tono. Es posible que tengas que introducir tu ID de Apple y contraseña o usar Touch ID o Face ID para confirmar tu compra. </li>
-</ol>
- <h2>Cómo descargar tonos de llamada bangla gratis desde la aplicación Zedge en Android</h2>
-<p>Si tienes un teléfono Android y quieres descargar tonos de llamada bangla gratis desde una aplicación confiable y fácil de usar, entonces puedes usar Zedge. Zedge es una aplicación popular que ofrece millones de tonos de llamada, fondos de pantalla, pegatinas e iconos para su teléfono. Puedes encontrar tonos de llamada en varios idiomas, incluyendo el bangla. Algunos de los tonos de llamada que puedes encontrar en Zedge son:</p>
-<ul>
-<li>Canción de amor bangla por Rana</li>
-<li>Canción triste bangla por Rajib</li>
-<li>Bangla canción divertida por Mithun</li>
-<li>Canción romántica bangla por Shreya Ghoshal</li>
-<li>Canción devocional bangla por Anuradha Paudwal</li>
-</ul>
-<p>Para descargar tonos de llamada bangla gratis desde la aplicación Zedge en su teléfono Android, debe seguir estos pasos:</p>
-<ol>
-<li>Descargar e instalar la aplicación Zedge de Google Play Store en su teléfono. </li>
-<li> Abra la aplicación y toque en el icono de tonos de llamada en la esquina inferior izquierda. </li>
-<li> Toque en el icono de búsqueda en la esquina superior derecha y escriba en bangla o cualquier otra palabra clave que desee. </li>
-<li> Desplazarse por los resultados y encontrar el tono de llamada que desee. Puede tocar en el tono de llamada para escuchar una vista previa. </li>
-<li>Toque en el icono de descarga en la esquina inferior derecha del tono de llamada. Puede elegir configurarlo como su tono de llamada predeterminado, tono de contacto, sonido de notificación o sonido de alarma. </li>
-<li>El tono de llamada se descargará en su teléfono y se establecerá según su elección. También puede acceder a ella desde la aplicación Configuración en Sonido > Tono de llamada del teléfono. </li>
-</ol>
- <h2>Cómo establecer un tono de llamada personalizado en su teléfono</h2>
-<p>Si tienes un tono de llamada bangla personalizado que has creado o descargado de otra fuente, y quieres configurarlo como tu tono de llamada del teléfono, entonces puedes hacerlo fácilmente. Estos son los pasos para establecer un tono de llamada personalizado en su teléfono:</p>
- <h3>Para usuarios de iPhone</h3>
-<p>Para establecer un tono de llamada personalizado en tu iPhone, debes seguir estos pasos:</p>
-<ol>
-<li>Abra iTunes en su computadora y seleccione su iPhone de la lista de dispositivos. </li>
-<li>Haga clic en la pestaña Tonos y marque la casilla Sincronizar tonos. </li>
-<li> Arrastre y suelte su archivo de tono de llamada personalizado bangla desde su computadora a la lista de tonos en iTunes. </li>
-<li>Haga clic en Aplicar o Sincronizar para transferir el tono de llamada a su iPhone. </li>
-<li>Desconecte su iPhone de su computadora y abra la aplicación Configuración en su teléfono. </li>
-<li>Toque en Sonidos y Haptics > Tono de llamada y seleccione su tono de llamada personalizado bangla de la lista. </li>
-</ol>
- <h3>Para usuarios de Android</h3>
-<p>Para establecer un tono de llamada de bangla personalizado en su teléfono Android, debe seguir estos pasos:</p>
-<ol>
-<li>Conecte su teléfono Android a su computadora usando un cable USB o Bluetooth.</li>
-<li>Abra el Explorador de archivos o el Finder en su computadora y localice el archivo de tono de llamada personalizado de Bangla. </li>
-<li>Copiar o mover el archivo a la carpeta Tonos de llamada en el almacenamiento interno del teléfono o la tarjeta SD. </li>
-<li>Desconecte su teléfono Android de su computadora y abra la aplicación Configuración en su teléfono. </li>
-<li>Toque en Sonido > Tono de llamada del teléfono y seleccione su tono de llamada personalizado bangla de la lista. </li>
-</ol>
- <h2>Conclusión: Resumen de los principales puntos y beneficios de los tonos de llamada Bangla</h2>
- <p>En conclusión, el bangla es un lenguaje hermoso y expresivo que puede hacer que el tono de llamada del teléfono sea más atractivo y significativo. Puede descargar tonos de llamada bangla gratis o pagados desde varios sitios web o aplicaciones, o puede establecer su propio tono de llamada bangla personalizado en su teléfono. Al hacerlo, puedes disfrutar de los beneficios de los tonos de llamada bangla, como:</p>
-<ul>
-<li>Mostrando tu amor y aprecio por la lengua y la cultura bangla. </li>
-<li>Impresionando a sus amigos y familiares con su tono de llamada único y pegadizo. </li>
-<li>Expresar tu estado de ánimo y personalidad con un tono de llamada adecuado. </li>
-<li>Apoyar a la industria de la música bangla y artistas mediante la compra de sus canciones como tonos de llamada. </li>
-</ul>
-<p>Esperamos que este artículo te haya ayudado a aprender a descargar y establecer un tono de llamada bangla que diga "te amo" de una manera dulce y melodiosa. Si tiene alguna pregunta o comentario, no dude en compartirlos a continuación. ¡Gracias por leer y feliz timbre! </p>
- <h2>Preguntas frecuentes: Cinco preguntas y respuestas comunes sobre tonos de llamada Bangla</h2>
-<p>Aquí están algunas de las preguntas y respuestas más frecuentes sobre los tonos de llamada bangla:</p>
- <h3>Q: ¿Cuáles son los mejores sitios web o aplicaciones para descargar tonos de llamada bangla gratis? </h3>
-<p>A: Algunos de los mejores sitios web o aplicaciones para descargar tonos de llamada bangla gratis son Prokerala, Zedge, tonos de llamada bengalíes, Mobile9 y Mobcup. Puedes encontrar una variedad de tonos de llamada en diferentes géneros y categorías en estas plataformas. </p>
- <h3>Q: ¿Cómo puedo crear mi propio tono de llamada personalizado de bangla? </h3>
-<p>A: Puedes crear tu propio tono de llamada personalizado usando algunas herramientas o software en línea, como Audacity, Ringtone Maker, Online Audio Cutter, etc. Puedes subir tu propio archivo de audio o grabar tu voz y editarla para hacer un tono de llamada. También puede agregar efectos, filtros o transiciones para hacerlo más atractivo. </p>
- <h3>Q: ¿Cómo puedo cambiar el volumen o la vibración de mi tono de llamada bangla? </h3>
-<p>A: Puede cambiar el volumen o la vibración de su tono de llamada bangla mediante el uso de la configuración en el teléfono. Para los usuarios de iPhone, puede utilizar los botones de volumen en el lado de su teléfono o el Centro de control para ajustar el volumen. También puede ir a Configuración > Sonidos y hápticos > Tono de llamada para cambiar el patrón de vibración. Para los usuarios de Android, puedes usar los botones de volumen en el lateral del teléfono o el panel Configuración rápida para ajustar el volumen. También puede ir a Configuración > Sonido > Tono de llamada del teléfono para cambiar el patrón de vibración. </p>
- <h3>Q: ¿Cómo puedo eliminar o quitar un tono de llamada bangla de mi teléfono? </h3>
-<p>A: Puedes eliminar o quitar un tono de llamada bangla de tu teléfono siguiendo estos pasos:</p>
-<ol>
-<li>Para los usuarios de Android, conecte su teléfono Android a su computadora utilizando un cable USB o Bluetooth. Abra Explorador de archivos o Finder en su computadora y localice la carpeta Tonos de llamada en el almacenamiento interno del teléfono o en la tarjeta SD. Elimine o mueva los tonos de llamada que desea eliminar de su teléfono. </li>
-</ol>
- <h3>Q: ¿Cómo puedo compartir mi tono de llamada bangla con otros? </h3>
-<p>A: Puedes compartir tu tono de llamada con otros usando algunos métodos, como:</p>
-<ul>
-<li>Correo electrónico: Puede adjuntar su archivo de tono de llamada a un correo electrónico y enviarlo a sus contactos. </li>
-<li>Mensajería: Puede enviar su archivo de tono de llamada como un archivo adjunto o un enlace a través de SMS, WhatsApp, Telegram, etc.</li>
-<li>Redes sociales: Puede subir su archivo de tono de llamada a un servicio en la nube, como Google Drive, Dropbox, etc., y compartir el enlace en Facebook, Twitter, Instagram, etc.</li>
-<li>Bluetooth: Puede emparejar su teléfono con otro dispositivo que tiene Bluetooth habilitado y enviar su archivo de tono de llamada de forma inalámbrica. </li>
-</ul></p> 64aa2da5cf<br />
-<br />
-<br />

spaces/Benson/text-generation/Examples/Caja Maldita Incredibox Descargar.md DELETED Viewed

@@ -1,92 +0,0 @@
-<br />
-<h1>Descargar Incredibox Soulgem: Cómo jugar la versión modificada del juego de música popular</h1>
- <p>Si eres un fan de los juegos de música, probablemente hayas oído hablar de <a href="( 1 )">Incredibox</a>, un juego basado en la web que te permite crear tu propia música mezclando diferentes sonidos y efectos. Incredibox es una manera divertida y fácil de expresar tu creatividad y talento musical, así como para descubrir nuevos géneros y estilos. También puedes compartir tus mezclas con otros jugadores online, o escuchar sus creaciones para inspirarte. </p>
- <p>Pero ¿sabías que hay una versión modificada de Incredibox que añade aún más características y posibilidades al juego? Se llama <strong>Soulgem</strong>, y es un proyecto hecho por fans que transforma el juego original en una nueva experiencia. Soulgem no es una actualización oficial o expansión de Incredibox, sino un juego separado que utiliza el mismo motor y concepto, pero con diferentes gráficos, sonidos y jugabilidad. </p>
-<h2>caja maldita incredibox descargar</h2><br /><p><b><b>Download Zip</b> &#10003; <a href="https://bltlly.com/2v6LIr">https://bltlly.com/2v6LIr</a></b></p><br /><br />
- <p>En este artículo, le diremos todo lo que necesita saber sobre Soulgem, incluyendo cómo descargarlo e instalarlo en su dispositivo, cuáles son sus características y beneficios, cómo reproducirlo y hacer la mejor música, qué otros mods están disponibles para Incredibox y más. Así que si estás listo para explorar una nueva dimensión de la música, ¡sigue leyendo! </p>
- <h2>Características de Soulgem: ¿Qué lo hace único y divertido? </h2>
- <p>Soulgem es una versión modificada de Incredibox que fue creada por <a href="( 2 )">Marchell</a>, un fan del juego original que quería agregar su propio toque y visión. Soulgem se basa en la primera versión de Incredibox, que fue lanzado en 2009, pero con muchos cambios y mejoras. Estas son algunas de las características que hacen que Soulgem se destaque del juego original:</p>
- <ul>
-<li><strong>Animaciones de bonificación y sorpresas</strong>: Soulgem tiene algunos secretos ocultos que puedes descubrir jugando el juego. Por ejemplo, si llenas todas las ranuras con el mismo personaje, desbloquearás una animación de bonificación que muestra al personaje realizando un movimiento o acción especial. Por ejemplo, el personaje con las gafas de sol tocará un solo de guitarra, el personaje con los auriculares rayará un disco de vinilo, y así sucesivamente. También hay algunos huevos de Pascua y referencias a otros juegos y medios que puedes encontrar jugando con los sonidos y efectos. </li>
-<li><strong>Mezclas personalizables y opciones para compartir</strong>: Soulgem te permite guardar y cargar tus mezclas, así como compartirlas con otros jugadores en línea. También puedes descargar tus mezclas como archivos MP3, o exportarlas como vídeos para subirlas a YouTube u otras plataformas. También puedes personalizar tus mezclas añadiendo tu propio título, descripción e imagen de portada. Soulgem tiene un sitio web dedicado donde puedes navegar y escuchar las mezclas de otros jugadores, calificarlos, comentarlos y seguir a tus creadores favoritos. </li>
-</ul>
- <h2>Consejos y trucos para jugar Soulgem: Cómo hacer la mejor música? </h2>
- <p>Soulgem es un juego que te permite dar rienda suelta a tu creatividad y habilidades musicales, pero también requiere algo de práctica y experimentación para dominarlo. Aquí hay algunos consejos y trucos que te ayudarán a jugar mejor Soulgem y hacer la mejor música posible:</p>
- <ul>
-<li><strong>Experimenta con diferentes combinaciones y estilos</strong>: Soulgem tiene muchos sonidos y efectos para elegir, y cada uno tiene un impacto diferente en la mezcla general. Puedes crear diferentes estados de ánimo, atmósferas y géneros combinando diferentes elementos. Por ejemplo, puedes crear una mezcla relajante usando sonidos y efectos suaves, o una mezcla energética usando sonidos y efectos fuertes y rápidos. También puedes mezclar y combinar diferentes estilos, como hip hop y rock, o pop y electro, para crear mezclas únicas y originales. </li>
-<li><strong>Mira los tutoriales y aprende de otros jugadores</strong>: Soulgem tiene un modo tutorial que te enseña los conceptos básicos del juego, como cómo arrastrar y soltar sonidos y efectos, cómo usar los botones shuffle y mute, cómo guardar y cargar mezclas, y más. Puede acceder al modo tutorial haciendo clic en el icono de interrogación en la esquina superior derecha de la pantalla. También puedes aprender de otros jugadores viendo sus mezclas en línea o leyendo sus comentarios y comentarios. Puedes obtener algunas ideas, consejos e inspiración de las mezclas de otros jugadores, así como compartir tus propios pensamientos y opiniones. </li>
-</ul>
- <h2>Alternativas a Soulgem: ¿Qué otros mods están disponibles? </h2>
- <p>Soulgem no es la única versión modificada de Incredibox que existe. Hay muchos otros mods que han sido creados por los fans del juego original, cada uno con su propio tema, estilo y características. Estos son algunos de los mods más populares que puedes encontrar en línea:</p>
- <tabla>
-<tr>
-<th>Nombre de mod</th>
-<th>Descripción</th>
-</tr>
-<tr>
-<td>Mecánico</td>
-<td>Un mod que tiene un tema futurista y robótico, con sonidos y efectos que se asemejan a máquinas, engranajes, láseres, etc.</td>
-</tr>
-<tr>
-<td>Xrun</td>
-<td>Un mod que tiene un tema de ritmo rápido y enérgico, con sonidos y efectos que se asemejan a los coches de carreras, motores, sirenas, etc.</td>
-</tr>
-<tr>
-<td>Evadare</td>
-<td>Un mod que tiene un tema misterioso y místico, con sonidos y efectos que se asemejan a hechizos mágicos, cantos, cristales, etc.</td>
-</tr>
-<tr>
-<td>Y más...</td>
-<td>Hay muchos otros mods que tienen diferentes temas, tales como horror, fantasía, medieval, etc. Puedes encontrarlos buscando en línea o visitando sitios web creados por fans. </td>
-</tr>
-</tabla>
- <p>Sin embargo, antes de jugar a estos mods, usted debe ser consciente de algunos pros y contras de las versiones modificadas vs el juego original. Aquí están algunos de ellos:</p>
- <ul>
-<li><strong>Pros</strong>:   <ul>
-  <li>Puedes disfrutar de nuevas y diferentes características y posibilidades que no están disponibles en el juego original. </li>
-  <li>Puedes apoyar y apreciar la creatividad y el talento de los creadores de mods hechos por fans. </li>
-  <li>Puedes explorar y descubrir nuevos géneros y estilos de música que quizás no hayas escuchado antes. </li>
-  </ul>
-</li>
-<li><strong>Contras</strong>:   <ul>
-  <li> Puede encontrar algunos errores, fallas o errores que pueden afectar la jugabilidad o el rendimiento del mod. </li>
-  <li>Es posible que no puedas acceder a algunas funciones u opciones disponibles en el juego original, como actualizaciones, logros, etc.</li>
-  <li>Es posible que no pueda jugar algunos mods en línea o compartirlos con otros jugadores, debido a problemas de compatibilidad o seguridad. </li>
-  </ul>
-</li>
-</ul>
- <h2>Conclusión: ¿Por qué usted debe intentar Soulgem hoy? </h2>
- <p>Soulgem es una versión modificada de Incredibox que ofrece una nueva y emocionante manera de jugar el popular juego de música. Soulgem tiene muchas características y beneficios que lo hacen único y divertido, como el nuevo diseño de personajes y efectos de sonido, animaciones de bonificación y sorpresas, mezclas personalizables y opciones para compartir, y más. Soulgem también es fácil de descargar e instalar en su dispositivo, y se puede jugar en línea o fuera de línea, dependiendo de su preferencia. </p>
- <p>Si estás buscando un juego de música fresco y original que desafíe tu creatividad y habilidades musicales, deberías probar Soulgem hoy. Soulgem le permitirá crear su propia música mediante la mezcla de diferentes sonidos y efectos, así como para escuchar mezclas de otros instrumentistas para la inspiración. También descubrirás nuevos géneros y estilos de música que quizás no hayas escuchado antes, como soul, funk, rock, electro y más. </p>
-<p></p>
- <h2>Preguntas frecuentes: Preguntas frecuentes sobre Soulgem</h2>
- <p>Aquí están algunas de las preguntas más comunes que la gente hace sobre Soulgem:</p>
- <ol>
-<li><strong>¿Es seguro descargar y jugar Soulgem? </strong></li>
-<p>Sí, Soulgem es seguro para descargar y jugar, siempre y cuando siga las instrucciones y utilice las aplicaciones y sitios web recomendados. Soulgem no contiene ningún virus, malware o spyware que pueda dañar su dispositivo o datos. Sin embargo, siempre debe tener cuidado al descargar cualquier archivo de Internet, y escanearlo con una aplicación antivirus antes de abrirlo. </p>
-<li><strong>¿Cómo puedo apoyar a los creadores de Soulgem e Incredibox? </strong></li>
-<p>Puedes apoyar a los creadores de Soulgem visitando su sitio web, siguiendo sus cuentas de redes sociales, valorando sus mezclas en línea, dejándoles comentarios y comentarios positivos, donándoles a través de PayPal o Patreon, o comprando su mercancía. También puede apoyar a los creadores de Incredibox visitando su sitio web, comprando su aplicación oficial o mercancía, suscribiéndose a su canal de YouTube, siguiendo sus cuentas de redes sociales, o donando a través de PayPal.</p>
-<li><strong>¿Puedo jugar Soulgem sin conexión o sin conexión a Internet? </strong></li>
-<p>Sí, puede jugar Soulgem sin conexión o sin conexión a Internet, siempre y cuando haya descargado el archivo mod en su dispositivo y tenga una aplicación Flash Player instalada. Sin embargo, no podrás acceder a algunas funciones u opciones que requieran conexión a Internet, como compartir tus mezclas en línea, escuchar las mezclas de otros jugadores en línea, actualizar el archivo mod, etc.</p>
-<li><strong>¿Puedo crear mi propio mod para Incredibox? </strong></li>
-<li><strong>¿Dónde puedo encontrar más información y actualizaciones sobre Soulgem e Incredibox? </strong></li>
-<p>Puedes encontrar más información y actualizaciones sobre Soulgem e Incredibox visitando sus sitios web oficiales, cuentas de redes sociales, canales de YouTube, foros creados por fans, blogs, wikis, etc. Estos son algunos de los enlaces que puedes consultar:</p>
-<ul>
-<li><a href="">Sitio web de Soulgem</a></li>
-<li><a href="">Canal de YouTube de Soulgem</a></li>
-<li><a href="">Cuenta de Instagram de Soulgem</a></li>
-<li><a href="">Sitio web de Incredibox</a></li>
-<li><a href="">Incredibox canal de YouTube</a></li>
-<li><a href="">Cuenta de Instagram Incredibox</a></li>
-<li><a href="">Incredibox wiki</a></li>
-<li><a href="">Foro de fans de Incredibox</a></li>
-</ul>
-</ol>
- <p>Espero que hayas disfrutado este artículo y hayas aprendido algo nuevo sobre Soulgem e Incredibox. Si tiene alguna pregunta o comentario, no dude en dejarlos abajo. Gracias por leer y hacer música feliz! </p> 64aa2da5cf<br />
-<br />
-<br />

spaces/Benson/text-generation/Examples/Descargar Carx Street Versin 0.8.5.md DELETED Viewed

@@ -1,57 +0,0 @@
-<br />
-<h1>Descargar CarX Street Versión 0.8.5: Una guía para los fanáticos de los juegos de carreras</h1>
-<p>Si eres un fan de los juegos de carreras, es posible que hayas oído hablar de CarX Street, un juego móvil que te permite experimentar la emoción de las carreras callejeras con física realista, gráficos impresionantes y una variedad de coches y opciones de personalización. En este artículo, te contaremos todo lo que necesitas saber sobre la versión 0.8.5 de CarX Street, la última actualización que trae nuevas características, mejoras y desafíos al juego. También le daremos algunos consejos y trucos sobre cómo descargar y jugar la versión 0.8.5 de CarX Street como un profesional. </p>
- <h2>¿Qué es CarX Street? </h2>
-<p>CarX Street es un juego de carreras móvil desarrollado por CarX Technologies, LLC, la misma compañía detrás de la popular serie CarX Drift Racing. CarX Street fue lanzado en 2021 y desde entonces ha ganado millones de descargas y comentarios positivos de jugadores y críticos por igual. </p>
-<h2>descargar carx street versión 0.8.5</h2><br /><p><b><b>DOWNLOAD</b> &mdash;&mdash;&mdash; <a href="https://bltlly.com/2v6KBZ">https://bltlly.com/2v6KBZ</a></b></p><br /><br />
-<p>CarX Street es diferente de otros juegos de carreras en que se centra en la cultura de las carreras callejeras, donde puedes elegir entre una amplia gama de autos, desde autos clásicos hasta supercoches modernos, y personalizarlos con varias partes, pinturas, calcomanías y pegatinas. También puede ajustar sus coches para adaptarse a su estilo de conducción y preferencias, como ajustar la potencia del motor, suspensión, frenos, neumáticos y más. </p>
-<p>CarX Street también cuenta con física y gráficos realistas que te hacen sentir como si realmente estuvieras conduciendo en las calles de diferentes ciudades de todo el mundo. Usted puede deriva, impulsar, adelantar, y chocar su camino a través de varios modos de juego, tales como el modo de carrera, el modo de carrera rápida, el modo club, y el modo en línea. También puedes competir con otros jugadores en tablas de clasificación, torneos y eventos. </p>
- <h2>Cómo descargar la versión 0.8.5</h2>
-<p>CarX Street versión 0.8.5 es la última actualización que se lanzó en junio de 2023. Trae nuevas características, mejoras y desafíos al juego que lo hacen más divertido y emocionante de jugar. </p>
-<p>Estos son los pasos para descargar CarX Street versión 0.8.5:</p>
-<p></p>
-<ol>
-<li>Ir a la Google Play Store o la App Store en su dispositivo y buscar "CarX Street". </li>
-<li>Seleccione el juego de los resultados y toque en "Instalar" o "Obtener". </li>
-<li>Espera a que el juego se descargue e instale en tu dispositivo. </li>
-<li>Iniciar el juego y disfrutar! </li>
-</ol>
- <h2>Por qué deberías jugar CarX Street versión 0.8.5</h2>
-<p>CarX Street versión 0.8.5 no es solo una actualización regular que corrige algunos errores y problemas técnicos. Es una actualización importante que añade nuevo contenido, características, mejoras y desafíos al juego que lo hacen más agradable y atractivo para los jugadores de todos los niveles. </p>
-<p>Estas son algunas de las razones por las que deberías jugar CarX Street versión 0.8.5:</p>
- <h3>Gráficos y rendimiento mejorados</h3>
-<p>CarX Street versión 0.8.5 mejora los gráficos y el rendimiento del juego mediante la optimización de las texturas, iluminación, sombras, reflejos y animaciones de los coches y entornos. El juego también se ejecuta más suave y rápido en diferentes dispositivos, reduciendo el retraso y los bloqueos. </p>
- <h3>Nuevo <h3>Nuevos coches y opciones de personalización</h3>
-<p>CarX Street versión 0.8.5 añade nuevos coches y opciones de personalización al juego que le permiten expresar su personalidad y estilo. Ahora puedes elegir entre más de 50 coches, incluyendo algunos de los modelos más icónicos y legendarios, como el Ford Mustang, el Chevrolet Camaro, el Nissan Skyline y el Lamborghini Aventador. También puede personalizar sus coches con más de 1000 piezas, pinturas, calcomanías y pegatinas, creando sus propios diseños únicos e impresionantes. </p>
- <h3>Más modos de juego y desafíos</h3>
- <h2>Consejos y trucos para CarX Street versión 0.8.5</h2>
-<p>CarX Street versión 0.8.5 no es un juego fácil de dominar. Requiere práctica, paciencia y estrategia para ganar carreras y progreso en el juego. Aquí hay algunos consejos y trucos que pueden ayudarle a mejorar su rendimiento y disfrutar del juego más:</p>
- <h3>Domina la mecánica de deriva y nitro</h3>
-<p>Drifting y nitro son dos de los mecánicos más importantes en la versión 0.8.5 de CarX Street. Drifting le permite tomar giros bruscos sin perder velocidad, mientras que nitro le da un impulso de aceleración que puede ayudarle a superar a sus oponentes o escapar de la policía. </p>
-<p>A la deriva, es necesario tocar el botón de freno mientras gira el volante. Cuanto más tiempo se mantenga el botón de freno, más se deriva. Para usar nitro, debe tocar el botón nitro cuando esté lleno. Puede llenar su medidor de nitro a la deriva, adelantando o realizando acrobacias. </p>
- <h3>Actualizar sus coches y sintonizarlos a su preferencia</h3>
-<p>Actualizar sus coches y sintonizarlos a su preferencia son esenciales para ganar carreras y avanzar en el juego. La actualización de sus coches aumentará su rendimiento, como la velocidad, la aceleración, el manejo y la durabilidad. Sintonizar sus coches le permitirá ajustar sus ajustes, como la potencia del motor, la suspensión, los frenos, los neumáticos y más. </p>
-<p>Para actualizar sus coches, es necesario gastar monedas o diamantes que se pueden ganar jugando el juego o viendo anuncios. Para ajustar sus coches, es necesario ir al garaje y utilizar los controles deslizantes para cambiar los valores de cada parámetro. </p>
- <h3>Únete a un club y compite con otros jugadores</h3>
-<p>Unirse a un club y competir con otros jugadores es una excelente manera de hacer amigos, aprender de otros y ganar recompensas en la versión 0.8.5 de CarX Street. Los clubes son grupos de jugadores que comparten un interés o objetivo común en el juego. Puede unirse a un club existente o crear su propio club con sus amigos. </p>
- <h2>Conclusión</h2>
-<p>CarX Street versión 0.8.5 es un juego imprescindible para los fanáticos de los juegos de carreras que quieren experimentar la emoción de las carreras callejeras con física realista, gráficos impresionantes y una variedad de coches y opciones de personalización. También es un juego divertido y desafiante que ofrece nuevas características, mejoras y desafíos que lo hacen más agradable y atractivo para jugadores de todos los niveles. </p>
-<p>Si quieres descargar la versión 0.8.5 de CarX Street y jugar como un profesional, sigue nuestra guía anterior y usa nuestros consejos y trucos para mejorar tu rendimiento y disfrutar más del juego. </p>
- <h3>Preguntas frecuentes</h3>
-<ul>
-<li>Q: ¿Cuánto espacio de almacenamiento necesito para descargar la versión 0.8.5 de CarX Street? </li>
-<li>A: Necesita al menos 1 GB de espacio de almacenamiento gratuito en su dispositivo para descargar la versión 0.8.5 de CarX Street. </li>
-<li>Q: ¿Cómo puedo desbloquear coches nuevos en CarX Street versión 0.8.5? </li>
-<li>A: Puedes desbloquear coches nuevos en la versión 0.8.5 de CarX Street completando etapas de modo carrera, ganando eventos y torneos, o comprándolos con monedas o diamantes. </li>
-<li>Q: <li>Q: ¿Cómo puedo ganar monedas y diamantes en CarX Street versión 0.8.5? </li>
-<li>A: Puedes ganar monedas y diamantes en la versión 0.8.5 de CarX Street al jugar el juego, completar misiones, ganar carreras, ver anuncios o comprarlos con dinero real. </li>
-<li>Q: ¿Cómo puedo usar nitro en CarX Street versión 0.8.5? </li>
-<li>A: Para la deriva, es necesario tocar el botón de freno mientras gira el volante. Para usar nitro, debes tocar el botón nitro cuando esté lleno. </li>
-<li>Q: ¿Cómo puedo unirme o crear un club en la versión 0.8.5 de CarX Street? </li>
-<li>A: Para unirse o crear un club en la versión 0.8.5 de CarX Street, debe ir al menú del club y tocar en el botón unirse o crear. A continuación, puede buscar un club existente o introducir el nombre y la descripción de su propio club. </li>
-</ul></p> 64aa2da5cf<br />
-<br />
-<br />

spaces/Benson/text-generation/Examples/Descargar Chicos Stumble Para Pc Sin Emulador.md DELETED Viewed

@@ -1,100 +0,0 @@
-<br />
-<h1>Cómo descargar Stumble Guys para PC sin emulador</h1>
-<p>Stumble Guys es un popular juego de fiesta multijugador en línea que te permite competir con hasta 32 jugadores a través de caóticas carreras de obstáculos. Usted puede correr, saltar, correr, deslizarse, y tropezar su camino a la línea de meta hasta que un vencedor es coronado. También puedes personalizar tu personaje con varios atuendos y emotes, e invitar a tus amigos a unirse a tu fiesta. </p>
-<h2>descargar chicos stumble para pc sin emulador</h2><br /><p><b><b>Download</b> &#10031; <a href="https://bltlly.com/2v6JNd">https://bltlly.com/2v6JNd</a></b></p><br /><br />
-<p>Stumble Guys está disponible para dispositivos Android en Google Play Store, pero ¿qué pasa si quieres jugar en tu PC? Puedes pensar que necesitas un emulador para ejecutar aplicaciones Android en tu ordenador, pero esa no es la única opción. De hecho, hay algunas maneras de jugar Stumble Guys en PC sin emulador, que puede ahorrarle tiempo, espacio y recursos. </p>
-<p>En este artículo, te mostraremos tres métodos para descargar Stumble Guys para PC sin emulador, y comparar sus pros y contras. Al final de este artículo, podrás disfrutar de Stumble Guys en una pantalla más grande y con mejores controles. </p>
- <h2>¿Qué es Stumble Guys? </h2>
-<p>Stumble Guys es un juego de batalla en línea royale partido que se inspira en programas de televisión como Wipeout y el castillo de Takeshi. El juego fue desarrollado por Scopely y lanzado en octubre de 2021. Ha recibido críticas positivas de jugadores y críticos por igual, y tiene más de 80.000 calificaciones en Steam.</p>
-<p></p>
-<p>El juego cuenta con gráficos coloridos y locos, juego basado en la física, y falla hilarante. Puedes elegir entre diferentes modos, como el modo en solitario o en equipo, y competir contra otros jugadores en línea. También puedes desbloquear nuevos atuendos y emociones para tu personaje, como superhéroes, animales, piratas, zombis y más. </p>
-<p>El juego es fácil de jugar pero difícil de dominar. Tienes que utilizar tus habilidades y estrategia para superar los diversos obstáculos y desafíos en cada nivel. Tienes que tener cuidado de no caerte de las plataformas, ser golpeado por bolas gigantes o ser eliminado por otros jugadores. El último que esté de pie gana el juego. </p>
-<p>Stumble Guys es un juego divertido y adictivo que puedes jugar en tu dispositivo Android, pero hay algunas razones por las que podrías querer jugarlo en tu PC. Estos son algunos de ellos:</p>
-<ul>
-<li> Puedes disfrutar del juego en una pantalla más grande y mejor, lo que puede mejorar los gráficos y la inmersión. </li>
-<li> Puedes usar el teclado y el ratón para controlar a tu personaje, lo que puede darte más precisión y capacidad de respuesta. </li>
-<li> Puede evitar el desagüe de la batería, el sobrecalentamiento y los problemas de retraso que pueden ocurrir en su dispositivo móvil. </li>
-<li>Puedes grabar y transmitir tu juego más fácilmente, y compartirlo con tus amigos o comunidad en línea. </li>
-</ul>
-<p>Sin embargo, jugar Stumble Guys en PC no es tan simple como descargarlo desde la Google Play Store. Es necesario utilizar algunas herramientas o métodos para ejecutar el juego en su ordenador. Una de las formas más comunes es utilizar un emulador, que es un software que imita el sistema operativo Android en su PC. Sin embargo, los emuladores tienen algunos inconvenientes, como:</p>
-<ul>
-<li> Pueden ocupar mucho espacio y recursos en su PC, lo que puede afectar su rendimiento y velocidad. </li>
-<li>Pueden ser complicados de configurar y configurar, especialmente para principiantes. </li>
-<li>Pueden tener problemas de compatibilidad y seguridad, que pueden causar errores o infecciones de malware. </li>
-</ul>
-<p>Es por eso que te mostraremos algunas formas alternativas de jugar Stumble Guys en PC sin emulador. Estos métodos son más simples, rápidos y seguros que usar emuladores. Echemos un vistazo a ellos. </p>
- <h2>¿Cómo jugar Stumble chicos en PC sin emulador? </h2>
-<h3>Método 1: iMyFone MirrorTo</h3>
-<p>iMyFone MirrorTo es una herramienta que le permite reflejar y controlar la pantalla del teléfono Android en su PC de forma inalámbrica. Puedes usarlo para jugar Stumble Guys en PC sin emulador siguiendo estos pasos:</p>
-<ol>
-<li>Descargar e instalar iMyFone MirrorTo en su PC desde <a href="">aquí</a>. </li>
-<li>En su teléfono, deslice hacia abajo desde la parte superior de la pantalla y toque en el "Cast" o "Screen Mirroring" opción. </li>
-<li>Seleccione su PC de la lista de dispositivos disponibles y toque en "Iniciar ahora". </li>
-<li> La pantalla del teléfono se reflejará en su PC. Puede utilizar el ratón para controlar la pantalla del teléfono. </li>
-<li>Abrir Stumble chicos en el teléfono y empezar a jugar en su PC.</li>
-</ol>
-<p>Las ventajas de iMyFone MirrorTo sobre emuladores son:</p>
-<ul>
-<li> Es fácil de usar y no requiere ninguna instalación o configuración en su teléfono. </li>
-<li> No consume mucho espacio o recursos en su PC, ya que solo refleja la pantalla del teléfono. </li>
-<li> No afecta el rendimiento o la calidad del juego, ya que se ejecuta de forma nativa en su teléfono. </li>
-</ul>
- <h3>Método 2: Android-x86</h3>
-<p>Android-x86 es un proyecto que conecta el sistema operativo Android para ejecutarse en equipos basados en x86. Puedes usarlo para jugar Stumble Guys en PC sin emulador siguiendo estos pasos:</p>
-<ol>
-<li>Descargar la última versión de Android-x86 desde <a href="">aquí</a>. </li>
-<li>Crear una unidad USB de arranque con Android-x86 utilizando una herramienta como Rufus o UNetbootin.</li>
-<li>Reinicie su PC y arranque desde la unidad USB. Verá un menú con diferentes opciones. Elija "Ejecutar Android-x86 sin instalación". </li>
-<li>Entrarás en el escritorio Android-x86. Conéctate a una red Wi-Fi y abre la aplicación Google Play Store. </li>
-<li>Inicia sesión con tu cuenta de Google y descarga Stumble Guys desde Google Play Store.</li>
-<li>Abrir Stumble chicos y empezar a jugar en su PC.</li>
-</ol>
- <p>Las ventajas de Android-x86 sobre los emuladores son:</p>
- <ul>
- <li>Se ejecuta más rápido y más suave que los emuladores, ya que utiliza el hardware nativo de su PC.</li>
- <li>Soporta más características y aplicaciones que emuladores, ya que se basa en el código fuente oficial de Android. </li>
- </ul>
- <p>Las desventajas de Android-x86 son:</p>
- <ul>
-<li>No soporta controles de teclado y ratón, ya que está diseñado para pantallas táctiles. </li>
-</ul>
- <h3>Método 3: Soldador ARC</h3>
-<p>ARC Welder es una extensión de Chrome que le permite ejecutar aplicaciones Android en su PC utilizando el navegador Chrome. Puedes usarlo para jugar Stumble Guys en PC sin emulador siguiendo estos pasos:</p>
-<ol>
-<li>Descargue e instale el navegador Chrome en su PC desde <a href="">aquí</a>. </li>
-<li>Descargue e instale la extensión ARC Welder desde <a href="">aquí</a>. </li>
-<li>Descargar el archivo APK Stumble Guys de <a href="">aquí</a>. </li>
-<li>Inicie la extensión ARC Welder y haga clic en "Añadir su APK". </li>
-<li> Seleccione el archivo APK Stumble Guys y configurar los ajustes que desee. </li>
-<li>Haga clic en "Prueba" para ejecutar Stumble Guys en su PC.</li>
-</ol>
-<p>Las ventajas de ARC Welder sobre los emuladores son:</p>
-<ul>
-<li> Es simple y rápido de usar, ya que no requiere ninguna instalación o configuración en su PC.</li>
-<li>No ocupa mucho espacio ni recursos en tu PC, ya que se ejecuta en tu navegador. </li>
-<li>Soporta controles de teclado y ratón, así como mandos y joysticks. </li>
-</ul>
-<p>Las desventajas de ARC Welder son:</p>
-<ul>
-<li>No es compatible con Google Play Services, lo que significa que no puede iniciar sesión con su cuenta de Google o acceder a algunas características del juego. </li>
-<li> No tiene un buen rendimiento o calidad, ya que no está optimizado para ejecutar aplicaciones Android. </li>
-<li> Puede tener problemas de compatibilidad y estabilidad, lo que puede causar fallos o errores. </li>
-</ul>
- <h2>Conclusión</h2>
- <h2>Preguntas frecuentes</h2>
-<h4>Q1: ¿Es Stumble Guys libre para jugar? </h4>
-<p>A1: Sí, Stumble Guys es libre de jugar, pero tiene compras en la aplicación para artículos cosméticos y emotes. </p>
- <h4>Q2: ¿Puedo jugar Stumble Guys con mis amigos? </h4>
-<p>A2: Sí, puedes invitar a tus amigos a unirse a tu grupo y competir contra otros jugadores en línea. </p>
- <h4>Q3: ¿Cuáles son los requisitos del sistema para Stumble Guys? </h4>
-<p>A3: Para dispositivos Android, necesita al menos Android 5.0 y 100 MB de espacio libre. Para PC, necesita al menos Windows 10, procesador Intel Core 2 Duo E8400 o AMD Phenom II X4 965, 4 GB de RAM, AMD Radeon HD 7750 o tarjeta gráfica NVIDIA Geforce GTX 260 y conexión a Internet de banda ancha. </p>
- <h4>Q4: ¿Cuántos jugadores pueden jugar Stumble Guys a la vez? </h4>
-<p>A4: Stumble Guys admite hasta 32 jugadores online en cada ronda. </p>
- <h4>Q5: ¿Cuántos niveles hay en Stumble Guys? </h4>
-<p>A5: Actualmente hay 17 carreras de obstáculos únicas en Stumble Guys, cada una con diferentes desafíos y temas. </p> 64aa2da5cf<br />
-<br />
-<br />

spaces/BernardoOlisan/vqganclip/taming-transformers/setup.py DELETED Viewed

@@ -1,13 +0,0 @@
-from setuptools import setup, find_packages
-setup(
-    name='taming-transformers',
-    version='0.0.1',
-    description='Taming Transformers for High-Resolution Image Synthesis',
-    packages=find_packages(),
-    install_requires=[
-        'torch',
-        'numpy',
-        'tqdm',
-    ],
-)

spaces/Big-Web/MMSD/env/Lib/site-packages/pip/_vendor/chardet/langthaimodel.py DELETED Viewed

The diff for this file is too large to render. See raw diff

spaces/Branon/oai-proxy/Dockerfile DELETED Viewed

@@ -1,11 +0,0 @@
-FROM node:18-bullseye-slim
-RUN apt-get update && \
-    apt-get install -y git
-RUN git clone https://gitlab.com/khanon/oai-proxy.git /app
-WORKDIR /app
-RUN npm install
-COPY Dockerfile greeting.md* .env* ./
-RUN npm run build
-EXPOSE 7860
-ENV NODE_ENV=production
-CMD [ "npm", "start" ]

spaces/CAPTY222/runwayml-stable-diffusion-v1-5/app.py DELETED Viewed

@@ -1,3 +0,0 @@
-import gradio as gr
-gr.Interface.load("models/runwayml/stable-diffusion-v1-5").launch()

spaces/CVPR/Dual-Key_Backdoor_Attacks/datagen/detectron2/projects/TridentNet/train_net.py DELETED Viewed

@@ -1,67 +0,0 @@
-#!/usr/bin/env python3
-# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
-"""
-TridentNet Training Script.
-This script is a simplified version of the training script in detectron2/tools.
-"""
-import os
-from detectron2.checkpoint import DetectionCheckpointer
-from detectron2.config import get_cfg
-from detectron2.engine import DefaultTrainer, default_argument_parser, default_setup, launch
-from detectron2.evaluation import COCOEvaluator
-from tridentnet import add_tridentnet_config
-class Trainer(DefaultTrainer):
-    @classmethod
-    def build_evaluator(cls, cfg, dataset_name, output_folder=None):
-        if output_folder is None:
-            output_folder = os.path.join(cfg.OUTPUT_DIR, "inference")
-        return COCOEvaluator(dataset_name, cfg, True, output_folder)
-def setup(args):
-    """
-    Create configs and perform basic setups.
-    """
-    cfg = get_cfg()
-    add_tridentnet_config(cfg)
-    cfg.merge_from_file(args.config_file)
-    cfg.merge_from_list(args.opts)
-    cfg.freeze()
-    default_setup(cfg, args)
-    return cfg
-def main(args):
-    cfg = setup(args)
-    if args.eval_only:
-        model = Trainer.build_model(cfg)
-        DetectionCheckpointer(model, save_dir=cfg.OUTPUT_DIR).resume_or_load(
-            cfg.MODEL.WEIGHTS, resume=args.resume
-        )
-        res = Trainer.test(cfg, model)
-        return res
-    trainer = Trainer(cfg)
-    trainer.resume_or_load(resume=args.resume)
-    return trainer.train()
-if __name__ == "__main__":
-    args = default_argument_parser().parse_args()
-    print("Command Line Args:", args)
-    launch(
-        main,
-        args.num_gpus,
-        num_machines=args.num_machines,
-        machine_rank=args.machine_rank,
-        dist_url=args.dist_url,
-        args=(args,),
-    )

spaces/CVPR/Dual-Key_Backdoor_Attacks/openvqa/openvqa/models/butd/adapter.py DELETED Viewed

@@ -1,71 +0,0 @@
-# --------------------------------------------------------
-# OpenVQA
-# Written by Zhenwei Shao https://github.com/ParadoxZW
-# --------------------------------------------------------
-import torch.nn as nn
-import torch
-from openvqa.core.base_dataset import BaseAdapter
-from openvqa.utils.make_mask import make_mask
-class Adapter(BaseAdapter):
-    def __init__(self, __C):
-        super(Adapter, self).__init__(__C)
-        self.__C = __C
-    def vqa_init(self, __C):
-        pass
-        # self.frcn_linear = nn.Linear(__C.FEAT_SIZE['vqa']['FRCN_FEAT_SIZE'][1], __C.HIDDEN_SIZE)
-    def gqa_init(self, __C):
-        imgfeat_linear_size = __C.FEAT_SIZE['gqa']['FRCN_FEAT_SIZE'][1]
-        if __C.USE_BBOX_FEAT:
-            self.bbox_linear = nn.Linear(5, __C.BBOXFEAT_EMB_SIZE)
-            imgfeat_linear_size += __C.BBOXFEAT_EMB_SIZE
-        self.frcn_linear = nn.Linear(imgfeat_linear_size, __C.HIDDEN_SIZE)
-        if __C.USE_AUX_FEAT:
-            self.grid_linear = nn.Linear(
-                __C.FEAT_SIZE['gqa']['GRID_FEAT_SIZE'][1], __C.HIDDEN_SIZE)
-    def clevr_init(self, __C):
-        self.grid_linear = nn.Linear(
-            __C.FEAT_SIZE['clevr']['GRID_FEAT_SIZE'][1], __C.HIDDEN_SIZE)
-    def vqa_forward(self, feat_dict):
-        frcn_feat = feat_dict['FRCN_FEAT']
-        bbox_feat = feat_dict['BBOX_FEAT']
-        img_feat_mask = make_mask(frcn_feat)
-        # img_feat = self.frcn_linear(frcn_feat)
-        return frcn_feat, img_feat_mask
-    def gqa_forward(self, feat_dict):
-        frcn_feat = feat_dict['FRCN_FEAT']
-        bbox_feat = feat_dict['BBOX_FEAT']
-        grid_feat = feat_dict['GRID_FEAT']
-        img_feat_mask = make_mask(frcn_feat)
-        if self.__C.USE_BBOX_FEAT:
-            bbox_feat = self.bbox_linear(bbox_feat)
-            frcn_feat = torch.cat((frcn_feat, bbox_feat), dim=-1)
-        img_feat = self.frcn_linear(frcn_feat)
-        return img_feat, img_feat_mask
-    def clevr_forward(self, feat_dict):
-        grid_feat = feat_dict['GRID_FEAT']
-        img_feat_mask = make_mask(grid_feat)
-        img_feat = self.grid_linear(grid_feat)
-        return img_feat, img_feat_mask

spaces/CVPR/LIVE/thrust/thrust/random/normal_distribution.h DELETED Viewed

@@ -1,275 +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 normal_distribution.h
- *  \brief A normal (Gaussian) distribution of real-valued numbers.
- */
-#pragma once
-#include <thrust/detail/config.h>
-#include <thrust/pair.h>
-#include <thrust/random/detail/random_core_access.h>
-#include <thrust/random/detail/normal_distribution_base.h>
-#include <iostream>
-namespace thrust
-{
-namespace random
-{
-/*! \addtogroup random_number_distributions
- *  \{
- */
-/*! \class normal_distribution
- *  \brief A \p normal_distribution random number distribution produces floating point
- *         Normally distributed random numbers.
- *
- *  \tparam RealType The type of floating point number to produce.
- *
- *  The following code snippet demonstrates examples of using a \p normal_distribution with a
- *  random number engine to produce random values drawn from the Normal distribution with a given
- *  mean and variance:
- *
- *  \code
- *  #include <thrust/random/linear_congruential_engine.h>
- *  #include <thrust/random/normal_distribution.h>
- *
- *  int main(void)
- *  {
- *    // create a minstd_rand object to act as our source of randomness
- *    thrust::minstd_rand rng;
- *
- *    // create a normal_distribution to produce floats from the Normal distribution
- *    // with mean 2.0 and standard deviation 3.5
- *    thrust::random::normal_distribution<float> dist(2.0f, 3.5f);
- *
- *    // write a random number to standard output
- *    std::cout << dist(rng) << std::endl;
- *
- *    // write the mean of the distribution, just in case we forgot
- *    std::cout << dist.mean() << std::endl;
- *
- *    // 2.0 is printed
- *
- *    // and the standard deviation
- *    std::cout << dist.stddev() << std::endl;
- *
- *    // 3.5 is printed
- *
- *    return 0;
- *  }
- *  \endcode
- */
-template<typename RealType = double>
-  class normal_distribution
-    : public detail::normal_distribution_base<RealType>::type
-{
-  private:
-    typedef typename detail::normal_distribution_base<RealType>::type super_t;
-  public:
-    // types
-    /*! \typedef result_type
-     *  \brief The type of the floating point number produced by this \p normal_distribution.
-     */
-    typedef RealType result_type;
-    /*! \typedef param_type
-     *  \brief The type of the object encapsulating this \p normal_distribution's parameters.
-     */
-    typedef thrust::pair<RealType,RealType> param_type;
-    // constructors and reset functions
-    /*! This constructor creates a new \p normal_distribution from two values defining the
-     *  half-open interval of the distribution.
-     *
-     *  \param mean The mean (expected value) of the distribution. Defaults to \c 0.0.
-     *  \param stddev The standard deviation of the distribution. Defaults to \c 1.0.
-     */
-    __host__ __device__
-    explicit normal_distribution(RealType mean = 0.0, RealType stddev = 1.0);
-    /*! This constructor creates a new \p normal_distribution from a \p param_type object
-     *  encapsulating the range of the distribution.
-     *
-     *  \param parm A \p param_type object encapsulating the parameters (i.e., the mean and standard deviation) of the distribution.
-     */
-    __host__ __device__
-    explicit normal_distribution(const param_type &parm);
-    /*! Calling this member function guarantees that subsequent uses of this
-     *  \p normal_distribution do not depend on values produced by any random
-     *  number generator prior to invoking this function.
-     */
-    __host__ __device__
-    void reset(void);
-    // generating functions
-    /*! This method produces a new Normal random integer drawn from this \p normal_distribution's
-     *  range using a \p UniformRandomNumberGenerator as a source of randomness.
-     *
-     *  \param urng The \p UniformRandomNumberGenerator to use as a source of randomness.
-     */
-    template<typename UniformRandomNumberGenerator>
-    __host__ __device__
-    result_type operator()(UniformRandomNumberGenerator &urng);
-    /*! This method produces a new Normal random integer as if by creating a new \p normal_distribution
-     *  from the given \p param_type object, and calling its <tt>operator()</tt> method with the given
-     *  \p UniformRandomNumberGenerator as a source of randomness.
-     *
-     *  \param urng The \p UniformRandomNumberGenerator to use as a source of randomness.
-     *  \param parm A \p param_type object encapsulating the parameters of the \p normal_distribution
-     *              to draw from.
-     */
-    template<typename UniformRandomNumberGenerator>
-    __host__ __device__
-    result_type operator()(UniformRandomNumberGenerator &urng, const param_type &parm);
-    // property functions
-    /*! This method returns the value of the parameter with which this \p normal_distribution
-     *  was constructed.
-     *
-     *  \return The mean (expected value) of this \p normal_distribution's output.
-     */
-    __host__ __device__
-    result_type mean(void) const;
-    /*! This method returns the value of the parameter with which this \p normal_distribution
-     *  was constructed.
-     *
-     *  \return The standard deviation of this \p uniform_real_distribution's output.
-     */
-    __host__ __device__
-    result_type stddev(void) const;
-    /*! This method returns a \p param_type object encapsulating the parameters with which this
-     *  \p normal_distribution was constructed.
-     *
-     *  \return A \p param_type object encapsulating the parameters (i.e., the mean and standard deviation) of this \p normal_distribution.
-     */
-    __host__ __device__
-    param_type param(void) const;
-    /*! This method changes the parameters of this \p normal_distribution using the values encapsulated
-     *  in a given \p param_type object.
-     *
-     *  \param parm A \p param_type object encapsulating the new parameters (i.e., the mean and variance) of this \p normal_distribution.
-     */
-    __host__ __device__
-    void param(const param_type &parm);
-    /*! This method returns the smallest floating point number this \p normal_distribution can potentially produce.
-     *
-     *  \return The lower bound of this \p normal_distribution's half-open interval.
-     */
-    __host__ __device__
-    result_type min THRUST_PREVENT_MACRO_SUBSTITUTION (void) const;
-    /*! This method returns the smallest number larger than largest floating point number this \p uniform_real_distribution can potentially produce.
-     *
-     *  \return The upper bound of this \p normal_distribution's half-open interval.
-     */
-    __host__ __device__
-    result_type max THRUST_PREVENT_MACRO_SUBSTITUTION (void) const;
-    /*! \cond
-     */
-  private:
-    param_type m_param;
-    friend struct thrust::random::detail::random_core_access;
-    __host__ __device__
-    bool equal(const normal_distribution &rhs) const;
-    template<typename CharT, typename Traits>
-    std::basic_ostream<CharT,Traits>& stream_out(std::basic_ostream<CharT,Traits> &os) const;
-    template<typename CharT, typename Traits>
-    std::basic_istream<CharT,Traits>& stream_in(std::basic_istream<CharT,Traits> &is);
-    /*! \endcond
-     */
-}; // end normal_distribution
-/*! This function checks two \p normal_distributions for equality.
- *  \param lhs The first \p normal_distribution to test.
- *  \param rhs The second \p normal_distribution to test.
- *  \return \c true if \p lhs is equal to \p rhs; \c false, otherwise.
- */
-template<typename RealType>
-__host__ __device__
-bool operator==(const normal_distribution<RealType> &lhs,
-                const normal_distribution<RealType> &rhs);
-/*! This function checks two \p normal_distributions for inequality.
- *  \param lhs The first \p normal_distribution to test.
- *  \param rhs The second \p normal_distribution to test.
- *  \return \c true if \p lhs is not equal to \p rhs; \c false, otherwise.
- */
-template<typename RealType>
-__host__ __device__
-bool operator!=(const normal_distribution<RealType> &lhs,
-                const normal_distribution<RealType> &rhs);
-/*! This function streams a normal_distribution to a \p std::basic_ostream.
- *  \param os The \p basic_ostream to stream out to.
- *  \param d The \p normal_distribution to stream out.
- *  \return \p os
- */
-template<typename RealType,
-         typename CharT, typename Traits>
-std::basic_ostream<CharT,Traits>&
-operator<<(std::basic_ostream<CharT,Traits> &os,
-           const normal_distribution<RealType> &d);
-/*! This function streams a normal_distribution in from a std::basic_istream.
- *  \param is The \p basic_istream to stream from.
- *  \param d The \p normal_distribution to stream in.
- *  \return \p is
- */
-template<typename RealType,
-         typename CharT, typename Traits>
-std::basic_istream<CharT,Traits>&
-operator>>(std::basic_istream<CharT,Traits> &is,
-           normal_distribution<RealType> &d);
-/*! \} // end random_number_distributions
- */
-} // end random
-using random::normal_distribution;
-} // end thrust
-#include <thrust/random/detail/normal_distribution.inl>

spaces/CVPR/Text2Human/Text2Human/models/archs/__init__.py DELETED Viewed

File without changes

spaces/CVPR/WALT/mmdet/core/bbox/__init__.py DELETED Viewed

@@ -1,27 +0,0 @@
-from .assigners import (AssignResult, BaseAssigner, CenterRegionAssigner,
-                        MaxIoUAssigner, RegionAssigner)
-from .builder import build_assigner, build_bbox_coder, build_sampler
-from .coder import (BaseBBoxCoder, DeltaXYWHBBoxCoder, PseudoBBoxCoder,
-                    TBLRBBoxCoder)
-from .iou_calculators import BboxOverlaps2D, bbox_overlaps
-from .samplers import (BaseSampler, CombinedSampler,
-                       InstanceBalancedPosSampler, IoUBalancedNegSampler,
-                       OHEMSampler, PseudoSampler, RandomSampler,
-                       SamplingResult, ScoreHLRSampler)
-from .transforms import (bbox2distance, bbox2result, bbox2roi,
-                         bbox_cxcywh_to_xyxy, bbox_flip, bbox_mapping,
-                         bbox_mapping_back, bbox_rescale, bbox_xyxy_to_cxcywh,
-                         distance2bbox, roi2bbox)
-__all__ = [
-    'bbox_overlaps', 'BboxOverlaps2D', 'BaseAssigner', 'MaxIoUAssigner',
-    'AssignResult', 'BaseSampler', 'PseudoSampler', 'RandomSampler',
-    'InstanceBalancedPosSampler', 'IoUBalancedNegSampler', 'CombinedSampler',
-    'OHEMSampler', 'SamplingResult', 'ScoreHLRSampler', 'build_assigner',
-    'build_sampler', 'bbox_flip', 'bbox_mapping', 'bbox_mapping_back',
-    'bbox2roi', 'roi2bbox', 'bbox2result', 'distance2bbox', 'bbox2distance',
-    'build_bbox_coder', 'BaseBBoxCoder', 'PseudoBBoxCoder',
-    'DeltaXYWHBBoxCoder', 'TBLRBBoxCoder', 'CenterRegionAssigner',
-    'bbox_rescale', 'bbox_cxcywh_to_xyxy', 'bbox_xyxy_to_cxcywh',
-    'RegionAssigner'
-]

spaces/CVPR/WALT/mmdet/core/post_processing/merge_augs.py DELETED Viewed

@@ -1,150 +0,0 @@
-import copy
-import warnings
-import numpy as np
-import torch
-from mmcv import ConfigDict
-from mmcv.ops import nms
-from ..bbox import bbox_mapping_back
-def merge_aug_proposals(aug_proposals, img_metas, cfg):
-    """Merge augmented proposals (multiscale, flip, etc.)
-    Args:
-        aug_proposals (list[Tensor]): proposals from different testing
-            schemes, shape (n, 5). Note that they are not rescaled to the
-            original image size.
-        img_metas (list[dict]): list of image info dict where each dict has:
-            'img_shape', 'scale_factor', 'flip', and may also contain
-            'filename', 'ori_shape', 'pad_shape', and 'img_norm_cfg'.
-            For details on the values of these keys see
-            `mmdet/datasets/pipelines/formatting.py:Collect`.
-        cfg (dict): rpn test config.
-    Returns:
-        Tensor: shape (n, 4), proposals corresponding to original image scale.
-    """
-    cfg = copy.deepcopy(cfg)
-    # deprecate arguments warning
-    if 'nms' not in cfg or 'max_num' in cfg or 'nms_thr' in cfg:
-        warnings.warn(
-            'In rpn_proposal or test_cfg, '
-            'nms_thr has been moved to a dict named nms as '
-            'iou_threshold, max_num has been renamed as max_per_img, '
-            'name of original arguments and the way to specify '
-            'iou_threshold of NMS will be deprecated.')
-    if 'nms' not in cfg:
-        cfg.nms = ConfigDict(dict(type='nms', iou_threshold=cfg.nms_thr))
-    if 'max_num' in cfg:
-        if 'max_per_img' in cfg:
-            assert cfg.max_num == cfg.max_per_img, f'You set max_num and ' \
-                f'max_per_img at the same time, but get {cfg.max_num} ' \
-                f'and {cfg.max_per_img} respectively' \
-                f'Please delete max_num which will be deprecated.'
-        else:
-            cfg.max_per_img = cfg.max_num
-    if 'nms_thr' in cfg:
-        assert cfg.nms.iou_threshold == cfg.nms_thr, f'You set ' \
-            f'iou_threshold in nms and ' \
-            f'nms_thr at the same time, but get ' \
-            f'{cfg.nms.iou_threshold} and {cfg.nms_thr}' \
-            f' respectively. Please delete the nms_thr ' \
-            f'which will be deprecated.'
-    recovered_proposals = []
-    for proposals, img_info in zip(aug_proposals, img_metas):
-        img_shape = img_info['img_shape']
-        scale_factor = img_info['scale_factor']
-        flip = img_info['flip']
-        flip_direction = img_info['flip_direction']
-        _proposals = proposals.clone()
-        _proposals[:, :4] = bbox_mapping_back(_proposals[:, :4], img_shape,
-                                              scale_factor, flip,
-                                              flip_direction)
-        recovered_proposals.append(_proposals)
-    aug_proposals = torch.cat(recovered_proposals, dim=0)
-    merged_proposals, _ = nms(aug_proposals[:, :4].contiguous(),
-                              aug_proposals[:, -1].contiguous(),
-                              cfg.nms.iou_threshold)
-    scores = merged_proposals[:, 4]
-    _, order = scores.sort(0, descending=True)
-    num = min(cfg.max_per_img, merged_proposals.shape[0])
-    order = order[:num]
-    merged_proposals = merged_proposals[order, :]
-    return merged_proposals
-def merge_aug_bboxes(aug_bboxes, aug_scores, img_metas, rcnn_test_cfg):
-    """Merge augmented detection bboxes and scores.
-    Args:
-        aug_bboxes (list[Tensor]): shape (n, 4*#class)
-        aug_scores (list[Tensor] or None): shape (n, #class)
-        img_shapes (list[Tensor]): shape (3, ).
-        rcnn_test_cfg (dict): rcnn test config.
-    Returns:
-        tuple: (bboxes, scores)
-    """
-    recovered_bboxes = []
-    for bboxes, img_info in zip(aug_bboxes, img_metas):
-        img_shape = img_info[0]['img_shape']
-        scale_factor = img_info[0]['scale_factor']
-        flip = img_info[0]['flip']
-        flip_direction = img_info[0]['flip_direction']
-        bboxes = bbox_mapping_back(bboxes, img_shape, scale_factor, flip,
-                                   flip_direction)
-        recovered_bboxes.append(bboxes)
-    bboxes = torch.stack(recovered_bboxes).mean(dim=0)
-    if aug_scores is None:
-        return bboxes
-    else:
-        scores = torch.stack(aug_scores).mean(dim=0)
-        return bboxes, scores
-def merge_aug_scores(aug_scores):
-    """Merge augmented bbox scores."""
-    if isinstance(aug_scores[0], torch.Tensor):
-        return torch.mean(torch.stack(aug_scores), dim=0)
-    else:
-        return np.mean(aug_scores, axis=0)
-def merge_aug_masks(aug_masks, img_metas, rcnn_test_cfg, weights=None):
-    """Merge augmented mask prediction.
-    Args:
-        aug_masks (list[ndarray]): shape (n, #class, h, w)
-        img_shapes (list[ndarray]): shape (3, ).
-        rcnn_test_cfg (dict): rcnn test config.
-    Returns:
-        tuple: (bboxes, scores)
-    """
-    recovered_masks = []
-    for mask, img_info in zip(aug_masks, img_metas):
-        flip = img_info[0]['flip']
-        flip_direction = img_info[0]['flip_direction']
-        if flip:
-            if flip_direction == 'horizontal':
-                mask = mask[:, :, :, ::-1]
-            elif flip_direction == 'vertical':
-                mask = mask[:, :, ::-1, :]
-            else:
-                raise ValueError(
-                    f"Invalid flipping direction '{flip_direction}'")
-        recovered_masks.append(mask)
-    if weights is None:
-        merged_masks = np.mean(recovered_masks, axis=0)
-    else:
-        merged_masks = np.average(
-            np.array(recovered_masks), axis=0, weights=np.array(weights))
-    return merged_masks

spaces/CVPR/regionclip-demo/detectron2/export/caffe2_modeling.py DELETED Viewed

@@ -1,503 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-import functools
-import io
-import struct
-import types
-import torch
-from detectron2.modeling import meta_arch
-from detectron2.modeling.box_regression import Box2BoxTransform
-from detectron2.modeling.meta_arch.panoptic_fpn import combine_semantic_and_instance_outputs
-from detectron2.modeling.meta_arch.retinanet import permute_to_N_HWA_K
-from detectron2.modeling.postprocessing import detector_postprocess, sem_seg_postprocess
-from detectron2.modeling.roi_heads import keypoint_head
-from detectron2.structures import Boxes, ImageList, Instances, RotatedBoxes
-from .c10 import Caffe2Compatible
-from .caffe2_patch import ROIHeadsPatcher, patch_generalized_rcnn
-from .shared import (
-    alias,
-    check_set_pb_arg,
-    get_pb_arg_floats,
-    get_pb_arg_valf,
-    get_pb_arg_vali,
-    get_pb_arg_vals,
-    mock_torch_nn_functional_interpolate,
-)
-def assemble_rcnn_outputs_by_name(image_sizes, tensor_outputs, force_mask_on=False):
-    """
-    A function to assemble caffe2 model's outputs (i.e. Dict[str, Tensor])
-    to detectron2's format (i.e. list of Instances instance).
-    This only works when the model follows the Caffe2 detectron's naming convention.
-    Args:
-        image_sizes (List[List[int, int]]): [H, W] of every image.
-        tensor_outputs (Dict[str, Tensor]): external_output to its tensor.
-        force_mask_on (Bool): if true, the it make sure there'll be pred_masks even
-            if the mask is not found from tensor_outputs (usually due to model crash)
-    """
-    results = [Instances(image_size) for image_size in image_sizes]
-    batch_splits = tensor_outputs.get("batch_splits", None)
-    if batch_splits:
-        raise NotImplementedError()
-    assert len(image_sizes) == 1
-    result = results[0]
-    bbox_nms = tensor_outputs["bbox_nms"]
-    score_nms = tensor_outputs["score_nms"]
-    class_nms = tensor_outputs["class_nms"]
-    # Detection will always success because Conv support 0-batch
-    assert bbox_nms is not None
-    assert score_nms is not None
-    assert class_nms is not None
-    if bbox_nms.shape[1] == 5:
-        result.pred_boxes = RotatedBoxes(bbox_nms)
-    else:
-        result.pred_boxes = Boxes(bbox_nms)
-    result.scores = score_nms
-    result.pred_classes = class_nms.to(torch.int64)
-    mask_fcn_probs = tensor_outputs.get("mask_fcn_probs", None)
-    if mask_fcn_probs is not None:
-        # finish the mask pred
-        mask_probs_pred = mask_fcn_probs
-        num_masks = mask_probs_pred.shape[0]
-        class_pred = result.pred_classes
-        indices = torch.arange(num_masks, device=class_pred.device)
-        mask_probs_pred = mask_probs_pred[indices, class_pred][:, None]
-        result.pred_masks = mask_probs_pred
-    elif force_mask_on:
-        # NOTE: there's no way to know the height/width of mask here, it won't be
-        # used anyway when batch size is 0, so just set them to 0.
-        result.pred_masks = torch.zeros([0, 1, 0, 0], dtype=torch.uint8)
-    keypoints_out = tensor_outputs.get("keypoints_out", None)
-    kps_score = tensor_outputs.get("kps_score", None)
-    if keypoints_out is not None:
-        # keypoints_out: [N, 4, #kypoints], where 4 is in order of (x, y, score, prob)
-        keypoints_tensor = keypoints_out
-        # NOTE: it's possible that prob is not calculated if "should_output_softmax"
-        # is set to False in HeatmapMaxKeypoint, so just using raw score, seems
-        # it doesn't affect mAP. TODO: check more carefully.
-        keypoint_xyp = keypoints_tensor.transpose(1, 2)[:, :, [0, 1, 2]]
-        result.pred_keypoints = keypoint_xyp
-    elif kps_score is not None:
-        # keypoint heatmap to sparse data structure
-        pred_keypoint_logits = kps_score
-        keypoint_head.keypoint_rcnn_inference(pred_keypoint_logits, [result])
-    return results
-def _cast_to_f32(f64):
-    return struct.unpack("f", struct.pack("f", f64))[0]
-def set_caffe2_compatible_tensor_mode(model, enable=True):
-    def _fn(m):
-        if isinstance(m, Caffe2Compatible):
-            m.tensor_mode = enable
-    model.apply(_fn)
-def convert_batched_inputs_to_c2_format(batched_inputs, size_divisibility, device):
-    """
-    See get_caffe2_inputs() below.
-    """
-    assert all(isinstance(x, dict) for x in batched_inputs)
-    assert all(x["image"].dim() == 3 for x in batched_inputs)
-    images = [x["image"] for x in batched_inputs]
-    images = ImageList.from_tensors(images, size_divisibility)
-    im_info = []
-    for input_per_image, image_size in zip(batched_inputs, images.image_sizes):
-        target_height = input_per_image.get("height", image_size[0])
-        target_width = input_per_image.get("width", image_size[1])  # noqa
-        # NOTE: The scale inside im_info is kept as convention and for providing
-        # post-processing information if further processing is needed. For
-        # current Caffe2 model definitions that don't include post-processing inside
-        # the model, this number is not used.
-        # NOTE: There can be a slight difference between width and height
-        # scales, using a single number can results in numerical difference
-        # compared with D2's post-processing.
-        scale = target_height / image_size[0]
-        im_info.append([image_size[0], image_size[1], scale])
-    im_info = torch.Tensor(im_info)
-    return images.tensor.to(device), im_info.to(device)
-class Caffe2MetaArch(Caffe2Compatible, torch.nn.Module):
-    """
-    Base class for caffe2-compatible implementation of a meta architecture.
-    The forward is traceable and its traced graph can be converted to caffe2
-    graph through ONNX.
-    """
-    def __init__(self, cfg, torch_model):
-        """
-        Args:
-            cfg (CfgNode):
-            torch_model (nn.Module): the detectron2 model (meta_arch) to be
-                converted.
-        """
-        super().__init__()
-        self._wrapped_model = torch_model
-        self.eval()
-        set_caffe2_compatible_tensor_mode(self, True)
-    def get_caffe2_inputs(self, batched_inputs):
-        """
-        Convert pytorch-style structured inputs to caffe2-style inputs that
-        are tuples of tensors.
-        Args:
-            batched_inputs (list[dict]): inputs to a detectron2 model
-                in its standard format. Each dict has "image" (CHW tensor), and optionally
-                "height" and "width".
-        Returns:
-            tuple[Tensor]:
-                tuple of tensors that will be the inputs to the
-                :meth:`forward` method. For existing models, the first
-                is an NCHW tensor (padded and batched); the second is
-                a im_info Nx3 tensor, where the rows are
-                (height, width, unused legacy parameter)
-        """
-        return convert_batched_inputs_to_c2_format(
-            batched_inputs,
-            self._wrapped_model.backbone.size_divisibility,
-            self._wrapped_model.device,
-        )
-    def encode_additional_info(self, predict_net, init_net):
-        """
-        Save extra metadata that will be used by inference in the output protobuf.
-        """
-        pass
-    def forward(self, inputs):
-        """
-        Run the forward in caffe2-style. It has to use caffe2-compatible ops
-        and the method will be used for tracing.
-        Args:
-            inputs (tuple[Tensor]): inputs defined by :meth:`get_caffe2_input`.
-                They will be the inputs of the converted caffe2 graph.
-        Returns:
-            tuple[Tensor]: output tensors. They will be the outputs of the
-                converted caffe2 graph.
-        """
-        raise NotImplementedError
-    def _caffe2_preprocess_image(self, inputs):
-        """
-        Caffe2 implementation of preprocess_image, which is called inside each MetaArch's forward.
-        It normalizes the input images, and the final caffe2 graph assumes the
-        inputs have been batched already.
-        """
-        data, im_info = inputs
-        data = alias(data, "data")
-        im_info = alias(im_info, "im_info")
-        mean, std = self._wrapped_model.pixel_mean, self._wrapped_model.pixel_std
-        normalized_data = (data - mean) / std
-        normalized_data = alias(normalized_data, "normalized_data")
-        # Pack (data, im_info) into ImageList which is recognized by self.inference.
-        images = ImageList(tensor=normalized_data, image_sizes=im_info)
-        return images
-    @staticmethod
-    def get_outputs_converter(predict_net, init_net):
-        """
-        Creates a function that converts outputs of the caffe2 model to
-        detectron2's standard format.
-        The function uses information in `predict_net` and `init_net` that are
-        available at inferene time. Therefore the function logic can be used in inference.
-        The returned function has the following signature:
-            def convert(batched_inputs, c2_inputs, c2_results) -> detectron2_outputs
-        Where
-            * batched_inputs (list[dict]): the original input format of the meta arch
-            * c2_inputs (tuple[Tensor]): the caffe2 inputs.
-            * c2_results (dict[str, Tensor]): the caffe2 output format,
-                corresponding to the outputs of the :meth:`forward` function.
-            * detectron2_outputs: the original output format of the meta arch.
-        This function can be used to compare the outputs of the original meta arch and
-        the converted caffe2 graph.
-        Returns:
-            callable: a callable of the above signature.
-        """
-        raise NotImplementedError
-class Caffe2GeneralizedRCNN(Caffe2MetaArch):
-    def __init__(self, cfg, torch_model):
-        assert isinstance(torch_model, meta_arch.GeneralizedRCNN)
-        torch_model = patch_generalized_rcnn(torch_model)
-        super().__init__(cfg, torch_model)
-        self.roi_heads_patcher = ROIHeadsPatcher(
-            self._wrapped_model.roi_heads, cfg.EXPORT_CAFFE2.USE_HEATMAP_MAX_KEYPOINT
-        )
-    def encode_additional_info(self, predict_net, init_net):
-        size_divisibility = self._wrapped_model.backbone.size_divisibility
-        check_set_pb_arg(predict_net, "size_divisibility", "i", size_divisibility)
-        check_set_pb_arg(
-            predict_net, "device", "s", str.encode(str(self._wrapped_model.device), "ascii")
-        )
-        check_set_pb_arg(predict_net, "meta_architecture", "s", b"GeneralizedRCNN")
-    @mock_torch_nn_functional_interpolate()
-    def forward(self, inputs):
-        if not self.tensor_mode:
-            return self._wrapped_model.inference(inputs)
-        images = self._caffe2_preprocess_image(inputs)
-        features = self._wrapped_model.backbone(images.tensor)
-        proposals, _ = self._wrapped_model.proposal_generator(images, features)
-        with self.roi_heads_patcher.mock_roi_heads():
-            detector_results, _ = self._wrapped_model.roi_heads(images, features, proposals)
-        return tuple(detector_results[0].flatten())
-    @staticmethod
-    def get_outputs_converter(predict_net, init_net):
-        def f(batched_inputs, c2_inputs, c2_results):
-            _, im_info = c2_inputs
-            image_sizes = [[int(im[0]), int(im[1])] for im in im_info]
-            results = assemble_rcnn_outputs_by_name(image_sizes, c2_results)
-            return meta_arch.GeneralizedRCNN._postprocess(results, batched_inputs, image_sizes)
-        return f
-class Caffe2PanopticFPN(Caffe2MetaArch):
-    def __init__(self, cfg, torch_model):
-        assert isinstance(torch_model, meta_arch.PanopticFPN)
-        torch_model = patch_generalized_rcnn(torch_model)
-        super().__init__(cfg, torch_model)
-        self.roi_heads_patcher = ROIHeadsPatcher(
-            self._wrapped_model.roi_heads, cfg.EXPORT_CAFFE2.USE_HEATMAP_MAX_KEYPOINT
-        )
-    @mock_torch_nn_functional_interpolate()
-    def forward(self, inputs):
-        assert self.tensor_mode
-        images = self._caffe2_preprocess_image(inputs)
-        features = self._wrapped_model.backbone(images.tensor)
-        sem_seg_results, _ = self._wrapped_model.sem_seg_head(features)
-        sem_seg_results = alias(sem_seg_results, "sem_seg")
-        proposals, _ = self._wrapped_model.proposal_generator(images, features)
-        with self.roi_heads_patcher.mock_roi_heads(self.tensor_mode):
-            detector_results, _ = self._wrapped_model.roi_heads(images, features, proposals)
-        return tuple(detector_results[0].flatten()) + (sem_seg_results,)
-    def encode_additional_info(self, predict_net, init_net):
-        size_divisibility = self._wrapped_model.backbone.size_divisibility
-        check_set_pb_arg(predict_net, "size_divisibility", "i", size_divisibility)
-        check_set_pb_arg(
-            predict_net, "device", "s", str.encode(str(self._wrapped_model.device), "ascii")
-        )
-        check_set_pb_arg(predict_net, "meta_architecture", "s", b"PanopticFPN")
-        # Inference parameters:
-        check_set_pb_arg(
-            predict_net,
-            "combine_overlap_threshold",
-            "f",
-            _cast_to_f32(self._wrapped_model.combine_overlap_thresh),
-        )
-        check_set_pb_arg(
-            predict_net,
-            "combine_stuff_area_limit",
-            "i",
-            self._wrapped_model.combine_stuff_area_thresh,
-        )
-        check_set_pb_arg(
-            predict_net,
-            "combine_instances_confidence_threshold",
-            "f",
-            _cast_to_f32(self._wrapped_model.combine_instances_score_thresh),
-        )
-    @staticmethod
-    def get_outputs_converter(predict_net, init_net):
-        combine_overlap_threshold = get_pb_arg_valf(predict_net, "combine_overlap_threshold", None)
-        combine_stuff_area_limit = get_pb_arg_vali(predict_net, "combine_stuff_area_limit", None)
-        combine_instances_confidence_threshold = get_pb_arg_valf(
-            predict_net, "combine_instances_confidence_threshold", None
-        )
-        def f(batched_inputs, c2_inputs, c2_results):
-            _, im_info = c2_inputs
-            image_sizes = [[int(im[0]), int(im[1])] for im in im_info]
-            detector_results = assemble_rcnn_outputs_by_name(
-                image_sizes, c2_results, force_mask_on=True
-            )
-            sem_seg_results = c2_results["sem_seg"]
-            # copied from meta_arch/panoptic_fpn.py ...
-            processed_results = []
-            for sem_seg_result, detector_result, input_per_image, image_size in zip(
-                sem_seg_results, detector_results, batched_inputs, image_sizes
-            ):
-                height = input_per_image.get("height", image_size[0])
-                width = input_per_image.get("width", image_size[1])
-                sem_seg_r = sem_seg_postprocess(sem_seg_result, image_size, height, width)
-                detector_r = detector_postprocess(detector_result, height, width)
-                processed_results.append({"sem_seg": sem_seg_r, "instances": detector_r})
-                panoptic_r = combine_semantic_and_instance_outputs(
-                    detector_r,
-                    sem_seg_r.argmax(dim=0),
-                    combine_overlap_threshold,
-                    combine_stuff_area_limit,
-                    combine_instances_confidence_threshold,
-                )
-                processed_results[-1]["panoptic_seg"] = panoptic_r
-            return processed_results
-        return f
-class Caffe2RetinaNet(Caffe2MetaArch):
-    def __init__(self, cfg, torch_model):
-        assert isinstance(torch_model, meta_arch.RetinaNet)
-        super().__init__(cfg, torch_model)
-    @mock_torch_nn_functional_interpolate()
-    def forward(self, inputs):
-        assert self.tensor_mode
-        images = self._caffe2_preprocess_image(inputs)
-        # explicitly return the images sizes to avoid removing "im_info" by ONNX
-        # since it's not used in the forward path
-        return_tensors = [images.image_sizes]
-        features = self._wrapped_model.backbone(images.tensor)
-        features = [features[f] for f in self._wrapped_model.head_in_features]
-        for i, feature_i in enumerate(features):
-            features[i] = alias(feature_i, "feature_{}".format(i), is_backward=True)
-            return_tensors.append(features[i])
-        pred_logits, pred_anchor_deltas = self._wrapped_model.head(features)
-        for i, (box_cls_i, box_delta_i) in enumerate(zip(pred_logits, pred_anchor_deltas)):
-            return_tensors.append(alias(box_cls_i, "box_cls_{}".format(i)))
-            return_tensors.append(alias(box_delta_i, "box_delta_{}".format(i)))
-        return tuple(return_tensors)
-    def encode_additional_info(self, predict_net, init_net):
-        size_divisibility = self._wrapped_model.backbone.size_divisibility
-        check_set_pb_arg(predict_net, "size_divisibility", "i", size_divisibility)
-        check_set_pb_arg(
-            predict_net, "device", "s", str.encode(str(self._wrapped_model.device), "ascii")
-        )
-        check_set_pb_arg(predict_net, "meta_architecture", "s", b"RetinaNet")
-        # Inference parameters:
-        check_set_pb_arg(
-            predict_net, "score_threshold", "f", _cast_to_f32(self._wrapped_model.test_score_thresh)
-        )
-        check_set_pb_arg(
-            predict_net, "topk_candidates", "i", self._wrapped_model.test_topk_candidates
-        )
-        check_set_pb_arg(
-            predict_net, "nms_threshold", "f", _cast_to_f32(self._wrapped_model.test_nms_thresh)
-        )
-        check_set_pb_arg(
-            predict_net,
-            "max_detections_per_image",
-            "i",
-            self._wrapped_model.max_detections_per_image,
-        )
-        check_set_pb_arg(
-            predict_net,
-            "bbox_reg_weights",
-            "floats",
-            [_cast_to_f32(w) for w in self._wrapped_model.box2box_transform.weights],
-        )
-        self._encode_anchor_generator_cfg(predict_net)
-    def _encode_anchor_generator_cfg(self, predict_net):
-        # serialize anchor_generator for future use
-        serialized_anchor_generator = io.BytesIO()
-        torch.save(self._wrapped_model.anchor_generator, serialized_anchor_generator)
-        # Ideally we can put anchor generating inside the model, then we don't
-        # need to store this information.
-        bytes = serialized_anchor_generator.getvalue()
-        check_set_pb_arg(predict_net, "serialized_anchor_generator", "s", bytes)
-    @staticmethod
-    def get_outputs_converter(predict_net, init_net):
-        self = types.SimpleNamespace()
-        serialized_anchor_generator = io.BytesIO(
-            get_pb_arg_vals(predict_net, "serialized_anchor_generator", None)
-        )
-        self.anchor_generator = torch.load(serialized_anchor_generator)
-        bbox_reg_weights = get_pb_arg_floats(predict_net, "bbox_reg_weights", None)
-        self.box2box_transform = Box2BoxTransform(weights=tuple(bbox_reg_weights))
-        self.test_score_thresh = get_pb_arg_valf(predict_net, "score_threshold", None)
-        self.test_topk_candidates = get_pb_arg_vali(predict_net, "topk_candidates", None)
-        self.test_nms_thresh = get_pb_arg_valf(predict_net, "nms_threshold", None)
-        self.max_detections_per_image = get_pb_arg_vali(
-            predict_net, "max_detections_per_image", None
-        )
-        # hack to reuse inference code from RetinaNet
-        self.inference = functools.partial(meta_arch.RetinaNet.inference, self)
-        self.inference_single_image = functools.partial(
-            meta_arch.RetinaNet.inference_single_image, self
-        )
-        def f(batched_inputs, c2_inputs, c2_results):
-            _, im_info = c2_inputs
-            image_sizes = [[int(im[0]), int(im[1])] for im in im_info]
-            num_features = len([x for x in c2_results.keys() if x.startswith("box_cls_")])
-            pred_logits = [c2_results["box_cls_{}".format(i)] for i in range(num_features)]
-            pred_anchor_deltas = [c2_results["box_delta_{}".format(i)] for i in range(num_features)]
-            # For each feature level, feature should have the same batch size and
-            # spatial dimension as the box_cls and box_delta.
-            dummy_features = [x.clone()[:, 0:0, :, :] for x in pred_logits]
-            anchors = self.anchor_generator(dummy_features)
-            # self.num_classess can be inferred
-            self.num_classes = pred_logits[0].shape[1] // (pred_anchor_deltas[0].shape[1] // 4)
-            pred_logits = [permute_to_N_HWA_K(x, self.num_classes) for x in pred_logits]
-            pred_anchor_deltas = [permute_to_N_HWA_K(x, 4) for x in pred_anchor_deltas]
-            results = self.inference(anchors, pred_logits, pred_anchor_deltas, image_sizes)
-            return meta_arch.GeneralizedRCNN._postprocess(results, batched_inputs, image_sizes)
-        return f
-META_ARCH_CAFFE2_EXPORT_TYPE_MAP = {
-    "GeneralizedRCNN": Caffe2GeneralizedRCNN,
-    "PanopticFPN": Caffe2PanopticFPN,
-    "RetinaNet": Caffe2RetinaNet,
-}

spaces/Catspin/2_ai_chat/index.html DELETED Viewed

	@@ -1 +0,0 @@
1	- <iframe src="https://ai.catspin.eu.org/" style= scrolling="no" height="100%" width="100%" allowfullscreen</iframe>

spaces/CikeyQI/meme-api/meme_generator/memes/capoo_strike/__init__.py DELETED Viewed

@@ -1,44 +0,0 @@
-from pathlib import Path
-from typing import List
-from pil_utils import BuildImage
-from meme_generator import add_meme
-from meme_generator.utils import FrameAlignPolicy, Maker, make_gif_or_combined_gif
-img_dir = Path(__file__).parent / "images"
-def capoo_strike(images: List[BuildImage], texts, args):
-    params = (
-        (((0, 4), (153, 0), (138, 105), (0, 157)), (28, 47)),
-        (((1, 13), (151, 0), (130, 104), (0, 156)), (28, 48)),
-        (((9, 10), (156, 0), (152, 108), (0, 155)), (18, 51)),
-        (((0, 21), (150, 0), (146, 115), (7, 145)), (17, 53)),
-        (((0, 19), (156, 0), (199, 109), (31, 145)), (2, 62)),
-        (((0, 28), (156, 0), (171, 115), (12, 154)), (16, 58)),
-        (((0, 25), (157, 0), (169, 113), (13, 147)), (18, 63)),
-    )
-    def maker(i: int) -> Maker:
-        def make(img: BuildImage) -> BuildImage:
-            img = img.convert("RGBA").resize((200, 160), keep_ratio=True)
-            points, pos = params[i]
-            frame = BuildImage.open(img_dir / f"{i}.png")
-            frame.paste(img.perspective(points), pos, below=True)
-            return frame
-        return make
-    return make_gif_or_combined_gif(
-        images[0], maker, 7, 0.05, FrameAlignPolicy.extend_loop
-    )
-add_meme(
-    "capoo_strike",
-    capoo_strike,
-    min_images=1,
-    max_images=1,
-    keywords=["咖波撞", "咖波头槌"],
-)

spaces/CjangCjengh/Shanghainese-TTS/monotonic_align/core.c DELETED Viewed

The diff for this file is too large to render. See raw diff

spaces/ClearLove443/Robby-chatbot/modules/llm.py DELETED Viewed

@@ -1,28 +0,0 @@
-import json
-from typing import Any, List, Mapping, Optional
-import requests
-from langchain.callbacks.manager import CallbackManagerForLLMRun
-from langchain.llms.base import LLM
-url = "https://openai.proxy.onlyyounotothers.top/chat"
-headers = {"Content-Type": "application/json"}
-class ChatGLM(LLM):
-    @property
-    def _llm_type(self) -> str:
-        return "custom"
-    type = "custom"
-    # 重写基类方法，根据用户输入的prompt来响应用户，返回字符串
-    def _call(
-        self,
-        prompt: str,
-        stop: Optional[List[str]] = None,
-        run_manager: Optional[CallbackManagerForLLMRun] = None,
-    ) -> str:
-        payload = json.dumps({"q": prompt})
-        response = requests.request("POST", url, headers=headers, data=payload)
-        return response.text

spaces/CofAI/chat.b4/g4f/Provider/Providers/Aichat.py DELETED Viewed

@@ -1,35 +0,0 @@
-import requests
-import os
-import json
-from ...typing import sha256, Dict, get_type_hints
-url = 'https://hteyun.com'
-model = ['gpt-3.5-turbo', 'gpt-3.5-turbo-16k', 'gpt-3.5-turbo-16k-0613', 'gpt-3.5-turbo-0613']
-supports_stream = True
-needs_auth = False
-def _create_completion(model: str, messages: list, stream: bool, temperature: float = 0.7, **kwargs):
-    headers = {
-        'Content-Type': 'application/json',
-    }
-    data = {
-        'model': model,
-        'temperature': 0.7,
-        'presence_penalty': 0,
-        'messages': messages,
-    }
-    response = requests.post(url + '/api/chat-stream',
-                             json=data, stream=True)
-    if stream:
-        for chunk in response.iter_content(chunk_size=None):
-            chunk = chunk.decode('utf-8')
-            if chunk.strip():
-                message = json.loads(chunk)['choices'][0]['message']['content']
-                yield message
-    else:
-        message = response.json()['choices'][0]['message']['content']
-        yield message
-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/CosmoAI/BhagwatGeeta/README.md DELETED Viewed

@@ -1,13 +0,0 @@
----
-title: BhagwatGeeta
-emoji: 🚀
-colorFrom: indigo
-colorTo: purple
-sdk: streamlit
-sdk_version: 1.26.0
-app_file: app.py
-pinned: false
-license: openrail
----
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

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

@@ -1,101 +0,0 @@
-from fontTools.pens.filterPen import ContourFilterPen
-class ExplicitClosingLinePen(ContourFilterPen):
-    """A filter pen that adds an explicit lineTo to the first point of each closed
-    contour if the end point of the last segment is not already the same as the first point.
-    Otherwise, it passes the contour through unchanged.
-    >>> from pprint import pprint
-    >>> from fontTools.pens.recordingPen import RecordingPen
-    >>> rec = RecordingPen()
-    >>> pen = ExplicitClosingLinePen(rec)
-    >>> pen.moveTo((0, 0))
-    >>> pen.lineTo((100, 0))
-    >>> pen.lineTo((100, 100))
-    >>> pen.closePath()
-    >>> pprint(rec.value)
-    [('moveTo', ((0, 0),)),
-     ('lineTo', ((100, 0),)),
-     ('lineTo', ((100, 100),)),
-     ('lineTo', ((0, 0),)),
-     ('closePath', ())]
-    >>> rec = RecordingPen()
-    >>> pen = ExplicitClosingLinePen(rec)
-    >>> pen.moveTo((0, 0))
-    >>> pen.lineTo((100, 0))
-    >>> pen.lineTo((100, 100))
-    >>> pen.lineTo((0, 0))
-    >>> pen.closePath()
-    >>> pprint(rec.value)
-    [('moveTo', ((0, 0),)),
-     ('lineTo', ((100, 0),)),
-     ('lineTo', ((100, 100),)),
-     ('lineTo', ((0, 0),)),
-     ('closePath', ())]
-    >>> rec = RecordingPen()
-    >>> pen = ExplicitClosingLinePen(rec)
-    >>> pen.moveTo((0, 0))
-    >>> pen.curveTo((100, 0), (0, 100), (100, 100))
-    >>> pen.closePath()
-    >>> pprint(rec.value)
-    [('moveTo', ((0, 0),)),
-     ('curveTo', ((100, 0), (0, 100), (100, 100))),
-     ('lineTo', ((0, 0),)),
-     ('closePath', ())]
-    >>> rec = RecordingPen()
-    >>> pen = ExplicitClosingLinePen(rec)
-    >>> pen.moveTo((0, 0))
-    >>> pen.curveTo((100, 0), (0, 100), (100, 100))
-    >>> pen.lineTo((0, 0))
-    >>> pen.closePath()
-    >>> pprint(rec.value)
-    [('moveTo', ((0, 0),)),
-     ('curveTo', ((100, 0), (0, 100), (100, 100))),
-     ('lineTo', ((0, 0),)),
-     ('closePath', ())]
-    >>> rec = RecordingPen()
-    >>> pen = ExplicitClosingLinePen(rec)
-    >>> pen.moveTo((0, 0))
-    >>> pen.curveTo((100, 0), (0, 100), (0, 0))
-    >>> pen.closePath()
-    >>> pprint(rec.value)
-    [('moveTo', ((0, 0),)),
-     ('curveTo', ((100, 0), (0, 100), (0, 0))),
-     ('closePath', ())]
-    >>> rec = RecordingPen()
-    >>> pen = ExplicitClosingLinePen(rec)
-    >>> pen.moveTo((0, 0))
-    >>> pen.closePath()
-    >>> pprint(rec.value)
-    [('moveTo', ((0, 0),)), ('closePath', ())]
-    >>> rec = RecordingPen()
-    >>> pen = ExplicitClosingLinePen(rec)
-    >>> pen.closePath()
-    >>> pprint(rec.value)
-    [('closePath', ())]
-    >>> rec = RecordingPen()
-    >>> pen = ExplicitClosingLinePen(rec)
-    >>> pen.moveTo((0, 0))
-    >>> pen.lineTo((100, 0))
-    >>> pen.lineTo((100, 100))
-    >>> pen.endPath()
-    >>> pprint(rec.value)
-    [('moveTo', ((0, 0),)),
-     ('lineTo', ((100, 0),)),
-     ('lineTo', ((100, 100),)),
-     ('endPath', ())]
-    """
-    def filterContour(self, contour):
-        if (
-            not contour
-            or contour[0][0] != "moveTo"
-            or contour[-1][0] != "closePath"
-            or len(contour) < 3
-        ):
-            return
-        movePt = contour[0][1][0]
-        lastSeg = contour[-2][1]
-        if lastSeg and movePt != lastSeg[-1]:
-            contour[-1:] = [("lineTo", (movePt,)), ("closePath", ())]

spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/fontTools/ttLib/tables/asciiTable.py DELETED Viewed

@@ -1,20 +0,0 @@
-from fontTools.misc.textTools import strjoin, tobytes, tostr
-from . import DefaultTable
-class asciiTable(DefaultTable.DefaultTable):
-    def toXML(self, writer, ttFont):
-        data = tostr(self.data)
-        # removing null bytes. XXX needed??
-        data = data.split("\0")
-        data = strjoin(data)
-        writer.begintag("source")
-        writer.newline()
-        writer.write_noindent(data)
-        writer.newline()
-        writer.endtag("source")
-        writer.newline()
-    def fromXML(self, name, attrs, content, ttFont):
-        lines = strjoin(content).split("\n")
-        self.data = tobytes("\n".join(lines[1:-1]))

spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/fsspec/tests/abstract/get.py DELETED Viewed

@@ -1,377 +0,0 @@
-class AbstractGetTests:
-    def test_get_file_to_existing_directory(
-        self,
-        fs,
-        fs_join,
-        fs_bulk_operations_scenario_0,
-        local_fs,
-        local_join,
-        local_target,
-    ):
-        # Copy scenario 1a
-        source = fs_bulk_operations_scenario_0
-        target = local_target
-        local_fs.mkdir(target)
-        assert local_fs.isdir(target)
-        target_file2 = local_join(target, "file2")
-        target_subfile1 = local_join(target, "subfile1")
-        # Copy from source directory
-        fs.get(fs_join(source, "file2"), target)
-        assert local_fs.isfile(target_file2)
-        # Copy from sub directory
-        fs.get(fs_join(source, "subdir", "subfile1"), target)
-        assert local_fs.isfile(target_subfile1)
-        # Remove copied files
-        local_fs.rm([target_file2, target_subfile1])
-        assert not local_fs.exists(target_file2)
-        assert not local_fs.exists(target_subfile1)
-        # Repeat with trailing slash on target
-        fs.get(fs_join(source, "file2"), target + "/")
-        assert local_fs.isdir(target)
-        assert local_fs.isfile(target_file2)
-        fs.get(fs_join(source, "subdir", "subfile1"), target + "/")
-        assert local_fs.isfile(target_subfile1)
-    def test_get_file_to_new_directory(
-        self,
-        fs,
-        fs_join,
-        fs_bulk_operations_scenario_0,
-        local_fs,
-        local_join,
-        local_target,
-    ):
-        # Copy scenario 1b
-        source = fs_bulk_operations_scenario_0
-        target = local_target
-        local_fs.mkdir(target)
-        fs.get(
-            fs_join(source, "subdir", "subfile1"), local_join(target, "newdir/")
-        )  # Note trailing slash
-        assert local_fs.isdir(target)
-        assert local_fs.isdir(local_join(target, "newdir"))
-        assert local_fs.isfile(local_join(target, "newdir", "subfile1"))
-    def test_get_file_to_file_in_existing_directory(
-        self,
-        fs,
-        fs_join,
-        fs_path,
-        fs_bulk_operations_scenario_0,
-        local_fs,
-        local_join,
-        local_target,
-    ):
-        # Copy scenario 1c
-        source = fs_bulk_operations_scenario_0
-        target = local_target
-        local_fs.mkdir(target)
-        fs.get(fs_join(source, "subdir", "subfile1"), local_join(target, "newfile"))
-        assert local_fs.isfile(local_join(target, "newfile"))
-    def test_get_file_to_file_in_new_directory(
-        self,
-        fs,
-        fs_join,
-        fs_bulk_operations_scenario_0,
-        local_fs,
-        local_join,
-        local_target,
-    ):
-        # Copy scenario 1d
-        source = fs_bulk_operations_scenario_0
-        target = local_target
-        local_fs.mkdir(target)
-        fs.get(
-            fs_join(source, "subdir", "subfile1"),
-            local_join(target, "newdir", "newfile"),
-        )
-        assert local_fs.isdir(local_join(target, "newdir"))
-        assert local_fs.isfile(local_join(target, "newdir", "newfile"))
-    def test_get_directory_to_existing_directory(
-        self,
-        fs,
-        fs_join,
-        fs_bulk_operations_scenario_0,
-        local_fs,
-        local_join,
-        local_target,
-    ):
-        # Copy scenario 1e
-        source = fs_bulk_operations_scenario_0
-        target = local_target
-        local_fs.mkdir(target)
-        for source_slash, target_slash in zip([False, True], [False, True]):
-            s = fs_join(source, "subdir")
-            if source_slash:
-                s += "/"
-            t = target + "/" if target_slash else target
-            # Without recursive does nothing
-            # ERROR: erroneously creates new directory
-            # fs.get(s, t)
-            # assert fs.ls(target) == []
-            # With recursive
-            fs.get(s, t, recursive=True)
-            if source_slash:
-                assert local_fs.isfile(local_join(target, "subfile1"))
-                assert local_fs.isfile(local_join(target, "subfile2"))
-                assert local_fs.isdir(local_join(target, "nesteddir"))
-                assert local_fs.isfile(local_join(target, "nesteddir", "nestedfile"))
-                local_fs.rm(
-                    [
-                        local_join(target, "subfile1"),
-                        local_join(target, "subfile2"),
-                        local_join(target, "nesteddir"),
-                    ],
-                    recursive=True,
-                )
-            else:
-                assert local_fs.isdir(local_join(target, "subdir"))
-                assert local_fs.isfile(local_join(target, "subdir", "subfile1"))
-                assert local_fs.isfile(local_join(target, "subdir", "subfile2"))
-                assert local_fs.isdir(local_join(target, "subdir", "nesteddir"))
-                assert local_fs.isfile(
-                    local_join(target, "subdir", "nesteddir", "nestedfile")
-                )
-                local_fs.rm(local_join(target, "subdir"), recursive=True)
-            assert local_fs.ls(target) == []
-            # Limit by maxdepth
-            # ERROR: maxdepth ignored here
-    def test_get_directory_to_new_directory(
-        self,
-        fs,
-        fs_join,
-        fs_bulk_operations_scenario_0,
-        local_fs,
-        local_join,
-        local_target,
-    ):
-        # Copy scenario 1f
-        source = fs_bulk_operations_scenario_0
-        target = local_target
-        local_fs.mkdir(target)
-        for source_slash, target_slash in zip([False, True], [False, True]):
-            s = fs_join(source, "subdir")
-            if source_slash:
-                s += "/"
-            t = local_join(target, "newdir")
-            if target_slash:
-                t += "/"
-            # Without recursive does nothing
-            # ERROR: erroneously creates new directory
-            # fs.get(s, t)
-            # assert fs.ls(target) == []
-            # With recursive
-            fs.get(s, t, recursive=True)
-            assert local_fs.isdir(local_join(target, "newdir"))
-            assert local_fs.isfile(local_join(target, "newdir", "subfile1"))
-            assert local_fs.isfile(local_join(target, "newdir", "subfile2"))
-            assert local_fs.isdir(local_join(target, "newdir", "nesteddir"))
-            assert local_fs.isfile(
-                local_join(target, "newdir", "nesteddir", "nestedfile")
-            )
-            local_fs.rm(local_join(target, "newdir"), recursive=True)
-            assert local_fs.ls(target) == []
-            # Limit by maxdepth
-            # ERROR: maxdepth ignored here
-    def test_get_glob_to_existing_directory(
-        self,
-        fs,
-        fs_join,
-        fs_bulk_operations_scenario_0,
-        local_fs,
-        local_join,
-        local_target,
-    ):
-        # Copy scenario 1g
-        source = fs_bulk_operations_scenario_0
-        target = local_target
-        local_fs.mkdir(target)
-        # for target_slash in [False, True]:
-        for target_slash in [False]:
-            t = target + "/" if target_slash else target
-            # Without recursive
-            fs.get(fs_join(source, "subdir", "*"), t)
-            assert local_fs.isfile(local_join(target, "subfile1"))
-            assert local_fs.isfile(local_join(target, "subfile2"))
-            # assert not local_fs.isdir(local_join(target, "nesteddir"))  # ERROR
-            assert not local_fs.isdir(local_join(target, "subdir"))
-            # With recursive
-            # Limit by maxdepth
-    def test_get_glob_to_new_directory(
-        self,
-        fs,
-        fs_join,
-        fs_bulk_operations_scenario_0,
-        local_fs,
-        local_join,
-        local_target,
-    ):
-        # Copy scenario 1h
-        source = fs_bulk_operations_scenario_0
-        target = local_target
-        local_fs.mkdir(target)
-        for target_slash in [False, True]:
-            t = fs_join(target, "newdir")
-            if target_slash:
-                t += "/"
-            # Without recursive
-            fs.get(fs_join(source, "subdir", "*"), t)
-            assert local_fs.isdir(local_join(target, "newdir"))
-            assert local_fs.isfile(local_join(target, "newdir", "subfile1"))
-            assert local_fs.isfile(local_join(target, "newdir", "subfile2"))
-            # ERROR - do not copy empty directory
-            # assert not local_fs.exists(local_join(target, "newdir", "nesteddir"))
-            local_fs.rm(local_join(target, "newdir"), recursive=True)
-            assert local_fs.ls(target) == []
-            # With recursive
-            fs.get(fs_join(source, "subdir", "*"), t, recursive=True)
-            assert local_fs.isdir(local_join(target, "newdir"))
-            assert local_fs.isfile(local_join(target, "newdir", "subfile1"))
-            assert local_fs.isfile(local_join(target, "newdir", "subfile2"))
-            assert local_fs.isdir(local_join(target, "newdir", "nesteddir"))
-            assert local_fs.isfile(
-                local_join(target, "newdir", "nesteddir", "nestedfile")
-            )
-            local_fs.rm(local_join(target, "newdir"), recursive=True)
-            assert local_fs.ls(target) == []
-            # Limit by maxdepth
-            # ERROR: this is not correct
-    def test_get_list_of_files_to_existing_directory(
-        self,
-        fs,
-        fs_join,
-        fs_bulk_operations_scenario_0,
-        local_fs,
-        local_join,
-        local_target,
-    ):
-        # Copy scenario 2a
-        source = fs_bulk_operations_scenario_0
-        target = local_target
-        local_fs.mkdir(target)
-        source_files = [
-            fs_join(source, "file1"),
-            fs_join(source, "file2"),
-            fs_join(source, "subdir", "subfile1"),
-        ]
-        for target_slash in [False, True]:
-            t = target + "/" if target_slash else target
-            fs.get(source_files, t)
-            assert local_fs.isfile(local_join(target, "file1"))
-            assert local_fs.isfile(local_join(target, "file2"))
-            assert local_fs.isfile(local_join(target, "subfile1"))
-            local_fs.rm(local_fs.find(target))
-            assert local_fs.ls(target) == []
-    def test_get_list_of_files_to_new_directory(
-        self,
-        fs,
-        fs_join,
-        fs_bulk_operations_scenario_0,
-        local_fs,
-        local_join,
-        local_target,
-    ):
-        # Copy scenario 2b
-        source = fs_bulk_operations_scenario_0
-        target = local_target
-        local_fs.mkdir(target)
-        source_files = [
-            fs_join(source, "file1"),
-            fs_join(source, "file2"),
-            fs_join(source, "subdir", "subfile1"),
-        ]
-        fs.get(source_files, local_join(target, "newdir") + "/")  # Note trailing slash
-        assert local_fs.isdir(local_join(target, "newdir"))
-        assert local_fs.isfile(local_join(target, "newdir", "file1"))
-        assert local_fs.isfile(local_join(target, "newdir", "file2"))
-        assert local_fs.isfile(local_join(target, "newdir", "subfile1"))
-    def test_get_directory_recursive(
-        self, fs, fs_join, fs_path, local_fs, local_join, local_target
-    ):
-        # https://github.com/fsspec/filesystem_spec/issues/1062
-        # Recursive cp/get/put of source directory into non-existent target directory.
-        src = fs_join(fs_path, "src")
-        src_file = fs_join(src, "file")
-        fs.mkdir(src)
-        fs.touch(src_file)
-        target = local_target
-        # get without slash
-        assert not local_fs.exists(target)
-        for loop in range(2):
-            fs.get(src, target, recursive=True)
-            assert local_fs.isdir(target)
-        if loop == 0:
-            assert local_fs.isfile(local_join(target, "file"))
-            assert not local_fs.exists(local_join(target, "src"))
-        else:
-            assert local_fs.isfile(local_join(target, "file"))
-            assert local_fs.isdir(local_join(target, "src"))
-            assert local_fs.isfile(local_join(target, "src", "file"))
-        local_fs.rm(target, recursive=True)
-        # get with slash
-        assert not local_fs.exists(target)
-        for loop in range(2):
-            fs.get(src + "/", target, recursive=True)
-            assert local_fs.isdir(target)
-            assert local_fs.isfile(local_join(target, "file"))
-            assert not local_fs.exists(local_join(target, "src"))

spaces/DReAMy-lib/dream/app.py DELETED Viewed

@@ -1,118 +0,0 @@
-import gradio as gr
-import pandas as pd
-languages = pd.read_csv("model_lang.csv", names=["Lang_acr"])
-def check_lang(lang_acronym):
-    if lang_acronym in languages["Lang_acr"].to_list():
-        return "True"
-    else:
-        return "False"
-title = "DReAM"
-description_main = """
-This space allows you to test a set of LLMs tuned to perform different tasks over dream reports.
-Three main tasks are available:
-- Name Entity Recognition (NER), with an English-only model that generates the identified characters.
-- Sentiment Analysis (SA), with two English-only models (one for multi-label classification, and one for generation) and a large multilingual model for multi-label classification.
-- Relation Extraction (RE), with an English-only model that identifies relevant characters and existing relations between them following the Activity feature of the Hall and Van de Castle framework.
-All models have been tuned on the Hall and Van de Castle framework. More details are on the page for each model. For more on the training framework, see the [Bertolini et al., 2023](https://arxiv.org/pdf/2302.14828.pdf) preprint.
-Use the current interface to check if a language is included in the multilingual SA model, using language acronyms (e.g. it for Italian). the tabs above will direct you to each model to query.
-If you want to use the models outside the space, you can easily do so via [DReAMy](https://github.com/lorenzoscottb/DReAMy)
-"""
-description_L = """
-This model is an XLM-R tuned model, pre-trained with 94 languages available, and tuned on emotion-annotated DreamBank English data. (see original model [card](https://huggingface.co/xlm-roberta-large) to see which are available)
-"""
-description_S = """
-A BERT-base-cased model pre-trained on English-only text and tuned on annotated DreamBank English data.
-"""
-description_G = """
-A T5 model tuned to perform text generation and predict emotion as well as the character experiencing those emotions.
-"""
-description_R = """
-A T5 model tuned to perform text generation and predicts the characters and the (activity) relation between them.
-"""
-description_GNER = """
-A T5 model tuned to perform text generation, and predict which characters are present in the report. Note that, in the Hall and Van de Castle, the character lists never includes the dreamer. Hence, if you (willingly or not) enter a report that does not contain another character reference, the model will/should (correctly) produce an empty string. Moreover, it is likely that the produced list of CHAR could be longer than the one produced by the SA model, as not all CHAR might be associated with emotions.
-"""
-example_main = ["en", "it", "pl"]
-examples = [
-    ["I was followed by the blue monster but was not scared. I was calm and relaxed."],
-    ["Ero seguito dal mostro blu, ma non ero spaventato. Ero calmo e rilassato."],
-    ["Śledził mnie niebieski potwór, ale się nie bałem. Byłem spokojny i zrelaksowany."],
-]
-examples_g = [
-    ["I'm in an auditorium. Susie S is concerned at her part in this disability awareness spoof we are preparing. I ask, 'Why not do it? Lots of AB's represent us in a patronizing way. Why shouldn't we represent ourselves in a good, funny way?' I watch the video we all made. It is funny. I try to sit on a folding chair. Some guy in front talks to me. Merle is in the audience somewhere. [BL]"],
-]
-examples_re = [
-    ["I was skating on the outdoor ice pond that used to be across the street from my house. I was not alone, but I did not recognize any of the other people who were skating around. I went through my whole repertoire of jumps, spires, and steps-some of which I can do and some of which I'm not yet sure of. They were all executed flawlessly-some I repeated, some I did only once. I seemed to know that if I went into competition, I would be sure of coming in third because there were only three contestants. Up to that time I hadn't considered it because I hadn't thought I was good enough, but now since everything was going so well, I decided to enter."],
-    ["I was talking on the telephone to the father of an old friend of mine (boy, 21 years old). We were discussing the party the Saturday night before to which I had invited his son as a guest. I asked him if his son had a good time at the party. He told me not to tell his son that he had told me, but that he had had a good time, except he was a little surprised that I had acted the way I did."],
-    ["I was walking alone with my dog in a forest."]
-]
-interface_words = gr.Interface(
-            fn=check_lang,
-            inputs="text",
-            outputs="text",
-            title=title,
-            description=description_main,
-            examples=example_main,
-)
-interface_model_L = gr.Interface.load(
-            name="models/DReAMy-lib/xlm-roberta-large-DreamBank-emotion-presence",
-            description=description_L,
-            examples=examples,
-            title="SA Large Multilingual",
-)
-interface_model_S = gr.Interface.load(
-            name="models/DReAMy-lib/bert-base-cased-DreamBank-emotion-presence",
-            description=description_S,
-            examples=examples[0],
-            title="SA Base English-Only",
-)
-interface_model_G = gr.Interface.load(
-            name="models/DReAMy-lib/t5-base-DreamBank-Generation-Emot-Char",
-            description=description_G,
-            examples=examples_g,
-            title="SA Generation",
-)
-interface_model_RE = gr.Interface.load(
-            name="models/DReAMy-lib/t5-base-DreamBank-Generation-Act-Char",
-            description=description_R,
-            examples=examples_re,
-            title="RE Generation",
-)
-interface_model_NER = gr.Interface.load(
-            name="models/DReAMy-lib/t5-base-DreamBank-Generation-NER-Char",
-            description=description_GNER,
-            examples=examples_g,
-            title="NER Generation",
-)
-gr.TabbedInterface(
-    [interface_words, interface_model_NER, interface_model_L, interface_model_S, interface_model_G, interface_model_RE],
-    ["Main", "NER Generation", "SA Large Multilingual", "SA Base En", "SA En Generation", "RE Generation"]
-).launch()