Update parquet files (step 18 of 476)

spaces/0x90e/ESRGAN-MANGA/ESRGAN_plus/architecture.py

@@ -1,38 +0,0 @@
-import math
-import torch
-import torch.nn as nn
-import ESRGAN_plus.block as B
-
-
-class RRDB_Net(nn.Module):
-    def __init__(self, in_nc, out_nc, nf, nb, gc=32, upscale=4, norm_type=None, act_type='leakyrelu', \
-            mode='CNA', res_scale=1, upsample_mode='upconv'):
-        super(RRDB_Net, self).__init__()
-        n_upscale = int(math.log(upscale, 2))
-        if upscale == 3:
-            n_upscale = 1
-
-        fea_conv = B.conv_block(in_nc, nf, kernel_size=3, norm_type=None, act_type=None)
-        rb_blocks = [B.RRDB(nf, kernel_size=3, gc=32, stride=1, bias=True, pad_type='zero', \
-            norm_type=norm_type, act_type=act_type, mode='CNA') for _ in range(nb)]
-        LR_conv = B.conv_block(nf, nf, kernel_size=3, norm_type=norm_type, act_type=None, mode=mode)
-
-        if upsample_mode == 'upconv':
-            upsample_block = B.upconv_blcok
-        elif upsample_mode == 'pixelshuffle':
-            upsample_block = B.pixelshuffle_block
-        else:
-            raise NotImplementedError('upsample mode [%s] is not found' % upsample_mode)
-        if upscale == 3:
-            upsampler = upsample_block(nf, nf, 3, act_type=act_type)
-        else:
-            upsampler = [upsample_block(nf, nf, act_type=act_type) for _ in range(n_upscale)]
-        HR_conv0 = B.conv_block(nf, nf, kernel_size=3, norm_type=None, act_type=act_type)
-        HR_conv1 = B.conv_block(nf, out_nc, kernel_size=3, norm_type=None, act_type=None)
-
-        self.model = B.sequential(fea_conv, B.ShortcutBlock(B.sequential(*rb_blocks, LR_conv)),\
-            *upsampler, HR_conv0, HR_conv1)
-
-    def forward(self, x):
-        x = self.model(x)
-        return x

spaces/101-5/gpt4free/g4f/.v1/gui/streamlit_chat_app.py

@@ -1,156 +0,0 @@
-import atexit
-import Levenshtein
-import os
-import sys
-
-sys.path.append(os.path.join(os.path.dirname(__file__), os.path.pardir))
-
-import streamlit as st
-from streamlit_chat import message
-from query_methods import query, avail_query_methods
-import pickle
-
-conversations_file = "conversations.pkl"
-
-def load_conversations():
-    try:
-        with open(conversations_file, "rb") as f:
-            return pickle.load(f)
-    except FileNotFoundError:
-        return []
-    except EOFError:
-        return []
-
-
-def save_conversations(conversations, current_conversation):
-    updated = False
-    for idx, conversation in enumerate(conversations):
-        if conversation == current_conversation:
-            conversations[idx] = current_conversation
-            updated = True
-            break
-    if not updated:
-        conversations.append(current_conversation)
-
-    temp_conversations_file = "temp_" + conversations_file
-    with open(temp_conversations_file, "wb") as f:
-        pickle.dump(conversations, f)
-
-    os.replace(temp_conversations_file, conversations_file)
-
-def delete_conversation(conversations, current_conversation):
-    for idx, conversation in enumerate(conversations):
-        conversations[idx] = current_conversation
-        break
-    conversations.remove(current_conversation)
-
-    temp_conversations_file = "temp_" + conversations_file
-    with open(temp_conversations_file, "wb") as f:
-        pickle.dump(conversations, f)
-
-    os.replace(temp_conversations_file, conversations_file)
-
-def exit_handler():
-    print("Exiting, saving data...")
-    # Perform cleanup operations here, like saving data or closing open files.
-    save_conversations(st.session_state.conversations, st.session_state.current_conversation)
-
-
-# Register the exit_handler function to be called when the program is closing.
-atexit.register(exit_handler)
-
-st.header("Chat Placeholder")
-
-if 'conversations' not in st.session_state:
-    st.session_state['conversations'] = load_conversations()
-
-if 'input_text' not in st.session_state:
-    st.session_state['input_text'] = ''
-
-if 'selected_conversation' not in st.session_state:
-    st.session_state['selected_conversation'] = None
-
-if 'input_field_key' not in st.session_state:
-    st.session_state['input_field_key'] = 0
-
-if 'query_method' not in st.session_state:
-    st.session_state['query_method'] = query
-
-if 'search_query' not in st.session_state:
-    st.session_state['search_query'] = ''
-
-# Initialize new conversation
-if 'current_conversation' not in st.session_state or st.session_state['current_conversation'] is None:
-    st.session_state['current_conversation'] = {'user_inputs': [], 'generated_responses': []}
-
-input_placeholder = st.empty()
-user_input = input_placeholder.text_input(
-    'You:', value=st.session_state['input_text'], key=f'input_text_-1'#{st.session_state["input_field_key"]}
-)
-submit_button = st.button("Submit")
-
-if (user_input and user_input != st.session_state['input_text']) or submit_button:
-    output = query(user_input, st.session_state['query_method'])
-
-    escaped_output = output.encode('utf-8').decode('unicode-escape')
-
-    st.session_state['current_conversation']['user_inputs'].append(user_input)
-    st.session_state.current_conversation['generated_responses'].append(escaped_output)
-    save_conversations(st.session_state.conversations, st.session_state.current_conversation)
-    st.session_state['input_text'] = ''
-    st.session_state['input_field_key'] += 1  # Increment key value for new widget
-    user_input = input_placeholder.text_input(
-        'You:', value=st.session_state['input_text'], key=f'input_text_{st.session_state["input_field_key"]}'
-    )  # Clear the input field
-
-# Add a button to create a new conversation
-if st.sidebar.button("New Conversation"):
-    st.session_state['selected_conversation'] = None
-    st.session_state['current_conversation'] = {'user_inputs': [], 'generated_responses': []}
-    st.session_state['input_field_key'] += 1  # Increment key value for new widget
-    st.session_state['query_method'] = st.sidebar.selectbox("Select API:", options=avail_query_methods, index=0)
-
-# Proxy
-st.session_state['proxy'] = st.sidebar.text_input("Proxy: ")
-
-# Searchbar
-search_query = st.sidebar.text_input("Search Conversations:", value=st.session_state.get('search_query', ''), key='search')
-
-if search_query:
-    filtered_conversations = []
-    indices = []
-    for idx, conversation in enumerate(st.session_state.conversations):
-        if search_query in conversation['user_inputs'][0]:
-            filtered_conversations.append(conversation)
-            indices.append(idx)
-
-    filtered_conversations = list(zip(indices, filtered_conversations))
-    conversations = sorted(filtered_conversations, key=lambda x: Levenshtein.distance(search_query, x[1]['user_inputs'][0]))
-
-    sidebar_header = f"Search Results ({len(conversations)})"
-else:
-    conversations = st.session_state.conversations
-    sidebar_header = "Conversation History"
-
-# Sidebar
-st.sidebar.header(sidebar_header)
-sidebar_col1, sidebar_col2 = st.sidebar.columns([5,1])
-for idx, conversation in enumerate(conversations):
-    if sidebar_col1.button(f"Conversation {idx + 1}: {conversation['user_inputs'][0]}", key=f"sidebar_btn_{idx}"):
-        st.session_state['selected_conversation'] = idx
-        st.session_state['current_conversation'] = conversation
-    if sidebar_col2.button('🗑️', key=f"sidebar_btn_delete_{idx}"):
-        if st.session_state['selected_conversation'] == idx:
-            st.session_state['selected_conversation'] = None
-            st.session_state['current_conversation'] = {'user_inputs': [], 'generated_responses': []}
-        delete_conversation(conversations, conversation)
-        st.experimental_rerun()
-if st.session_state['selected_conversation'] is not None:
-    conversation_to_display = conversations[st.session_state['selected_conversation']]
-else:
-    conversation_to_display = st.session_state.current_conversation
-
-if conversation_to_display['generated_responses']:
-    for i in range(len(conversation_to_display['generated_responses']) - 1, -1, -1):
-        message(conversation_to_display["generated_responses"][i], key=f"display_generated_{i}")
-        message(conversation_to_display['user_inputs'][i], is_user=True, key=f"display_user_{i}")

spaces/1acneusushi/gradio-2dmoleculeeditor/data/Fusion 360 2008 32 Bit __EXCLUSIVE__ Xforce Keygen.md

@@ -1,40 +0,0 @@
-
-<h1>Fusion 360 2008 32 Bit Xforce Keygen: How to Activate Autodesk Products for Free</h1>
- <p>If you are looking for a powerful and versatile software for designing, modeling, and engineering, you might have heard of <strong>Fusion 360</strong>. Fusion 360 is a cloud-based CAD/CAM/CAE software that allows you to create, edit, and share your designs in various formats. It also integrates with other Autodesk products and services, such as AutoCAD, Inventor, Revit, Maya, and more.</p>
-<h2>Fusion 360 2008 32 Bit Xforce Keygen</h2><br /><p><b><b>Download File</b> &rarr;&rarr;&rarr; <a href="https://byltly.com/2uKxYI">https://byltly.com/2uKxYI</a></b></p><br /><br />
- <p>However, Fusion 360 is not a cheap software. It requires a monthly or yearly subscription fee that can range from $25 to $500 depending on your plan. If you want to use Fusion 360 without paying anything, you might be tempted to use a <strong>Xforce keygen</strong>. Xforce keygen is a crack tool that can generate activation codes for any Autodesk product. By using Xforce keygen, you can bypass the license verification process and activate Fusion 360 for free.</p>
- <p>But is it worth it? In this article, we will show you how to use Xforce keygen for Fusion 360 2008 32 bit, as well as the benefits and risks of doing so. We will also answer some frequently asked questions about Fusion 360 and Xforce keygen. Read on to find out more.</p>
- <h2>How to Download and Install Fusion 360 2008 32 Bit</h2>
- <p>Before you can use Xforce keygen for Fusion 360, you need to download and install the software first. Here are the steps to do so:</p> - Step 1: Download Fusion 360 2008 32 bit from the official website or a trusted source. You can find the download link here: . Make sure you choose the correct version for your operating system and system requirements. - Step 2: Run the setup file and follow the instructions. You may need to accept the terms and conditions, choose the installation location, and select the components you want to install. The installation process may take some time depending on your internet speed and computer performance. - Step 3: Choose the trial version or enter a serial number. If you have a valid serial number, you can enter it and activate Fusion 360. If not, you can choose the trial version and use it for 30 days. You can also sign in with your Autodesk account if you have one. <h2>How to Download and Use Xforce Keygen for Fusion 360 2008 32 Bit</h2>
- <p>Once you have installed Fusion 360, you can use Xforce keygen to activate it for free. Here are the steps to do so:</p>
- - Step 1: Download Xforce keygen from a reliable source. You can find many websites that offer Xforce keygen for various Autodesk products, but be careful of malware and viruses. One of the most popular sources is , but use it at your own risk. - Step 2: Disable your antivirus and internet connection. This is important because Xforce keygen is detected as a malicious program by most antivirus software and may be blocked or deleted. Also, disconnecting from the internet will prevent Autodesk from verifying your license online. - Step 3: Run Xforce keygen as administrator and click on "Patch". You will see a window that asks you to locate the file "xf-adsk2018_x86.exe" in your Fusion 360 installation folder. Usually, it is located in "C:\Program Files\Autodesk\Fusion 360\bin". Select the file and click on "Open". - Step 4: Copy the request code from Fusion 360 and paste it into Xforce keygen. To get the request code, open Fusion 360 and go to the "Help" menu. Click on "Register" and then on "Activate". You will see a screen that shows your serial number and a request code. Copy the request code and paste it into Xforce keygen where it says "Request". - Step 5: Click on "Generate" and copy the activation code from Xforce keygen. You will see a long string of letters and numbers that is your activation code. Copy it and go back to Fusion 360. - Step 6: Paste the activation code into Fusion 360 and click on "Next". You will see a message that says "Activation successful". Click on "Finish" and enjoy using Fusion 360 for free. <h2>How to Verify that Fusion 360 is Activated</h2>
- <p>To make sure that Fusion 360 is activated, you can do the following:</p>
- - Step 1: Open Fusion 360 and go to the "Help" menu. - Step 2: Click on "About Autodesk Fusion 360". - Step 3: Check the license status and expiration date. You should see that your license is valid until January 1, 2060, which means that you have activated Fusion 360 with Xforce keygen. <h2>Benefits of Using Fusion 360 with Xforce Keygen</h2>
- <p>By using Xforce keygen for Fusion 360, you can enjoy some benefits, such as:</p>
-<p></p>
- - Access to all features and updates of Fusion 360. You can use all the tools and functions of Fusion 360 without any limitations or restrictions. You can also download and install any updates or patches that are released by Autodesk. - No need to pay for a subscription or license. You can save money by not having to pay for a monthly or yearly fee to use Fusion 360. You can also avoid any renewal or cancellation issues that may arise with a subscription plan. - Ability to create, edit, and share designs in various formats. You can work on any type of design project with Fusion 360, from sketching to rendering to simulation. You can also export and import your designs in different formats, such as DWG, DXF, STL, OBJ, IGES, STEP, etc. - Compatibility with other Autodesk products and services. You can integrate your designs with other Autodesk software, such as AutoCAD, Inventor, Revit, Maya, etc. You can also access other Autodesk services, such as A360 cloud storage, Autodesk Gallery, Autodesk Education Community, etc. <h2>Risks and Drawbacks of Using Fusion 360 with Xforce Keygen</h2>
- <p>However, using Xforce keygen for Fusion 360 also comes with some risks and drawbacks, such as:</p>
- - Legal and ethical issues of using - Legal and ethical issues of using pirated software. By using Xforce keygen, you are violating the terms and conditions of Autodesk and infringing their intellectual property rights. You are also depriving them of their revenue and supporting software piracy. This can lead to legal consequences, such as fines, lawsuits, or even jail time. You are also acting unethically, as you are not respecting the work and effort of the software developers and creators. - Potential malware and virus infection from untrusted sources. Xforce keygen is not an official or authorized tool from Autodesk. It is created by hackers and crackers who may have malicious intentions. They may embed malware or viruses into the Xforce keygen file or the websites that offer it. This can compromise your computer security and privacy, as well as damage your files and data. - Possible errors and glitches in the software performance. Xforce keygen may not work properly with Fusion 360, especially if there are updates or patches from Autodesk. It may cause errors, crashes, or glitches in the software functionality or stability. It may also interfere with other programs or applications on your computer. - No technical support or customer service from Autodesk. If you encounter any problems or issues with Fusion 360, you cannot contact Autodesk for help or assistance. You are on your own, as Autodesk does not provide any support or service for pirated software. You may also miss out on some features or benefits that are only available for licensed users, such as online forums, tutorials, feedback, etc. <h2>Conclusion</h2>
- <p>Fusion 360 is a great software for design, modeling, and engineering. However, it is not a cheap software, and you may want to use Xforce keygen to activate it for free. Xforce keygen is a crack tool that can generate activation codes for any Autodesk product, including Fusion 360.</p>
- <p>In this article, we have shown you how to use Xforce keygen for Fusion 360 2008 32 bit, as well as the benefits and risks of doing so. We have also answered some frequently asked questions about Fusion 360 and Xforce keygen.</p>
- <p>Using Xforce keygen for Fusion 360 can give you access to all features and updates of the software without paying anything. However, it can also expose you to legal and ethical issues, malware and virus infection, errors and glitches, and no technical support or customer service.</p>
- <p>Ultimately, the decision is yours to make. We do not recommend or endorse using Xforce keygen for Fusion 360 or any other Autodesk product. We advise you to use the official website or a trusted source to download and install Fusion 360, and to pay for a subscription or license if you want to use it legally and ethically.</p>
- <p>If you found this article helpful, please share it with your friends and colleagues who may be interested in using Fusion 360 with Xforce keygen. If you have any questions or feedback, please leave a comment below. Thank you for reading.</p>
- <h2>FAQs</h2>
- <p>Here are some of the most common questions that people ask about Fusion 360 and Xforce keygen:</p>
- <h3>What is the difference between Fusion 360 and AutoCAD?</h3>
- <p>Fusion 360 and AutoCAD are both products from Autodesk that are used for design and engineering. However, they have some differences in their features and functions.</p>
- <p>AutoCAD is a 2D and 3D CAD software that is mainly used for drafting, documentation, and detailing. It has a wide range of tools and commands that allow you to create precise and accurate drawings and models.</p>
- <p>Fusion 360 is a cloud-based CAD/CAM/CAE software that is mainly used for design, modeling, and simulation. It has a more intuitive and user-friendly interface that allows you to create complex and organic shapes and forms. It also integrates with other Autodesk products and services, such as Inventor, Revit, Maya, etc.</p>
- <h3>Is Fusion 360 free for students and educators?</h3>
- <p>Yes, Fusion 360 is free for students and educators who are enrolled in or employed by a qualified educational institution. You can apply for a free educational license that will allow you to use Fusion 360 for non-commercial purposes for up to three years.</p>
- <p>To get a free educational license for Fusion 360, you need to create an Autodesk account with your educational email address. Then, you need to verify your eligibility by providing proof of your enrollment or employment status. After that, you can download and install Fusion 360 from the Autodesk Education Community website.</p>
- <h3>How can I update Fusion 360 after using Xforce keygen?</h3>
- <p>If you have used Xforce keygen to activate Fusion 360, you may not be able to update it automatically from the software itself. This is because Autodesk may detect - your license as invalid or expired and prevent you from updating. You may also lose your activation if you update Fusion 360 with Xforce keygen. - To update Fusion 360 after using Xforce keygen, you need to download the latest version of the software from the official website or a trusted source. Then, you need to uninstall the previous version of Fusion 360 and install the new one. After that, you need to use Xforce keygen again to activate the new version of Fusion 360. - Alternatively, you can use a patcher tool that can update Fusion 360 without affecting your activation. One of the most popular patchers is , but use it at your own risk. <h3>What are some alternatives to Xforce keygen for activating Autodesk products?</h3>
- <p>Xforce keygen is not the only crack tool that can activate Autodesk products. There are some other tools that can do the same thing, such as:</p>
- - : This is a universal keygen that can generate serial numbers and product keys for any Autodesk product. It also has a patch function that can modify the software files and bypass the license verification process. - : This is a patcher tool that can activate any Autodesk product by modifying the registry entries and the hosts file. It also has a backup and restore function that can save and restore your activation data. - : This is a loader tool that can activate any Autodesk product by injecting a DLL file into the software process. It also has a stealth mode that can hide the loader from detection. <p>However, these tools are also illegal and unethical, and they may have the same risks and drawbacks as Xforce keygen. We do not recommend or endorse using these tools for activating Autodesk products.</p>
- <h3>Where can I find more tutorials and resources for Fusion 360?</h3>
- <p>If you want to learn more about Fusion 360 and how to use it effectively, you can find many tutorials and resources online, such as:</p>
- - : This is the official website of Fusion 360, where you can find information, documentation, downloads, updates, forums, blogs, videos, webinars, events, and more. - : This is the official YouTube channel of Fusion 360, where you can find tutorials, tips, tricks, demos, showcases, live streams, and more. - : This is an online learning platform that offers courses and lessons on Fusion 360 and other Autodesk products. You can learn from experts and professionals at your own pace and level. - : This is an online community of Fusion 360 users, where you can share your designs, projects, questions, feedback, ideas, and more. You can also join groups, challenges, contests, and events. <p>These are some of the best sources for learning and improving your skills in Fusion 360. You can also search for other websites, blogs, podcasts, books, magazines, etc. that offer Fusion 360 tutorials and resources.</p> b2dd77e56b<br />
-<br />
-<br />

spaces/1gistliPinn/ChatGPT4/Examples/Cossacks Back To War __EXCLUSIVE__ Full Game Download.md

@@ -1,32 +0,0 @@
-<h2>cossacks back to war full game download</h2><br /><p><b><b>Download</b> &#9658;&#9658;&#9658; <a href="https://imgfil.com/2uy1Yf">https://imgfil.com/2uy1Yf</a></b></p><br /><br />
-
-ZOMBIE ATTACK (2014)
-
-NOVOLAND
-
-Jakob Keseberg
-
-As zombie hordes gather in occupied Europe, a powerful armada of airborne attack vehicles emerge to fight them. Heroes have to fight the undead from the skies or else face the devastating consequences.
-
-Jakob Keseberg grew up in Germany as a creative hobbyist with a passion for game development. He was already making video games at the age of 12, inspired by old arcade titles. Later he founded a company called Geek Bytes Studio, and to this day he continues to develop games.
-
-After finishing school he moved to Hamburg to work as a web developer. In 2011 Jakob Keseberg started studying to be a game developer and took his first steps in the game industry by creating the text adventure game "The Vampyricium" and the social game "Heroes of Shadow".
-
-ZOMBIE ATTACK (2014) (click the thumbnail for the official trailer)
-
-REAL-TIME STRATEGY WITH A HISTORICAL BACKGROUND
-
-The game puts the player in the shoes of a powerful airborne commander. The player takes control of ground and air forces to lead military operations on the continent of Europe. The player creates a strategic combination of military forces to defeat the invading zombie hordes.
-
-You have the opportunity to operate military operations at the strategic level of European politics, and the challenge of making history. The year is 1530, and Europe is about to plunge into chaos. Religiously motivated wars are spreading like wildfire across the continent, while great powers like Spain, France, and England are preparing to fight for the control of the new world. During this time, new kinds of weapons become available. It is your mission to determine who will survive, and to rule the world in their place.
-
-ZOMBIE ATTACK (2014) is a strategy game inspired by the German popular saying "Zombie attack!"
-
-TO THE ROOF OF EUROPE
-
-Europe has been invaded by hordes of undead, and the continent is experiencing its worst war. Now, armed with sword, pistol, and shotgun, you will lead the only force of its kind to make history. At the helm of your military force you will shape the destiny of the continent.
-
-In ZOMBIE ATTACK (2014) you will lead your forces to the roof of Europe. Through 4fefd39f24<br />
-<br />
-<br />
-<p></p>

spaces/1gistliPinn/ChatGPT4/Examples/Fallout 3 Crack [BEST]ed Launcher 1.7.md

@@ -1,6 +0,0 @@
-<br />
-<p>bethesda's <em>fallout 4</em> is a completely overhauled version of the fallout engine. the title is based on the "true" fallout universe established by<em> fallout 3</em> and <em>fallout new vegas</em>, and the setting takes place in boston, which has been the center of civilization in the present and future. fallout 4 will include a full open world, with large towns, a government to rule, factions to choose from, and a dynamic main quest. the game's creators say it will also be the first entry in the series to feature a linear narrative.</p>
-<h2>fallout 3 cracked launcher 1.7</h2><br /><p><b><b>Download</b> ---> <a href="https://imgfil.com/2uy19L">https://imgfil.com/2uy19L</a></b></p><br /><br />
-<p>bethesda softworks also announced a new version of the game would be released on march 27, 2011. it was available on steam on march 29, 2011, and costs $15 for a pc edition or $40 for a game plus the director's cut. the director's cut consists of six new expansion packs, including <i>fallout: new california</i>, <i>fallout: new vegas</i>, <i>fallout: brotherhood of steel</i>, <i>fallout: brotherhood of steel - the pitt</i>, <i>fallout: brotherhood of steel - point lookout</i> and <i>fallout: brotherhood of steel - mothership zeta</i>, all free of drm and released on a weekly basis. <sup id=cite_ref-3 class=reference> [3] </sup> bethesda softworks also announced a new version of the game would be released on march 27, 2011. <sup id=cite_ref-4 class=reference> [4] </sup> the game also includes an enhanced version of the <i>companion app</i>, which allows players to access the in-game radio, map and quick-travel to an area with the iphone or ipod touch. the game was also re-released as a part of a bundle pack with the first two expansion packs, which included the game and the first two expansion packs, which included the game and the first two expansion packs. </p> 899543212b<br />
-<br />
-<br />

spaces/1phancelerku/anime-remove-background/Download Free Games for MacBook Air and Experience the Thrill of Gaming.md

@@ -1,140 +0,0 @@
-<br />
-<h1>How to Download Free Games for MacBook Air</h1>
-<p>If you are a MacBook Air user, you might be wondering how to download free games for your device. After all, gaming is not only fun but also a great way to relax and unwind. However, finding free games for Mac can be challenging, as not all games are compatible with macOS or optimized for the MacBook Air's performance. In this article, we will show you how to download free games for MacBook Air using different methods, such as Steam, the App Store, and iPad games. We will also recommend some of the best free games that you can enjoy on your MacBook Air.</p>
- <h2>Install Steam on Mac</h2>
-<p>Steam is one of the most popular online gaming platforms for PC and Mac users. It offers thousands of games across various genres, many of which are free to play or have free demos. To use Steam on your Mac, you need to install the Steam app first. Here's how:</p>
-<h2>download free games for macbook air</h2><br /><p><b><b>DOWNLOAD</b> &#10027;&#10027;&#10027; <a href="https://jinyurl.com/2uNNPs">https://jinyurl.com/2uNNPs</a></b></p><br /><br />
-<ul>
-<li>Go to <a href="(^1^)">steampowered.com</a> in your browser.</li>
-<li>Click Install Steam at the top right of the webpage.</li>
-<li>Choose Install Steam.</li>
-<li>Next, click the show downloads button.</li>
-<li>Double-click on steam.dmg to launch the installer.</li>
-<li>Drag Steam into the Applications folder.</li>
-<li>Exit the window.</li>
-</ul>
- <h2>Download a Steam game on Mac</h2>
-<p>Once you have installed Steam on your Mac, you can browse and download games from its library. To download a Steam game on your Mac, follow these steps:</p>
-<ul>
-<li>Launch Steam from the Applications folder.</li>
-<li>Choose Open, if applicable.</li>
-<li>Wait for Steam to update.</li>
-<li>Create a new account or log in into an existing account if you have one.</li>
-<li>Go to Store.</li>
-<li>Browse or search for the game that you want to download. Make sure it has an Apple logo next to it, which means it is compatible with Mac.</li>
-<li>Click on the title you want to download.</li>
-<li>Choose Add to Cart.</li>
-<li>Click Purchase for myself.</li>
-<li>Select your payment method. You can also use your Steam Wallet balance if you have any.</li>
-<li>Fill out your payment information.</li>
-<li>Click Continue.</li>
-<li>Click the checkbox to agree to the terms.</li>
-<li>Click Purchase.</li>
-</ul>
-<p>From here, your game will begin to download, and you can start playing as soon as it's done. You can also manage your downloads and library from the Library tab in Steam.</p>
- <h2>Download apps from the App Store on Mac</h2>
-<p>If you prefer not to use Steam or want to find more games that are designed for macOS, you can use the App Store on your Mac. The App Store has a wide selection of apps and games for your Mac, some of which are free or have free trials. To download apps from the App Store on your Mac, follow these steps:</p>
-<ul>
-<li>Open the App Store from the Dock or the Applications folder.</li>
-<li>Sign in with your Apple ID and password if you haven't already.</li>
-<li>Go to Games.</li>
-<li>Browse or search for the game that you want to download. You can also filter by categories, ratings, prices, and more.</li>
-<li>Click on the game that you want to download.</li>
-<li>Click Get if the game is free, or click the price if it is paid.</li>
-<li>Enter your Apple ID password or use Touch ID if prompted.</li>
-<li>Wait for the game to download and install on your Mac.</li>
-</ul>
-<p>You can find your downloaded games in the Launchpad or the Applications folder. You can also manage your purchases and updates from the App Store.</p>
- <h2>Download iPad games on Mac with Apple Silicon</h2>
-<p>If you have a MacBook Air with an Apple Silicon processor, such as the M1 chip, you can also download and play iPad games on your Mac. This is because Apple Silicon Macs can run iOS apps natively, without any emulation or compatibility issues. However, not all iPad games are available for Mac, as some developers may choose to opt out of this feature. To download iPad games on your Mac with Apple Silicon, follow these steps:</p>
-<p>download free games for macbook air 2023<br />
-download free games for macbook air offline<br />
-download free games for macbook air without app store<br />
-download free games for macbook air full version<br />
-download free games for macbook air no internet<br />
-download free games for macbook air from steam<br />
-download free games for macbook air adventure<br />
-download free games for macbook air racing<br />
-download free games for macbook air puzzle<br />
-download free games for macbook air strategy<br />
-download free games for macbook air simulation<br />
-download free games for macbook air action<br />
-download free games for macbook air horror<br />
-download free games for macbook air rpg<br />
-download free games for macbook air multiplayer<br />
-download free games for macbook air shooting<br />
-download free games for macbook air sports<br />
-download free games for macbook air educational<br />
-download free games for macbook air casual<br />
-download free games for macbook air hidden object<br />
-download free games for macbook air arcade<br />
-download free games for macbook air platformer<br />
-download free games for macbook air sandbox<br />
-download free games for macbook air survival<br />
-download free games for macbook air tycoon<br />
-download free games for macbook air card<br />
-download free games for macbook air board<br />
-download free games for macbook air trivia<br />
-download free games for macbook air word<br />
-download free games for macbook air match 3<br />
-download free games for macbook air solitaire<br />
-download free games for macbook air mahjong<br />
-download free games for macbook air sudoku<br />
-download free games for macbook air crossword<br />
-download free games for macbook air chess<br />
-download free games for macbook air checkers<br />
-download free games for macbook air backgammon<br />
-download free games for macbook air minesweeper<br />
-download free games for macbook air snake<br />
-download free games for macbook air tetris<br />
-download free games for macbook air pacman<br />
-download free games for macbook air pinball<br />
-download free games for macbook air breakout<br />
-download free games for macbook air space invaders<br />
-download free games for macbook air frogger<br />
-download free games for macbook air asteroids<br />
-download free games for macbook air pong<br />
-download free games for macbook air galaga<br />
-download free games for macbook air donkey kong</p>
-<ul>
-<li>Open the App Store from the Dock or the Applications folder.</li>
-<li>Sign in with your Apple ID and password if you haven't already.</li>
-<li>Go to Games.</li>
-<li>Click on iPhone & iPad Apps in the sidebar.</li>
-<li>Browse or search for the game that you want to download. You can also filter by categories, ratings, prices, and more.</li>
-<li>Click on the game that you want to download.</li>
-<li>Click Get if the game is free, or click the price if it is paid.</li>
-<li>Enter your Apple ID password or use Touch ID if prompted.</li>
-<li>Wait for the game to download and install on your Mac.</li>
-</ul>
-<p>You can find your downloaded iPad games in the Launchpad or the Applications folder. You can also manage your purchases and updates from the App Store.</p>
- <h2>Best free games for MacBook Air</h2>
-<p>Now that you know how to download free games for MacBook Air using different methods, you might be wondering what are some of the best free games that you can play on your device. Here are some of our recommendations:</p>
-<ol>
-<li><strong>Dota 2</strong>: Dota 2 is one of the most popular and competitive multiplayer online battle arena (MOBA) games in the world. It features hundreds of heroes, each with their own unique abilities and playstyles, and a variety of game modes and maps. You can team up with friends or strangers and fight against other players in matches that can last from 20 minutes to over an hour. Dota 2 is free to play on Steam, but you can also buy cosmetic items and battle passes to enhance your experience. <a href="">Download Dota 2 here</a>.</li>
-<li><strong>Among Us</strong>: Among Us is a social deduction game that has taken the internet by storm. It is set in a spaceship where one or more impostors are trying to sabotage and kill the crewmates, while the crewmates are trying to complete tasks and find out who the impostors are. You can play online with up to 10 players, or locally with up to 4 players. Among Us is free to play on iOS devices, but you can also buy it for $4.99 on Steam or $6.99 on the App Store for Mac. <a href="">Download Among Us here</a>.</li>
-<li><strong>Fallout Shelter</strong>: Fallout Shelter is a simulation game based on the Fallout series. It puts you in charge of a vault, where you have to build rooms, assign dwellers, manage resources, and protect your vault from disasters and enemies. You can also explore the wasteland, send dwellers on quests, and collect weapons and outfits. Fallout Shelter is free to play on iOS devices, but you can also buy it for $9.99 on Steam or $14.99 on the App Store for Mac. <a href="">Download Fallout Shelter here</a>.</li>
-</ol>
- <h2>Conclusion</h2>
-<p>In this article, we have shown you how to download free games for MacBook Air using different methods, such as Steam, the App Store, and iPad games. We have also recommended some of the best free games that you can play on your MacBook Air, such as Dota 2, Among Us, and Fallout Shelter. We hope you have found this article helpful and informative, and that you have fun playing these games on your MacBook Air. Here are some FAQs that you might have about downloading free games for MacBook Air.</p>
- <h2>FAQs</h2>
-<dl>
-<dt>How do I uninstall a game from my MacBook Air?</dt>
-<dd>To uninstall a game from your MacBook Air, you can either drag it to the Trash from the Applications folder, or use an uninstaller app that can remove all the associated files and folders. You can also delete a game from Steam or the App Store by right-clicking on it and choosing Delete or Move to Trash.</dd>
-<dt>How do I update a game on my MacBook Air?</dt>
-<dd>To update a game on your MacBook Air, you can either check for updates manually from the game's menu or settings, or enable automatic updates from Steam or the App Store. You can also check for updates from the Updates tab in the App Store, or from the Downloads tab in Steam.</dd>
-<dt>How do I optimize a game's performance on my MacBook Air?</dt>
-<dd>To optimize a game's performance on your MacBook Air, you can try some of the following tips: <ul>
-<li>Close any unnecessary apps or tabs that are running in the background.</li>
-<li>Adjust the game's graphics settings to lower the resolution, quality, or effects.</li>
-<li>Use an external monitor, keyboard, and mouse for better gaming experience.</li>
-<li>Keep your MacBook Air cool and ventilated by using a cooling pad or fan.</li>
-<li>Update your macOS and drivers to the latest versions.</li>
-</ul></dd>
-<dt>How do I play online games on my MacBook Air?</dt>
-<dd>To play online games on your MacBook Air, you need to have a stable and fast internet connection, preferably wired or Wi-Fi. You also need to have an account for the online gaming platform or service that you are using, such as Steam, Origin, Epic Games, etc. You may also need to pay a subscription fee or buy in-game currency or items for some online games.</dd>
-<dt>How do I play Windows games on my MacBook Air?</dt>
-<dd>To play Windows games on your MacBook Air, you need to use a software that can run Windows applications on Mac, such as Boot Camp, Parallels Desktop, Wine, or Crossover. However, not all Windows games are compatible with Mac, and some may have performance issues or bugs. You also need to have a valid license for Windows and enough disk space and memory for the installation.</dd>
-</dl></p> 197e85843d<br />
-<br />
-<br />

spaces/1toTree/lora_test/ppdiffusers/pipelines/stable_diffusion/pipeline_cycle_diffusion.py

@@ -1,631 +0,0 @@
-# Copyright (c) 2022 PaddlePaddle Authors. All Rights Reserved.
-# Copyright 2022 The HuggingFace Team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import inspect
-from typing import Callable, List, Optional, Union
-
-import numpy as np
-import paddle
-import PIL
-from packaging import version
-
-from paddlenlp.transformers import CLIPFeatureExtractor, CLIPTextModel, CLIPTokenizer
-
-from ...configuration_utils import FrozenDict
-from ...models import AutoencoderKL, UNet2DConditionModel
-from ...pipeline_utils import DiffusionPipeline
-from ...schedulers import DDIMScheduler
-from ...utils import PIL_INTERPOLATION, deprecate, logging
-from . import StableDiffusionPipelineOutput
-from .safety_checker import StableDiffusionSafetyChecker
-
-logger = logging.get_logger(__name__)  # pylint: disable=invalid-name
-
-
-# Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion_img2img.preprocess
-def preprocess(image):
-    if isinstance(image, paddle.Tensor):
-        return image
-    elif isinstance(image, PIL.Image.Image):
-        image = [image]
-
-    if isinstance(image[0], PIL.Image.Image):
-        w, h = image[0].size
-        w, h = map(lambda x: x - x % 32, (w, h))  # resize to integer multiple of 32
-
-        image = [np.array(i.resize((w, h), resample=PIL_INTERPOLATION["lanczos"]))[None, :] for i in image]
-        image = np.concatenate(image, axis=0)
-        image = np.array(image).astype(np.float32) / 255.0
-        image = image.transpose(0, 3, 1, 2)
-        image = 2.0 * image - 1.0
-        image = paddle.to_tensor(image)
-    elif isinstance(image[0], paddle.Tensor):
-        image = paddle.concat(image, axis=0)
-    return image
-
-
-def posterior_sample(scheduler, latents, timestep, clean_latents, generator, eta):
-    # 1. get previous step value (=t-1)
-    prev_timestep = timestep - scheduler.config.num_train_timesteps // scheduler.num_inference_steps
-
-    if prev_timestep <= 0:
-        return clean_latents
-
-    # 2. compute alphas, betas
-    alpha_prod_t = scheduler.alphas_cumprod[timestep]
-    alpha_prod_t_prev = (
-        scheduler.alphas_cumprod[prev_timestep] if prev_timestep >= 0 else scheduler.final_alpha_cumprod
-    )
-
-    variance = scheduler._get_variance(timestep, prev_timestep)
-    std_dev_t = eta * variance ** (0.5)
-
-    # direction pointing to x_t
-    e_t = (latents - alpha_prod_t ** (0.5) * clean_latents) / (1 - alpha_prod_t) ** (0.5)
-    dir_xt = (1.0 - alpha_prod_t_prev - std_dev_t**2) ** (0.5) * e_t
-    noise = std_dev_t * paddle.randn(clean_latents.shape, dtype=clean_latents.dtype, generator=generator)
-    prev_latents = alpha_prod_t_prev ** (0.5) * clean_latents + dir_xt + noise
-
-    return prev_latents
-
-
-def compute_noise(scheduler, prev_latents, latents, timestep, noise_pred, eta):
-    # 1. get previous step value (=t-1)
-    prev_timestep = timestep - scheduler.config.num_train_timesteps // scheduler.num_inference_steps
-
-    # 2. compute alphas, betas
-    alpha_prod_t = scheduler.alphas_cumprod[timestep]
-    alpha_prod_t_prev = (
-        scheduler.alphas_cumprod[prev_timestep] if prev_timestep >= 0 else scheduler.final_alpha_cumprod
-    )
-
-    beta_prod_t = 1 - alpha_prod_t
-
-    # 3. compute predicted original sample from predicted noise also called
-    # "predicted x_0" of formula (12) from https://arxiv.org/pdf/2010.02502.pdf
-    pred_original_sample = (latents - beta_prod_t ** (0.5) * noise_pred) / alpha_prod_t ** (0.5)
-
-    # 4. Clip "predicted x_0"
-    if scheduler.config.clip_sample:
-        pred_original_sample = pred_original_sample.clip(-1, 1)
-
-    # 5. compute variance: "sigma_t(η)" -> see formula (16)
-    # σ_t = sqrt((1 − α_t−1)/(1 − α_t)) * sqrt(1 − α_t/α_t−1)
-    variance = scheduler._get_variance(timestep, prev_timestep)
-    std_dev_t = eta * variance ** (0.5)
-
-    # 6. compute "direction pointing to x_t" of formula (12) from https://arxiv.org/pdf/2010.02502.pdf
-    pred_sample_direction = (1 - alpha_prod_t_prev - std_dev_t**2) ** (0.5) * noise_pred
-
-    noise = (prev_latents - (alpha_prod_t_prev ** (0.5) * pred_original_sample + pred_sample_direction)) / (
-        variance ** (0.5) * eta
-    )
-    return noise
-
-
-class CycleDiffusionPipeline(DiffusionPipeline):
-    r"""
-    Pipeline for text-guided image to image generation using Stable Diffusion.
-
-    This model inherits from [`DiffusionPipeline`]. Check the superclass documentation for the generic methods the
-    library implements for all the pipelines (such as downloading or saving, running on a particular xxxx, etc.)
-
-    Args:
-        vae ([`AutoencoderKL`]):
-            Variational Auto-Encoder (VAE) Model to encode and decode images to and from latent representations.
-        text_encoder ([`CLIPTextModel`]):
-            Frozen text-encoder. Stable Diffusion uses the text portion of
-            [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel), specifically
-            the [clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14) variant.
-        tokenizer (`CLIPTokenizer`):
-            Tokenizer of class
-            [CLIPTokenizer](https://huggingface.co/docs/transformers/v4.21.0/en/model_doc/clip#transformers.CLIPTokenizer).
-        unet ([`UNet2DConditionModel`]): Conditional U-Net architecture to denoise the encoded image latents.
-        scheduler ([`SchedulerMixin`]):
-            A scheduler to be used in combination with `unet` to denoise the encoded image latents. Can be one of
-            [`DDIMScheduler`], [`LMSDiscreteScheduler`], or [`PNDMScheduler`].
-        safety_checker ([`StableDiffusionSafetyChecker`]):
-            Classification module that estimates whether generated images could be considered offensive or harmful.
-            Please, refer to the [model card](https://huggingface.co/CompVis/stable-diffusion-v1-4) for details.
-        feature_extractor ([`CLIPFeatureExtractor`]):
-            Model that extracts features from generated images to be used as inputs for the `safety_checker`.
-    """
-    _optional_components = ["safety_checker", "feature_extractor"]
-
-    def __init__(
-        self,
-        vae: AutoencoderKL,
-        text_encoder: CLIPTextModel,
-        tokenizer: CLIPTokenizer,
-        unet: UNet2DConditionModel,
-        scheduler: DDIMScheduler,
-        safety_checker: StableDiffusionSafetyChecker,
-        feature_extractor: CLIPFeatureExtractor,
-        requires_safety_checker: bool = True,
-    ):
-        super().__init__()
-
-        if hasattr(scheduler.config, "steps_offset") and scheduler.config.steps_offset != 1:
-            deprecation_message = (
-                f"The configuration file of this scheduler: {scheduler} is outdated. `steps_offset`"
-                f" should be set to 1 instead of {scheduler.config.steps_offset}. Please make sure "
-                "to update the config accordingly as leaving `steps_offset` might led to incorrect results"
-                " in future versions. If you have downloaded this checkpoint from the Hugging Face Hub,"
-                " it would be very nice if you could open a Pull request for the `scheduler/scheduler_config.json`"
-                " file"
-            )
-            deprecate("steps_offset!=1", "1.0.0", deprecation_message, standard_warn=False)
-            new_config = dict(scheduler.config)
-            new_config["steps_offset"] = 1
-            scheduler._internal_dict = FrozenDict(new_config)
-
-        if safety_checker is None and requires_safety_checker:
-            logger.warning(
-                f"You have disabled the safety checker for {self.__class__} by passing `safety_checker=None`. Ensure"
-                " that you abide to the conditions of the Stable Diffusion license and do not expose unfiltered"
-                " results in services or applications open to the public. PaddleNLP team, diffusers team and Hugging Face"
-                " strongly recommend to keep the safety filter enabled in all public facing circumstances, disabling"
-                " it only for use-cases that involve analyzing network behavior or auditing its results. For more"
-                " information, please have a look at https://github.com/huggingface/diffusers/pull/254 ."
-            )
-        if safety_checker is not None and feature_extractor is None:
-            raise ValueError(
-                "Make sure to define a feature extractor when loading {self.__class__} if you want to use the safety"
-                " checker. If you do not want to use the safety checker, you can pass `'safety_checker=None'` instead."
-            )
-        is_unet_version_less_0_9_0 = hasattr(unet.config, "_ppdiffusers_version") and version.parse(
-            version.parse(unet.config._ppdiffusers_version).base_version
-        ) < version.parse("0.9.0.dev0")
-        is_unet_sample_size_less_64 = hasattr(unet.config, "sample_size") and unet.config.sample_size < 64
-        if is_unet_version_less_0_9_0 and is_unet_sample_size_less_64:
-            deprecation_message = (
-                "The configuration file of the unet has set the default `sample_size` to smaller than"
-                " 64 which seems highly unlikely. If your checkpoint is a fine-tuned version of any of the"
-                " following: \n- CompVis/stable-diffusion-v1-4 \n- CompVis/stable-diffusion-v1-3 \n-"
-                " CompVis/stable-diffusion-v1-2 \n- CompVis/stable-diffusion-v1-1 \n- runwayml/stable-diffusion-v1-5"
-                " \n- runwayml/stable-diffusion-inpainting \n you should change 'sample_size' to 64 in the"
-                " configuration file. Please make sure to update the config accordingly as leaving `sample_size=32`"
-                " in the config might lead to incorrect results in future versions. If you have downloaded this"
-                " checkpoint from the Hugging Face Hub, it would be very nice if you could open a Pull request for"
-                " the `unet/config.json` file"
-            )
-            deprecate("sample_size<64", "1.0.0", deprecation_message, standard_warn=False)
-            new_config = dict(unet.config)
-            new_config["sample_size"] = 64
-            unet._internal_dict = FrozenDict(new_config)
-
-        self.register_modules(
-            vae=vae,
-            text_encoder=text_encoder,
-            tokenizer=tokenizer,
-            unet=unet,
-            scheduler=scheduler,
-            safety_checker=safety_checker,
-            feature_extractor=feature_extractor,
-        )
-
-        self.register_to_config(requires_safety_checker=requires_safety_checker)
-
-    # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline._encode_prompt
-    def _encode_prompt(self, prompt, num_images_per_prompt, do_classifier_free_guidance, negative_prompt):
-        r"""
-        Encodes the prompt into text encoder hidden states.
-
-        Args:
-            prompt (`str` or `list(int)`):
-                prompt to be encoded
-            num_images_per_prompt (`int`):
-                number of images that should be generated per prompt
-            do_classifier_free_guidance (`bool`):
-                whether to use classifier free guidance or not
-            negative_prompt (`str` or `List[str]`):
-                The prompt or prompts not to guide the image generation. Ignored when not using guidance (i.e., ignored
-                if `guidance_scale` is less than `1`).
-        """
-        batch_size = len(prompt) if isinstance(prompt, list) else 1
-
-        text_inputs = self.tokenizer(
-            prompt,
-            padding="max_length",
-            max_length=self.tokenizer.model_max_length,
-            truncation=True,
-            return_tensors="pd",
-        )
-        text_input_ids = text_inputs.input_ids
-        untruncated_ids = self.tokenizer(prompt, padding="longest", return_tensors="pd").input_ids
-
-        if untruncated_ids.shape[-1] >= text_input_ids.shape[-1] and not paddle.equal_all(
-            text_input_ids, untruncated_ids
-        ):
-            removed_text = self.tokenizer.batch_decode(untruncated_ids[:, self.tokenizer.model_max_length - 1 : -1])
-            logger.warning(
-                "The following part of your input was truncated because CLIP can only handle sequences up to"
-                f" {self.tokenizer.model_max_length} tokens: {removed_text}"
-            )
-
-        if hasattr(self.text_encoder.config, "use_attention_mask") and self.text_encoder.config.use_attention_mask:
-            attention_mask = text_inputs.attention_mask
-        else:
-            attention_mask = None
-
-        text_embeddings = self.text_encoder(
-            text_input_ids,
-            attention_mask=attention_mask,
-        )
-        text_embeddings = text_embeddings[0]
-
-        # duplicate text embeddings for each generation per prompt, using mps friendly method
-        bs_embed, seq_len, _ = text_embeddings.shape
-        text_embeddings = text_embeddings.tile([1, num_images_per_prompt, 1])
-        text_embeddings = text_embeddings.reshape([bs_embed * num_images_per_prompt, seq_len, -1])
-
-        # get unconditional embeddings for classifier free guidance
-        if do_classifier_free_guidance:
-            uncond_tokens: List[str]
-            if negative_prompt is None:
-                uncond_tokens = [""] * batch_size
-            elif type(prompt) is not type(negative_prompt):
-                raise TypeError(
-                    f"`negative_prompt` should be the same type to `prompt`, but got {type(negative_prompt)} !="
-                    f" {type(prompt)}."
-                )
-            elif isinstance(negative_prompt, str):
-                uncond_tokens = [negative_prompt]
-            elif batch_size != len(negative_prompt):
-                raise ValueError(
-                    f"`negative_prompt`: {negative_prompt} has batch size {len(negative_prompt)}, but `prompt`:"
-                    f" {prompt} has batch size {batch_size}. Please make sure that passed `negative_prompt` matches"
-                    " the batch size of `prompt`."
-                )
-            else:
-                uncond_tokens = negative_prompt
-
-            max_length = text_input_ids.shape[-1]
-            uncond_input = self.tokenizer(
-                uncond_tokens,
-                padding="max_length",
-                max_length=max_length,
-                truncation=True,
-                return_tensors="pd",
-            )
-
-            if hasattr(self.text_encoder.config, "use_attention_mask") and self.text_encoder.config.use_attention_mask:
-                attention_mask = uncond_input.attention_mask
-            else:
-                attention_mask = None
-
-            uncond_embeddings = self.text_encoder(
-                uncond_input.input_ids,
-                attention_mask=attention_mask,
-            )
-            uncond_embeddings = uncond_embeddings[0]
-
-            # duplicate unconditional embeddings for each generation per prompt, using mps friendly method
-            seq_len = uncond_embeddings.shape[1]
-            uncond_embeddings = uncond_embeddings.tile([1, num_images_per_prompt, 1])
-            uncond_embeddings = uncond_embeddings.reshape([batch_size * num_images_per_prompt, seq_len, -1])
-
-            # For classifier free guidance, we need to do two forward passes.
-            # Here we concatenate the unconditional and text embeddings into a single batch
-            # to avoid doing two forward passes
-            text_embeddings = paddle.concat([uncond_embeddings, text_embeddings])
-
-        return text_embeddings
-
-    # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion_img2img.StableDiffusionImg2ImgPipeline.check_inputs
-    def check_inputs(self, prompt, strength, callback_steps):
-        if not isinstance(prompt, str) and not isinstance(prompt, list):
-            raise ValueError(f"`prompt` has to be of type `str` or `list` but is {type(prompt)}")
-
-        if strength < 0 or strength > 1:
-            raise ValueError(f"The value of strength should in [1.0, 1.0] but is {strength}")
-
-        if (callback_steps is None) or (
-            callback_steps is not None and (not isinstance(callback_steps, int) or callback_steps <= 0)
-        ):
-            raise ValueError(
-                f"`callback_steps` has to be a positive integer but is {callback_steps} of type"
-                f" {type(callback_steps)}."
-            )
-
-    # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline.prepare_extra_step_kwargs
-    def prepare_extra_step_kwargs(self, generator, eta):
-        # prepare extra kwargs for the scheduler step, since not all schedulers have the same signature
-        # eta (η) is only used with the DDIMScheduler, it will be ignored for other schedulers.
-        # eta corresponds to η in DDIM paper: https://arxiv.org/abs/2010.02502
-        # and should be between [0, 1]
-
-        accepts_eta = "eta" in set(inspect.signature(self.scheduler.step).parameters.keys())
-        extra_step_kwargs = {}
-        if accepts_eta:
-            extra_step_kwargs["eta"] = eta
-
-        # check if the scheduler accepts generator
-        accepts_generator = "generator" in set(inspect.signature(self.scheduler.step).parameters.keys())
-        if accepts_generator:
-            extra_step_kwargs["generator"] = generator
-        return extra_step_kwargs
-
-    # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline.run_safety_checker
-    def run_safety_checker(self, image, dtype):
-        if self.safety_checker is not None:
-            safety_checker_input = self.feature_extractor(self.numpy_to_pil(image), return_tensors="pd")
-            image, has_nsfw_concept = self.safety_checker(
-                images=image, clip_input=safety_checker_input.pixel_values.cast(dtype)
-            )
-        else:
-            has_nsfw_concept = None
-        return image, has_nsfw_concept
-
-    # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline.decode_latents
-    def decode_latents(self, latents):
-        latents = 1 / 0.18215 * latents
-        image = self.vae.decode(latents).sample
-        image = (image / 2 + 0.5).clip(0, 1)
-        # we always cast to float32 as this does not cause significant overhead and is compatible with bfloa16
-        image = image.transpose([0, 2, 3, 1]).cast("float32").numpy()
-        return image
-
-    # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion_img2img.StableDiffusionImg2ImgPipeline.get_timesteps
-    def get_timesteps(self, num_inference_steps, strength):
-        # get the original timestep using init_timestep
-        init_timestep = min(int(num_inference_steps * strength), num_inference_steps)
-
-        t_start = max(num_inference_steps - init_timestep, 0)
-        timesteps = self.scheduler.timesteps[t_start:]
-
-        return timesteps, num_inference_steps - t_start
-
-    def prepare_latents(self, image, timestep, batch_size, num_images_per_prompt, dtype, generator=None):
-        image = image.cast(dtype=dtype)
-
-        batch_size = image.shape[0]
-        if isinstance(generator, list) and len(generator) != batch_size:
-            raise ValueError(
-                f"You have passed a list of generators of length {len(generator)}, but requested an effective batch"
-                f" size of {batch_size}. Make sure the batch size matches the length of the generators."
-            )
-
-        if isinstance(generator, list):
-            init_latents = [
-                self.vae.encode(image[i : i + 1]).latent_dist.sample(generator[i]) for i in range(batch_size)
-            ]
-            init_latents = paddle.concat(init_latents, axis=0)
-        else:
-            init_latents = self.vae.encode(image).latent_dist.sample(generator)
-        init_latents = 0.18215 * init_latents
-
-        if batch_size > init_latents.shape[0] and batch_size % init_latents.shape[0] == 0:
-            # expand init_latents for batch_size
-            deprecation_message = (
-                f"You have passed {batch_size} text prompts (`prompt`), but only {init_latents.shape[0]} initial"
-                " images (`image`). Initial images are now duplicating to match the number of text prompts. Note"
-                " that this behavior is deprecated and will be removed in a version 1.0.0. Please make sure to update"
-                " your script to pass as many initial images as text prompts to suppress this warning."
-            )
-            deprecate("len(prompt) != len(image)", "1.0.0", deprecation_message, standard_warn=False)
-            additional_image_per_prompt = batch_size // init_latents.shape[0]
-            init_latents = paddle.concat([init_latents] * additional_image_per_prompt * num_images_per_prompt, axis=0)
-        elif batch_size > init_latents.shape[0] and batch_size % init_latents.shape[0] != 0:
-            raise ValueError(
-                f"Cannot duplicate `image` of batch size {init_latents.shape[0]} to {batch_size} text prompts."
-            )
-        else:
-            init_latents = paddle.concat([init_latents] * num_images_per_prompt, axis=0)
-
-        # add noise to latents using the timestep
-        shape = init_latents.shape
-        if isinstance(generator, list):
-            shape = [
-                1,
-            ] + shape[1:]
-            noise = [paddle.randn(shape, generator=generator[i], dtype=dtype) for i in range(batch_size)]
-            noise = paddle.concat(noise, axis=0)
-        else:
-            noise = paddle.randn(shape, generator=generator, dtype=dtype)
-
-        # get latents
-        clean_latents = init_latents
-        init_latents = self.scheduler.add_noise(init_latents, noise, timestep)
-        latents = init_latents
-
-        return latents, clean_latents
-
-    @paddle.no_grad()
-    def __call__(
-        self,
-        prompt: Union[str, List[str]],
-        source_prompt: Union[str, List[str]],
-        image: Union[paddle.Tensor, PIL.Image.Image] = None,
-        strength: float = 0.8,
-        num_inference_steps: Optional[int] = 50,
-        guidance_scale: Optional[float] = 7.5,
-        source_guidance_scale: Optional[float] = 1,
-        num_images_per_prompt: Optional[int] = 1,
-        eta: Optional[float] = 0.1,
-        generator: Optional[Union[paddle.Generator, List[paddle.Generator]]] = None,
-        output_type: Optional[str] = "pil",
-        return_dict: bool = True,
-        callback: Optional[Callable[[int, int, paddle.Tensor], None]] = None,
-        callback_steps: Optional[int] = 1,
-    ):
-        r"""
-        Function invoked when calling the pipeline for generation.
-
-        Args:
-            prompt (`str` or `List[str]`):
-                The prompt or prompts to guide the image generation.
-            image (`paddle.Tensor` or `PIL.Image.Image`):
-                `Image`, or tensor representing an image batch, that will be used as the starting point for the
-                process.
-            strength (`float`, *optional*, defaults to 0.8):
-                Conceptually, indicates how much to transform the reference `image`. Must be between 0 and 1.
-                `image` will be used as a starting point, adding more noise to it the larger the `strength`. The
-                number of denoising steps depends on the amount of noise initially added. When `strength` is 1, added
-                noise will be maximum and the denoising process will run for the full number of iterations specified in
-                `num_inference_steps`. A value of 1, therefore, essentially ignores `image`.
-            num_inference_steps (`int`, *optional*, defaults to 50):
-                The number of denoising steps. More denoising steps usually lead to a higher quality image at the
-                expense of slower inference. This parameter will be modulated by `strength`.
-            guidance_scale (`float`, *optional*, defaults to 7.5):
-                Guidance scale as defined in [Classifier-Free Diffusion Guidance](https://arxiv.org/abs/2207.12598).
-                `guidance_scale` is defined as `w` of equation 2. of [Imagen
-                Paper](https://arxiv.org/pdf/2205.11487.pdf). Guidance scale is enabled by setting `guidance_scale >
-                1`. Higher guidance scale encourages to generate images that are closely linked to the text `prompt`,
-                usually at the expense of lower image quality.
-            source_guidance_scale (`float`, *optional*, defaults to 1):
-                Guidance scale for the source prompt. This is useful to control the amount of influence the source
-                prompt for encoding.
-            num_images_per_prompt (`int`, *optional*, defaults to 1):
-                The number of images to generate per prompt.
-            eta (`float`, *optional*, defaults to 0.1):
-                Corresponds to parameter eta (η) in the DDIM paper: https://arxiv.org/abs/2010.02502. Only applies to
-                [`schedulers.DDIMScheduler`], will be ignored for others.
-            generator (`paddle.Generator`, *optional*):
-                One or a list of paddle generator(s) to make generation deterministic.
-            output_type (`str`, *optional*, defaults to `"pil"`):
-                The output format of the generate image. Choose between
-                [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` or `np.array`.
-            return_dict (`bool`, *optional*, defaults to `True`):
-                Whether or not to return a [`~pipelines.stable_diffusion.StableDiffusionPipelineOutput`] instead of a
-                plain tuple.
-            callback (`Callable`, *optional*):
-                A function that will be called every `callback_steps` steps during inference. The function will be
-                called with the following arguments: `callback(step: int, timestep: int, latents: paddle.Tensor)`.
-            callback_steps (`int`, *optional*, defaults to 1):
-                The frequency at which the `callback` function will be called. If not specified, the callback will be
-                called at every step.
-
-        Returns:
-            [`~pipelines.stable_diffusion.StableDiffusionPipelineOutput`] or `tuple`:
-            [`~pipelines.stable_diffusion.StableDiffusionPipelineOutput`] if `return_dict` is True, otherwise a `tuple.
-            When returning a tuple, the first element is a list with the generated images, and the second element is a
-            list of `bool`s denoting whether the corresponding generated image likely represents "not-safe-for-work"
-            (nsfw) content, according to the `safety_checker`.
-        """
-        # 1. Check inputs
-        self.check_inputs(prompt, strength, callback_steps)
-
-        # 2. Define call parameters
-        batch_size = 1 if isinstance(prompt, str) else len(prompt)
-        # here `guidance_scale` is defined analog to the guidance weight `w` of equation (2)
-        # of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1`
-        # corresponds to doing no classifier free guidance.
-        do_classifier_free_guidance = guidance_scale > 1.0
-
-        # 3. Encode input prompt
-        text_embeddings = self._encode_prompt(prompt, num_images_per_prompt, do_classifier_free_guidance, None)
-        source_text_embeddings = self._encode_prompt(
-            source_prompt, num_images_per_prompt, do_classifier_free_guidance, None
-        )
-
-        # 4. Preprocess image
-        image = preprocess(image)
-
-        # 5. Prepare timesteps
-        self.scheduler.set_timesteps(num_inference_steps)
-        timesteps, num_inference_steps = self.get_timesteps(num_inference_steps, strength)
-        latent_timestep = timesteps[:1].tile([batch_size * num_images_per_prompt])
-
-        # 6. Prepare latent variables
-        latents, clean_latents = self.prepare_latents(
-            image, latent_timestep, batch_size, num_images_per_prompt, text_embeddings.dtype, generator
-        )
-        source_latents = latents
-
-        # 7. Prepare extra step kwargs. TODO: Logic should ideally just be moved out of the pipeline
-        extra_step_kwargs = self.prepare_extra_step_kwargs(generator, eta)
-        generator = extra_step_kwargs.pop("generator", None)
-
-        # 8. Denoising loop
-        num_warmup_steps = len(timesteps) - num_inference_steps * self.scheduler.order
-        with self.progress_bar(total=num_inference_steps) as progress_bar:
-            for i, t in enumerate(timesteps):
-                # expand the latents if we are doing classifier free guidance
-                latent_model_input = paddle.concat([latents] * 2)
-                source_latent_model_input = paddle.concat([source_latents] * 2)
-                latent_model_input = self.scheduler.scale_model_input(latent_model_input, t)
-                source_latent_model_input = self.scheduler.scale_model_input(source_latent_model_input, t)
-
-                # predict the noise residual
-                concat_latent_model_input = paddle.stack(
-                    [
-                        source_latent_model_input[0],
-                        latent_model_input[0],
-                        source_latent_model_input[1],
-                        latent_model_input[1],
-                    ],
-                    axis=0,
-                )
-                concat_text_embeddings = paddle.stack(
-                    [
-                        source_text_embeddings[0],
-                        text_embeddings[0],
-                        source_text_embeddings[1],
-                        text_embeddings[1],
-                    ],
-                    axis=0,
-                )
-                concat_noise_pred = self.unet(
-                    concat_latent_model_input, t, encoder_hidden_states=concat_text_embeddings
-                ).sample
-
-                # perform guidance
-                (
-                    source_noise_pred_uncond,
-                    noise_pred_uncond,
-                    source_noise_pred_text,
-                    noise_pred_text,
-                ) = concat_noise_pred.chunk(4, axis=0)
-                noise_pred = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)
-                source_noise_pred = source_noise_pred_uncond + source_guidance_scale * (
-                    source_noise_pred_text - source_noise_pred_uncond
-                )
-
-                # Sample source_latents from the posterior distribution.
-                prev_source_latents = posterior_sample(
-                    self.scheduler, source_latents, t, clean_latents, generator=generator, **extra_step_kwargs
-                )
-                # Compute noise.
-                noise = compute_noise(
-                    self.scheduler, prev_source_latents, source_latents, t, source_noise_pred, **extra_step_kwargs
-                )
-                source_latents = prev_source_latents
-
-                # compute the previous noisy sample x_t -> x_t-1
-                latents = self.scheduler.step(
-                    noise_pred, t, latents, variance_noise=noise, **extra_step_kwargs
-                ).prev_sample
-
-                # call the callback, if provided
-                if i == len(timesteps) - 1 or ((i + 1) > num_warmup_steps and (i + 1) % self.scheduler.order == 0):
-                    progress_bar.update()
-                    if callback is not None and i % callback_steps == 0:
-                        callback(i, t, latents)
-
-        # 9. Post-processing
-        image = self.decode_latents(latents)
-
-        # 10. Run safety checker
-        image, has_nsfw_concept = self.run_safety_checker(image, text_embeddings.dtype)
-
-        # 11. Convert to PIL
-        if output_type == "pil":
-            image = self.numpy_to_pil(image)
-
-        if not return_dict:
-            return (image, has_nsfw_concept)
-
-        return StableDiffusionPipelineOutput(images=image, nsfw_content_detected=has_nsfw_concept)

spaces/7thHeaven/ochyai_food/README.md

@@ -1,13 +0,0 @@
----
-title: ochyai_food
-emoji: 🍛
-colorFrom: yellow
-colorTo: red
-sdk: gradio
-sdk_version: 3.19.1
-app_file: app.py
-pinned: false
-duplicated_from: ochyai/ochyai_food
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/801artistry/RVC801/infer/lib/infer_pack/onnx_inference.py

@@ -1,149 +0,0 @@
-import librosa
-import numpy as np
-import onnxruntime
-import soundfile
-
-import logging
-
-logger = logging.getLogger(__name__)
-
-
-class ContentVec:
-    def __init__(self, vec_path="pretrained/vec-768-layer-12.onnx", device=None):
-        logger.info("Load model(s) from {}".format(vec_path))
-        if device == "cpu" or device is None:
-            providers = ["CPUExecutionProvider"]
-        elif device == "cuda":
-            providers = ["CUDAExecutionProvider", "CPUExecutionProvider"]
-        elif device == "dml":
-            providers = ["DmlExecutionProvider"]
-        else:
-            raise RuntimeError("Unsportted Device")
-        self.model = onnxruntime.InferenceSession(vec_path, providers=providers)
-
-    def __call__(self, wav):
-        return self.forward(wav)
-
-    def forward(self, wav):
-        feats = wav
-        if feats.ndim == 2:  # double channels
-            feats = feats.mean(-1)
-        assert feats.ndim == 1, feats.ndim
-        feats = np.expand_dims(np.expand_dims(feats, 0), 0)
-        onnx_input = {self.model.get_inputs()[0].name: feats}
-        logits = self.model.run(None, onnx_input)[0]
-        return logits.transpose(0, 2, 1)
-
-
-def get_f0_predictor(f0_predictor, hop_length, sampling_rate, **kargs):
-    if f0_predictor == "pm":
-        from lib.infer_pack.modules.F0Predictor.PMF0Predictor import PMF0Predictor
-
-        f0_predictor_object = PMF0Predictor(
-            hop_length=hop_length, sampling_rate=sampling_rate
-        )
-    elif f0_predictor == "harvest":
-        from lib.infer_pack.modules.F0Predictor.HarvestF0Predictor import (
-            HarvestF0Predictor,
-        )
-
-        f0_predictor_object = HarvestF0Predictor(
-            hop_length=hop_length, sampling_rate=sampling_rate
-        )
-    elif f0_predictor == "dio":
-        from lib.infer_pack.modules.F0Predictor.DioF0Predictor import DioF0Predictor
-
-        f0_predictor_object = DioF0Predictor(
-            hop_length=hop_length, sampling_rate=sampling_rate
-        )
-    else:
-        raise Exception("Unknown f0 predictor")
-    return f0_predictor_object
-
-
-class OnnxRVC:
-    def __init__(
-        self,
-        model_path,
-        sr=40000,
-        hop_size=512,
-        vec_path="vec-768-layer-12",
-        device="cpu",
-    ):
-        vec_path = f"pretrained/{vec_path}.onnx"
-        self.vec_model = ContentVec(vec_path, device)
-        if device == "cpu" or device is None:
-            providers = ["CPUExecutionProvider"]
-        elif device == "cuda":
-            providers = ["CUDAExecutionProvider", "CPUExecutionProvider"]
-        elif device == "dml":
-            providers = ["DmlExecutionProvider"]
-        else:
-            raise RuntimeError("Unsportted Device")
-        self.model = onnxruntime.InferenceSession(model_path, providers=providers)
-        self.sampling_rate = sr
-        self.hop_size = hop_size
-
-    def forward(self, hubert, hubert_length, pitch, pitchf, ds, rnd):
-        onnx_input = {
-            self.model.get_inputs()[0].name: hubert,
-            self.model.get_inputs()[1].name: hubert_length,
-            self.model.get_inputs()[2].name: pitch,
-            self.model.get_inputs()[3].name: pitchf,
-            self.model.get_inputs()[4].name: ds,
-            self.model.get_inputs()[5].name: rnd,
-        }
-        return (self.model.run(None, onnx_input)[0] * 32767).astype(np.int16)
-
-    def inference(
-        self,
-        raw_path,
-        sid,
-        f0_method="dio",
-        f0_up_key=0,
-        pad_time=0.5,
-        cr_threshold=0.02,
-    ):
-        f0_min = 50
-        f0_max = 1100
-        f0_mel_min = 1127 * np.log(1 + f0_min / 700)
-        f0_mel_max = 1127 * np.log(1 + f0_max / 700)
-        f0_predictor = get_f0_predictor(
-            f0_method,
-            hop_length=self.hop_size,
-            sampling_rate=self.sampling_rate,
-            threshold=cr_threshold,
-        )
-        wav, sr = librosa.load(raw_path, sr=self.sampling_rate)
-        org_length = len(wav)
-        if org_length / sr > 50.0:
-            raise RuntimeError("Reached Max Length")
-
-        wav16k = librosa.resample(wav, orig_sr=self.sampling_rate, target_sr=16000)
-        wav16k = wav16k
-
-        hubert = self.vec_model(wav16k)
-        hubert = np.repeat(hubert, 2, axis=2).transpose(0, 2, 1).astype(np.float32)
-        hubert_length = hubert.shape[1]
-
-        pitchf = f0_predictor.compute_f0(wav, hubert_length)
-        pitchf = pitchf * 2 ** (f0_up_key / 12)
-        pitch = pitchf.copy()
-        f0_mel = 1127 * np.log(1 + pitch / 700)
-        f0_mel[f0_mel > 0] = (f0_mel[f0_mel > 0] - f0_mel_min) * 254 / (
-            f0_mel_max - f0_mel_min
-        ) + 1
-        f0_mel[f0_mel <= 1] = 1
-        f0_mel[f0_mel > 255] = 255
-        pitch = np.rint(f0_mel).astype(np.int64)
-
-        pitchf = pitchf.reshape(1, len(pitchf)).astype(np.float32)
-        pitch = pitch.reshape(1, len(pitch))
-        ds = np.array([sid]).astype(np.int64)
-
-        rnd = np.random.randn(1, 192, hubert_length).astype(np.float32)
-        hubert_length = np.array([hubert_length]).astype(np.int64)
-
-        out_wav = self.forward(hubert, hubert_length, pitch, pitchf, ds, rnd).squeeze()
-        out_wav = np.pad(out_wav, (0, 2 * self.hop_size), "constant")
-        return out_wav[0:org_length]

spaces/AIFILMS/StyleGANEX/models/stylegan2/op_ori/upfirdn2d.cpp

@@ -1,23 +0,0 @@
-#include <torch/extension.h>
-
-
-torch::Tensor upfirdn2d_op(const torch::Tensor& input, const torch::Tensor& kernel,
-                            int up_x, int up_y, int down_x, int down_y,
-                            int pad_x0, int pad_x1, int pad_y0, int pad_y1);
-
-#define CHECK_CUDA(x) TORCH_CHECK(x.type().is_cuda(), #x " must be a CUDA tensor")
-#define CHECK_CONTIGUOUS(x) TORCH_CHECK(x.is_contiguous(), #x " must be contiguous")
-#define CHECK_INPUT(x) CHECK_CUDA(x); CHECK_CONTIGUOUS(x)
-
-torch::Tensor upfirdn2d(const torch::Tensor& input, const torch::Tensor& kernel,
-                        int up_x, int up_y, int down_x, int down_y,
-                        int pad_x0, int pad_x1, int pad_y0, int pad_y1) {
-    CHECK_CUDA(input);
-    CHECK_CUDA(kernel);
-
-    return upfirdn2d_op(input, kernel, up_x, up_y, down_x, down_y, pad_x0, pad_x1, pad_y0, pad_y1);
-}
-
-PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {
-    m.def("upfirdn2d", &upfirdn2d, "upfirdn2d (CUDA)");
-}

spaces/AIGC-Audio/Make_An_Audio_inpaint/ldm/modules/losses_audio/vggishish/predict.py

@@ -1,90 +0,0 @@
-import os
-from torch.utils.data import DataLoader
-import torchvision
-from tqdm import tqdm
-from dataset import VGGSound
-import torch
-import torch.nn as nn
-from metrics import metrics
-from omegaconf import OmegaConf
-from model import VGGishish
-from transforms import Crop, StandardNormalizeAudio, ToTensor
-
-
-if __name__ == '__main__':
-    cfg_cli = OmegaConf.from_cli()
-    print(cfg_cli.config)
-    cfg_yml = OmegaConf.load(cfg_cli.config)
-    # the latter arguments are prioritized
-    cfg = OmegaConf.merge(cfg_yml, cfg_cli)
-    OmegaConf.set_readonly(cfg, True)
-    print(OmegaConf.to_yaml(cfg))
-
-    # logger = LoggerWithTBoard(cfg)
-    transforms = [
-        StandardNormalizeAudio(cfg.mels_path),
-        ToTensor(),
-    ]
-    if cfg.cropped_size not in [None, 'None', 'none']:
-        transforms.append(Crop(cfg.cropped_size))
-    transforms = torchvision.transforms.transforms.Compose(transforms)
-
-    datasets = {
-        'test': VGGSound('test', cfg.mels_path, transforms),
-    }
-
-    loaders = {
-        'test': DataLoader(datasets['test'], batch_size=cfg.batch_size,
-                           num_workers=cfg.num_workers, pin_memory=True)
-    }
-
-    device = torch.device(cfg.device if torch.cuda.is_available() else 'cpu')
-    model = VGGishish(cfg.conv_layers, cfg.use_bn, num_classes=len(datasets['test'].target2label))
-    model = model.to(device)
-
-    optimizer = torch.optim.Adam(model.parameters(), lr=cfg.learning_rate)
-    criterion = nn.CrossEntropyLoss()
-
-    # loading the best model
-    folder_name = os.path.split(cfg.config)[0].split('/')[-1]
-    print(folder_name)
-    ckpt = torch.load(f'./logs/{folder_name}/vggishish-{folder_name}.pt', map_location='cpu')
-    model.load_state_dict(ckpt['model'])
-    print((f'The model was trained for {ckpt["epoch"]} epochs. Loss: {ckpt["loss"]:.4f}'))
-
-    # Testing the model
-    model.eval()
-    running_loss = 0
-    preds_from_each_batch = []
-    targets_from_each_batch = []
-
-    for i, batch in enumerate(tqdm(loaders['test'])):
-        inputs = batch['input'].to(device)
-        targets = batch['target'].to(device)
-
-        # zero the parameter gradients
-        optimizer.zero_grad()
-
-        # forward + backward + optimize
-        with torch.set_grad_enabled(False):
-            outputs = model(inputs)
-            loss = criterion(outputs, targets)
-
-        # loss
-        running_loss += loss.item()
-
-        # for metrics calculation later on
-        preds_from_each_batch += [outputs.detach().cpu()]
-        targets_from_each_batch += [targets.cpu()]
-
-    # logging metrics
-    preds_from_each_batch = torch.cat(preds_from_each_batch)
-    targets_from_each_batch = torch.cat(targets_from_each_batch)
-    test_metrics_dict = metrics(targets_from_each_batch, preds_from_each_batch)
-    test_metrics_dict['avg_loss'] = running_loss / len(loaders['test'])
-    test_metrics_dict['param_num'] = sum(p.numel() for p in model.parameters() if p.requires_grad)
-
-    # TODO: I have no idea why tboard doesn't keep metrics (hparams) in a tensorboard when
-    # I run this experiment from cli: `python main.py config=./configs/vggish.yaml`
-    # while when I run it in vscode debugger the metrics are present in the tboard (weird)
-    print(test_metrics_dict)

spaces/ATang0729/Forecast4Muses/Model/Model6/Model6_2_ProfileRecogition/mmpretrain/configs/resnet/resnet50_8xb16_cifar100.py

@@ -1,19 +0,0 @@
-_base_ = [
-    '../_base_/models/resnet50_cifar.py',
-    '../_base_/datasets/cifar100_bs16.py',
-    '../_base_/schedules/cifar10_bs128.py',
-    '../_base_/default_runtime.py',
-]
-
-# model settings
-model = dict(head=dict(num_classes=100))
-
-# schedule settings
-optim_wrapper = dict(optimizer=dict(weight_decay=0.0005))
-
-param_scheduler = dict(
-    type='MultiStepLR',
-    by_epoch=True,
-    milestones=[60, 120, 160],
-    gamma=0.2,
-)

spaces/Adapter/CoAdapter/ldm/models/autoencoder.py

@@ -1,211 +0,0 @@
-import torch
-import pytorch_lightning as pl
-import torch.nn.functional as F
-import torch.nn as nn
-from contextlib import contextmanager
-
-from ldm.modules.diffusionmodules.model import Encoder, Decoder
-from ldm.modules.distributions.distributions import DiagonalGaussianDistribution
-
-from ldm.util import instantiate_from_config
-from ldm.modules.ema import LitEma
-
-
-class AutoencoderKL(pl.LightningModule):
-    def __init__(self,
-                 ddconfig,
-                 lossconfig,
-                 embed_dim,
-                 ckpt_path=None,
-                 ignore_keys=[],
-                 image_key="image",
-                 colorize_nlabels=None,
-                 monitor=None,
-                 ema_decay=None,
-                 learn_logvar=False
-                 ):
-        super().__init__()
-        self.learn_logvar = learn_logvar
-        self.image_key = image_key
-        self.encoder = Encoder(**ddconfig)
-        self.decoder = Decoder(**ddconfig)
-        self.loss = instantiate_from_config(lossconfig)
-        assert ddconfig["double_z"]
-        self.quant_conv = torch.nn.Conv2d(2*ddconfig["z_channels"], 2*embed_dim, 1)
-        self.post_quant_conv = torch.nn.Conv2d(embed_dim, ddconfig["z_channels"], 1)
-        self.embed_dim = embed_dim
-        if colorize_nlabels is not None:
-            assert type(colorize_nlabels)==int
-            self.register_buffer("colorize", torch.randn(3, colorize_nlabels, 1, 1))
-        if monitor is not None:
-            self.monitor = monitor
-
-        self.use_ema = ema_decay is not None
-        if self.use_ema:
-            self.ema_decay = ema_decay
-            assert 0. < ema_decay < 1.
-            self.model_ema = LitEma(self, decay=ema_decay)
-            print(f"Keeping EMAs of {len(list(self.model_ema.buffers()))}.")
-
-        if ckpt_path is not None:
-            self.init_from_ckpt(ckpt_path, ignore_keys=ignore_keys)
-
-    def init_from_ckpt(self, path, ignore_keys=list()):
-        sd = torch.load(path, map_location="cpu")["state_dict"]
-        keys = list(sd.keys())
-        for k in keys:
-            for ik in ignore_keys:
-                if k.startswith(ik):
-                    print("Deleting key {} from state_dict.".format(k))
-                    del sd[k]
-        self.load_state_dict(sd, strict=False)
-        print(f"Restored from {path}")
-
-    @contextmanager
-    def ema_scope(self, context=None):
-        if self.use_ema:
-            self.model_ema.store(self.parameters())
-            self.model_ema.copy_to(self)
-            if context is not None:
-                print(f"{context}: Switched to EMA weights")
-        try:
-            yield None
-        finally:
-            if self.use_ema:
-                self.model_ema.restore(self.parameters())
-                if context is not None:
-                    print(f"{context}: Restored training weights")
-
-    def on_train_batch_end(self, *args, **kwargs):
-        if self.use_ema:
-            self.model_ema(self)
-
-    def encode(self, x):
-        h = self.encoder(x)
-        moments = self.quant_conv(h)
-        posterior = DiagonalGaussianDistribution(moments)
-        return posterior
-
-    def decode(self, z):
-        z = self.post_quant_conv(z)
-        dec = self.decoder(z)
-        return dec
-
-    def forward(self, input, sample_posterior=True):
-        posterior = self.encode(input)
-        if sample_posterior:
-            z = posterior.sample()
-        else:
-            z = posterior.mode()
-        dec = self.decode(z)
-        return dec, posterior
-
-    def get_input(self, batch, k):
-        x = batch[k]
-        if len(x.shape) == 3:
-            x = x[..., None]
-        x = x.permute(0, 3, 1, 2).to(memory_format=torch.contiguous_format).float()
-        return x
-
-    def training_step(self, batch, batch_idx, optimizer_idx):
-        inputs = self.get_input(batch, self.image_key)
-        reconstructions, posterior = self(inputs)
-
-        if optimizer_idx == 0:
-            # train encoder+decoder+logvar
-            aeloss, log_dict_ae = self.loss(inputs, reconstructions, posterior, optimizer_idx, self.global_step,
-                                            last_layer=self.get_last_layer(), split="train")
-            self.log("aeloss", aeloss, prog_bar=True, logger=True, on_step=True, on_epoch=True)
-            self.log_dict(log_dict_ae, prog_bar=False, logger=True, on_step=True, on_epoch=False)
-            return aeloss
-
-        if optimizer_idx == 1:
-            # train the discriminator
-            discloss, log_dict_disc = self.loss(inputs, reconstructions, posterior, optimizer_idx, self.global_step,
-                                                last_layer=self.get_last_layer(), split="train")
-
-            self.log("discloss", discloss, prog_bar=True, logger=True, on_step=True, on_epoch=True)
-            self.log_dict(log_dict_disc, prog_bar=False, logger=True, on_step=True, on_epoch=False)
-            return discloss
-
-    def validation_step(self, batch, batch_idx):
-        log_dict = self._validation_step(batch, batch_idx)
-        with self.ema_scope():
-            log_dict_ema = self._validation_step(batch, batch_idx, postfix="_ema")
-        return log_dict
-
-    def _validation_step(self, batch, batch_idx, postfix=""):
-        inputs = self.get_input(batch, self.image_key)
-        reconstructions, posterior = self(inputs)
-        aeloss, log_dict_ae = self.loss(inputs, reconstructions, posterior, 0, self.global_step,
-                                        last_layer=self.get_last_layer(), split="val"+postfix)
-
-        discloss, log_dict_disc = self.loss(inputs, reconstructions, posterior, 1, self.global_step,
-                                            last_layer=self.get_last_layer(), split="val"+postfix)
-
-        self.log(f"val{postfix}/rec_loss", log_dict_ae[f"val{postfix}/rec_loss"])
-        self.log_dict(log_dict_ae)
-        self.log_dict(log_dict_disc)
-        return self.log_dict
-
-    def configure_optimizers(self):
-        lr = self.learning_rate
-        ae_params_list = list(self.encoder.parameters()) + list(self.decoder.parameters()) + list(
-            self.quant_conv.parameters()) + list(self.post_quant_conv.parameters())
-        if self.learn_logvar:
-            print(f"{self.__class__.__name__}: Learning logvar")
-            ae_params_list.append(self.loss.logvar)
-        opt_ae = torch.optim.Adam(ae_params_list,
-                                  lr=lr, betas=(0.5, 0.9))
-        opt_disc = torch.optim.Adam(self.loss.discriminator.parameters(),
-                                    lr=lr, betas=(0.5, 0.9))
-        return [opt_ae, opt_disc], []
-
-    def get_last_layer(self):
-        return self.decoder.conv_out.weight
-
-    @torch.no_grad()
-    def log_images(self, batch, only_inputs=False, log_ema=False, **kwargs):
-        log = dict()
-        x = self.get_input(batch, self.image_key)
-        x = x.to(self.device)
-        if not only_inputs:
-            xrec, posterior = self(x)
-            if x.shape[1] > 3:
-                # colorize with random projection
-                assert xrec.shape[1] > 3
-                x = self.to_rgb(x)
-                xrec = self.to_rgb(xrec)
-            log["samples"] = self.decode(torch.randn_like(posterior.sample()))
-            log["reconstructions"] = xrec
-        log["inputs"] = x
-        return log
-
-    def to_rgb(self, x):
-        assert self.image_key == "segmentation"
-        if not hasattr(self, "colorize"):
-            self.register_buffer("colorize", torch.randn(3, x.shape[1], 1, 1).to(x))
-        x = F.conv2d(x, weight=self.colorize)
-        x = 2.*(x-x.min())/(x.max()-x.min()) - 1.
-        return x
-
-
-class IdentityFirstStage(nn.Module):
-    def __init__(self, *args, vq_interface=False, **kwargs):
-        self.vq_interface = vq_interface
-        super().__init__()
-
-    def encode(self, x, *args, **kwargs):
-        return x
-
-    def decode(self, x, *args, **kwargs):
-        return x
-
-    def quantize(self, x, *args, **kwargs):
-        if self.vq_interface:
-            return x, None, [None, None, None]
-        return x
-
-    def forward(self, x, *args, **kwargs):
-        return x
-

spaces/Adapter/CoAdapter/ldm/models/diffusion/dpm_solver/sampler.py

@@ -1,87 +0,0 @@
-"""SAMPLING ONLY."""
-import torch
-
-from .dpm_solver import NoiseScheduleVP, model_wrapper, DPM_Solver
-
-
-MODEL_TYPES = {
-    "eps": "noise",
-    "v": "v"
-}
-
-
-class DPMSolverSampler(object):
-    def __init__(self, model, **kwargs):
-        super().__init__()
-        self.model = model
-        to_torch = lambda x: x.clone().detach().to(torch.float32).to(model.device)
-        self.register_buffer('alphas_cumprod', to_torch(model.alphas_cumprod))
-
-    def register_buffer(self, name, attr):
-        if type(attr) == torch.Tensor:
-            if attr.device != torch.device("cuda"):
-                attr = attr.to(torch.device("cuda"))
-        setattr(self, name, attr)
-
-    @torch.no_grad()
-    def sample(self,
-               S,
-               batch_size,
-               shape,
-               conditioning=None,
-               callback=None,
-               normals_sequence=None,
-               img_callback=None,
-               quantize_x0=False,
-               eta=0.,
-               mask=None,
-               x0=None,
-               temperature=1.,
-               noise_dropout=0.,
-               score_corrector=None,
-               corrector_kwargs=None,
-               verbose=True,
-               x_T=None,
-               log_every_t=100,
-               unconditional_guidance_scale=1.,
-               unconditional_conditioning=None,
-               # this has to come in the same format as the conditioning, # e.g. as encoded tokens, ...
-               **kwargs
-               ):
-        if conditioning is not None:
-            if isinstance(conditioning, dict):
-                cbs = conditioning[list(conditioning.keys())[0]].shape[0]
-                if cbs != batch_size:
-                    print(f"Warning: Got {cbs} conditionings but batch-size is {batch_size}")
-            else:
-                if conditioning.shape[0] != batch_size:
-                    print(f"Warning: Got {conditioning.shape[0]} conditionings but batch-size is {batch_size}")
-
-        # sampling
-        C, H, W = shape
-        size = (batch_size, C, H, W)
-
-        print(f'Data shape for DPM-Solver sampling is {size}, sampling steps {S}')
-
-        device = self.model.betas.device
-        if x_T is None:
-            img = torch.randn(size, device=device)
-        else:
-            img = x_T
-
-        ns = NoiseScheduleVP('discrete', alphas_cumprod=self.alphas_cumprod)
-
-        model_fn = model_wrapper(
-            lambda x, t, c: self.model.apply_model(x, t, c),
-            ns,
-            model_type=MODEL_TYPES[self.model.parameterization],
-            guidance_type="classifier-free",
-            condition=conditioning,
-            unconditional_condition=unconditional_conditioning,
-            guidance_scale=unconditional_guidance_scale,
-        )
-
-        dpm_solver = DPM_Solver(model_fn, ns, predict_x0=True, thresholding=False)
-        x = dpm_solver.sample(img, steps=S, skip_type="time_uniform", method="multistep", order=2, lower_order_final=True)
-
-        return x.to(device), None

spaces/Adapter/CoAdapter/ldm/modules/diffusionmodules/openaimodel.py

@@ -1,798 +0,0 @@
-from abc import abstractmethod
-import math
-import torch
-
-import numpy as np
-import torch as th
-import torch.nn as nn
-import torch.nn.functional as F
-
-from ldm.modules.diffusionmodules.util import (
-    checkpoint,
-    conv_nd,
-    linear,
-    avg_pool_nd,
-    zero_module,
-    normalization,
-    timestep_embedding,
-)
-from ldm.modules.attention import SpatialTransformer
-from ldm.util import exists
-
-
-# dummy replace
-def convert_module_to_f16(x):
-    pass
-
-def convert_module_to_f32(x):
-    pass
-
-
-## go
-class AttentionPool2d(nn.Module):
-    """
-    Adapted from CLIP: https://github.com/openai/CLIP/blob/main/clip/model.py
-    """
-
-    def __init__(
-        self,
-        spacial_dim: int,
-        embed_dim: int,
-        num_heads_channels: int,
-        output_dim: int = None,
-    ):
-        super().__init__()
-        self.positional_embedding = nn.Parameter(th.randn(embed_dim, spacial_dim ** 2 + 1) / embed_dim ** 0.5)
-        self.qkv_proj = conv_nd(1, embed_dim, 3 * embed_dim, 1)
-        self.c_proj = conv_nd(1, embed_dim, output_dim or embed_dim, 1)
-        self.num_heads = embed_dim // num_heads_channels
-        self.attention = QKVAttention(self.num_heads)
-
-    def forward(self, x):
-        b, c, *_spatial = x.shape
-        x = x.reshape(b, c, -1)  # NC(HW)
-        x = th.cat([x.mean(dim=-1, keepdim=True), x], dim=-1)  # NC(HW+1)
-        x = x + self.positional_embedding[None, :, :].to(x.dtype)  # NC(HW+1)
-        x = self.qkv_proj(x)
-        x = self.attention(x)
-        x = self.c_proj(x)
-        return x[:, :, 0]
-
-
-class TimestepBlock(nn.Module):
-    """
-    Any module where forward() takes timestep embeddings as a second argument.
-    """
-
-    @abstractmethod
-    def forward(self, x, emb):
-        """
-        Apply the module to `x` given `emb` timestep embeddings.
-        """
-
-
-class TimestepEmbedSequential(nn.Sequential, TimestepBlock):
-    """
-    A sequential module that passes timestep embeddings to the children that
-    support it as an extra input.
-    """
-
-    def forward(self, x, emb, context=None):
-        for layer in self:
-            if isinstance(layer, TimestepBlock):
-                x = layer(x, emb)
-            elif isinstance(layer, SpatialTransformer):
-                x = layer(x, context)
-            else:
-                x = layer(x)
-        return x
-
-
-class Upsample(nn.Module):
-    """
-    An upsampling layer with an optional convolution.
-    :param channels: channels in the inputs and outputs.
-    :param use_conv: a bool determining if a convolution is applied.
-    :param dims: determines if the signal is 1D, 2D, or 3D. If 3D, then
-                 upsampling occurs in the inner-two dimensions.
-    """
-
-    def __init__(self, channels, use_conv, dims=2, out_channels=None, padding=1):
-        super().__init__()
-        self.channels = channels
-        self.out_channels = out_channels or channels
-        self.use_conv = use_conv
-        self.dims = dims
-        if use_conv:
-            self.conv = conv_nd(dims, self.channels, self.out_channels, 3, padding=padding)
-
-    def forward(self, x):
-        assert x.shape[1] == self.channels
-        if self.dims == 3:
-            x = F.interpolate(
-                x, (x.shape[2], x.shape[3] * 2, x.shape[4] * 2), mode="nearest"
-            )
-        else:
-            x = F.interpolate(x, scale_factor=2, mode="nearest")
-        if self.use_conv:
-            x = self.conv(x)
-        return x
-
-class TransposedUpsample(nn.Module):
-    'Learned 2x upsampling without padding'
-    def __init__(self, channels, out_channels=None, ks=5):
-        super().__init__()
-        self.channels = channels
-        self.out_channels = out_channels or channels
-
-        self.up = nn.ConvTranspose2d(self.channels,self.out_channels,kernel_size=ks,stride=2)
-
-    def forward(self,x):
-        return self.up(x)
-
-
-class Downsample(nn.Module):
-    """
-    A downsampling layer with an optional convolution.
-    :param channels: channels in the inputs and outputs.
-    :param use_conv: a bool determining if a convolution is applied.
-    :param dims: determines if the signal is 1D, 2D, or 3D. If 3D, then
-                 downsampling occurs in the inner-two dimensions.
-    """
-
-    def __init__(self, channels, use_conv, dims=2, out_channels=None,padding=1):
-        super().__init__()
-        self.channels = channels
-        self.out_channels = out_channels or channels
-        self.use_conv = use_conv
-        self.dims = dims
-        stride = 2 if dims != 3 else (1, 2, 2)
-        if use_conv:
-            self.op = conv_nd(
-                dims, self.channels, self.out_channels, 3, stride=stride, padding=padding
-            )
-        else:
-            assert self.channels == self.out_channels
-            self.op = avg_pool_nd(dims, kernel_size=stride, stride=stride)
-
-    def forward(self, x):
-        assert x.shape[1] == self.channels
-        return self.op(x)
-
-
-class ResBlock(TimestepBlock):
-    """
-    A residual block that can optionally change the number of channels.
-    :param channels: the number of input channels.
-    :param emb_channels: the number of timestep embedding channels.
-    :param dropout: the rate of dropout.
-    :param out_channels: if specified, the number of out channels.
-    :param use_conv: if True and out_channels is specified, use a spatial
-        convolution instead of a smaller 1x1 convolution to change the
-        channels in the skip connection.
-    :param dims: determines if the signal is 1D, 2D, or 3D.
-    :param use_checkpoint: if True, use gradient checkpointing on this module.
-    :param up: if True, use this block for upsampling.
-    :param down: if True, use this block for downsampling.
-    """
-
-    def __init__(
-        self,
-        channels,
-        emb_channels,
-        dropout,
-        out_channels=None,
-        use_conv=False,
-        use_scale_shift_norm=False,
-        dims=2,
-        use_checkpoint=False,
-        up=False,
-        down=False,
-    ):
-        super().__init__()
-        self.channels = channels
-        self.emb_channels = emb_channels
-        self.dropout = dropout
-        self.out_channels = out_channels or channels
-        self.use_conv = use_conv
-        self.use_checkpoint = use_checkpoint
-        self.use_scale_shift_norm = use_scale_shift_norm
-
-        self.in_layers = nn.Sequential(
-            normalization(channels),
-            nn.SiLU(),
-            conv_nd(dims, channels, self.out_channels, 3, padding=1),
-        )
-
-        self.updown = up or down
-
-        if up:
-            self.h_upd = Upsample(channels, False, dims)
-            self.x_upd = Upsample(channels, False, dims)
-        elif down:
-            self.h_upd = Downsample(channels, False, dims)
-            self.x_upd = Downsample(channels, False, dims)
-        else:
-            self.h_upd = self.x_upd = nn.Identity()
-
-        self.emb_layers = nn.Sequential(
-            nn.SiLU(),
-            linear(
-                emb_channels,
-                2 * self.out_channels if use_scale_shift_norm else self.out_channels,
-            ),
-        )
-        self.out_layers = nn.Sequential(
-            normalization(self.out_channels),
-            nn.SiLU(),
-            nn.Dropout(p=dropout),
-            zero_module(
-                conv_nd(dims, self.out_channels, self.out_channels, 3, padding=1)
-            ),
-        )
-
-        if self.out_channels == channels:
-            self.skip_connection = nn.Identity()
-        elif use_conv:
-            self.skip_connection = conv_nd(
-                dims, channels, self.out_channels, 3, padding=1
-            )
-        else:
-            self.skip_connection = conv_nd(dims, channels, self.out_channels, 1)
-
-    def forward(self, x, emb):
-        """
-        Apply the block to a Tensor, conditioned on a timestep embedding.
-        :param x: an [N x C x ...] Tensor of features.
-        :param emb: an [N x emb_channels] Tensor of timestep embeddings.
-        :return: an [N x C x ...] Tensor of outputs.
-        """
-        return checkpoint(
-            self._forward, (x, emb), self.parameters(), self.use_checkpoint
-        )
-
-
-    def _forward(self, x, emb):
-        if self.updown:
-            in_rest, in_conv = self.in_layers[:-1], self.in_layers[-1]
-            h = in_rest(x)
-            h = self.h_upd(h)
-            x = self.x_upd(x)
-            h = in_conv(h)
-        else:
-            h = self.in_layers(x)
-        emb_out = self.emb_layers(emb).type(h.dtype)
-        while len(emb_out.shape) < len(h.shape):
-            emb_out = emb_out[..., None]
-        if self.use_scale_shift_norm:
-            out_norm, out_rest = self.out_layers[0], self.out_layers[1:]
-            scale, shift = th.chunk(emb_out, 2, dim=1)
-            h = out_norm(h) * (1 + scale) + shift
-            h = out_rest(h)
-        else:
-            h = h + emb_out
-            h = self.out_layers(h)
-        return self.skip_connection(x) + h
-
-
-class AttentionBlock(nn.Module):
-    """
-    An attention block that allows spatial positions to attend to each other.
-    Originally ported from here, but adapted to the N-d case.
-    https://github.com/hojonathanho/diffusion/blob/1e0dceb3b3495bbe19116a5e1b3596cd0706c543/diffusion_tf/models/unet.py#L66.
-    """
-
-    def __init__(
-        self,
-        channels,
-        num_heads=1,
-        num_head_channels=-1,
-        use_checkpoint=False,
-        use_new_attention_order=False,
-    ):
-        super().__init__()
-        self.channels = channels
-        if num_head_channels == -1:
-            self.num_heads = num_heads
-        else:
-            assert (
-                channels % num_head_channels == 0
-            ), f"q,k,v channels {channels} is not divisible by num_head_channels {num_head_channels}"
-            self.num_heads = channels // num_head_channels
-        self.use_checkpoint = use_checkpoint
-        self.norm = normalization(channels)
-        self.qkv = conv_nd(1, channels, channels * 3, 1)
-        if use_new_attention_order:
-            # split qkv before split heads
-            self.attention = QKVAttention(self.num_heads)
-        else:
-            # split heads before split qkv
-            self.attention = QKVAttentionLegacy(self.num_heads)
-
-        self.proj_out = zero_module(conv_nd(1, channels, channels, 1))
-
-    def forward(self, x):
-        return checkpoint(self._forward, (x,), self.parameters(), True)   # TODO: check checkpoint usage, is True # TODO: fix the .half call!!!
-        #return pt_checkpoint(self._forward, x)  # pytorch
-
-    def _forward(self, x):
-        b, c, *spatial = x.shape
-        x = x.reshape(b, c, -1)
-        qkv = self.qkv(self.norm(x))
-        h = self.attention(qkv)
-        h = self.proj_out(h)
-        return (x + h).reshape(b, c, *spatial)
-
-
-def count_flops_attn(model, _x, y):
-    """
-    A counter for the `thop` package to count the operations in an
-    attention operation.
-    Meant to be used like:
-        macs, params = thop.profile(
-            model,
-            inputs=(inputs, timestamps),
-            custom_ops={QKVAttention: QKVAttention.count_flops},
-        )
-    """
-    b, c, *spatial = y[0].shape
-    num_spatial = int(np.prod(spatial))
-    # We perform two matmuls with the same number of ops.
-    # The first computes the weight matrix, the second computes
-    # the combination of the value vectors.
-    matmul_ops = 2 * b * (num_spatial ** 2) * c
-    model.total_ops += th.DoubleTensor([matmul_ops])
-
-
-class QKVAttentionLegacy(nn.Module):
-    """
-    A module which performs QKV attention. Matches legacy QKVAttention + input/ouput heads shaping
-    """
-
-    def __init__(self, n_heads):
-        super().__init__()
-        self.n_heads = n_heads
-
-    def forward(self, qkv):
-        """
-        Apply QKV attention.
-        :param qkv: an [N x (H * 3 * C) x T] tensor of Qs, Ks, and Vs.
-        :return: an [N x (H * C) x T] tensor after attention.
-        """
-        bs, width, length = qkv.shape
-        assert width % (3 * self.n_heads) == 0
-        ch = width // (3 * self.n_heads)
-        q, k, v = qkv.reshape(bs * self.n_heads, ch * 3, length).split(ch, dim=1)
-        scale = 1 / math.sqrt(math.sqrt(ch))
-        weight = th.einsum(
-            "bct,bcs->bts", q * scale, k * scale
-        )  # More stable with f16 than dividing afterwards
-        weight = th.softmax(weight.float(), dim=-1).type(weight.dtype)
-        a = th.einsum("bts,bcs->bct", weight, v)
-        return a.reshape(bs, -1, length)
-
-    @staticmethod
-    def count_flops(model, _x, y):
-        return count_flops_attn(model, _x, y)
-
-
-class QKVAttention(nn.Module):
-    """
-    A module which performs QKV attention and splits in a different order.
-    """
-
-    def __init__(self, n_heads):
-        super().__init__()
-        self.n_heads = n_heads
-
-    def forward(self, qkv):
-        """
-        Apply QKV attention.
-        :param qkv: an [N x (3 * H * C) x T] tensor of Qs, Ks, and Vs.
-        :return: an [N x (H * C) x T] tensor after attention.
-        """
-        bs, width, length = qkv.shape
-        assert width % (3 * self.n_heads) == 0
-        ch = width // (3 * self.n_heads)
-        q, k, v = qkv.chunk(3, dim=1)
-        scale = 1 / math.sqrt(math.sqrt(ch))
-        weight = th.einsum(
-            "bct,bcs->bts",
-            (q * scale).view(bs * self.n_heads, ch, length),
-            (k * scale).view(bs * self.n_heads, ch, length),
-        )  # More stable with f16 than dividing afterwards
-        weight = th.softmax(weight.float(), dim=-1).type(weight.dtype)
-        a = th.einsum("bts,bcs->bct", weight, v.reshape(bs * self.n_heads, ch, length))
-        return a.reshape(bs, -1, length)
-
-    @staticmethod
-    def count_flops(model, _x, y):
-        return count_flops_attn(model, _x, y)
-
-
-class UNetModel(nn.Module):
-    """
-    The full UNet model with attention and timestep embedding.
-    :param in_channels: channels in the input Tensor.
-    :param model_channels: base channel count for the model.
-    :param out_channels: channels in the output Tensor.
-    :param num_res_blocks: number of residual blocks per downsample.
-    :param attention_resolutions: a collection of downsample rates at which
-        attention will take place. May be a set, list, or tuple.
-        For example, if this contains 4, then at 4x downsampling, attention
-        will be used.
-    :param dropout: the dropout probability.
-    :param channel_mult: channel multiplier for each level of the UNet.
-    :param conv_resample: if True, use learned convolutions for upsampling and
-        downsampling.
-    :param dims: determines if the signal is 1D, 2D, or 3D.
-    :param num_classes: if specified (as an int), then this model will be
-        class-conditional with `num_classes` classes.
-    :param use_checkpoint: use gradient checkpointing to reduce memory usage.
-    :param num_heads: the number of attention heads in each attention layer.
-    :param num_heads_channels: if specified, ignore num_heads and instead use
-                               a fixed channel width per attention head.
-    :param num_heads_upsample: works with num_heads to set a different number
-                               of heads for upsampling. Deprecated.
-    :param use_scale_shift_norm: use a FiLM-like conditioning mechanism.
-    :param resblock_updown: use residual blocks for up/downsampling.
-    :param use_new_attention_order: use a different attention pattern for potentially
-                                    increased efficiency.
-    """
-
-    def __init__(
-        self,
-        image_size,
-        in_channels,
-        model_channels,
-        out_channels,
-        num_res_blocks,
-        attention_resolutions,
-        dropout=0,
-        channel_mult=(1, 2, 4, 8),
-        conv_resample=True,
-        dims=2,
-        num_classes=None,
-        use_checkpoint=False,
-        use_fp16=False,
-        num_heads=-1,
-        num_head_channels=-1,
-        num_heads_upsample=-1,
-        use_scale_shift_norm=False,
-        resblock_updown=False,
-        use_new_attention_order=False,
-        use_spatial_transformer=False,    # custom transformer support
-        transformer_depth=1,              # custom transformer support
-        context_dim=None,                 # custom transformer support
-        n_embed=None,                     # custom support for prediction of discrete ids into codebook of first stage vq model
-        legacy=True,
-        disable_self_attentions=None,
-        num_attention_blocks=None,
-        disable_middle_self_attn=False,
-        use_linear_in_transformer=False,
-    ):
-        super().__init__()
-        if use_spatial_transformer:
-            assert context_dim is not None, 'Fool!! You forgot to include the dimension of your cross-attention conditioning...'
-
-        if context_dim is not None:
-            assert use_spatial_transformer, 'Fool!! You forgot to use the spatial transformer for your cross-attention conditioning...'
-            from omegaconf.listconfig import ListConfig
-            if type(context_dim) == ListConfig:
-                context_dim = list(context_dim)
-
-        if num_heads_upsample == -1:
-            num_heads_upsample = num_heads
-
-        if num_heads == -1:
-            assert num_head_channels != -1, 'Either num_heads or num_head_channels has to be set'
-
-        if num_head_channels == -1:
-            assert num_heads != -1, 'Either num_heads or num_head_channels has to be set'
-
-        self.image_size = image_size
-        self.in_channels = in_channels
-        self.model_channels = model_channels
-        self.out_channels = out_channels
-        if isinstance(num_res_blocks, int):
-            self.num_res_blocks = len(channel_mult) * [num_res_blocks]
-        else:
-            if len(num_res_blocks) != len(channel_mult):
-                raise ValueError("provide num_res_blocks either as an int (globally constant) or "
-                                 "as a list/tuple (per-level) with the same length as channel_mult")
-            self.num_res_blocks = num_res_blocks
-        if disable_self_attentions is not None:
-            # should be a list of booleans, indicating whether to disable self-attention in TransformerBlocks or not
-            assert len(disable_self_attentions) == len(channel_mult)
-        if num_attention_blocks is not None:
-            assert len(num_attention_blocks) == len(self.num_res_blocks)
-            assert all(map(lambda i: self.num_res_blocks[i] >= num_attention_blocks[i], range(len(num_attention_blocks))))
-            print(f"Constructor of UNetModel received num_attention_blocks={num_attention_blocks}. "
-                  f"This option has LESS priority than attention_resolutions {attention_resolutions}, "
-                  f"i.e., in cases where num_attention_blocks[i] > 0 but 2**i not in attention_resolutions, "
-                  f"attention will still not be set.")
-
-        self.attention_resolutions = attention_resolutions
-        self.dropout = dropout
-        self.channel_mult = channel_mult
-        self.conv_resample = conv_resample
-        self.num_classes = num_classes
-        self.use_checkpoint = use_checkpoint
-        self.dtype = th.float16 if use_fp16 else th.float32
-        self.num_heads = num_heads
-        self.num_head_channels = num_head_channels
-        self.num_heads_upsample = num_heads_upsample
-        self.predict_codebook_ids = n_embed is not None
-
-        time_embed_dim = model_channels * 4
-        self.time_embed = nn.Sequential(
-            linear(model_channels, time_embed_dim),
-            nn.SiLU(),
-            linear(time_embed_dim, time_embed_dim),
-        )
-
-        if self.num_classes is not None:
-            if isinstance(self.num_classes, int):
-                self.label_emb = nn.Embedding(num_classes, time_embed_dim)
-            elif self.num_classes == "continuous":
-                print("setting up linear c_adm embedding layer")
-                self.label_emb = nn.Linear(1, time_embed_dim)
-            else:
-                raise ValueError()
-
-        self.input_blocks = nn.ModuleList(
-            [
-                TimestepEmbedSequential(
-                    conv_nd(dims, in_channels, model_channels, 3, padding=1)
-                )
-            ]
-        )
-        self._feature_size = model_channels
-        input_block_chans = [model_channels]
-        ch = model_channels
-        ds = 1
-        for level, mult in enumerate(channel_mult):
-            for nr in range(self.num_res_blocks[level]):
-                layers = [
-                    ResBlock(
-                        ch,
-                        time_embed_dim,
-                        dropout,
-                        out_channels=mult * model_channels,
-                        dims=dims,
-                        use_checkpoint=use_checkpoint,
-                        use_scale_shift_norm=use_scale_shift_norm,
-                    )
-                ]
-                ch = mult * model_channels
-                if ds in attention_resolutions:
-                    if num_head_channels == -1:
-                        dim_head = ch // num_heads
-                    else:
-                        num_heads = ch // num_head_channels
-                        dim_head = num_head_channels
-                    if legacy:
-                        #num_heads = 1
-                        dim_head = ch // num_heads if use_spatial_transformer else num_head_channels
-                    if exists(disable_self_attentions):
-                        disabled_sa = disable_self_attentions[level]
-                    else:
-                        disabled_sa = False
-
-                    if not exists(num_attention_blocks) or nr < num_attention_blocks[level]:
-                        layers.append(
-                            AttentionBlock(
-                                ch,
-                                use_checkpoint=use_checkpoint,
-                                num_heads=num_heads,
-                                num_head_channels=dim_head,
-                                use_new_attention_order=use_new_attention_order,
-                            ) if not use_spatial_transformer else SpatialTransformer(
-                                ch, num_heads, dim_head, depth=transformer_depth, context_dim=context_dim,
-                                disable_self_attn=disabled_sa, use_linear=use_linear_in_transformer,
-                                use_checkpoint=use_checkpoint
-                            )
-                        )
-                self.input_blocks.append(TimestepEmbedSequential(*layers))
-                self._feature_size += ch
-                input_block_chans.append(ch)
-            if level != len(channel_mult) - 1:
-                out_ch = ch
-                self.input_blocks.append(
-                    TimestepEmbedSequential(
-                        ResBlock(
-                            ch,
-                            time_embed_dim,
-                            dropout,
-                            out_channels=out_ch,
-                            dims=dims,
-                            use_checkpoint=use_checkpoint,
-                            use_scale_shift_norm=use_scale_shift_norm,
-                            down=True,
-                        )
-                        if resblock_updown
-                        else Downsample(
-                            ch, conv_resample, dims=dims, out_channels=out_ch
-                        )
-                    )
-                )
-                ch = out_ch
-                input_block_chans.append(ch)
-                ds *= 2
-                self._feature_size += ch
-
-        if num_head_channels == -1:
-            dim_head = ch // num_heads
-        else:
-            num_heads = ch // num_head_channels
-            dim_head = num_head_channels
-        if legacy:
-            #num_heads = 1
-            dim_head = ch // num_heads if use_spatial_transformer else num_head_channels
-        self.middle_block = TimestepEmbedSequential(
-            ResBlock(
-                ch,
-                time_embed_dim,
-                dropout,
-                dims=dims,
-                use_checkpoint=use_checkpoint,
-                use_scale_shift_norm=use_scale_shift_norm,
-            ),
-            AttentionBlock(
-                ch,
-                use_checkpoint=use_checkpoint,
-                num_heads=num_heads,
-                num_head_channels=dim_head,
-                use_new_attention_order=use_new_attention_order,
-            ) if not use_spatial_transformer else SpatialTransformer(  # always uses a self-attn
-                            ch, num_heads, dim_head, depth=transformer_depth, context_dim=context_dim,
-                            disable_self_attn=disable_middle_self_attn, use_linear=use_linear_in_transformer,
-                            use_checkpoint=use_checkpoint
-                        ),
-            ResBlock(
-                ch,
-                time_embed_dim,
-                dropout,
-                dims=dims,
-                use_checkpoint=use_checkpoint,
-                use_scale_shift_norm=use_scale_shift_norm,
-            ),
-        )
-        self._feature_size += ch
-
-        self.output_blocks = nn.ModuleList([])
-        for level, mult in list(enumerate(channel_mult))[::-1]:
-            for i in range(self.num_res_blocks[level] + 1):
-                ich = input_block_chans.pop()
-                layers = [
-                    ResBlock(
-                        ch + ich,
-                        time_embed_dim,
-                        dropout,
-                        out_channels=model_channels * mult,
-                        dims=dims,
-                        use_checkpoint=use_checkpoint,
-                        use_scale_shift_norm=use_scale_shift_norm,
-                    )
-                ]
-                ch = model_channels * mult
-                if ds in attention_resolutions:
-                    if num_head_channels == -1:
-                        dim_head = ch // num_heads
-                    else:
-                        num_heads = ch // num_head_channels
-                        dim_head = num_head_channels
-                    if legacy:
-                        #num_heads = 1
-                        dim_head = ch // num_heads if use_spatial_transformer else num_head_channels
-                    if exists(disable_self_attentions):
-                        disabled_sa = disable_self_attentions[level]
-                    else:
-                        disabled_sa = False
-
-                    if not exists(num_attention_blocks) or i < num_attention_blocks[level]:
-                        layers.append(
-                            AttentionBlock(
-                                ch,
-                                use_checkpoint=use_checkpoint,
-                                num_heads=num_heads_upsample,
-                                num_head_channels=dim_head,
-                                use_new_attention_order=use_new_attention_order,
-                            ) if not use_spatial_transformer else SpatialTransformer(
-                                ch, num_heads, dim_head, depth=transformer_depth, context_dim=context_dim,
-                                disable_self_attn=disabled_sa, use_linear=use_linear_in_transformer,
-                                use_checkpoint=use_checkpoint
-                            )
-                        )
-                if level and i == self.num_res_blocks[level]:
-                    out_ch = ch
-                    layers.append(
-                        ResBlock(
-                            ch,
-                            time_embed_dim,
-                            dropout,
-                            out_channels=out_ch,
-                            dims=dims,
-                            use_checkpoint=use_checkpoint,
-                            use_scale_shift_norm=use_scale_shift_norm,
-                            up=True,
-                        )
-                        if resblock_updown
-                        else Upsample(ch, conv_resample, dims=dims, out_channels=out_ch)
-                    )
-                    ds //= 2
-                self.output_blocks.append(TimestepEmbedSequential(*layers))
-                self._feature_size += ch
-
-        self.out = nn.Sequential(
-            normalization(ch),
-            nn.SiLU(),
-            zero_module(conv_nd(dims, model_channels, out_channels, 3, padding=1)),
-        )
-        if self.predict_codebook_ids:
-            self.id_predictor = nn.Sequential(
-            normalization(ch),
-            conv_nd(dims, model_channels, n_embed, 1),
-            #nn.LogSoftmax(dim=1)  # change to cross_entropy and produce non-normalized logits
-        )
-
-    def convert_to_fp16(self):
-        """
-        Convert the torso of the model to float16.
-        """
-        self.input_blocks.apply(convert_module_to_f16)
-        self.middle_block.apply(convert_module_to_f16)
-        self.output_blocks.apply(convert_module_to_f16)
-
-    def convert_to_fp32(self):
-        """
-        Convert the torso of the model to float32.
-        """
-        self.input_blocks.apply(convert_module_to_f32)
-        self.middle_block.apply(convert_module_to_f32)
-        self.output_blocks.apply(convert_module_to_f32)
-
-    def forward(self, x, timesteps=None, context=None, y=None, features_adapter=None, append_to_context=None, **kwargs):
-        """
-        Apply the model to an input batch.
-        :param x: an [N x C x ...] Tensor of inputs.
-        :param timesteps: a 1-D batch of timesteps.
-        :param context: conditioning plugged in via crossattn
-        :param y: an [N] Tensor of labels, if class-conditional.
-        :return: an [N x C x ...] Tensor of outputs.
-        """
-        assert (y is not None) == (
-            self.num_classes is not None
-        ), "must specify y if and only if the model is class-conditional"
-        hs = []
-        t_emb = timestep_embedding(timesteps, self.model_channels, repeat_only=False)
-        emb = self.time_embed(t_emb)
-
-        if self.num_classes is not None:
-            assert y.shape[0] == x.shape[0]
-            emb = emb + self.label_emb(y)
-
-        h = x.type(self.dtype)
-
-        if append_to_context is not None:
-            context = torch.cat([context, append_to_context], dim=1)
-
-        adapter_idx = 0
-        for id, module in enumerate(self.input_blocks):
-            h = module(h, emb, context)
-            if ((id+1)%3 == 0) and features_adapter is not None:
-                h = h + features_adapter[adapter_idx]
-                adapter_idx += 1
-            hs.append(h)
-        if features_adapter is not None:
-            assert len(features_adapter)==adapter_idx, 'Wrong features_adapter'
-
-        h = self.middle_block(h, emb, context)
-        for module in self.output_blocks:
-            h = th.cat([h, hs.pop()], dim=1)
-            h = module(h, emb, context)
-        h = h.type(x.dtype)
-        if self.predict_codebook_ids:
-            return self.id_predictor(h)
-        else:
-            return self.out(h)

spaces/Aditya9790/yolo7-object-tracking/utils/aws/userdata.sh

@@ -1,27 +0,0 @@
-#!/bin/bash
-# AWS EC2 instance startup script https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/user-data.html
-# This script will run only once on first instance start (for a re-start script see mime.sh)
-# /home/ubuntu (ubuntu) or /home/ec2-user (amazon-linux) is working dir
-# Use >300 GB SSD
-
-cd home/ubuntu
-if [ ! -d yolor ]; then
-  echo "Running first-time script." # install dependencies, download COCO, pull Docker
-  git clone -b main https://github.com/WongKinYiu/yolov7 && sudo chmod -R 777 yolov7
-  cd yolov7
-  bash data/scripts/get_coco.sh && echo "Data done." &
-  sudo docker pull nvcr.io/nvidia/pytorch:21.08-py3 && echo "Docker done." &
-  python -m pip install --upgrade pip && pip install -r requirements.txt && python detect.py && echo "Requirements done." &
-  wait && echo "All tasks done." # finish background tasks
-else
-  echo "Running re-start script." # resume interrupted runs
-  i=0
-  list=$(sudo docker ps -qa) # container list i.e. $'one\ntwo\nthree\nfour'
-  while IFS= read -r id; do
-    ((i++))
-    echo "restarting container $i: $id"
-    sudo docker start $id
-    # sudo docker exec -it $id python train.py --resume # single-GPU
-    sudo docker exec -d $id python utils/aws/resume.py # multi-scenario
-  done <<<"$list"
-fi

spaces/AlbertoFH98/CastenaApp/README.md

@@ -1,13 +0,0 @@
----
-title: CastenaApp
-emoji: 📈
-colorFrom: green
-colorTo: gray
-sdk: streamlit
-sdk_version: 1.27.2
-app_file: app.py
-pinned: false
-license: apache-2.0
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/AlekseyKorshuk/thin-plate-spline-motion-model/frames_dataset.py

@@ -1,173 +0,0 @@
-import os
-from skimage import io, img_as_float32
-from skimage.color import gray2rgb
-from sklearn.model_selection import train_test_split
-from imageio import mimread
-from skimage.transform import resize
-import numpy as np
-from torch.utils.data import Dataset
-from augmentation import AllAugmentationTransform
-import glob
-from functools import partial
-
-
-def read_video(name, frame_shape):
-    """
-    Read video which can be:
-      - an image of concatenated frames
-      - '.mp4' and'.gif'
-      - folder with videos
-    """
-
-    if os.path.isdir(name):
-        frames = sorted(os.listdir(name))
-        num_frames = len(frames)
-        video_array = np.array(
-            [img_as_float32(io.imread(os.path.join(name, frames[idx]))) for idx in range(num_frames)])
-    elif name.lower().endswith('.png') or name.lower().endswith('.jpg'):
-        image = io.imread(name)
-
-        if len(image.shape) == 2 or image.shape[2] == 1:
-            image = gray2rgb(image)
-
-        if image.shape[2] == 4:
-            image = image[..., :3]
-
-        image = img_as_float32(image)
-
-        video_array = np.moveaxis(image, 1, 0)
-
-        video_array = video_array.reshape((-1,) + frame_shape)
-        video_array = np.moveaxis(video_array, 1, 2)
-    elif name.lower().endswith('.gif') or name.lower().endswith('.mp4') or name.lower().endswith('.mov'):
-        video = mimread(name)
-        if len(video[0].shape) == 2:
-            video = [gray2rgb(frame) for frame in video]
-        if frame_shape is not None:
-            video = np.array([resize(frame, frame_shape) for frame in video])
-        video = np.array(video)
-        if video.shape[-1] == 4:
-            video = video[..., :3]
-        video_array = img_as_float32(video)
-    else:
-        raise Exception("Unknown file extensions  %s" % name)
-
-    return video_array
-
-
-class FramesDataset(Dataset):
-    """
-    Dataset of videos, each video can be represented as:
-      - an image of concatenated frames
-      - '.mp4' or '.gif'
-      - folder with all frames
-    """
-
-    def __init__(self, root_dir, frame_shape=(256, 256, 3), id_sampling=False, is_train=True,
-                 random_seed=0, pairs_list=None, augmentation_params=None):
-        self.root_dir = root_dir
-        self.videos = os.listdir(root_dir)
-        self.frame_shape = frame_shape
-        print(self.frame_shape)
-        self.pairs_list = pairs_list
-        self.id_sampling = id_sampling
-
-        if os.path.exists(os.path.join(root_dir, 'train')):
-            assert os.path.exists(os.path.join(root_dir, 'test'))
-            print("Use predefined train-test split.")
-            if id_sampling:
-                train_videos = {os.path.basename(video).split('#')[0] for video in
-                                os.listdir(os.path.join(root_dir, 'train'))}
-                train_videos = list(train_videos)
-            else:
-                train_videos = os.listdir(os.path.join(root_dir, 'train'))
-            test_videos = os.listdir(os.path.join(root_dir, 'test'))
-            self.root_dir = os.path.join(self.root_dir, 'train' if is_train else 'test')
-        else:
-            print("Use random train-test split.")
-            train_videos, test_videos = train_test_split(self.videos, random_state=random_seed, test_size=0.2)
-
-        if is_train:
-            self.videos = train_videos
-        else:
-            self.videos = test_videos
-
-        self.is_train = is_train
-
-        if self.is_train:
-            self.transform = AllAugmentationTransform(**augmentation_params)
-        else:
-            self.transform = None
-
-    def __len__(self):
-        return len(self.videos)
-
-    def __getitem__(self, idx):
-            
-        if self.is_train and self.id_sampling:   
-            name = self.videos[idx]
-            path = np.random.choice(glob.glob(os.path.join(self.root_dir, name + '*.mp4')))
-        else:
-            name = self.videos[idx]
-            path = os.path.join(self.root_dir, name)
-
-        video_name = os.path.basename(path)
-        if self.is_train and os.path.isdir(path):
-
-            frames = os.listdir(path)
-            num_frames = len(frames)
-            frame_idx = np.sort(np.random.choice(num_frames, replace=True, size=2))
-            
-            if self.frame_shape is not None:
-                resize_fn = partial(resize, output_shape=self.frame_shape)
-            else:
-                resize_fn = img_as_float32
-
-            if type(frames[0]) is bytes:
-                video_array = [resize_fn(io.imread(os.path.join(path, frames[idx].decode('utf-8')))) for idx in
-                            frame_idx]
-            else:
-                video_array = [resize_fn(io.imread(os.path.join(path, frames[idx]))) for idx in frame_idx]
-        else:
-                 
-            video_array = read_video(path, frame_shape=self.frame_shape)
-            
-            num_frames = len(video_array)
-            frame_idx = np.sort(np.random.choice(num_frames, replace=True, size=2)) if self.is_train else range(
-                num_frames)
-            video_array = video_array[frame_idx]
-            
-
-        if self.transform is not None:
-            video_array = self.transform(video_array)
-
-        out = {}
-        if self.is_train:
-            source = np.array(video_array[0], dtype='float32')
-            driving = np.array(video_array[1], dtype='float32')
-
-            out['driving'] = driving.transpose((2, 0, 1))
-            out['source'] = source.transpose((2, 0, 1))
-        else:
-            video = np.array(video_array, dtype='float32')
-            out['video'] = video.transpose((3, 0, 1, 2))
-
-        out['name'] = video_name
-        return out
-
-
-class DatasetRepeater(Dataset):
-    """
-    Pass several times over the same dataset for better i/o performance
-    """
-
-    def __init__(self, dataset, num_repeats=100):
-        self.dataset = dataset
-        self.num_repeats = num_repeats
-
-    def __len__(self):
-        return self.num_repeats * self.dataset.__len__()
-
-    def __getitem__(self, idx):
-        return self.dataset[idx % self.dataset.__len__()]
-

spaces/Amrrs/DragGan-Inversion/PTI/models/StyleCLIP/mapper/latent_mappers.py

@@ -1,81 +0,0 @@
-import torch
-from torch import nn
-from torch.nn import Module
-
-from models.StyleCLIP.models.stylegan2.model import EqualLinear, PixelNorm
-
-
-class Mapper(Module):
-
-    def __init__(self, opts):
-        super(Mapper, self).__init__()
-
-        self.opts = opts
-        layers = [PixelNorm()]
-
-        for i in range(4):
-            layers.append(
-                EqualLinear(
-                    512, 512, lr_mul=0.01, activation='fused_lrelu'
-                )
-            )
-
-        self.mapping = nn.Sequential(*layers)
-
-
-    def forward(self, x):
-        x = self.mapping(x)
-        return x
-
-
-class SingleMapper(Module):
-
-    def __init__(self, opts):
-        super(SingleMapper, self).__init__()
-
-        self.opts = opts
-
-        self.mapping = Mapper(opts)
-
-    def forward(self, x):
-        out = self.mapping(x)
-        return out
-
-
-class LevelsMapper(Module):
-
-    def __init__(self, opts):
-        super(LevelsMapper, self).__init__()
-
-        self.opts = opts
-
-        if not opts.no_coarse_mapper:
-            self.course_mapping = Mapper(opts)
-        if not opts.no_medium_mapper:
-            self.medium_mapping = Mapper(opts)
-        if not opts.no_fine_mapper:
-            self.fine_mapping = Mapper(opts)
-
-    def forward(self, x):
-        x_coarse = x[:, :4, :]
-        x_medium = x[:, 4:8, :]
-        x_fine = x[:, 8:, :]
-
-        if not self.opts.no_coarse_mapper:
-            x_coarse = self.course_mapping(x_coarse)
-        else:
-            x_coarse = torch.zeros_like(x_coarse)
-        if not self.opts.no_medium_mapper:
-            x_medium = self.medium_mapping(x_medium)
-        else:
-            x_medium = torch.zeros_like(x_medium)
-        if not self.opts.no_fine_mapper:
-            x_fine = self.fine_mapping(x_fine)
-        else:
-            x_fine = torch.zeros_like(x_fine)
-
-
-        out = torch.cat([x_coarse, x_medium, x_fine], dim=1)
-
-        return out
-

spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/docs/source/en/optimization/fp16.md

@@ -1,434 +0,0 @@
-<!--Copyright 2023 The HuggingFace Team. All rights reserved.
-
-Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
-the License. You may obtain a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
-an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
-specific language governing permissions and limitations under the License.
--->
-
-# Memory and speed
-
-We present some techniques and ideas to optimize 🤗 Diffusers _inference_ for memory or speed. As a general rule, we recommend the use of [xFormers](https://github.com/facebookresearch/xformers) for memory efficient attention, please see the recommended [installation instructions](xformers).
-
-We'll discuss how the following settings impact performance and memory.
-
-|                  | Latency | Speedup |
-| ---------------- | ------- | ------- |
-| original         | 9.50s   | x1      |
-| fp16             | 3.61s   | x2.63   |
-| channels last    | 3.30s   | x2.88   |
-| traced UNet      | 3.21s   | x2.96   |
-| memory efficient attention  | 2.63s  | x3.61   |
-
-<em>
-  obtained on NVIDIA TITAN RTX by generating a single image of size 512x512 from
-  the prompt "a photo of an astronaut riding a horse on mars" with 50 DDIM
-  steps.
-</em>
-
-### Use tf32 instead of fp32 (on Ampere and later CUDA devices)
-
-On Ampere and later CUDA devices matrix multiplications and convolutions can use the TensorFloat32 (TF32) mode for faster but slightly less accurate computations. By default PyTorch enables TF32 mode for convolutions but not matrix multiplications, and unless a network requires full float32 precision we recommend enabling this setting for matrix multiplications, too. It can significantly speed up computations with typically negligible loss of numerical accuracy. You can read more about it [here](https://huggingface.co/docs/transformers/v4.18.0/en/performance#tf32). All you need to do is to add this before your inference:
-
-```python
-import torch
-
-torch.backends.cuda.matmul.allow_tf32 = True
-```
-
-## Half precision weights
-
-To save more GPU memory and get more speed, you can load and run the model weights directly in half precision. This involves loading the float16 version of the weights, which was saved to a branch named `fp16`, and telling PyTorch to use the `float16` type when loading them:
-
-```Python
-import torch
-from diffusers import DiffusionPipeline
-
-pipe = DiffusionPipeline.from_pretrained(
-    "runwayml/stable-diffusion-v1-5",
-    torch_dtype=torch.float16,
-)
-pipe = pipe.to("cuda")
-
-prompt = "a photo of an astronaut riding a horse on mars"
-image = pipe(prompt).images[0]
-```
-
-<Tip warning={true}>
-
-  It is strongly discouraged to make use of [`torch.autocast`](https://pytorch.org/docs/stable/amp.html#torch.autocast) in any of the pipelines as it can lead to black images and is always slower than using pure 
-  float16 precision.
-  
-</Tip>
-
-## Sliced attention for additional memory savings
-
-For even additional memory savings, you can use a sliced version of attention that performs the computation in steps instead of all at once.
-
-<Tip>
-  Attention slicing is useful even if a batch size of just 1 is used - as long
-  as the model uses more than one attention head. If there is more than one
-  attention head the *QK^T* attention matrix can be computed sequentially for
-  each head which can save a significant amount of memory.
-</Tip>
-
-To perform the attention computation sequentially over each head, you only need to invoke [`~DiffusionPipeline.enable_attention_slicing`] in your pipeline before inference, like here:
-
-```Python
-import torch
-from diffusers import DiffusionPipeline
-
-pipe = DiffusionPipeline.from_pretrained(
-    "runwayml/stable-diffusion-v1-5",
-    torch_dtype=torch.float16,
-)
-pipe = pipe.to("cuda")
-
-prompt = "a photo of an astronaut riding a horse on mars"
-pipe.enable_attention_slicing()
-image = pipe(prompt).images[0]
-```
-
-There's a small performance penalty of about 10% slower inference times, but this method allows you to use Stable Diffusion in as little as 3.2 GB of VRAM!
-
-
-## Sliced VAE decode for larger batches
-
-To decode large batches of images with limited VRAM, or to enable batches with 32 images or more, you can use sliced VAE decode that decodes the batch latents one image at a time.
-
-You likely want to couple this with [`~StableDiffusionPipeline.enable_attention_slicing`] or [`~StableDiffusionPipeline.enable_xformers_memory_efficient_attention`] to further minimize memory use.
-
-To perform the VAE decode one image at a time, invoke [`~StableDiffusionPipeline.enable_vae_slicing`] in your pipeline before inference. For example:
-
-```Python
-import torch
-from diffusers import StableDiffusionPipeline
-
-pipe = StableDiffusionPipeline.from_pretrained(
-    "runwayml/stable-diffusion-v1-5",
-    torch_dtype=torch.float16,
-)
-pipe = pipe.to("cuda")
-
-prompt = "a photo of an astronaut riding a horse on mars"
-pipe.enable_vae_slicing()
-images = pipe([prompt] * 32).images
-```
-
-You may see a small performance boost in VAE decode on multi-image batches. There should be no performance impact on single-image batches.
-
-
-## Tiled VAE decode and encode for large images
-
-Tiled VAE processing makes it possible to work with large images on limited VRAM. For example, generating 4k images in 8GB of VRAM. Tiled VAE decoder splits the image into overlapping tiles, decodes the tiles, and blends the outputs to make the final image.
-
-You want to couple this with [`~StableDiffusionPipeline.enable_attention_slicing`] or [`~StableDiffusionPipeline.enable_xformers_memory_efficient_attention`] to further minimize memory use.
-
-To use tiled VAE processing, invoke [`~StableDiffusionPipeline.enable_vae_tiling`] in your pipeline before inference. For example:
-
-```python
-import torch
-from diffusers import StableDiffusionPipeline, UniPCMultistepScheduler
-
-pipe = StableDiffusionPipeline.from_pretrained(
-    "runwayml/stable-diffusion-v1-5",
-    torch_dtype=torch.float16,
-)
-pipe.scheduler = UniPCMultistepScheduler.from_config(pipe.scheduler.config)
-pipe = pipe.to("cuda")
-prompt = "a beautiful landscape photograph"
-pipe.enable_vae_tiling()
-pipe.enable_xformers_memory_efficient_attention()
-
-image = pipe([prompt], width=3840, height=2224, num_inference_steps=20).images[0]
-```
-
-The output image will have some tile-to-tile tone variation from the tiles having separate decoders, but you shouldn't see sharp seams between the tiles. The tiling is turned off for images that are 512x512 or smaller.
-
-
-<a name="sequential_offloading"></a>
-## Offloading to CPU with accelerate for memory savings
-
-For additional memory savings, you can offload the weights to CPU and only load them to GPU when performing the forward pass.
-
-To perform CPU offloading, all you have to do is invoke [`~StableDiffusionPipeline.enable_sequential_cpu_offload`]:
-
-```Python
-import torch
-from diffusers import StableDiffusionPipeline
-
-pipe = StableDiffusionPipeline.from_pretrained(
-    "runwayml/stable-diffusion-v1-5",
-    torch_dtype=torch.float16,
-)
-
-prompt = "a photo of an astronaut riding a horse on mars"
-pipe.enable_sequential_cpu_offload()
-image = pipe(prompt).images[0]
-```
-
-And you can get the memory consumption to < 3GB.
-
-Note that this method works at the submodule level, not on whole models. This is the best way to minimize memory consumption, but inference is much slower due to the iterative nature of the process. The UNet component of the pipeline runs several times (as many as `num_inference_steps`); each time, the different submodules of the UNet are sequentially onloaded and then offloaded as they are needed, so the number of memory transfers is large.
-
-<Tip>
-Consider using <a href="#model_offloading">model offloading</a> as another point in the optimization space: it will be much faster, but memory savings won't be as large.
-</Tip>
-
-It is also possible to chain offloading with attention slicing for minimal memory consumption (< 2GB).
-
-```Python
-import torch
-from diffusers import StableDiffusionPipeline
-
-pipe = StableDiffusionPipeline.from_pretrained(
-    "runwayml/stable-diffusion-v1-5",
-    torch_dtype=torch.float16,
-)
-
-prompt = "a photo of an astronaut riding a horse on mars"
-pipe.enable_sequential_cpu_offload()
-pipe.enable_attention_slicing(1)
-
-image = pipe(prompt).images[0]
-```
-
-**Note**: When using `enable_sequential_cpu_offload()`, it is important to **not** move the pipeline to CUDA beforehand or else the gain in memory consumption will only be minimal. See [this issue](https://github.com/huggingface/diffusers/issues/1934) for more information.
-
-**Note**: `enable_sequential_cpu_offload()` is a stateful operation that installs hooks on the models.
-
-
-<a name="model_offloading"></a>
-## Model offloading for fast inference and memory savings
-
-[Sequential CPU offloading](#sequential_offloading), as discussed in the previous section, preserves a lot of memory but makes inference slower, because submodules are moved to GPU as needed, and immediately returned to CPU when a new module runs.
-
-Full-model offloading is an alternative that moves whole models to the GPU, instead of handling each model's constituent _modules_. This results in a negligible impact on inference time (compared with moving the pipeline to `cuda`), while still providing some memory savings.
-
-In this scenario, only one of the main components of the pipeline (typically: text encoder, unet and vae)
-will be in the GPU while the others wait in the CPU. Components like the UNet that run for multiple iterations will stay on GPU until they are no longer needed.
-
-This feature can be enabled by invoking `enable_model_cpu_offload()` on the pipeline, as shown below.
-
-```Python
-import torch
-from diffusers import StableDiffusionPipeline
-
-pipe = StableDiffusionPipeline.from_pretrained(
-    "runwayml/stable-diffusion-v1-5",  
-    torch_dtype=torch.float16,
-)
-
-prompt = "a photo of an astronaut riding a horse on mars"
-pipe.enable_model_cpu_offload()
-image = pipe(prompt).images[0]
-```
-
-This is also compatible with attention slicing for additional memory savings.
-
-```Python
-import torch
-from diffusers import StableDiffusionPipeline
-
-pipe = StableDiffusionPipeline.from_pretrained(
-    "runwayml/stable-diffusion-v1-5",
-    torch_dtype=torch.float16,
-)
-
-prompt = "a photo of an astronaut riding a horse on mars"
-pipe.enable_model_cpu_offload()
-pipe.enable_attention_slicing(1)
-
-image = pipe(prompt).images[0]
-```
-
-<Tip>
-This feature requires `accelerate` version 0.17.0 or larger.
-</Tip>
-
-**Note**: `enable_model_cpu_offload()` is a stateful operation that installs hooks on the models and state on the pipeline. In order to properly offload
-models after they are called, it is required that the entire pipeline is run and models are called in the order the pipeline expects them to be. Exercise caution
-if models are re-used outside the context of the pipeline after hooks have been installed. See [accelerate](https://huggingface.co/docs/accelerate/v0.18.0/en/package_reference/big_modeling#accelerate.hooks.remove_hook_from_module)
-for further docs on removing hooks.
-
-## Using Channels Last memory format
-
-Channels last memory format is an alternative way of ordering NCHW tensors in memory preserving dimensions ordering. Channels last tensors ordered in such a way that channels become the densest dimension (aka storing images pixel-per-pixel). Since not all operators currently support channels last format it may result in a worst performance, so it's better to try it and see if it works for your model.
-
-For example, in order to set the UNet model in our pipeline to use channels last format, we can use the following:
-
-```python
-print(pipe.unet.conv_out.state_dict()["weight"].stride())  # (2880, 9, 3, 1)
-pipe.unet.to(memory_format=torch.channels_last)  # in-place operation
-print(
-    pipe.unet.conv_out.state_dict()["weight"].stride()
-)  # (2880, 1, 960, 320) having a stride of 1 for the 2nd dimension proves that it works
-```
-
-## Tracing
-
-Tracing runs an example input tensor through your model, and captures the operations that are invoked as that input makes its way through the model's layers so that an executable or `ScriptFunction` is returned that will be optimized using just-in-time compilation.
-
-To trace our UNet model, we can use the following:
-
-```python
-import time
-import torch
-from diffusers import StableDiffusionPipeline
-import functools
-
-# torch disable grad
-torch.set_grad_enabled(False)
-
-# set variables
-n_experiments = 2
-unet_runs_per_experiment = 50
-
-
-# load inputs
-def generate_inputs():
-    sample = torch.randn(2, 4, 64, 64).half().cuda()
-    timestep = torch.rand(1).half().cuda() * 999
-    encoder_hidden_states = torch.randn(2, 77, 768).half().cuda()
-    return sample, timestep, encoder_hidden_states
-
-
-pipe = StableDiffusionPipeline.from_pretrained(
-    "runwayml/stable-diffusion-v1-5",
-    torch_dtype=torch.float16,
-).to("cuda")
-unet = pipe.unet
-unet.eval()
-unet.to(memory_format=torch.channels_last)  # use channels_last memory format
-unet.forward = functools.partial(unet.forward, return_dict=False)  # set return_dict=False as default
-
-# warmup
-for _ in range(3):
-    with torch.inference_mode():
-        inputs = generate_inputs()
-        orig_output = unet(*inputs)
-
-# trace
-print("tracing..")
-unet_traced = torch.jit.trace(unet, inputs)
-unet_traced.eval()
-print("done tracing")
-
-
-# warmup and optimize graph
-for _ in range(5):
-    with torch.inference_mode():
-        inputs = generate_inputs()
-        orig_output = unet_traced(*inputs)
-
-
-# benchmarking
-with torch.inference_mode():
-    for _ in range(n_experiments):
-        torch.cuda.synchronize()
-        start_time = time.time()
-        for _ in range(unet_runs_per_experiment):
-            orig_output = unet_traced(*inputs)
-        torch.cuda.synchronize()
-        print(f"unet traced inference took {time.time() - start_time:.2f} seconds")
-    for _ in range(n_experiments):
-        torch.cuda.synchronize()
-        start_time = time.time()
-        for _ in range(unet_runs_per_experiment):
-            orig_output = unet(*inputs)
-        torch.cuda.synchronize()
-        print(f"unet inference took {time.time() - start_time:.2f} seconds")
-
-# save the model
-unet_traced.save("unet_traced.pt")
-```
-
-Then we can replace the `unet` attribute of the pipeline with the traced model like the following
-
-```python
-from diffusers import StableDiffusionPipeline
-import torch
-from dataclasses import dataclass
-
-
-@dataclass
-class UNet2DConditionOutput:
-    sample: torch.FloatTensor
-
-
-pipe = StableDiffusionPipeline.from_pretrained(
-    "runwayml/stable-diffusion-v1-5",
-    torch_dtype=torch.float16,
-).to("cuda")
-
-# use jitted unet
-unet_traced = torch.jit.load("unet_traced.pt")
-
-
-# del pipe.unet
-class TracedUNet(torch.nn.Module):
-    def __init__(self):
-        super().__init__()
-        self.in_channels = pipe.unet.in_channels
-        self.device = pipe.unet.device
-
-    def forward(self, latent_model_input, t, encoder_hidden_states):
-        sample = unet_traced(latent_model_input, t, encoder_hidden_states)[0]
-        return UNet2DConditionOutput(sample=sample)
-
-
-pipe.unet = TracedUNet()
-
-with torch.inference_mode():
-    image = pipe([prompt] * 1, num_inference_steps=50).images[0]
-```
-
-
-## Memory Efficient Attention
-
-Recent work on optimizing the bandwitdh in the attention block has generated huge speed ups and gains in GPU memory usage. The most recent being Flash Attention from @tridao: [code](https://github.com/HazyResearch/flash-attention), [paper](https://arxiv.org/pdf/2205.14135.pdf).
-
-Here are the speedups we obtain on a few Nvidia GPUs when running the inference at 512x512 with a batch size of 1 (one prompt):
-
-| GPU              	| Base Attention FP16 	| Memory Efficient Attention FP16 	|
-|------------------	|---------------------	|---------------------------------	|
-| NVIDIA Tesla T4  	| 3.5it/s             	| 5.5it/s                         	|
-| NVIDIA 3060 RTX  	| 4.6it/s             	| 7.8it/s                         	|
-| NVIDIA A10G      	| 8.88it/s            	| 15.6it/s                        	|
-| NVIDIA RTX A6000 	| 11.7it/s            	| 21.09it/s                       	|
-| NVIDIA TITAN RTX  | 12.51it/s         	| 18.22it/s                       	|
-| A100-SXM4-40GB    	| 18.6it/s            	| 29.it/s                        	|
-| A100-SXM-80GB    	| 18.7it/s            	| 29.5it/s                        	|
-
-To leverage it just make sure you have:
-
-<Tip warning={true}>
-
-If you have PyTorch 2.0 installed, you shouldn't use xFormers!
-
-</Tip>
-
- - PyTorch > 1.12
- - Cuda available
- - [Installed the xformers library](xformers).
-```python
-from diffusers import DiffusionPipeline
-import torch
-
-pipe = DiffusionPipeline.from_pretrained(
-    "runwayml/stable-diffusion-v1-5",
-    torch_dtype=torch.float16,
-).to("cuda")
-
-pipe.enable_xformers_memory_efficient_attention()
-
-with torch.inference_mode():
-    sample = pipe("a small cat")
-
-# optional: You can disable it via
-# pipe.disable_xformers_memory_efficient_attention()
-```

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

@@ -1,4 +0,0 @@
-_base_ = [
-    '../_base_/models/ccnet_r50-d8.py', '../_base_/datasets/cityscapes.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
-]

spaces/Andy1621/uniformer_light/imagenet_class_index.py

@@ -1,1002 +0,0 @@
-imagenet_classnames = {
-    "0": ["n01440764", "tench"], 
-    "1": ["n01443537", "goldfish"], 
-    "2": ["n01484850", "great_white_shark"], 
-    "3": ["n01491361", "tiger_shark"], 
-    "4": ["n01494475", "hammerhead"], 
-    "5": ["n01496331", "electric_ray"], 
-    "6": ["n01498041", "stingray"], 
-    "7": ["n01514668", "cock"], 
-    "8": ["n01514859", "hen"], 
-    "9": ["n01518878", "ostrich"], 
-    "10": ["n01530575", "brambling"], 
-    "11": ["n01531178", "goldfinch"], 
-    "12": ["n01532829", "house_finch"], 
-    "13": ["n01534433", "junco"], 
-    "14": ["n01537544", "indigo_bunting"], 
-    "15": ["n01558993", "robin"], 
-    "16": ["n01560419", "bulbul"], 
-    "17": ["n01580077", "jay"], 
-    "18": ["n01582220", "magpie"], 
-    "19": ["n01592084", "chickadee"], 
-    "20": ["n01601694", "water_ouzel"], 
-    "21": ["n01608432", "kite"], 
-    "22": ["n01614925", "bald_eagle"], 
-    "23": ["n01616318", "vulture"], 
-    "24": ["n01622779", "great_grey_owl"], 
-    "25": ["n01629819", "European_fire_salamander"], 
-    "26": ["n01630670", "common_newt"], 
-    "27": ["n01631663", "eft"], 
-    "28": ["n01632458", "spotted_salamander"], 
-    "29": ["n01632777", "axolotl"], 
-    "30": ["n01641577", "bullfrog"], 
-    "31": ["n01644373", "tree_frog"], 
-    "32": ["n01644900", "tailed_frog"], 
-    "33": ["n01664065", "loggerhead"], 
-    "34": ["n01665541", "leatherback_turtle"], 
-    "35": ["n01667114", "mud_turtle"], 
-    "36": ["n01667778", "terrapin"], 
-    "37": ["n01669191", "box_turtle"], 
-    "38": ["n01675722", "banded_gecko"], 
-    "39": ["n01677366", "common_iguana"], 
-    "40": ["n01682714", "American_chameleon"], 
-    "41": ["n01685808", "whiptail"], 
-    "42": ["n01687978", "agama"], 
-    "43": ["n01688243", "frilled_lizard"], 
-    "44": ["n01689811", "alligator_lizard"], 
-    "45": ["n01692333", "Gila_monster"], 
-    "46": ["n01693334", "green_lizard"], 
-    "47": ["n01694178", "African_chameleon"], 
-    "48": ["n01695060", "Komodo_dragon"], 
-    "49": ["n01697457", "African_crocodile"], 
-    "50": ["n01698640", "American_alligator"], 
-    "51": ["n01704323", "triceratops"], 
-    "52": ["n01728572", "thunder_snake"], 
-    "53": ["n01728920", "ringneck_snake"], 
-    "54": ["n01729322", "hognose_snake"], 
-    "55": ["n01729977", "green_snake"], 
-    "56": ["n01734418", "king_snake"], 
-    "57": ["n01735189", "garter_snake"], 
-    "58": ["n01737021", "water_snake"], 
-    "59": ["n01739381", "vine_snake"], 
-    "60": ["n01740131", "night_snake"], 
-    "61": ["n01742172", "boa_constrictor"], 
-    "62": ["n01744401", "rock_python"], 
-    "63": ["n01748264", "Indian_cobra"], 
-    "64": ["n01749939", "green_mamba"], 
-    "65": ["n01751748", "sea_snake"], 
-    "66": ["n01753488", "horned_viper"], 
-    "67": ["n01755581", "diamondback"], 
-    "68": ["n01756291", "sidewinder"], 
-    "69": ["n01768244", "trilobite"], 
-    "70": ["n01770081", "harvestman"], 
-    "71": ["n01770393", "scorpion"], 
-    "72": ["n01773157", "black_and_gold_garden_spider"], 
-    "73": ["n01773549", "barn_spider"], 
-    "74": ["n01773797", "garden_spider"], 
-    "75": ["n01774384", "black_widow"], 
-    "76": ["n01774750", "tarantula"], 
-    "77": ["n01775062", "wolf_spider"], 
-    "78": ["n01776313", "tick"], 
-    "79": ["n01784675", "centipede"], 
-    "80": ["n01795545", "black_grouse"], 
-    "81": ["n01796340", "ptarmigan"], 
-    "82": ["n01797886", "ruffed_grouse"], 
-    "83": ["n01798484", "prairie_chicken"], 
-    "84": ["n01806143", "peacock"], 
-    "85": ["n01806567", "quail"], 
-    "86": ["n01807496", "partridge"], 
-    "87": ["n01817953", "African_grey"], 
-    "88": ["n01818515", "macaw"], 
-    "89": ["n01819313", "sulphur-crested_cockatoo"], 
-    "90": ["n01820546", "lorikeet"], 
-    "91": ["n01824575", "coucal"], 
-    "92": ["n01828970", "bee_eater"], 
-    "93": ["n01829413", "hornbill"], 
-    "94": ["n01833805", "hummingbird"], 
-    "95": ["n01843065", "jacamar"], 
-    "96": ["n01843383", "toucan"], 
-    "97": ["n01847000", "drake"], 
-    "98": ["n01855032", "red-breasted_merganser"], 
-    "99": ["n01855672", "goose"], 
-    "100": ["n01860187", "black_swan"], 
-    "101": ["n01871265", "tusker"], 
-    "102": ["n01872401", "echidna"], 
-    "103": ["n01873310", "platypus"], 
-    "104": ["n01877812", "wallaby"], 
-    "105": ["n01882714", "koala"], 
-    "106": ["n01883070", "wombat"], 
-    "107": ["n01910747", "jellyfish"], 
-    "108": ["n01914609", "sea_anemone"], 
-    "109": ["n01917289", "brain_coral"], 
-    "110": ["n01924916", "flatworm"], 
-    "111": ["n01930112", "nematode"], 
-    "112": ["n01943899", "conch"], 
-    "113": ["n01944390", "snail"], 
-    "114": ["n01945685", "slug"], 
-    "115": ["n01950731", "sea_slug"], 
-    "116": ["n01955084", "chiton"], 
-    "117": ["n01968897", "chambered_nautilus"], 
-    "118": ["n01978287", "Dungeness_crab"], 
-    "119": ["n01978455", "rock_crab"], 
-    "120": ["n01980166", "fiddler_crab"], 
-    "121": ["n01981276", "king_crab"], 
-    "122": ["n01983481", "American_lobster"], 
-    "123": ["n01984695", "spiny_lobster"], 
-    "124": ["n01985128", "crayfish"], 
-    "125": ["n01986214", "hermit_crab"], 
-    "126": ["n01990800", "isopod"], 
-    "127": ["n02002556", "white_stork"], 
-    "128": ["n02002724", "black_stork"], 
-    "129": ["n02006656", "spoonbill"], 
-    "130": ["n02007558", "flamingo"], 
-    "131": ["n02009229", "little_blue_heron"], 
-    "132": ["n02009912", "American_egret"], 
-    "133": ["n02011460", "bittern"], 
-    "134": ["n02012849", "crane"], 
-    "135": ["n02013706", "limpkin"], 
-    "136": ["n02017213", "European_gallinule"], 
-    "137": ["n02018207", "American_coot"], 
-    "138": ["n02018795", "bustard"], 
-    "139": ["n02025239", "ruddy_turnstone"], 
-    "140": ["n02027492", "red-backed_sandpiper"], 
-    "141": ["n02028035", "redshank"], 
-    "142": ["n02033041", "dowitcher"], 
-    "143": ["n02037110", "oystercatcher"], 
-    "144": ["n02051845", "pelican"], 
-    "145": ["n02056570", "king_penguin"], 
-    "146": ["n02058221", "albatross"], 
-    "147": ["n02066245", "grey_whale"], 
-    "148": ["n02071294", "killer_whale"], 
-    "149": ["n02074367", "dugong"], 
-    "150": ["n02077923", "sea_lion"], 
-    "151": ["n02085620", "Chihuahua"], 
-    "152": ["n02085782", "Japanese_spaniel"], 
-    "153": ["n02085936", "Maltese_dog"], 
-    "154": ["n02086079", "Pekinese"], 
-    "155": ["n02086240", "Shih-Tzu"], 
-    "156": ["n02086646", "Blenheim_spaniel"], 
-    "157": ["n02086910", "papillon"], 
-    "158": ["n02087046", "toy_terrier"], 
-    "159": ["n02087394", "Rhodesian_ridgeback"], 
-    "160": ["n02088094", "Afghan_hound"], 
-    "161": ["n02088238", "basset"], 
-    "162": ["n02088364", "beagle"], 
-    "163": ["n02088466", "bloodhound"], 
-    "164": ["n02088632", "bluetick"], 
-    "165": ["n02089078", "black-and-tan_coonhound"], 
-    "166": ["n02089867", "Walker_hound"], 
-    "167": ["n02089973", "English_foxhound"], 
-    "168": ["n02090379", "redbone"], 
-    "169": ["n02090622", "borzoi"], 
-    "170": ["n02090721", "Irish_wolfhound"], 
-    "171": ["n02091032", "Italian_greyhound"], 
-    "172": ["n02091134", "whippet"], 
-    "173": ["n02091244", "Ibizan_hound"], 
-    "174": ["n02091467", "Norwegian_elkhound"], 
-    "175": ["n02091635", "otterhound"], 
-    "176": ["n02091831", "Saluki"], 
-    "177": ["n02092002", "Scottish_deerhound"], 
-    "178": ["n02092339", "Weimaraner"], 
-    "179": ["n02093256", "Staffordshire_bullterrier"], 
-    "180": ["n02093428", "American_Staffordshire_terrier"], 
-    "181": ["n02093647", "Bedlington_terrier"], 
-    "182": ["n02093754", "Border_terrier"], 
-    "183": ["n02093859", "Kerry_blue_terrier"], 
-    "184": ["n02093991", "Irish_terrier"], 
-    "185": ["n02094114", "Norfolk_terrier"], 
-    "186": ["n02094258", "Norwich_terrier"], 
-    "187": ["n02094433", "Yorkshire_terrier"], 
-    "188": ["n02095314", "wire-haired_fox_terrier"], 
-    "189": ["n02095570", "Lakeland_terrier"], 
-    "190": ["n02095889", "Sealyham_terrier"], 
-    "191": ["n02096051", "Airedale"], 
-    "192": ["n02096177", "cairn"], 
-    "193": ["n02096294", "Australian_terrier"], 
-    "194": ["n02096437", "Dandie_Dinmont"], 
-    "195": ["n02096585", "Boston_bull"], 
-    "196": ["n02097047", "miniature_schnauzer"], 
-    "197": ["n02097130", "giant_schnauzer"], 
-    "198": ["n02097209", "standard_schnauzer"], 
-    "199": ["n02097298", "Scotch_terrier"], 
-    "200": ["n02097474", "Tibetan_terrier"], 
-    "201": ["n02097658", "silky_terrier"], 
-    "202": ["n02098105", "soft-coated_wheaten_terrier"], 
-    "203": ["n02098286", "West_Highland_white_terrier"], 
-    "204": ["n02098413", "Lhasa"], 
-    "205": ["n02099267", "flat-coated_retriever"], 
-    "206": ["n02099429", "curly-coated_retriever"], 
-    "207": ["n02099601", "golden_retriever"], 
-    "208": ["n02099712", "Labrador_retriever"], 
-    "209": ["n02099849", "Chesapeake_Bay_retriever"], 
-    "210": ["n02100236", "German_short-haired_pointer"], 
-    "211": ["n02100583", "vizsla"], 
-    "212": ["n02100735", "English_setter"], 
-    "213": ["n02100877", "Irish_setter"], 
-    "214": ["n02101006", "Gordon_setter"], 
-    "215": ["n02101388", "Brittany_spaniel"], 
-    "216": ["n02101556", "clumber"], 
-    "217": ["n02102040", "English_springer"], 
-    "218": ["n02102177", "Welsh_springer_spaniel"], 
-    "219": ["n02102318", "cocker_spaniel"], 
-    "220": ["n02102480", "Sussex_spaniel"], 
-    "221": ["n02102973", "Irish_water_spaniel"], 
-    "222": ["n02104029", "kuvasz"], 
-    "223": ["n02104365", "schipperke"], 
-    "224": ["n02105056", "groenendael"], 
-    "225": ["n02105162", "malinois"], 
-    "226": ["n02105251", "briard"], 
-    "227": ["n02105412", "kelpie"], 
-    "228": ["n02105505", "komondor"], 
-    "229": ["n02105641", "Old_English_sheepdog"], 
-    "230": ["n02105855", "Shetland_sheepdog"], 
-    "231": ["n02106030", "collie"], 
-    "232": ["n02106166", "Border_collie"], 
-    "233": ["n02106382", "Bouvier_des_Flandres"], 
-    "234": ["n02106550", "Rottweiler"], 
-    "235": ["n02106662", "German_shepherd"], 
-    "236": ["n02107142", "Doberman"], 
-    "237": ["n02107312", "miniature_pinscher"], 
-    "238": ["n02107574", "Greater_Swiss_Mountain_dog"], 
-    "239": ["n02107683", "Bernese_mountain_dog"], 
-    "240": ["n02107908", "Appenzeller"], 
-    "241": ["n02108000", "EntleBucher"], 
-    "242": ["n02108089", "boxer"], 
-    "243": ["n02108422", "bull_mastiff"], 
-    "244": ["n02108551", "Tibetan_mastiff"], 
-    "245": ["n02108915", "French_bulldog"], 
-    "246": ["n02109047", "Great_Dane"], 
-    "247": ["n02109525", "Saint_Bernard"], 
-    "248": ["n02109961", "Eskimo_dog"], 
-    "249": ["n02110063", "malamute"], 
-    "250": ["n02110185", "Siberian_husky"], 
-    "251": ["n02110341", "dalmatian"], 
-    "252": ["n02110627", "affenpinscher"], 
-    "253": ["n02110806", "basenji"], 
-    "254": ["n02110958", "pug"], 
-    "255": ["n02111129", "Leonberg"], 
-    "256": ["n02111277", "Newfoundland"], 
-    "257": ["n02111500", "Great_Pyrenees"], 
-    "258": ["n02111889", "Samoyed"], 
-    "259": ["n02112018", "Pomeranian"], 
-    "260": ["n02112137", "chow"], 
-    "261": ["n02112350", "keeshond"], 
-    "262": ["n02112706", "Brabancon_griffon"], 
-    "263": ["n02113023", "Pembroke"], 
-    "264": ["n02113186", "Cardigan"], 
-    "265": ["n02113624", "toy_poodle"], 
-    "266": ["n02113712", "miniature_poodle"], 
-    "267": ["n02113799", "standard_poodle"], 
-    "268": ["n02113978", "Mexican_hairless"], 
-    "269": ["n02114367", "timber_wolf"], 
-    "270": ["n02114548", "white_wolf"], 
-    "271": ["n02114712", "red_wolf"], 
-    "272": ["n02114855", "coyote"], 
-    "273": ["n02115641", "dingo"], 
-    "274": ["n02115913", "dhole"], 
-    "275": ["n02116738", "African_hunting_dog"], 
-    "276": ["n02117135", "hyena"], 
-    "277": ["n02119022", "red_fox"], 
-    "278": ["n02119789", "kit_fox"], 
-    "279": ["n02120079", "Arctic_fox"], 
-    "280": ["n02120505", "grey_fox"], 
-    "281": ["n02123045", "tabby"], 
-    "282": ["n02123159", "tiger_cat"], 
-    "283": ["n02123394", "Persian_cat"], 
-    "284": ["n02123597", "Siamese_cat"], 
-    "285": ["n02124075", "Egyptian_cat"], 
-    "286": ["n02125311", "cougar"], 
-    "287": ["n02127052", "lynx"], 
-    "288": ["n02128385", "leopard"], 
-    "289": ["n02128757", "snow_leopard"], 
-    "290": ["n02128925", "jaguar"], 
-    "291": ["n02129165", "lion"], 
-    "292": ["n02129604", "tiger"], 
-    "293": ["n02130308", "cheetah"], 
-    "294": ["n02132136", "brown_bear"], 
-    "295": ["n02133161", "American_black_bear"], 
-    "296": ["n02134084", "ice_bear"], 
-    "297": ["n02134418", "sloth_bear"], 
-    "298": ["n02137549", "mongoose"], 
-    "299": ["n02138441", "meerkat"], 
-    "300": ["n02165105", "tiger_beetle"], 
-    "301": ["n02165456", "ladybug"], 
-    "302": ["n02167151", "ground_beetle"], 
-    "303": ["n02168699", "long-horned_beetle"], 
-    "304": ["n02169497", "leaf_beetle"], 
-    "305": ["n02172182", "dung_beetle"], 
-    "306": ["n02174001", "rhinoceros_beetle"], 
-    "307": ["n02177972", "weevil"], 
-    "308": ["n02190166", "fly"], 
-    "309": ["n02206856", "bee"], 
-    "310": ["n02219486", "ant"], 
-    "311": ["n02226429", "grasshopper"], 
-    "312": ["n02229544", "cricket"], 
-    "313": ["n02231487", "walking_stick"], 
-    "314": ["n02233338", "cockroach"], 
-    "315": ["n02236044", "mantis"], 
-    "316": ["n02256656", "cicada"], 
-    "317": ["n02259212", "leafhopper"], 
-    "318": ["n02264363", "lacewing"], 
-    "319": ["n02268443", "dragonfly"], 
-    "320": ["n02268853", "damselfly"], 
-    "321": ["n02276258", "admiral"], 
-    "322": ["n02277742", "ringlet"], 
-    "323": ["n02279972", "monarch"], 
-    "324": ["n02280649", "cabbage_butterfly"], 
-    "325": ["n02281406", "sulphur_butterfly"], 
-    "326": ["n02281787", "lycaenid"], 
-    "327": ["n02317335", "starfish"], 
-    "328": ["n02319095", "sea_urchin"], 
-    "329": ["n02321529", "sea_cucumber"], 
-    "330": ["n02325366", "wood_rabbit"], 
-    "331": ["n02326432", "hare"], 
-    "332": ["n02328150", "Angora"], 
-    "333": ["n02342885", "hamster"], 
-    "334": ["n02346627", "porcupine"], 
-    "335": ["n02356798", "fox_squirrel"], 
-    "336": ["n02361337", "marmot"], 
-    "337": ["n02363005", "beaver"], 
-    "338": ["n02364673", "guinea_pig"], 
-    "339": ["n02389026", "sorrel"], 
-    "340": ["n02391049", "zebra"], 
-    "341": ["n02395406", "hog"], 
-    "342": ["n02396427", "wild_boar"], 
-    "343": ["n02397096", "warthog"], 
-    "344": ["n02398521", "hippopotamus"], 
-    "345": ["n02403003", "ox"], 
-    "346": ["n02408429", "water_buffalo"], 
-    "347": ["n02410509", "bison"], 
-    "348": ["n02412080", "ram"], 
-    "349": ["n02415577", "bighorn"], 
-    "350": ["n02417914", "ibex"], 
-    "351": ["n02422106", "hartebeest"], 
-    "352": ["n02422699", "impala"], 
-    "353": ["n02423022", "gazelle"], 
-    "354": ["n02437312", "Arabian_camel"], 
-    "355": ["n02437616", "llama"], 
-    "356": ["n02441942", "weasel"], 
-    "357": ["n02442845", "mink"], 
-    "358": ["n02443114", "polecat"], 
-    "359": ["n02443484", "black-footed_ferret"], 
-    "360": ["n02444819", "otter"], 
-    "361": ["n02445715", "skunk"], 
-    "362": ["n02447366", "badger"], 
-    "363": ["n02454379", "armadillo"], 
-    "364": ["n02457408", "three-toed_sloth"], 
-    "365": ["n02480495", "orangutan"], 
-    "366": ["n02480855", "gorilla"], 
-    "367": ["n02481823", "chimpanzee"], 
-    "368": ["n02483362", "gibbon"], 
-    "369": ["n02483708", "siamang"], 
-    "370": ["n02484975", "guenon"], 
-    "371": ["n02486261", "patas"], 
-    "372": ["n02486410", "baboon"], 
-    "373": ["n02487347", "macaque"], 
-    "374": ["n02488291", "langur"], 
-    "375": ["n02488702", "colobus"], 
-    "376": ["n02489166", "proboscis_monkey"], 
-    "377": ["n02490219", "marmoset"], 
-    "378": ["n02492035", "capuchin"], 
-    "379": ["n02492660", "howler_monkey"], 
-    "380": ["n02493509", "titi"], 
-    "381": ["n02493793", "spider_monkey"], 
-    "382": ["n02494079", "squirrel_monkey"], 
-    "383": ["n02497673", "Madagascar_cat"], 
-    "384": ["n02500267", "indri"], 
-    "385": ["n02504013", "Indian_elephant"], 
-    "386": ["n02504458", "African_elephant"], 
-    "387": ["n02509815", "lesser_panda"], 
-    "388": ["n02510455", "giant_panda"], 
-    "389": ["n02514041", "barracouta"], 
-    "390": ["n02526121", "eel"], 
-    "391": ["n02536864", "coho"], 
-    "392": ["n02606052", "rock_beauty"], 
-    "393": ["n02607072", "anemone_fish"], 
-    "394": ["n02640242", "sturgeon"], 
-    "395": ["n02641379", "gar"], 
-    "396": ["n02643566", "lionfish"], 
-    "397": ["n02655020", "puffer"], 
-    "398": ["n02666196", "abacus"], 
-    "399": ["n02667093", "abaya"], 
-    "400": ["n02669723", "academic_gown"], 
-    "401": ["n02672831", "accordion"], 
-    "402": ["n02676566", "acoustic_guitar"], 
-    "403": ["n02687172", "aircraft_carrier"], 
-    "404": ["n02690373", "airliner"], 
-    "405": ["n02692877", "airship"], 
-    "406": ["n02699494", "altar"], 
-    "407": ["n02701002", "ambulance"], 
-    "408": ["n02704792", "amphibian"], 
-    "409": ["n02708093", "analog_clock"], 
-    "410": ["n02727426", "apiary"], 
-    "411": ["n02730930", "apron"], 
-    "412": ["n02747177", "ashcan"], 
-    "413": ["n02749479", "assault_rifle"], 
-    "414": ["n02769748", "backpack"], 
-    "415": ["n02776631", "bakery"], 
-    "416": ["n02777292", "balance_beam"], 
-    "417": ["n02782093", "balloon"], 
-    "418": ["n02783161", "ballpoint"], 
-    "419": ["n02786058", "Band_Aid"], 
-    "420": ["n02787622", "banjo"], 
-    "421": ["n02788148", "bannister"], 
-    "422": ["n02790996", "barbell"], 
-    "423": ["n02791124", "barber_chair"], 
-    "424": ["n02791270", "barbershop"], 
-    "425": ["n02793495", "barn"], 
-    "426": ["n02794156", "barometer"], 
-    "427": ["n02795169", "barrel"], 
-    "428": ["n02797295", "barrow"], 
-    "429": ["n02799071", "baseball"], 
-    "430": ["n02802426", "basketball"], 
-    "431": ["n02804414", "bassinet"], 
-    "432": ["n02804610", "bassoon"], 
-    "433": ["n02807133", "bathing_cap"], 
-    "434": ["n02808304", "bath_towel"], 
-    "435": ["n02808440", "bathtub"], 
-    "436": ["n02814533", "beach_wagon"], 
-    "437": ["n02814860", "beacon"], 
-    "438": ["n02815834", "beaker"], 
-    "439": ["n02817516", "bearskin"], 
-    "440": ["n02823428", "beer_bottle"], 
-    "441": ["n02823750", "beer_glass"], 
-    "442": ["n02825657", "bell_cote"], 
-    "443": ["n02834397", "bib"], 
-    "444": ["n02835271", "bicycle-built-for-two"], 
-    "445": ["n02837789", "bikini"], 
-    "446": ["n02840245", "binder"], 
-    "447": ["n02841315", "binoculars"], 
-    "448": ["n02843684", "birdhouse"], 
-    "449": ["n02859443", "boathouse"], 
-    "450": ["n02860847", "bobsled"], 
-    "451": ["n02865351", "bolo_tie"], 
-    "452": ["n02869837", "bonnet"], 
-    "453": ["n02870880", "bookcase"], 
-    "454": ["n02871525", "bookshop"], 
-    "455": ["n02877765", "bottlecap"], 
-    "456": ["n02879718", "bow"], 
-    "457": ["n02883205", "bow_tie"], 
-    "458": ["n02892201", "brass"], 
-    "459": ["n02892767", "brassiere"], 
-    "460": ["n02894605", "breakwater"], 
-    "461": ["n02895154", "breastplate"], 
-    "462": ["n02906734", "broom"], 
-    "463": ["n02909870", "bucket"], 
-    "464": ["n02910353", "buckle"], 
-    "465": ["n02916936", "bulletproof_vest"], 
-    "466": ["n02917067", "bullet_train"], 
-    "467": ["n02927161", "butcher_shop"], 
-    "468": ["n02930766", "cab"], 
-    "469": ["n02939185", "caldron"], 
-    "470": ["n02948072", "candle"], 
-    "471": ["n02950826", "cannon"], 
-    "472": ["n02951358", "canoe"], 
-    "473": ["n02951585", "can_opener"], 
-    "474": ["n02963159", "cardigan"], 
-    "475": ["n02965783", "car_mirror"], 
-    "476": ["n02966193", "carousel"], 
-    "477": ["n02966687", "carpenter's_kit"], 
-    "478": ["n02971356", "carton"], 
-    "479": ["n02974003", "car_wheel"], 
-    "480": ["n02977058", "cash_machine"], 
-    "481": ["n02978881", "cassette"], 
-    "482": ["n02979186", "cassette_player"], 
-    "483": ["n02980441", "castle"], 
-    "484": ["n02981792", "catamaran"], 
-    "485": ["n02988304", "CD_player"], 
-    "486": ["n02992211", "cello"], 
-    "487": ["n02992529", "cellular_telephone"], 
-    "488": ["n02999410", "chain"], 
-    "489": ["n03000134", "chainlink_fence"], 
-    "490": ["n03000247", "chain_mail"], 
-    "491": ["n03000684", "chain_saw"], 
-    "492": ["n03014705", "chest"], 
-    "493": ["n03016953", "chiffonier"], 
-    "494": ["n03017168", "chime"], 
-    "495": ["n03018349", "china_cabinet"], 
-    "496": ["n03026506", "Christmas_stocking"], 
-    "497": ["n03028079", "church"], 
-    "498": ["n03032252", "cinema"], 
-    "499": ["n03041632", "cleaver"], 
-    "500": ["n03042490", "cliff_dwelling"], 
-    "501": ["n03045698", "cloak"], 
-    "502": ["n03047690", "clog"], 
-    "503": ["n03062245", "cocktail_shaker"], 
-    "504": ["n03063599", "coffee_mug"], 
-    "505": ["n03063689", "coffeepot"], 
-    "506": ["n03065424", "coil"], 
-    "507": ["n03075370", "combination_lock"], 
-    "508": ["n03085013", "computer_keyboard"], 
-    "509": ["n03089624", "confectionery"], 
-    "510": ["n03095699", "container_ship"], 
-    "511": ["n03100240", "convertible"], 
-    "512": ["n03109150", "corkscrew"], 
-    "513": ["n03110669", "cornet"], 
-    "514": ["n03124043", "cowboy_boot"], 
-    "515": ["n03124170", "cowboy_hat"], 
-    "516": ["n03125729", "cradle"], 
-    "517": ["n03126707", "crane"], 
-    "518": ["n03127747", "crash_helmet"], 
-    "519": ["n03127925", "crate"], 
-    "520": ["n03131574", "crib"], 
-    "521": ["n03133878", "Crock_Pot"], 
-    "522": ["n03134739", "croquet_ball"], 
-    "523": ["n03141823", "crutch"], 
-    "524": ["n03146219", "cuirass"], 
-    "525": ["n03160309", "dam"], 
-    "526": ["n03179701", "desk"], 
-    "527": ["n03180011", "desktop_computer"], 
-    "528": ["n03187595", "dial_telephone"], 
-    "529": ["n03188531", "diaper"], 
-    "530": ["n03196217", "digital_clock"], 
-    "531": ["n03197337", "digital_watch"], 
-    "532": ["n03201208", "dining_table"], 
-    "533": ["n03207743", "dishrag"], 
-    "534": ["n03207941", "dishwasher"], 
-    "535": ["n03208938", "disk_brake"], 
-    "536": ["n03216828", "dock"], 
-    "537": ["n03218198", "dogsled"], 
-    "538": ["n03220513", "dome"], 
-    "539": ["n03223299", "doormat"], 
-    "540": ["n03240683", "drilling_platform"], 
-    "541": ["n03249569", "drum"], 
-    "542": ["n03250847", "drumstick"], 
-    "543": ["n03255030", "dumbbell"], 
-    "544": ["n03259280", "Dutch_oven"], 
-    "545": ["n03271574", "electric_fan"], 
-    "546": ["n03272010", "electric_guitar"], 
-    "547": ["n03272562", "electric_locomotive"], 
-    "548": ["n03290653", "entertainment_center"], 
-    "549": ["n03291819", "envelope"], 
-    "550": ["n03297495", "espresso_maker"], 
-    "551": ["n03314780", "face_powder"], 
-    "552": ["n03325584", "feather_boa"], 
-    "553": ["n03337140", "file"], 
-    "554": ["n03344393", "fireboat"], 
-    "555": ["n03345487", "fire_engine"], 
-    "556": ["n03347037", "fire_screen"], 
-    "557": ["n03355925", "flagpole"], 
-    "558": ["n03372029", "flute"], 
-    "559": ["n03376595", "folding_chair"], 
-    "560": ["n03379051", "football_helmet"], 
-    "561": ["n03384352", "forklift"], 
-    "562": ["n03388043", "fountain"], 
-    "563": ["n03388183", "fountain_pen"], 
-    "564": ["n03388549", "four-poster"], 
-    "565": ["n03393912", "freight_car"], 
-    "566": ["n03394916", "French_horn"], 
-    "567": ["n03400231", "frying_pan"], 
-    "568": ["n03404251", "fur_coat"], 
-    "569": ["n03417042", "garbage_truck"], 
-    "570": ["n03424325", "gasmask"], 
-    "571": ["n03425413", "gas_pump"], 
-    "572": ["n03443371", "goblet"], 
-    "573": ["n03444034", "go-kart"], 
-    "574": ["n03445777", "golf_ball"], 
-    "575": ["n03445924", "golfcart"], 
-    "576": ["n03447447", "gondola"], 
-    "577": ["n03447721", "gong"], 
-    "578": ["n03450230", "gown"], 
-    "579": ["n03452741", "grand_piano"], 
-    "580": ["n03457902", "greenhouse"], 
-    "581": ["n03459775", "grille"], 
-    "582": ["n03461385", "grocery_store"], 
-    "583": ["n03467068", "guillotine"], 
-    "584": ["n03476684", "hair_slide"], 
-    "585": ["n03476991", "hair_spray"], 
-    "586": ["n03478589", "half_track"], 
-    "587": ["n03481172", "hammer"], 
-    "588": ["n03482405", "hamper"], 
-    "589": ["n03483316", "hand_blower"], 
-    "590": ["n03485407", "hand-held_computer"], 
-    "591": ["n03485794", "handkerchief"], 
-    "592": ["n03492542", "hard_disc"], 
-    "593": ["n03494278", "harmonica"], 
-    "594": ["n03495258", "harp"], 
-    "595": ["n03496892", "harvester"], 
-    "596": ["n03498962", "hatchet"], 
-    "597": ["n03527444", "holster"], 
-    "598": ["n03529860", "home_theater"], 
-    "599": ["n03530642", "honeycomb"], 
-    "600": ["n03532672", "hook"], 
-    "601": ["n03534580", "hoopskirt"], 
-    "602": ["n03535780", "horizontal_bar"], 
-    "603": ["n03538406", "horse_cart"], 
-    "604": ["n03544143", "hourglass"], 
-    "605": ["n03584254", "iPod"], 
-    "606": ["n03584829", "iron"], 
-    "607": ["n03590841", "jack-o'-lantern"], 
-    "608": ["n03594734", "jean"], 
-    "609": ["n03594945", "jeep"], 
-    "610": ["n03595614", "jersey"], 
-    "611": ["n03598930", "jigsaw_puzzle"], 
-    "612": ["n03599486", "jinrikisha"], 
-    "613": ["n03602883", "joystick"], 
-    "614": ["n03617480", "kimono"], 
-    "615": ["n03623198", "knee_pad"], 
-    "616": ["n03627232", "knot"], 
-    "617": ["n03630383", "lab_coat"], 
-    "618": ["n03633091", "ladle"], 
-    "619": ["n03637318", "lampshade"], 
-    "620": ["n03642806", "laptop"], 
-    "621": ["n03649909", "lawn_mower"], 
-    "622": ["n03657121", "lens_cap"], 
-    "623": ["n03658185", "letter_opener"], 
-    "624": ["n03661043", "library"], 
-    "625": ["n03662601", "lifeboat"], 
-    "626": ["n03666591", "lighter"], 
-    "627": ["n03670208", "limousine"], 
-    "628": ["n03673027", "liner"], 
-    "629": ["n03676483", "lipstick"], 
-    "630": ["n03680355", "Loafer"], 
-    "631": ["n03690938", "lotion"], 
-    "632": ["n03691459", "loudspeaker"], 
-    "633": ["n03692522", "loupe"], 
-    "634": ["n03697007", "lumbermill"], 
-    "635": ["n03706229", "magnetic_compass"], 
-    "636": ["n03709823", "mailbag"], 
-    "637": ["n03710193", "mailbox"], 
-    "638": ["n03710637", "maillot"], 
-    "639": ["n03710721", "maillot"], 
-    "640": ["n03717622", "manhole_cover"], 
-    "641": ["n03720891", "maraca"], 
-    "642": ["n03721384", "marimba"], 
-    "643": ["n03724870", "mask"], 
-    "644": ["n03729826", "matchstick"], 
-    "645": ["n03733131", "maypole"], 
-    "646": ["n03733281", "maze"], 
-    "647": ["n03733805", "measuring_cup"], 
-    "648": ["n03742115", "medicine_chest"], 
-    "649": ["n03743016", "megalith"], 
-    "650": ["n03759954", "microphone"], 
-    "651": ["n03761084", "microwave"], 
-    "652": ["n03763968", "military_uniform"], 
-    "653": ["n03764736", "milk_can"], 
-    "654": ["n03769881", "minibus"], 
-    "655": ["n03770439", "miniskirt"], 
-    "656": ["n03770679", "minivan"], 
-    "657": ["n03773504", "missile"], 
-    "658": ["n03775071", "mitten"], 
-    "659": ["n03775546", "mixing_bowl"], 
-    "660": ["n03776460", "mobile_home"], 
-    "661": ["n03777568", "Model_T"], 
-    "662": ["n03777754", "modem"], 
-    "663": ["n03781244", "monastery"], 
-    "664": ["n03782006", "monitor"], 
-    "665": ["n03785016", "moped"], 
-    "666": ["n03786901", "mortar"], 
-    "667": ["n03787032", "mortarboard"], 
-    "668": ["n03788195", "mosque"], 
-    "669": ["n03788365", "mosquito_net"], 
-    "670": ["n03791053", "motor_scooter"], 
-    "671": ["n03792782", "mountain_bike"], 
-    "672": ["n03792972", "mountain_tent"], 
-    "673": ["n03793489", "mouse"], 
-    "674": ["n03794056", "mousetrap"], 
-    "675": ["n03796401", "moving_van"], 
-    "676": ["n03803284", "muzzle"], 
-    "677": ["n03804744", "nail"], 
-    "678": ["n03814639", "neck_brace"], 
-    "679": ["n03814906", "necklace"], 
-    "680": ["n03825788", "nipple"], 
-    "681": ["n03832673", "notebook"], 
-    "682": ["n03837869", "obelisk"], 
-    "683": ["n03838899", "oboe"], 
-    "684": ["n03840681", "ocarina"], 
-    "685": ["n03841143", "odometer"], 
-    "686": ["n03843555", "oil_filter"], 
-    "687": ["n03854065", "organ"], 
-    "688": ["n03857828", "oscilloscope"], 
-    "689": ["n03866082", "overskirt"], 
-    "690": ["n03868242", "oxcart"], 
-    "691": ["n03868863", "oxygen_mask"], 
-    "692": ["n03871628", "packet"], 
-    "693": ["n03873416", "paddle"], 
-    "694": ["n03874293", "paddlewheel"], 
-    "695": ["n03874599", "padlock"], 
-    "696": ["n03876231", "paintbrush"], 
-    "697": ["n03877472", "pajama"], 
-    "698": ["n03877845", "palace"], 
-    "699": ["n03884397", "panpipe"], 
-    "700": ["n03887697", "paper_towel"], 
-    "701": ["n03888257", "parachute"], 
-    "702": ["n03888605", "parallel_bars"], 
-    "703": ["n03891251", "park_bench"], 
-    "704": ["n03891332", "parking_meter"], 
-    "705": ["n03895866", "passenger_car"], 
-    "706": ["n03899768", "patio"], 
-    "707": ["n03902125", "pay-phone"], 
-    "708": ["n03903868", "pedestal"], 
-    "709": ["n03908618", "pencil_box"], 
-    "710": ["n03908714", "pencil_sharpener"], 
-    "711": ["n03916031", "perfume"], 
-    "712": ["n03920288", "Petri_dish"], 
-    "713": ["n03924679", "photocopier"], 
-    "714": ["n03929660", "pick"], 
-    "715": ["n03929855", "pickelhaube"], 
-    "716": ["n03930313", "picket_fence"], 
-    "717": ["n03930630", "pickup"], 
-    "718": ["n03933933", "pier"], 
-    "719": ["n03935335", "piggy_bank"], 
-    "720": ["n03937543", "pill_bottle"], 
-    "721": ["n03938244", "pillow"], 
-    "722": ["n03942813", "ping-pong_ball"], 
-    "723": ["n03944341", "pinwheel"], 
-    "724": ["n03947888", "pirate"], 
-    "725": ["n03950228", "pitcher"], 
-    "726": ["n03954731", "plane"], 
-    "727": ["n03956157", "planetarium"], 
-    "728": ["n03958227", "plastic_bag"], 
-    "729": ["n03961711", "plate_rack"], 
-    "730": ["n03967562", "plow"], 
-    "731": ["n03970156", "plunger"], 
-    "732": ["n03976467", "Polaroid_camera"], 
-    "733": ["n03976657", "pole"], 
-    "734": ["n03977966", "police_van"], 
-    "735": ["n03980874", "poncho"], 
-    "736": ["n03982430", "pool_table"], 
-    "737": ["n03983396", "pop_bottle"], 
-    "738": ["n03991062", "pot"], 
-    "739": ["n03992509", "potter's_wheel"], 
-    "740": ["n03995372", "power_drill"], 
-    "741": ["n03998194", "prayer_rug"], 
-    "742": ["n04004767", "printer"], 
-    "743": ["n04005630", "prison"], 
-    "744": ["n04008634", "projectile"], 
-    "745": ["n04009552", "projector"], 
-    "746": ["n04019541", "puck"], 
-    "747": ["n04023962", "punching_bag"], 
-    "748": ["n04026417", "purse"], 
-    "749": ["n04033901", "quill"], 
-    "750": ["n04033995", "quilt"], 
-    "751": ["n04037443", "racer"], 
-    "752": ["n04039381", "racket"], 
-    "753": ["n04040759", "radiator"], 
-    "754": ["n04041544", "radio"], 
-    "755": ["n04044716", "radio_telescope"], 
-    "756": ["n04049303", "rain_barrel"], 
-    "757": ["n04065272", "recreational_vehicle"], 
-    "758": ["n04067472", "reel"], 
-    "759": ["n04069434", "reflex_camera"], 
-    "760": ["n04070727", "refrigerator"], 
-    "761": ["n04074963", "remote_control"], 
-    "762": ["n04081281", "restaurant"], 
-    "763": ["n04086273", "revolver"], 
-    "764": ["n04090263", "rifle"], 
-    "765": ["n04099969", "rocking_chair"], 
-    "766": ["n04111531", "rotisserie"], 
-    "767": ["n04116512", "rubber_eraser"], 
-    "768": ["n04118538", "rugby_ball"], 
-    "769": ["n04118776", "rule"], 
-    "770": ["n04120489", "running_shoe"], 
-    "771": ["n04125021", "safe"], 
-    "772": ["n04127249", "safety_pin"], 
-    "773": ["n04131690", "saltshaker"], 
-    "774": ["n04133789", "sandal"], 
-    "775": ["n04136333", "sarong"], 
-    "776": ["n04141076", "sax"], 
-    "777": ["n04141327", "scabbard"], 
-    "778": ["n04141975", "scale"], 
-    "779": ["n04146614", "school_bus"], 
-    "780": ["n04147183", "schooner"], 
-    "781": ["n04149813", "scoreboard"], 
-    "782": ["n04152593", "screen"], 
-    "783": ["n04153751", "screw"], 
-    "784": ["n04154565", "screwdriver"], 
-    "785": ["n04162706", "seat_belt"], 
-    "786": ["n04179913", "sewing_machine"], 
-    "787": ["n04192698", "shield"], 
-    "788": ["n04200800", "shoe_shop"], 
-    "789": ["n04201297", "shoji"], 
-    "790": ["n04204238", "shopping_basket"], 
-    "791": ["n04204347", "shopping_cart"], 
-    "792": ["n04208210", "shovel"], 
-    "793": ["n04209133", "shower_cap"], 
-    "794": ["n04209239", "shower_curtain"], 
-    "795": ["n04228054", "ski"], 
-    "796": ["n04229816", "ski_mask"], 
-    "797": ["n04235860", "sleeping_bag"], 
-    "798": ["n04238763", "slide_rule"], 
-    "799": ["n04239074", "sliding_door"], 
-    "800": ["n04243546", "slot"], 
-    "801": ["n04251144", "snorkel"], 
-    "802": ["n04252077", "snowmobile"], 
-    "803": ["n04252225", "snowplow"], 
-    "804": ["n04254120", "soap_dispenser"], 
-    "805": ["n04254680", "soccer_ball"], 
-    "806": ["n04254777", "sock"], 
-    "807": ["n04258138", "solar_dish"], 
-    "808": ["n04259630", "sombrero"], 
-    "809": ["n04263257", "soup_bowl"], 
-    "810": ["n04264628", "space_bar"], 
-    "811": ["n04265275", "space_heater"], 
-    "812": ["n04266014", "space_shuttle"], 
-    "813": ["n04270147", "spatula"], 
-    "814": ["n04273569", "speedboat"], 
-    "815": ["n04275548", "spider_web"], 
-    "816": ["n04277352", "spindle"], 
-    "817": ["n04285008", "sports_car"], 
-    "818": ["n04286575", "spotlight"], 
-    "819": ["n04296562", "stage"], 
-    "820": ["n04310018", "steam_locomotive"], 
-    "821": ["n04311004", "steel_arch_bridge"], 
-    "822": ["n04311174", "steel_drum"], 
-    "823": ["n04317175", "stethoscope"], 
-    "824": ["n04325704", "stole"], 
-    "825": ["n04326547", "stone_wall"], 
-    "826": ["n04328186", "stopwatch"], 
-    "827": ["n04330267", "stove"], 
-    "828": ["n04332243", "strainer"], 
-    "829": ["n04335435", "streetcar"], 
-    "830": ["n04336792", "stretcher"], 
-    "831": ["n04344873", "studio_couch"], 
-    "832": ["n04346328", "stupa"], 
-    "833": ["n04347754", "submarine"], 
-    "834": ["n04350905", "suit"], 
-    "835": ["n04355338", "sundial"], 
-    "836": ["n04355933", "sunglass"], 
-    "837": ["n04356056", "sunglasses"], 
-    "838": ["n04357314", "sunscreen"], 
-    "839": ["n04366367", "suspension_bridge"], 
-    "840": ["n04367480", "swab"], 
-    "841": ["n04370456", "sweatshirt"], 
-    "842": ["n04371430", "swimming_trunks"], 
-    "843": ["n04371774", "swing"], 
-    "844": ["n04372370", "switch"], 
-    "845": ["n04376876", "syringe"], 
-    "846": ["n04380533", "table_lamp"], 
-    "847": ["n04389033", "tank"], 
-    "848": ["n04392985", "tape_player"], 
-    "849": ["n04398044", "teapot"], 
-    "850": ["n04399382", "teddy"], 
-    "851": ["n04404412", "television"], 
-    "852": ["n04409515", "tennis_ball"], 
-    "853": ["n04417672", "thatch"], 
-    "854": ["n04418357", "theater_curtain"], 
-    "855": ["n04423845", "thimble"], 
-    "856": ["n04428191", "thresher"], 
-    "857": ["n04429376", "throne"], 
-    "858": ["n04435653", "tile_roof"], 
-    "859": ["n04442312", "toaster"], 
-    "860": ["n04443257", "tobacco_shop"], 
-    "861": ["n04447861", "toilet_seat"], 
-    "862": ["n04456115", "torch"], 
-    "863": ["n04458633", "totem_pole"], 
-    "864": ["n04461696", "tow_truck"], 
-    "865": ["n04462240", "toyshop"], 
-    "866": ["n04465501", "tractor"], 
-    "867": ["n04467665", "trailer_truck"], 
-    "868": ["n04476259", "tray"], 
-    "869": ["n04479046", "trench_coat"], 
-    "870": ["n04482393", "tricycle"], 
-    "871": ["n04483307", "trimaran"], 
-    "872": ["n04485082", "tripod"], 
-    "873": ["n04486054", "triumphal_arch"], 
-    "874": ["n04487081", "trolleybus"], 
-    "875": ["n04487394", "trombone"], 
-    "876": ["n04493381", "tub"], 
-    "877": ["n04501370", "turnstile"], 
-    "878": ["n04505470", "typewriter_keyboard"], 
-    "879": ["n04507155", "umbrella"], 
-    "880": ["n04509417", "unicycle"], 
-    "881": ["n04515003", "upright"], 
-    "882": ["n04517823", "vacuum"], 
-    "883": ["n04522168", "vase"], 
-    "884": ["n04523525", "vault"], 
-    "885": ["n04525038", "velvet"], 
-    "886": ["n04525305", "vending_machine"], 
-    "887": ["n04532106", "vestment"], 
-    "888": ["n04532670", "viaduct"], 
-    "889": ["n04536866", "violin"], 
-    "890": ["n04540053", "volleyball"], 
-    "891": ["n04542943", "waffle_iron"], 
-    "892": ["n04548280", "wall_clock"], 
-    "893": ["n04548362", "wallet"], 
-    "894": ["n04550184", "wardrobe"], 
-    "895": ["n04552348", "warplane"], 
-    "896": ["n04553703", "washbasin"], 
-    "897": ["n04554684", "washer"], 
-    "898": ["n04557648", "water_bottle"], 
-    "899": ["n04560804", "water_jug"], 
-    "900": ["n04562935", "water_tower"], 
-    "901": ["n04579145", "whiskey_jug"], 
-    "902": ["n04579432", "whistle"], 
-    "903": ["n04584207", "wig"], 
-    "904": ["n04589890", "window_screen"], 
-    "905": ["n04590129", "window_shade"], 
-    "906": ["n04591157", "Windsor_tie"], 
-    "907": ["n04591713", "wine_bottle"], 
-    "908": ["n04592741", "wing"], 
-    "909": ["n04596742", "wok"], 
-    "910": ["n04597913", "wooden_spoon"], 
-    "911": ["n04599235", "wool"], 
-    "912": ["n04604644", "worm_fence"], 
-    "913": ["n04606251", "wreck"], 
-    "914": ["n04612504", "yawl"], 
-    "915": ["n04613696", "yurt"], 
-    "916": ["n06359193", "web_site"], 
-    "917": ["n06596364", "comic_book"], 
-    "918": ["n06785654", "crossword_puzzle"], 
-    "919": ["n06794110", "street_sign"], 
-    "920": ["n06874185", "traffic_light"], 
-    "921": ["n07248320", "book_jacket"], 
-    "922": ["n07565083", "menu"], 
-    "923": ["n07579787", "plate"], 
-    "924": ["n07583066", "guacamole"], 
-    "925": ["n07584110", "consomme"], 
-    "926": ["n07590611", "hot_pot"], 
-    "927": ["n07613480", "trifle"], 
-    "928": ["n07614500", "ice_cream"], 
-    "929": ["n07615774", "ice_lolly"], 
-    "930": ["n07684084", "French_loaf"], 
-    "931": ["n07693725", "bagel"], 
-    "932": ["n07695742", "pretzel"], 
-    "933": ["n07697313", "cheeseburger"], 
-    "934": ["n07697537", "hotdog"], 
-    "935": ["n07711569", "mashed_potato"], 
-    "936": ["n07714571", "head_cabbage"], 
-    "937": ["n07714990", "broccoli"], 
-    "938": ["n07715103", "cauliflower"], 
-    "939": ["n07716358", "zucchini"], 
-    "940": ["n07716906", "spaghetti_squash"], 
-    "941": ["n07717410", "acorn_squash"], 
-    "942": ["n07717556", "butternut_squash"], 
-    "943": ["n07718472", "cucumber"], 
-    "944": ["n07718747", "artichoke"], 
-    "945": ["n07720875", "bell_pepper"], 
-    "946": ["n07730033", "cardoon"], 
-    "947": ["n07734744", "mushroom"], 
-    "948": ["n07742313", "Granny_Smith"], 
-    "949": ["n07745940", "strawberry"], 
-    "950": ["n07747607", "orange"], 
-    "951": ["n07749582", "lemon"], 
-    "952": ["n07753113", "fig"], 
-    "953": ["n07753275", "pineapple"], 
-    "954": ["n07753592", "banana"], 
-    "955": ["n07754684", "jackfruit"], 
-    "956": ["n07760859", "custard_apple"], 
-    "957": ["n07768694", "pomegranate"], 
-    "958": ["n07802026", "hay"], 
-    "959": ["n07831146", "carbonara"], 
-    "960": ["n07836838", "chocolate_sauce"], 
-    "961": ["n07860988", "dough"], 
-    "962": ["n07871810", "meat_loaf"], 
-    "963": ["n07873807", "pizza"], 
-    "964": ["n07875152", "potpie"], 
-    "965": ["n07880968", "burrito"], 
-    "966": ["n07892512", "red_wine"], 
-    "967": ["n07920052", "espresso"], 
-    "968": ["n07930864", "cup"], 
-    "969": ["n07932039", "eggnog"], 
-    "970": ["n09193705", "alp"], 
-    "971": ["n09229709", "bubble"], 
-    "972": ["n09246464", "cliff"], 
-    "973": ["n09256479", "coral_reef"], 
-    "974": ["n09288635", "geyser"], 
-    "975": ["n09332890", "lakeside"], 
-    "976": ["n09399592", "promontory"], 
-    "977": ["n09421951", "sandbar"], 
-    "978": ["n09428293", "seashore"], 
-    "979": ["n09468604", "valley"], 
-    "980": ["n09472597", "volcano"], 
-    "981": ["n09835506", "ballplayer"], 
-    "982": ["n10148035", "groom"], 
-    "983": ["n10565667", "scuba_diver"], 
-    "984": ["n11879895", "rapeseed"], 
-    "985": ["n11939491", "daisy"], 
-    "986": ["n12057211", "yellow_lady's_slipper"], 
-    "987": ["n12144580", "corn"], 
-    "988": ["n12267677", "acorn"], 
-    "989": ["n12620546", "hip"], 
-    "990": ["n12768682", "buckeye"], 
-    "991": ["n12985857", "coral_fungus"], 
-    "992": ["n12998815", "agaric"], 
-    "993": ["n13037406", "gyromitra"], 
-    "994": ["n13040303", "stinkhorn"], 
-    "995": ["n13044778", "earthstar"], 
-    "996": ["n13052670", "hen-of-the-woods"], 
-    "997": ["n13054560", "bolete"], 
-    "998": ["n13133613", "ear"], 
-    "999": ["n15075141", "toilet_tissue"]
-}

spaces/AnimalEquality/chatbot/_proc/_docs/site_libs/quarto-search/fuse.min.js

@@ -1,9 +0,0 @@
-/**
- * Fuse.js v6.6.2 - Lightweight fuzzy-search (http://fusejs.io)
- *
- * Copyright (c) 2022 Kiro Risk (http://kiro.me)
- * All Rights Reserved. Apache Software License 2.0
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- */
-var e,t;e=this,t=function(){"use strict";function e(e,t){var n=Object.keys(e);if(Object.getOwnPropertySymbols){var r=Object.getOwnPropertySymbols(e);t&&(r=r.filter((function(t){return Object.getOwnPropertyDescriptor(e,t).enumerable}))),n.push.apply(n,r)}return n}function t(t){for(var n=1;n<arguments.length;n++){var r=null!=arguments[n]?arguments[n]:{};n%2?e(Object(r),!0).forEach((function(e){c(t,e,r[e])})):Object.getOwnPropertyDescriptors?Object.defineProperties(t,Object.getOwnPropertyDescriptors(r)):e(Object(r)).forEach((function(e){Object.defineProperty(t,e,Object.getOwnPropertyDescriptor(r,e))}))}return t}function n(e){return n="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e},n(e)}function r(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function i(e,t){for(var n=0;n<t.length;n++){var r=t[n];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(e,r.key,r)}}function o(e,t,n){return t&&i(e.prototype,t),n&&i(e,n),Object.defineProperty(e,"prototype",{writable:!1}),e}function c(e,t,n){return t in e?Object.defineProperty(e,t,{value:n,enumerable:!0,configurable:!0,writable:!0}):e[t]=n,e}function a(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function");Object.defineProperty(e,"prototype",{value:Object.create(t&&t.prototype,{constructor:{value:e,writable:!0,configurable:!0}}),writable:!1}),t&&u(e,t)}function s(e){return s=Object.setPrototypeOf?Object.getPrototypeOf:function(e){return e.__proto__||Object.getPrototypeOf(e)},s(e)}function u(e,t){return u=Object.setPrototypeOf||function(e,t){return e.__proto__=t,e},u(e,t)}function h(e,t){if(t&&("object"==typeof t||"function"==typeof t))return t;if(void 0!==t)throw new TypeError("Derived constructors may only return object or undefined");return function(e){if(void 0===e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return e}(e)}function l(e){var t=function(){if("undefined"==typeof Reflect||!Reflect.construct)return!1;if(Reflect.construct.sham)return!1;if("function"==typeof Proxy)return!0;try{return Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],(function(){}))),!0}catch(e){return!1}}();return function(){var n,r=s(e);if(t){var i=s(this).constructor;n=Reflect.construct(r,arguments,i)}else n=r.apply(this,arguments);return h(this,n)}}function f(e){return function(e){if(Array.isArray(e))return d(e)}(e)||function(e){if("undefined"!=typeof Symbol&&null!=e[Symbol.iterator]||null!=e["@@iterator"])return Array.from(e)}(e)||function(e,t){if(e){if("string"==typeof e)return d(e,t);var n=Object.prototype.toString.call(e).slice(8,-1);return"Object"===n&&e.constructor&&(n=e.constructor.name),"Map"===n||"Set"===n?Array.from(e):"Arguments"===n||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)?d(e,t):void 0}}(e)||function(){throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}()}function d(e,t){(null==t||t>e.length)&&(t=e.length);for(var n=0,r=new Array(t);n<t;n++)r[n]=e[n];return r}function v(e){return Array.isArray?Array.isArray(e):"[object Array]"===b(e)}function g(e){return"string"==typeof e}function y(e){return"number"==typeof e}function p(e){return!0===e||!1===e||function(e){return m(e)&&null!==e}(e)&&"[object Boolean]"==b(e)}function m(e){return"object"===n(e)}function k(e){return null!=e}function M(e){return!e.trim().length}function b(e){return null==e?void 0===e?"[object Undefined]":"[object Null]":Object.prototype.toString.call(e)}var x=function(e){return"Invalid value for key ".concat(e)},w=function(e){return"Pattern length exceeds max of ".concat(e,".")},L=Object.prototype.hasOwnProperty,S=function(){function e(t){var n=this;r(this,e),this._keys=[],this._keyMap={};var i=0;t.forEach((function(e){var t=_(e);i+=t.weight,n._keys.push(t),n._keyMap[t.id]=t,i+=t.weight})),this._keys.forEach((function(e){e.weight/=i}))}return o(e,[{key:"get",value:function(e){return this._keyMap[e]}},{key:"keys",value:function(){return this._keys}},{key:"toJSON",value:function(){return JSON.stringify(this._keys)}}]),e}();function _(e){var t=null,n=null,r=null,i=1,o=null;if(g(e)||v(e))r=e,t=O(e),n=j(e);else{if(!L.call(e,"name"))throw new Error(function(e){return"Missing ".concat(e," property in key")}("name"));var c=e.name;if(r=c,L.call(e,"weight")&&(i=e.weight)<=0)throw new Error(function(e){return"Property 'weight' in key '".concat(e,"' must be a positive integer")}(c));t=O(c),n=j(c),o=e.getFn}return{path:t,id:n,weight:i,src:r,getFn:o}}function O(e){return v(e)?e:e.split(".")}function j(e){return v(e)?e.join("."):e}var A={useExtendedSearch:!1,getFn:function(e,t){var n=[],r=!1;return function e(t,i,o){if(k(t))if(i[o]){var c=t[i[o]];if(!k(c))return;if(o===i.length-1&&(g(c)||y(c)||p(c)))n.push(function(e){return null==e?"":function(e){if("string"==typeof e)return e;var t=e+"";return"0"==t&&1/e==-1/0?"-0":t}(e)}(c));else if(v(c)){r=!0;for(var a=0,s=c.length;a<s;a+=1)e(c[a],i,o+1)}else i.length&&e(c,i,o+1)}else n.push(t)}(e,g(t)?t.split("."):t,0),r?n:n[0]},ignoreLocation:!1,ignoreFieldNorm:!1,fieldNormWeight:1},I=t(t(t(t({},{isCaseSensitive:!1,includeScore:!1,keys:[],shouldSort:!0,sortFn:function(e,t){return e.score===t.score?e.idx<t.idx?-1:1:e.score<t.score?-1:1}}),{includeMatches:!1,findAllMatches:!1,minMatchCharLength:1}),{location:0,threshold:.6,distance:100}),A),C=/[^ ]+/g;function E(){var e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:1,t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:3,n=new Map,r=Math.pow(10,t);return{get:function(t){var i=t.match(C).length;if(n.has(i))return n.get(i);var o=1/Math.pow(i,.5*e),c=parseFloat(Math.round(o*r)/r);return n.set(i,c),c},clear:function(){n.clear()}}}var $=function(){function e(){var t=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{},n=t.getFn,i=void 0===n?I.getFn:n,o=t.fieldNormWeight,c=void 0===o?I.fieldNormWeight:o;r(this,e),this.norm=E(c,3),this.getFn=i,this.isCreated=!1,this.setIndexRecords()}return o(e,[{key:"setSources",value:function(){var e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:[];this.docs=e}},{key:"setIndexRecords",value:function(){var e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:[];this.records=e}},{key:"setKeys",value:function(){var e=this,t=arguments.length>0&&void 0!==arguments[0]?arguments[0]:[];this.keys=t,this._keysMap={},t.forEach((function(t,n){e._keysMap[t.id]=n}))}},{key:"create",value:function(){var e=this;!this.isCreated&&this.docs.length&&(this.isCreated=!0,g(this.docs[0])?this.docs.forEach((function(t,n){e._addString(t,n)})):this.docs.forEach((function(t,n){e._addObject(t,n)})),this.norm.clear())}},{key:"add",value:function(e){var t=this.size();g(e)?this._addString(e,t):this._addObject(e,t)}},{key:"removeAt",value:function(e){this.records.splice(e,1);for(var t=e,n=this.size();t<n;t+=1)this.records[t].i-=1}},{key:"getValueForItemAtKeyId",value:function(e,t){return e[this._keysMap[t]]}},{key:"size",value:function(){return this.records.length}},{key:"_addString",value:function(e,t){if(k(e)&&!M(e)){var n={v:e,i:t,n:this.norm.get(e)};this.records.push(n)}}},{key:"_addObject",value:function(e,t){var n=this,r={i:t,$:{}};this.keys.forEach((function(t,i){var o=t.getFn?t.getFn(e):n.getFn(e,t.path);if(k(o))if(v(o))!function(){for(var e=[],t=[{nestedArrIndex:-1,value:o}];t.length;){var c=t.pop(),a=c.nestedArrIndex,s=c.value;if(k(s))if(g(s)&&!M(s)){var u={v:s,i:a,n:n.norm.get(s)};e.push(u)}else v(s)&&s.forEach((function(e,n){t.push({nestedArrIndex:n,value:e})}))}r.$[i]=e}();else if(g(o)&&!M(o)){var c={v:o,n:n.norm.get(o)};r.$[i]=c}})),this.records.push(r)}},{key:"toJSON",value:function(){return{keys:this.keys,records:this.records}}}]),e}();function F(e,t){var n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{},r=n.getFn,i=void 0===r?I.getFn:r,o=n.fieldNormWeight,c=void 0===o?I.fieldNormWeight:o,a=new $({getFn:i,fieldNormWeight:c});return a.setKeys(e.map(_)),a.setSources(t),a.create(),a}function R(e){var t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{},n=t.errors,r=void 0===n?0:n,i=t.currentLocation,o=void 0===i?0:i,c=t.expectedLocation,a=void 0===c?0:c,s=t.distance,u=void 0===s?I.distance:s,h=t.ignoreLocation,l=void 0===h?I.ignoreLocation:h,f=r/e.length;if(l)return f;var d=Math.abs(a-o);return u?f+d/u:d?1:f}function N(){for(var e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:[],t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:I.minMatchCharLength,n=[],r=-1,i=-1,o=0,c=e.length;o<c;o+=1){var a=e[o];a&&-1===r?r=o:a||-1===r||((i=o-1)-r+1>=t&&n.push([r,i]),r=-1)}return e[o-1]&&o-r>=t&&n.push([r,o-1]),n}var P=32;function W(e){for(var t={},n=0,r=e.length;n<r;n+=1){var i=e.charAt(n);t[i]=(t[i]||0)|1<<r-n-1}return t}var T=function(){function e(t){var n=this,i=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{},o=i.location,c=void 0===o?I.location:o,a=i.threshold,s=void 0===a?I.threshold:a,u=i.distance,h=void 0===u?I.distance:u,l=i.includeMatches,f=void 0===l?I.includeMatches:l,d=i.findAllMatches,v=void 0===d?I.findAllMatches:d,g=i.minMatchCharLength,y=void 0===g?I.minMatchCharLength:g,p=i.isCaseSensitive,m=void 0===p?I.isCaseSensitive:p,k=i.ignoreLocation,M=void 0===k?I.ignoreLocation:k;if(r(this,e),this.options={location:c,threshold:s,distance:h,includeMatches:f,findAllMatches:v,minMatchCharLength:y,isCaseSensitive:m,ignoreLocation:M},this.pattern=m?t:t.toLowerCase(),this.chunks=[],this.pattern.length){var b=function(e,t){n.chunks.push({pattern:e,alphabet:W(e),startIndex:t})},x=this.pattern.length;if(x>P){for(var w=0,L=x%P,S=x-L;w<S;)b(this.pattern.substr(w,P),w),w+=P;if(L){var _=x-P;b(this.pattern.substr(_),_)}}else b(this.pattern,0)}}return o(e,[{key:"searchIn",value:function(e){var t=this.options,n=t.isCaseSensitive,r=t.includeMatches;if(n||(e=e.toLowerCase()),this.pattern===e){var i={isMatch:!0,score:0};return r&&(i.indices=[[0,e.length-1]]),i}var o=this.options,c=o.location,a=o.distance,s=o.threshold,u=o.findAllMatches,h=o.minMatchCharLength,l=o.ignoreLocation,d=[],v=0,g=!1;this.chunks.forEach((function(t){var n=t.pattern,i=t.alphabet,o=t.startIndex,y=function(e,t,n){var r=arguments.length>3&&void 0!==arguments[3]?arguments[3]:{},i=r.location,o=void 0===i?I.location:i,c=r.distance,a=void 0===c?I.distance:c,s=r.threshold,u=void 0===s?I.threshold:s,h=r.findAllMatches,l=void 0===h?I.findAllMatches:h,f=r.minMatchCharLength,d=void 0===f?I.minMatchCharLength:f,v=r.includeMatches,g=void 0===v?I.includeMatches:v,y=r.ignoreLocation,p=void 0===y?I.ignoreLocation:y;if(t.length>P)throw new Error(w(P));for(var m,k=t.length,M=e.length,b=Math.max(0,Math.min(o,M)),x=u,L=b,S=d>1||g,_=S?Array(M):[];(m=e.indexOf(t,L))>-1;){var O=R(t,{currentLocation:m,expectedLocation:b,distance:a,ignoreLocation:p});if(x=Math.min(O,x),L=m+k,S)for(var j=0;j<k;)_[m+j]=1,j+=1}L=-1;for(var A=[],C=1,E=k+M,$=1<<k-1,F=0;F<k;F+=1){for(var W=0,T=E;W<T;)R(t,{errors:F,currentLocation:b+T,expectedLocation:b,distance:a,ignoreLocation:p})<=x?W=T:E=T,T=Math.floor((E-W)/2+W);E=T;var z=Math.max(1,b-T+1),D=l?M:Math.min(b+T,M)+k,K=Array(D+2);K[D+1]=(1<<F)-1;for(var q=D;q>=z;q-=1){var B=q-1,J=n[e.charAt(B)];if(S&&(_[B]=+!!J),K[q]=(K[q+1]<<1|1)&J,F&&(K[q]|=(A[q+1]|A[q])<<1|1|A[q+1]),K[q]&$&&(C=R(t,{errors:F,currentLocation:B,expectedLocation:b,distance:a,ignoreLocation:p}))<=x){if(x=C,(L=B)<=b)break;z=Math.max(1,2*b-L)}}if(R(t,{errors:F+1,currentLocation:b,expectedLocation:b,distance:a,ignoreLocation:p})>x)break;A=K}var U={isMatch:L>=0,score:Math.max(.001,C)};if(S){var V=N(_,d);V.length?g&&(U.indices=V):U.isMatch=!1}return U}(e,n,i,{location:c+o,distance:a,threshold:s,findAllMatches:u,minMatchCharLength:h,includeMatches:r,ignoreLocation:l}),p=y.isMatch,m=y.score,k=y.indices;p&&(g=!0),v+=m,p&&k&&(d=[].concat(f(d),f(k)))}));var y={isMatch:g,score:g?v/this.chunks.length:1};return g&&r&&(y.indices=d),y}}]),e}(),z=function(){function e(t){r(this,e),this.pattern=t}return o(e,[{key:"search",value:function(){}}],[{key:"isMultiMatch",value:function(e){return D(e,this.multiRegex)}},{key:"isSingleMatch",value:function(e){return D(e,this.singleRegex)}}]),e}();function D(e,t){var n=e.match(t);return n?n[1]:null}var K=function(e){a(n,e);var t=l(n);function n(e){return r(this,n),t.call(this,e)}return o(n,[{key:"search",value:function(e){var t=e===this.pattern;return{isMatch:t,score:t?0:1,indices:[0,this.pattern.length-1]}}}],[{key:"type",get:function(){return"exact"}},{key:"multiRegex",get:function(){return/^="(.*)"$/}},{key:"singleRegex",get:function(){return/^=(.*)$/}}]),n}(z),q=function(e){a(n,e);var t=l(n);function n(e){return r(this,n),t.call(this,e)}return o(n,[{key:"search",value:function(e){var t=-1===e.indexOf(this.pattern);return{isMatch:t,score:t?0:1,indices:[0,e.length-1]}}}],[{key:"type",get:function(){return"inverse-exact"}},{key:"multiRegex",get:function(){return/^!"(.*)"$/}},{key:"singleRegex",get:function(){return/^!(.*)$/}}]),n}(z),B=function(e){a(n,e);var t=l(n);function n(e){return r(this,n),t.call(this,e)}return o(n,[{key:"search",value:function(e){var t=e.startsWith(this.pattern);return{isMatch:t,score:t?0:1,indices:[0,this.pattern.length-1]}}}],[{key:"type",get:function(){return"prefix-exact"}},{key:"multiRegex",get:function(){return/^\^"(.*)"$/}},{key:"singleRegex",get:function(){return/^\^(.*)$/}}]),n}(z),J=function(e){a(n,e);var t=l(n);function n(e){return r(this,n),t.call(this,e)}return o(n,[{key:"search",value:function(e){var t=!e.startsWith(this.pattern);return{isMatch:t,score:t?0:1,indices:[0,e.length-1]}}}],[{key:"type",get:function(){return"inverse-prefix-exact"}},{key:"multiRegex",get:function(){return/^!\^"(.*)"$/}},{key:"singleRegex",get:function(){return/^!\^(.*)$/}}]),n}(z),U=function(e){a(n,e);var t=l(n);function n(e){return r(this,n),t.call(this,e)}return o(n,[{key:"search",value:function(e){var t=e.endsWith(this.pattern);return{isMatch:t,score:t?0:1,indices:[e.length-this.pattern.length,e.length-1]}}}],[{key:"type",get:function(){return"suffix-exact"}},{key:"multiRegex",get:function(){return/^"(.*)"\$$/}},{key:"singleRegex",get:function(){return/^(.*)\$$/}}]),n}(z),V=function(e){a(n,e);var t=l(n);function n(e){return r(this,n),t.call(this,e)}return o(n,[{key:"search",value:function(e){var t=!e.endsWith(this.pattern);return{isMatch:t,score:t?0:1,indices:[0,e.length-1]}}}],[{key:"type",get:function(){return"inverse-suffix-exact"}},{key:"multiRegex",get:function(){return/^!"(.*)"\$$/}},{key:"singleRegex",get:function(){return/^!(.*)\$$/}}]),n}(z),G=function(e){a(n,e);var t=l(n);function n(e){var i,o=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{},c=o.location,a=void 0===c?I.location:c,s=o.threshold,u=void 0===s?I.threshold:s,h=o.distance,l=void 0===h?I.distance:h,f=o.includeMatches,d=void 0===f?I.includeMatches:f,v=o.findAllMatches,g=void 0===v?I.findAllMatches:v,y=o.minMatchCharLength,p=void 0===y?I.minMatchCharLength:y,m=o.isCaseSensitive,k=void 0===m?I.isCaseSensitive:m,M=o.ignoreLocation,b=void 0===M?I.ignoreLocation:M;return r(this,n),(i=t.call(this,e))._bitapSearch=new T(e,{location:a,threshold:u,distance:l,includeMatches:d,findAllMatches:g,minMatchCharLength:p,isCaseSensitive:k,ignoreLocation:b}),i}return o(n,[{key:"search",value:function(e){return this._bitapSearch.searchIn(e)}}],[{key:"type",get:function(){return"fuzzy"}},{key:"multiRegex",get:function(){return/^"(.*)"$/}},{key:"singleRegex",get:function(){return/^(.*)$/}}]),n}(z),H=function(e){a(n,e);var t=l(n);function n(e){return r(this,n),t.call(this,e)}return o(n,[{key:"search",value:function(e){for(var t,n=0,r=[],i=this.pattern.length;(t=e.indexOf(this.pattern,n))>-1;)n=t+i,r.push([t,n-1]);var o=!!r.length;return{isMatch:o,score:o?0:1,indices:r}}}],[{key:"type",get:function(){return"include"}},{key:"multiRegex",get:function(){return/^'"(.*)"$/}},{key:"singleRegex",get:function(){return/^'(.*)$/}}]),n}(z),Q=[K,H,B,J,V,U,q,G],X=Q.length,Y=/ +(?=(?:[^\"]*\"[^\"]*\")*[^\"]*$)/;function Z(e){var t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};return e.split("|").map((function(e){for(var n=e.trim().split(Y).filter((function(e){return e&&!!e.trim()})),r=[],i=0,o=n.length;i<o;i+=1){for(var c=n[i],a=!1,s=-1;!a&&++s<X;){var u=Q[s],h=u.isMultiMatch(c);h&&(r.push(new u(h,t)),a=!0)}if(!a)for(s=-1;++s<X;){var l=Q[s],f=l.isSingleMatch(c);if(f){r.push(new l(f,t));break}}}return r}))}var ee=new Set([G.type,H.type]),te=function(){function e(t){var n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{},i=n.isCaseSensitive,o=void 0===i?I.isCaseSensitive:i,c=n.includeMatches,a=void 0===c?I.includeMatches:c,s=n.minMatchCharLength,u=void 0===s?I.minMatchCharLength:s,h=n.ignoreLocation,l=void 0===h?I.ignoreLocation:h,f=n.findAllMatches,d=void 0===f?I.findAllMatches:f,v=n.location,g=void 0===v?I.location:v,y=n.threshold,p=void 0===y?I.threshold:y,m=n.distance,k=void 0===m?I.distance:m;r(this,e),this.query=null,this.options={isCaseSensitive:o,includeMatches:a,minMatchCharLength:u,findAllMatches:d,ignoreLocation:l,location:g,threshold:p,distance:k},this.pattern=o?t:t.toLowerCase(),this.query=Z(this.pattern,this.options)}return o(e,[{key:"searchIn",value:function(e){var t=this.query;if(!t)return{isMatch:!1,score:1};var n=this.options,r=n.includeMatches;e=n.isCaseSensitive?e:e.toLowerCase();for(var i=0,o=[],c=0,a=0,s=t.length;a<s;a+=1){var u=t[a];o.length=0,i=0;for(var h=0,l=u.length;h<l;h+=1){var d=u[h],v=d.search(e),g=v.isMatch,y=v.indices,p=v.score;if(!g){c=0,i=0,o.length=0;break}if(i+=1,c+=p,r){var m=d.constructor.type;ee.has(m)?o=[].concat(f(o),f(y)):o.push(y)}}if(i){var k={isMatch:!0,score:c/i};return r&&(k.indices=o),k}}return{isMatch:!1,score:1}}}],[{key:"condition",value:function(e,t){return t.useExtendedSearch}}]),e}(),ne=[];function re(e,t){for(var n=0,r=ne.length;n<r;n+=1){var i=ne[n];if(i.condition(e,t))return new i(e,t)}return new T(e,t)}var ie="$and",oe="$or",ce="$path",ae="$val",se=function(e){return!(!e[ie]&&!e[oe])},ue=function(e){return!!e[ce]},he=function(e){return!v(e)&&m(e)&&!se(e)},le=function(e){return c({},ie,Object.keys(e).map((function(t){return c({},t,e[t])})))};function fe(e,t){var n=t.ignoreFieldNorm,r=void 0===n?I.ignoreFieldNorm:n;e.forEach((function(e){var t=1;e.matches.forEach((function(e){var n=e.key,i=e.norm,o=e.score,c=n?n.weight:null;t*=Math.pow(0===o&&c?Number.EPSILON:o,(c||1)*(r?1:i))})),e.score=t}))}function de(e,t){var n=e.matches;t.matches=[],k(n)&&n.forEach((function(e){if(k(e.indices)&&e.indices.length){var n={indices:e.indices,value:e.value};e.key&&(n.key=e.key.src),e.idx>-1&&(n.refIndex=e.idx),t.matches.push(n)}}))}function ve(e,t){t.score=e.score}function ge(e,t){var n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{},r=n.includeMatches,i=void 0===r?I.includeMatches:r,o=n.includeScore,c=void 0===o?I.includeScore:o,a=[];return i&&a.push(de),c&&a.push(ve),e.map((function(e){var n=e.idx,r={item:t[n],refIndex:n};return a.length&&a.forEach((function(t){t(e,r)})),r}))}var ye=function(){function e(n){var i=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{},o=arguments.length>2?arguments[2]:void 0;r(this,e),this.options=t(t({},I),i),this.options.useExtendedSearch,this._keyStore=new S(this.options.keys),this.setCollection(n,o)}return o(e,[{key:"setCollection",value:function(e,t){if(this._docs=e,t&&!(t instanceof $))throw new Error("Incorrect 'index' type");this._myIndex=t||F(this.options.keys,this._docs,{getFn:this.options.getFn,fieldNormWeight:this.options.fieldNormWeight})}},{key:"add",value:function(e){k(e)&&(this._docs.push(e),this._myIndex.add(e))}},{key:"remove",value:function(){for(var e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:function(){return!1},t=[],n=0,r=this._docs.length;n<r;n+=1){var i=this._docs[n];e(i,n)&&(this.removeAt(n),n-=1,r-=1,t.push(i))}return t}},{key:"removeAt",value:function(e){this._docs.splice(e,1),this._myIndex.removeAt(e)}},{key:"getIndex",value:function(){return this._myIndex}},{key:"search",value:function(e){var t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{},n=t.limit,r=void 0===n?-1:n,i=this.options,o=i.includeMatches,c=i.includeScore,a=i.shouldSort,s=i.sortFn,u=i.ignoreFieldNorm,h=g(e)?g(this._docs[0])?this._searchStringList(e):this._searchObjectList(e):this._searchLogical(e);return fe(h,{ignoreFieldNorm:u}),a&&h.sort(s),y(r)&&r>-1&&(h=h.slice(0,r)),ge(h,this._docs,{includeMatches:o,includeScore:c})}},{key:"_searchStringList",value:function(e){var t=re(e,this.options),n=this._myIndex.records,r=[];return n.forEach((function(e){var n=e.v,i=e.i,o=e.n;if(k(n)){var c=t.searchIn(n),a=c.isMatch,s=c.score,u=c.indices;a&&r.push({item:n,idx:i,matches:[{score:s,value:n,norm:o,indices:u}]})}})),r}},{key:"_searchLogical",value:function(e){var t=this,n=function(e,t){var n=(arguments.length>2&&void 0!==arguments[2]?arguments[2]:{}).auto,r=void 0===n||n,i=function e(n){var i=Object.keys(n),o=ue(n);if(!o&&i.length>1&&!se(n))return e(le(n));if(he(n)){var c=o?n[ce]:i[0],a=o?n[ae]:n[c];if(!g(a))throw new Error(x(c));var s={keyId:j(c),pattern:a};return r&&(s.searcher=re(a,t)),s}var u={children:[],operator:i[0]};return i.forEach((function(t){var r=n[t];v(r)&&r.forEach((function(t){u.children.push(e(t))}))})),u};return se(e)||(e=le(e)),i(e)}(e,this.options),r=function e(n,r,i){if(!n.children){var o=n.keyId,c=n.searcher,a=t._findMatches({key:t._keyStore.get(o),value:t._myIndex.getValueForItemAtKeyId(r,o),searcher:c});return a&&a.length?[{idx:i,item:r,matches:a}]:[]}for(var s=[],u=0,h=n.children.length;u<h;u+=1){var l=e(n.children[u],r,i);if(l.length)s.push.apply(s,f(l));else if(n.operator===ie)return[]}return s},i=this._myIndex.records,o={},c=[];return i.forEach((function(e){var t=e.$,i=e.i;if(k(t)){var a=r(n,t,i);a.length&&(o[i]||(o[i]={idx:i,item:t,matches:[]},c.push(o[i])),a.forEach((function(e){var t,n=e.matches;(t=o[i].matches).push.apply(t,f(n))})))}})),c}},{key:"_searchObjectList",value:function(e){var t=this,n=re(e,this.options),r=this._myIndex,i=r.keys,o=r.records,c=[];return o.forEach((function(e){var r=e.$,o=e.i;if(k(r)){var a=[];i.forEach((function(e,i){a.push.apply(a,f(t._findMatches({key:e,value:r[i],searcher:n})))})),a.length&&c.push({idx:o,item:r,matches:a})}})),c}},{key:"_findMatches",value:function(e){var t=e.key,n=e.value,r=e.searcher;if(!k(n))return[];var i=[];if(v(n))n.forEach((function(e){var n=e.v,o=e.i,c=e.n;if(k(n)){var a=r.searchIn(n),s=a.isMatch,u=a.score,h=a.indices;s&&i.push({score:u,key:t,value:n,idx:o,norm:c,indices:h})}}));else{var o=n.v,c=n.n,a=r.searchIn(o),s=a.isMatch,u=a.score,h=a.indices;s&&i.push({score:u,key:t,value:o,norm:c,indices:h})}return i}}]),e}();return ye.version="6.6.2",ye.createIndex=F,ye.parseIndex=function(e){var t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{},n=t.getFn,r=void 0===n?I.getFn:n,i=t.fieldNormWeight,o=void 0===i?I.fieldNormWeight:i,c=e.keys,a=e.records,s=new $({getFn:r,fieldNormWeight:o});return s.setKeys(c),s.setIndexRecords(a),s},ye.config=I,function(){ne.push.apply(ne,arguments)}(te),ye},"object"==typeof exports&&"undefined"!=typeof module?module.exports=t():"function"==typeof define&&define.amd?define(t):(e="undefined"!=typeof globalThis?globalThis:e||self).Fuse=t();

spaces/Anonymous-123/ImageNet-Editing/object_removal/TFill/model/losses.py

@@ -1,364 +0,0 @@
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-import torchvision.models as models
-
-
-####################################################################################################
-# adversarial loss for different gan mode
-####################################################################################################
-class GANLoss(nn.Module):
-    """Define different GAN objectives.
-
-    The GANLoss class abstracts away the need to create the target label tensor
-    that has the same size as the input.
-    """
-
-    def __init__(self, gan_mode, target_real_label=1.0, target_fake_label=0.0):
-        """ Initialize the GANLoss class.
-
-        Parameters:
-            gan_mode (str) - - the type of GAN objective. It currently supports vanilla, lsgan, and wgangp.
-            target_real_label (bool) - - label for a real image
-            target_fake_label (bool) - - label of a fake image
-
-        Note: Do not use sigmoid as the last layer of Discriminator.
-        LSGAN needs no sigmoid. vanilla GANs will handle it with BCEWithLogitsLoss.
-        """
-        super(GANLoss, self).__init__()
-        self.register_buffer('real_label', torch.tensor(target_real_label))
-        self.register_buffer('fake_label', torch.tensor(target_fake_label))
-        self.gan_mode = gan_mode
-        if gan_mode == 'lsgan':
-            self.loss = nn.MSELoss()
-        elif gan_mode == 'vanilla':
-            self.loss = nn.BCEWithLogitsLoss()
-        elif gan_mode == 'hinge':
-            self.loss = nn.ReLU()
-        elif gan_mode in ['wgangp', 'nonsaturating']:
-            self.loss = None
-        else:
-            raise NotImplementedError('gan mode %s not implemented' % gan_mode)
-
-    def get_target_tensor(self, prediction, target_is_real):
-        """Create label tensors with the same size as the input.
-
-        Parameters:
-            prediction (tensor) - - tpyically the prediction from a discriminator
-            target_is_real (bool) - - if the ground truth label is for real examples or fake examples
-
-        Returns:
-            A label tensor filled with ground truth label, and with the size of the input
-        """
-
-        if target_is_real:
-            target_tensor = self.real_label
-        else:
-            target_tensor = self.fake_label
-        return target_tensor.expand_as(prediction)
-
-    def calculate_loss(self, prediction, target_is_real, is_dis=False):
-        """Calculate loss given Discriminator's output and grount truth labels.
-
-        Parameters:
-            prediction (tensor) - - tpyically the prediction output from a discriminator
-            target_is_real (bool) - - if the ground truth label is for real examples or fake examples
-
-        Returns:
-            the calculated loss.
-        """
-        if self.gan_mode in ['lsgan', 'vanilla']:
-            target_tensor = self.get_target_tensor(prediction, target_is_real)
-            loss = self.loss(prediction, target_tensor)
-            if self.gan_mode == 'lsgan':
-                loss = loss * 0.5
-        else:
-            if is_dis:
-                if target_is_real:
-                    prediction = -prediction
-                if self.gan_mode == 'wgangp':
-                    loss = prediction.mean()
-                elif self.gan_mode == 'nonsaturating':
-                    loss = F.softplus(prediction).mean()
-                elif self.gan_mode == 'hinge':
-                    loss = self.loss(1+prediction).mean()
-            else:
-                if self.gan_mode == 'nonsaturating':
-                   loss = F.softplus(-prediction).mean()
-                else:
-                    loss = -prediction.mean()
-        return loss
-
-    def __call__(self, predictions, target_is_real, is_dis=False):
-        """Calculate loss for multi-scales gan"""
-        if isinstance(predictions, list):
-            losses = []
-            for prediction in predictions:
-                losses.append(self.calculate_loss(prediction, target_is_real, is_dis))
-            loss = sum(losses)
-        else:
-            loss = self.calculate_loss(predictions, target_is_real, is_dis)
-
-        return loss
-
-
-def cal_gradient_penalty(netD, real_data, fake_data, device, type='mixed', constant=1.0, lambda_gp=10.0):
-    """Calculate the gradient penalty loss, used in WGAN-GP paper https://arxiv.org/abs/1704.00028
-
-    Arguments:
-        netD (network)              -- discriminator network
-        real_data (tensor array)    -- real examples
-        fake_data (tensor array)    -- generated examples from the generator
-        device (str)                -- GPU / CPU: from torch.device('cuda:{}'.format(self.gpu_ids[0])) if self.gpu_ids else torch.device('cpu')
-        type (str)                  -- if we mix real and fake data or not [real | fake | mixed].
-        constant (float)            -- the constant used in formula ( ||gradient||_2 - constant)^2
-        lambda_gp (float)           -- weight for this loss
-
-    Returns the gradient penalty loss
-    """
-    if lambda_gp > 0.0:
-        if type == 'real':   # either use real examples, fake examples, or a linear interpolation of two.
-            interpolatesv = real_data
-        elif type == 'fake':
-            interpolatesv = fake_data
-        elif type == 'mixed':
-            alpha = torch.rand(real_data.shape[0], 1, device=device)
-            alpha = alpha.expand(real_data.shape[0], real_data.nelement() // real_data.shape[0]).contiguous().view(*real_data.shape)
-            interpolatesv = alpha * real_data + ((1 - alpha) * fake_data)
-        else:
-            raise NotImplementedError('{} not implemented'.format(type))
-        interpolatesv.requires_grad_(True)
-        disc_interpolates = netD(interpolatesv)
-        if isinstance(disc_interpolates, list):
-            gradients = 0
-            for disc_interpolate in disc_interpolates:
-                gradients += torch.autograd.grad(outputs=disc_interpolate, inputs=interpolatesv,
-                                        grad_outputs=torch.ones(disc_interpolate.size()).to(device),
-                                        create_graph=True, retain_graph=True, only_inputs=True)[0]
-        else:
-            gradients = torch.autograd.grad(outputs=disc_interpolates, inputs=interpolatesv,
-                                            grad_outputs=torch.ones(disc_interpolates.size()).to(device),
-                                            create_graph=True, retain_graph=True, only_inputs=True)[0]
-        gradients = gradients.view(real_data.size(0), -1)  # flat the data
-        gradient_penalty = (((gradients + 1e-16).norm(2, dim=1) - constant) ** 2).mean() * lambda_gp        # added eps
-        return gradient_penalty, gradients
-    else:
-        return 0.0, None
-
-
-####################################################################################################
-# trained LPIPS loss
-####################################################################################################
-def normalize_tensor(x, eps=1e-10):
-    norm_factor = torch.sqrt(torch.sum(x**2, dim=1, keepdim=True))
-    return x/(norm_factor+eps)
-
-
-def spatial_average(x, keepdim=True):
-    return x.mean([2, 3], keepdim=keepdim)
-
-
-class NetLinLayer(nn.Module):
-    """ A single linear layer which does a 1x1 conv """
-    def __init__(self, chn_in, chn_out=1, use_dropout=False):
-        super(NetLinLayer, self).__init__()
-        layers = [nn.Dropout(), ] if (use_dropout) else []
-        layers += [nn.Conv2d(chn_in, chn_out, 1, stride=1, padding=0, bias=False), ]
-        self.model = nn.Sequential(*layers)
-
-
-class LPIPSLoss(nn.Module):
-    """
-    Learned perceptual metric
-    https://github.com/richzhang/PerceptualSimilarity
-    """
-    def __init__(self, use_dropout=True, ckpt_path=None):
-        super(LPIPSLoss, self).__init__()
-        self.path = ckpt_path
-        self.net = VGG16()
-        self.chns = [64, 128, 256, 512, 512]  # vg16 features
-        self.lin0 = NetLinLayer(self.chns[0], use_dropout=use_dropout)
-        self.lin1 = NetLinLayer(self.chns[1], use_dropout=use_dropout)
-        self.lin2 = NetLinLayer(self.chns[2], use_dropout=use_dropout)
-        self.lin3 = NetLinLayer(self.chns[3], use_dropout=use_dropout)
-        self.lin4 = NetLinLayer(self.chns[4], use_dropout=use_dropout)
-        self.load_from_pretrained()
-        for param in self.parameters():
-            param.requires_grad = False
-
-    def load_from_pretrained(self):
-        self.load_state_dict(torch.load(self.path, map_location=torch.device("cpu")), strict=False)
-        print("loaded pretrained LPIPS loss from {}".format(self.path))
-
-    def _get_features(self, vgg_f):
-        names = ['relu1_2', 'relu2_2', 'relu3_3', 'relu4_3', 'relu5_3']
-        feats = []
-        for i in range(len(names)):
-            name = names[i]
-            feat = vgg_f[name]
-            feats.append(feat)
-        return feats
-
-    def forward(self, x, y):
-        x_vgg, y_vgg = self._get_features(self.net(x)), self._get_features(self.net(y))
-        lins = [self.lin0, self.lin1, self.lin2, self.lin3, self.lin4]
-        reses = []
-        loss = 0
-
-        for i in range(len(self.chns)):
-            x_feats, y_feats = normalize_tensor(x_vgg[i]), normalize_tensor(y_vgg[i])
-            diffs = (x_feats - y_feats) ** 2
-            res = spatial_average(lins[i].model(diffs))
-            loss += res
-            reses.append(res)
-
-        return loss
-
-
-class PerceptualLoss(nn.Module):
-    r"""
-    Perceptual loss, VGG-based
-    https://arxiv.org/abs/1603.08155
-    https://github.com/dxyang/StyleTransfer/blob/master/utils.py
-    """
-
-    def __init__(self, weights=[1.0, 1.0, 1.0, 1.0, 0.0]):
-        super(PerceptualLoss, self).__init__()
-        self.add_module('vgg', VGG16())
-        self.criterion = nn.L1Loss()
-        self.weights = weights
-
-    def __call__(self, x, y):
-        # Compute features
-        x_vgg, y_vgg = self.vgg(x), self.vgg(y)
-
-        content_loss = 0.0
-        content_loss += self.weights[0] * self.criterion(x_vgg['relu1_2'], y_vgg['relu1_2']) if self.weights[0] > 0 else 0
-        content_loss += self.weights[1] * self.criterion(x_vgg['relu2_2'], y_vgg['relu2_2']) if self.weights[1] > 0 else 0
-        content_loss += self.weights[2] * self.criterion(x_vgg['relu3_3'], y_vgg['relu3_3']) if self.weights[2] > 0 else 0
-        content_loss += self.weights[3] * self.criterion(x_vgg['relu4_3'], y_vgg['relu4_3']) if self.weights[3] > 0 else 0
-        content_loss += self.weights[4] * self.criterion(x_vgg['relu5_3'], y_vgg['relu5_3']) if self.weights[4] > 0 else 0
-
-        return content_loss
-
-
-class Normalization(nn.Module):
-    def __init__(self, device):
-        super(Normalization, self).__init__()
-        # .view the mean and std to make them [C x 1 x 1] so that they can
-        # directly work with image Tensor of shape [B x C x H x W].
-        # B is batch size. C is number of channels. H is height and W is width.
-        mean = torch.tensor([0.485, 0.456, 0.406]).to(device)
-        std = torch.tensor([0.229, 0.224, 0.225]).to(device)
-        self.mean = mean.view(-1, 1, 1)
-        self.std = std.view(-1, 1, 1)
-
-    def forward(self, img):
-        # normalize img
-        return (img - self.mean) / self.std
-
-
-class VGG16(nn.Module):
-    def __init__(self):
-        super(VGG16, self).__init__()
-        features = models.vgg16(pretrained=True).features
-        self.relu1_1 = torch.nn.Sequential()
-        self.relu1_2 = torch.nn.Sequential()
-
-        self.relu2_1 = torch.nn.Sequential()
-        self.relu2_2 = torch.nn.Sequential()
-
-        self.relu3_1 = torch.nn.Sequential()
-        self.relu3_2 = torch.nn.Sequential()
-        self.relu3_3 = torch.nn.Sequential()
-
-        self.relu4_1 = torch.nn.Sequential()
-        self.relu4_2 = torch.nn.Sequential()
-        self.relu4_3 = torch.nn.Sequential()
-
-        self.relu5_1 = torch.nn.Sequential()
-        self.relu5_2 = torch.nn.Sequential()
-        self.relu5_3 = torch.nn.Sequential()
-
-        for x in range(2):
-            self.relu1_1.add_module(str(x), features[x])
-
-        for x in range(2, 4):
-            self.relu1_2.add_module(str(x), features[x])
-
-        for x in range(4, 7):
-            self.relu2_1.add_module(str(x), features[x])
-
-        for x in range(7, 9):
-            self.relu2_2.add_module(str(x), features[x])
-
-        for x in range(9, 12):
-            self.relu3_1.add_module(str(x), features[x])
-
-        for x in range(12, 14):
-            self.relu3_2.add_module(str(x), features[x])
-
-        for x in range(14, 16):
-            self.relu3_3.add_module(str(x), features[x])
-
-        for x in range(16, 18):
-            self.relu4_1.add_module(str(x), features[x])
-
-        for x in range(18, 21):
-            self.relu4_2.add_module(str(x), features[x])
-
-        for x in range(21, 23):
-            self.relu4_3.add_module(str(x), features[x])
-
-        for x in range(23, 26):
-            self.relu5_1.add_module(str(x), features[x])
-
-        for x in range(26, 28):
-            self.relu5_2.add_module(str(x), features[x])
-
-        for x in range(28, 30):
-            self.relu5_3.add_module(str(x), features[x])
-
-        # don't need the gradients, just want the features
-        for param in self.parameters():
-           param.requires_grad = False
-
-    def forward(self, x,):
-        relu1_1 = self.relu1_1(x)
-        relu1_2 = self.relu1_2(relu1_1)
-
-        relu2_1 = self.relu2_1(relu1_2)
-        relu2_2 = self.relu2_2(relu2_1)
-
-        relu3_1 = self.relu3_1(relu2_2)
-        relu3_2 = self.relu3_2(relu3_1)
-        relu3_3 = self.relu3_3(relu3_2)
-
-        relu4_1 = self.relu4_1(relu3_3)
-        relu4_2 = self.relu4_2(relu4_1)
-        relu4_3 = self.relu4_3(relu4_2)
-
-        relu5_1 = self.relu5_1(relu4_3)
-        relu5_2 = self.relu5_2(relu5_1)
-        relu5_3 = self.relu5_3(relu5_2)
-
-        out = {
-            'relu1_1': relu1_1,
-            'relu1_2': relu1_2,
-
-            'relu2_1': relu2_1,
-            'relu2_2': relu2_2,
-
-            'relu3_1': relu3_1,
-            'relu3_2': relu3_2,
-            'relu3_3': relu3_3,
-
-            'relu4_1': relu4_1,
-            'relu4_2': relu4_2,
-            'relu4_3': relu4_3,
-
-            'relu5_1': relu5_1,
-            'relu5_2': relu5_2,
-            'relu5_3': relu5_3,
-        }
-        return out

spaces/Anonymous-sub/Rerender/ControlNet/annotator/uniformer/mmcv/image/io.py

@@ -1,258 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import io
-import os.path as osp
-from pathlib import Path
-
-import cv2
-import numpy as np
-from cv2 import (IMREAD_COLOR, IMREAD_GRAYSCALE, IMREAD_IGNORE_ORIENTATION,
-                 IMREAD_UNCHANGED)
-
-from annotator.uniformer.mmcv.utils import check_file_exist, is_str, mkdir_or_exist
-
-try:
-    from turbojpeg import TJCS_RGB, TJPF_BGR, TJPF_GRAY, TurboJPEG
-except ImportError:
-    TJCS_RGB = TJPF_GRAY = TJPF_BGR = TurboJPEG = None
-
-try:
-    from PIL import Image, ImageOps
-except ImportError:
-    Image = None
-
-try:
-    import tifffile
-except ImportError:
-    tifffile = None
-
-jpeg = None
-supported_backends = ['cv2', 'turbojpeg', 'pillow', 'tifffile']
-
-imread_flags = {
-    'color': IMREAD_COLOR,
-    'grayscale': IMREAD_GRAYSCALE,
-    'unchanged': IMREAD_UNCHANGED,
-    'color_ignore_orientation': IMREAD_IGNORE_ORIENTATION | IMREAD_COLOR,
-    'grayscale_ignore_orientation':
-    IMREAD_IGNORE_ORIENTATION | IMREAD_GRAYSCALE
-}
-
-imread_backend = 'cv2'
-
-
-def use_backend(backend):
-    """Select a backend for image decoding.
-
-    Args:
-        backend (str): The image decoding backend type. Options are `cv2`,
-        `pillow`, `turbojpeg` (see https://github.com/lilohuang/PyTurboJPEG)
-        and `tifffile`. `turbojpeg` is faster but it only supports `.jpeg`
-        file format.
-    """
-    assert backend in supported_backends
-    global imread_backend
-    imread_backend = backend
-    if imread_backend == 'turbojpeg':
-        if TurboJPEG is None:
-            raise ImportError('`PyTurboJPEG` is not installed')
-        global jpeg
-        if jpeg is None:
-            jpeg = TurboJPEG()
-    elif imread_backend == 'pillow':
-        if Image is None:
-            raise ImportError('`Pillow` is not installed')
-    elif imread_backend == 'tifffile':
-        if tifffile is None:
-            raise ImportError('`tifffile` is not installed')
-
-
-def _jpegflag(flag='color', channel_order='bgr'):
-    channel_order = channel_order.lower()
-    if channel_order not in ['rgb', 'bgr']:
-        raise ValueError('channel order must be either "rgb" or "bgr"')
-
-    if flag == 'color':
-        if channel_order == 'bgr':
-            return TJPF_BGR
-        elif channel_order == 'rgb':
-            return TJCS_RGB
-    elif flag == 'grayscale':
-        return TJPF_GRAY
-    else:
-        raise ValueError('flag must be "color" or "grayscale"')
-
-
-def _pillow2array(img, flag='color', channel_order='bgr'):
-    """Convert a pillow image to numpy array.
-
-    Args:
-        img (:obj:`PIL.Image.Image`): The image loaded using PIL
-        flag (str): Flags specifying the color type of a loaded image,
-            candidates are 'color', 'grayscale' and 'unchanged'.
-            Default to 'color'.
-        channel_order (str): The channel order of the output image array,
-            candidates are 'bgr' and 'rgb'. Default to 'bgr'.
-
-    Returns:
-        np.ndarray: The converted numpy array
-    """
-    channel_order = channel_order.lower()
-    if channel_order not in ['rgb', 'bgr']:
-        raise ValueError('channel order must be either "rgb" or "bgr"')
-
-    if flag == 'unchanged':
-        array = np.array(img)
-        if array.ndim >= 3 and array.shape[2] >= 3:  # color image
-            array[:, :, :3] = array[:, :, (2, 1, 0)]  # RGB to BGR
-    else:
-        # Handle exif orientation tag
-        if flag in ['color', 'grayscale']:
-            img = ImageOps.exif_transpose(img)
-        # If the image mode is not 'RGB', convert it to 'RGB' first.
-        if img.mode != 'RGB':
-            if img.mode != 'LA':
-                # Most formats except 'LA' can be directly converted to RGB
-                img = img.convert('RGB')
-            else:
-                # When the mode is 'LA', the default conversion will fill in
-                #  the canvas with black, which sometimes shadows black objects
-                #  in the foreground.
-                #
-                # Therefore, a random color (124, 117, 104) is used for canvas
-                img_rgba = img.convert('RGBA')
-                img = Image.new('RGB', img_rgba.size, (124, 117, 104))
-                img.paste(img_rgba, mask=img_rgba.split()[3])  # 3 is alpha
-        if flag in ['color', 'color_ignore_orientation']:
-            array = np.array(img)
-            if channel_order != 'rgb':
-                array = array[:, :, ::-1]  # RGB to BGR
-        elif flag in ['grayscale', 'grayscale_ignore_orientation']:
-            img = img.convert('L')
-            array = np.array(img)
-        else:
-            raise ValueError(
-                'flag must be "color", "grayscale", "unchanged", '
-                f'"color_ignore_orientation" or "grayscale_ignore_orientation"'
-                f' but got {flag}')
-    return array
-
-
-def imread(img_or_path, flag='color', channel_order='bgr', backend=None):
-    """Read an image.
-
-    Args:
-        img_or_path (ndarray or str or Path): Either a numpy array or str or
-            pathlib.Path. If it is a numpy array (loaded image), then
-            it will be returned as is.
-        flag (str): Flags specifying the color type of a loaded image,
-            candidates are `color`, `grayscale`, `unchanged`,
-            `color_ignore_orientation` and `grayscale_ignore_orientation`.
-            By default, `cv2` and `pillow` backend would rotate the image
-            according to its EXIF info unless called with `unchanged` or
-            `*_ignore_orientation` flags. `turbojpeg` and `tifffile` backend
-            always ignore image's EXIF info regardless of the flag.
-            The `turbojpeg` backend only supports `color` and `grayscale`.
-        channel_order (str): Order of channel, candidates are `bgr` and `rgb`.
-        backend (str | None): The image decoding backend type. Options are
-            `cv2`, `pillow`, `turbojpeg`, `tifffile`, `None`.
-            If backend is None, the global imread_backend specified by
-            ``mmcv.use_backend()`` will be used. Default: None.
-
-    Returns:
-        ndarray: Loaded image array.
-    """
-
-    if backend is None:
-        backend = imread_backend
-    if backend not in supported_backends:
-        raise ValueError(f'backend: {backend} is not supported. Supported '
-                         "backends are 'cv2', 'turbojpeg', 'pillow'")
-    if isinstance(img_or_path, Path):
-        img_or_path = str(img_or_path)
-
-    if isinstance(img_or_path, np.ndarray):
-        return img_or_path
-    elif is_str(img_or_path):
-        check_file_exist(img_or_path,
-                         f'img file does not exist: {img_or_path}')
-        if backend == 'turbojpeg':
-            with open(img_or_path, 'rb') as in_file:
-                img = jpeg.decode(in_file.read(),
-                                  _jpegflag(flag, channel_order))
-                if img.shape[-1] == 1:
-                    img = img[:, :, 0]
-            return img
-        elif backend == 'pillow':
-            img = Image.open(img_or_path)
-            img = _pillow2array(img, flag, channel_order)
-            return img
-        elif backend == 'tifffile':
-            img = tifffile.imread(img_or_path)
-            return img
-        else:
-            flag = imread_flags[flag] if is_str(flag) else flag
-            img = cv2.imread(img_or_path, flag)
-            if flag == IMREAD_COLOR and channel_order == 'rgb':
-                cv2.cvtColor(img, cv2.COLOR_BGR2RGB, img)
-            return img
-    else:
-        raise TypeError('"img" must be a numpy array or a str or '
-                        'a pathlib.Path object')
-
-
-def imfrombytes(content, flag='color', channel_order='bgr', backend=None):
-    """Read an image from bytes.
-
-    Args:
-        content (bytes): Image bytes got from files or other streams.
-        flag (str): Same as :func:`imread`.
-        backend (str | None): The image decoding backend type. Options are
-            `cv2`, `pillow`, `turbojpeg`, `None`. If backend is None, the
-            global imread_backend specified by ``mmcv.use_backend()`` will be
-            used. Default: None.
-
-    Returns:
-        ndarray: Loaded image array.
-    """
-
-    if backend is None:
-        backend = imread_backend
-    if backend not in supported_backends:
-        raise ValueError(f'backend: {backend} is not supported. Supported '
-                         "backends are 'cv2', 'turbojpeg', 'pillow'")
-    if backend == 'turbojpeg':
-        img = jpeg.decode(content, _jpegflag(flag, channel_order))
-        if img.shape[-1] == 1:
-            img = img[:, :, 0]
-        return img
-    elif backend == 'pillow':
-        buff = io.BytesIO(content)
-        img = Image.open(buff)
-        img = _pillow2array(img, flag, channel_order)
-        return img
-    else:
-        img_np = np.frombuffer(content, np.uint8)
-        flag = imread_flags[flag] if is_str(flag) else flag
-        img = cv2.imdecode(img_np, flag)
-        if flag == IMREAD_COLOR and channel_order == 'rgb':
-            cv2.cvtColor(img, cv2.COLOR_BGR2RGB, img)
-        return img
-
-
-def imwrite(img, file_path, params=None, auto_mkdir=True):
-    """Write image to file.
-
-    Args:
-        img (ndarray): Image array to be written.
-        file_path (str): Image file path.
-        params (None or list): Same as opencv :func:`imwrite` interface.
-        auto_mkdir (bool): If the parent folder of `file_path` does not exist,
-            whether to create it automatically.
-
-    Returns:
-        bool: Successful or not.
-    """
-    if auto_mkdir:
-        dir_name = osp.abspath(osp.dirname(file_path))
-        mkdir_or_exist(dir_name)
-    return cv2.imwrite(file_path, img, params)

spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/setuptools/_distutils/log.py

@@ -1,80 +0,0 @@
-"""A simple log mechanism styled after PEP 282."""
-
-# The class here is styled after PEP 282 so that it could later be
-# replaced with a standard Python logging implementation.
-
-import sys
-
-DEBUG = 1
-INFO = 2
-WARN = 3
-ERROR = 4
-FATAL = 5
-
-
-class Log:
-    def __init__(self, threshold=WARN):
-        self.threshold = threshold
-
-    def _log(self, level, msg, args):
-        if level not in (DEBUG, INFO, WARN, ERROR, FATAL):
-            raise ValueError('%s wrong log level' % str(level))
-
-        if level >= self.threshold:
-            if args:
-                msg = msg % args
-            if level in (WARN, ERROR, FATAL):
-                stream = sys.stderr
-            else:
-                stream = sys.stdout
-            try:
-                stream.write('%s\n' % msg)
-            except UnicodeEncodeError:
-                # emulate backslashreplace error handler
-                encoding = stream.encoding
-                msg = msg.encode(encoding, "backslashreplace").decode(encoding)
-                stream.write('%s\n' % msg)
-            stream.flush()
-
-    def log(self, level, msg, *args):
-        self._log(level, msg, args)
-
-    def debug(self, msg, *args):
-        self._log(DEBUG, msg, args)
-
-    def info(self, msg, *args):
-        self._log(INFO, msg, args)
-
-    def warn(self, msg, *args):
-        self._log(WARN, msg, args)
-
-    def error(self, msg, *args):
-        self._log(ERROR, msg, args)
-
-    def fatal(self, msg, *args):
-        self._log(FATAL, msg, args)
-
-
-_global_log = Log()
-log = _global_log.log
-debug = _global_log.debug
-info = _global_log.info
-warn = _global_log.warn
-error = _global_log.error
-fatal = _global_log.fatal
-
-
-def set_threshold(level):
-    # return the old threshold for use from tests
-    old = _global_log.threshold
-    _global_log.threshold = level
-    return old
-
-
-def set_verbosity(v):
-    if v <= 0:
-        set_threshold(WARN)
-    elif v == 1:
-        set_threshold(INFO)
-    elif v >= 2:
-        set_threshold(DEBUG)

spaces/Audio-AGI/WavJourney/VoiceParser/hubert_manager.py

@@ -1,33 +0,0 @@
-import os.path
-import shutil
-import urllib.request
-
-import huggingface_hub
-
-
-class HuBERTManager:
-    @staticmethod
-    def make_sure_hubert_installed(download_url: str = 'https://dl.fbaipublicfiles.com/hubert/hubert_base_ls960.pt', file_name: str = 'hubert.pt'):
-        install_dir = os.path.join('VoiceParser', 'hubert')
-        if not os.path.isdir(install_dir):
-            os.makedirs(install_dir, exist_ok=True)
-        install_file = os.path.join(install_dir, file_name)
-        if not os.path.isfile(install_file):
-            print('Downloading HuBERT base model')
-            urllib.request.urlretrieve(download_url, install_file)
-            print('Downloaded HuBERT')
-        return install_file
-
-
-    @staticmethod
-    def make_sure_tokenizer_installed(model: str = 'quantifier_hubert_base_ls960_14.pth', repo: str = 'GitMylo/bark-voice-cloning', local_file: str = 'tokenizer.pth'):
-        install_dir = os.path.join('VoiceParser', 'hubert')
-        if not os.path.isdir(install_dir):
-            os.makedirs(install_dir, exist_ok=True)
-        install_file = os.path.join(install_dir, local_file)
-        if not os.path.isfile(install_file):
-            print('Downloading HuBERT custom tokenizer')
-            huggingface_hub.hf_hub_download(repo, model, local_dir=install_dir, local_dir_use_symlinks=False)
-            shutil.move(os.path.join(install_dir, model), install_file)
-            print('Downloaded tokenizer')
-        return install_file

spaces/Audio-AGI/WavJourney/voice_presets.py

@@ -1,96 +0,0 @@
-import os
-import json, json5
-from pathlib import Path
-
-import utils
-from APIs import VP
-
-
-def save_voice_presets_metadata(voice_presets_path, metadata):
-    with open(voice_presets_path / 'metadata.json', 'w') as f:
-        json.dump(metadata, f, indent=4)
-
-def load_voice_presets_metadata(voice_presets_path, safe_if_metadata_not_exist=False):
-    metadata_full_path = Path(voice_presets_path) / 'metadata.json'
-
-    if safe_if_metadata_not_exist:
-        if not os.path.exists(metadata_full_path):
-            return {}
-
-    with open(metadata_full_path, 'r') as f:
-        presets = json5.load(f)
-
-    return presets
-
-# return system voice presets and session voice presets individually, each in a list
-def get_voice_presets(session_id):
-    system_presets, session_presets = [], []
-
-    # Load system presets
-    system_presets = load_voice_presets_metadata(utils.get_system_voice_preset_path())
-
-    # Load session presets
-    session_presets = load_voice_presets_metadata(
-        utils.get_session_voice_preset_path(session_id),
-        safe_if_metadata_not_exist=True
-    )
-
-    return system_presets, session_presets
-
-# return merged voice presets in a {voice_preset_name: voice_preset} dict
-def get_merged_voice_presets(session_id):
-    system_presets, session_presets = get_voice_presets(session_id)
-    res = {}
-    for preset in list(system_presets.values()) + list(session_presets.values()):
-        res[preset['id']] = preset  # session presets with the same id will cover that of system presets
-    return res
-
-def add_voice_preset(voice_presets_path, presets, id, desc, wav_file_path):
-    if id in presets:
-        raise KeyError(f'{id} already in voice preset, path={voice_presets_path}!')
-
-    # Convert wav to npz
-    npz_path = voice_presets_path / 'npz'
-    VP(wav_file_path, npz_path)
-    npz_file_path = npz_path / f'{Path(wav_file_path).stem}.npz'
-
-    presets[id]  = {
-        'id': id,
-        'desc': desc,
-        'npz_path': str(npz_file_path)
-    }
-    save_voice_presets_metadata(voice_presets_path, presets)
-    return presets[id]
-
-def add_session_voice_preset(id, desc, wav_file_path, session_id):
-    voice_presets_path = utils.get_session_voice_preset_path(session_id)
-    os.makedirs(voice_presets_path / 'npz', exist_ok=True)
-    presets = load_voice_presets_metadata(voice_presets_path, safe_if_metadata_not_exist=True)
-    if len(presets) >= 3:
-        raise ValueError(f'session voice presets size exceed 3')
-    if id in presets:
-        raise KeyError(f'{id} already in voice preset, path={voice_presets_path}!')
-
-    return add_voice_preset(voice_presets_path, presets, id, desc, wav_file_path)
-
-def add_system_voice_preset(id, desc, wav_file_path):
-    voice_presets_path = utils.get_system_voice_preset_path()
-    presets = load_voice_presets_metadata(voice_presets_path)
-    return add_voice_preset(voice_presets_path, presets, id, desc, wav_file_path)
-
-# if session_id set to '', we are removing system voice presets
-def remove_session_voice_preset(id, session_id):
-    voice_presets_path = utils.get_session_voice_preset_path(session_id)
-    presets = load_voice_presets_metadata(
-        voice_presets_path,
-        safe_if_metadata_not_exist=True
-    )
-    preset = presets.pop(id)
-    npz_path = preset['npz_path']
-
-    try:
-        os.remove(npz_path)
-    except FileNotFoundError:
-        print(f"INFO: trying to delete {npz_path} which does not exist, path={voice_presets_path}.")
-
-    save_voice_presets_metadata(voice_presets_path, presets)

spaces/B10915003/B10915003-autotrain-jimmy-test-face-identification-53251125423/README.md

@@ -1,13 +0,0 @@
----
-title: B10915003 Autotrain Jimmy Test Face Identification 53251125423
-emoji: 👁
-colorFrom: green
-colorTo: indigo
-sdk: gradio
-sdk_version: 3.27.0
-app_file: app.py
-pinned: false
-license: apache-2.0
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/BAAI/dreambooth-altdiffusion/app.py

@@ -1,654 +0,0 @@
-import gradio as gr
-import os
-from pathlib import Path
-import argparse
-import shutil
-from train_dreambooth import run_training
-from convertosd import convert
-from PIL import Image
-from slugify import slugify
-import requests
-import torch
-import zipfile
-import tarfile
-import urllib.parse
-import gc
-# from diffusers import StableDiffusionPipeline
-from huggingface_hub import snapshot_download
-
-
-is_spaces = True if "SPACE_ID" in os.environ else False
-is_shared_ui = True if "IS_SHARED_UI" in os.environ else False
-is_gpu_associated = torch.cuda.is_available()
-
-css = '''
-    .instruction{position: absolute; top: 0;right: 0;margin-top: 0px !important}
-    .arrow{position: absolute;top: 0;right: -110px;margin-top: -8px !important}
-    #component-4, #component-3, #component-10{min-height: 0}
-    .duplicate-button img{margin: 0}
-'''
-maximum_concepts = 3
-
-#Pre download the files
-if(is_gpu_associated):
-    model_v1 = snapshot_download(repo_id="multimodalart/sd-fine-tunable")
-    model_v2 = snapshot_download(repo_id="stabilityai/stable-diffusion-2")
-    model_v2_512 = snapshot_download(repo_id="stabilityai/stable-diffusion-2-base")
-    model_alt = snapshot_download(repo_id="BAAI/AltDiffusion")
-    model_alt_m9 = snapshot_download(repo_id="BAAI/AltDiffusion-m9")
-    safety_checker = snapshot_download(repo_id="multimodalart/sd-sc")
-    model_to_load = model_alt_m9
-with zipfile.ZipFile("mix.zip", 'r') as zip_ref:
-    zip_ref.extractall(".")
-
-def swap_text(option, base):
-    resize_width = 768 if base == "v2-768" else 512
-    mandatory_liability = "You must have the right to do so and you are liable for the images you use, example:"
-    if(option == "object"):
-        instance_prompt_example = "cttoy"
-        freeze_for = 30
-        return [f"You are going to train `object`(s), upload 5-10 images of each object you are planning on training on from different angles/perspectives. You can use services like <a style='text-decoration: underline' target='_blank' href='https://www.birme.net/?target_width={resize_width}&target_height={resize_width}'>birme</a> for smart cropping. {mandatory_liability}:", '''<img src="https://raw.githubusercontent.com/superhero-7/img_bank/main/Naruto.png" />''', f"You should name your concept with a unique made up word that has low chance of the model already knowing it (e.g.: `{instance_prompt_example}` here). Images will be automatically cropped to {resize_width}x{resize_width}.", freeze_for, gr.update(visible=False)]
-    elif(option == "person"):
-       instance_prompt_example = "julcto"
-       freeze_for = 70
-       #show_prior_preservation = True if base != "v2-768" else False
-       show_prior_preservation=False
-       if(show_prior_preservation):
-           prior_preservation_box_update = gr.update(visible=show_prior_preservation)
-       else: 
-           prior_preservation_box_update = gr.update(visible=show_prior_preservation, value=False)
-       return [f"You are going to train a `person`(s), upload 10-20 images of each person you are planning on training on from different angles/perspectives. You can use services like <a style='text-decoration: underline' target='_blank' href='https://www.birme.net/?target_width={resize_width}&target_height={resize_width}'>birme</a> for smart cropping. {mandatory_liability}:", '''<img src="https://raw.githubusercontent.com/superhero-7/img_bank/main/cxk.png" />''', f"You should name your concept with a unique made up word that has low chance of the model already knowing it (e.g.: `{instance_prompt_example}` here). Images will be automatically cropped to {resize_width}x{resize_width}.", freeze_for, prior_preservation_box_update]
-    elif(option == "style"):
-        instance_prompt_example = "trsldamrl"
-        freeze_for = 10
-        return [f"You are going to train a `style`, upload 10-20 images of the style you are planning on training on. You can use services like <a style='text-decoration: underline' target='_blank' href='https://www.birme.net/?target_width={resize_width}&target_height={resize_width}'>birme</a> for smart cropping. Name the files with the words you would like  {mandatory_liability}:", '''<img src="file/trsl_style.png" />''', f"You should name your concept with a unique made up word that has low chance of the model already knowing it (e.g.: `{instance_prompt_example}` here). Images will be automatically cropped to {resize_width}x{resize_width}", freeze_for, gr.update(visible=False)]
-
-def swap_base_model(selected_model):
-    if(is_gpu_associated):
-        global model_to_load
-        # if(selected_model == "v1-5"):
-        #     model_to_load = model_v1
-        # elif(selected_model == "v2-768"):
-        #     model_to_load = model_v2
-        # elif(selected_model == "alt"):
-        #     model_to_load = model_alt
-        # elif(selected_model == "alt_m9"):
-        #     model_to_load = model_alt_m9
-        # else:
-        #     model_to_load = model_v2_512
-        if(selected_model == "alt"):
-            model_to_load = model_alt
-
-def count_files(*inputs):
-    file_counter = 0
-    concept_counter = 0
-    for i, input in enumerate(inputs):
-        if(i < maximum_concepts-1):
-            files = inputs[i]
-            if(files):
-                concept_counter+=1
-                file_counter+=len(files)
-    uses_custom = inputs[-1] 
-    type_of_thing = inputs[-4]
-    selected_model = inputs[-5]
-    experimental_faces = inputs[-6]
-    if(uses_custom):
-        Training_Steps = int(inputs[-3])
-    else:
-        Training_Steps = file_counter*150
-        if(type_of_thing == "person" and Training_Steps > 2400):
-            Training_Steps = 2400 #Avoid overfitting on person faces
-    if(is_spaces):
-        if(selected_model == "v1-5" or selected_model == "alt" or selected_model == "alt_m9"):
-            its = 1.1
-            if(experimental_faces):
-                its = 1
-        elif(selected_model == "v2-512"):
-            its = 0.8
-            if(experimental_faces):
-                its = 0.7
-        elif(selected_model == "v2-768"):
-            its = 0.5
-        summary_sentence = f'''You are going to train {concept_counter} {type_of_thing}(s), with {file_counter} images for {Training_Steps} steps. The training should take around {round(Training_Steps/its, 2)} seconds, or {round((Training_Steps/its)/60, 2)} minutes.
-            The setup, compression and uploading the model can take up to 20 minutes.<br>As the T4-Small GPU costs US$0.60 for 1h, <span style="font-size: 120%"><b>the estimated cost for this training is below US${round((((Training_Steps/its)/3600)+0.3+0.1)*0.60, 2)}.</b></span><br><br>
-            If you check the box below the GPU attribution will automatically removed after training is done and the model is uploaded. If not, don't forget to come back here and swap the hardware back to CPU.<br><br>'''
-    else:
-        summary_sentence = f'''You are going to train {concept_counter} {type_of_thing}(s), with {file_counter} images for {Training_Steps} steps.<br><br>'''
-        
-    return([gr.update(visible=True), gr.update(visible=True, value=summary_sentence)])
-
-def update_steps(*files_list):
-    file_counter = 0
-    for i, files in enumerate(files_list):
-        if(files):
-            file_counter+=len(files)
-    return(gr.update(value=file_counter*200))
-
-def pad_image(image):
-    w, h = image.size
-    if w == h:
-        return image
-    elif w > h:
-        new_image = Image.new(image.mode, (w, w), (0, 0, 0))
-        new_image.paste(image, (0, (w - h) // 2))
-        return new_image
-    else:
-        new_image = Image.new(image.mode, (h, h), (0, 0, 0))
-        new_image.paste(image, ((h - w) // 2, 0))
-        return new_image
-
-def train(*inputs):
-    if is_shared_ui:
-        raise gr.Error("This Space only works in duplicated instances")
-    if not is_gpu_associated:
-        raise gr.Error("Please associate a T4 GPU for this Space")
-    torch.cuda.empty_cache()
-    if 'pipe' in globals():
-        global pipe, pipe_is_set
-        del pipe
-        pipe_is_set = False
-        gc.collect()
-        
-    if os.path.exists("output_model"): shutil.rmtree('output_model')
-    if os.path.exists("instance_images"): shutil.rmtree('instance_images')
-    if os.path.exists("diffusers_model.tar"): os.remove("diffusers_model.tar")
-    if os.path.exists("model.ckpt"): os.remove("model.ckpt")
-    if os.path.exists("hastrained.success"): os.remove("hastrained.success")
-    file_counter = 0
-    which_model = inputs[-10]
-    resolution = 512 if which_model != "v2-768" else 768
-    for i, input in enumerate(inputs):
-        if(i < maximum_concepts-1):
-            if(input):
-                os.makedirs('instance_images',exist_ok=True)
-                files = inputs[i+(maximum_concepts*2)]
-                prompt = inputs[i+maximum_concepts]
-                if(prompt == "" or prompt == None):
-                    raise gr.Error("You forgot to define your concept prompt")
-                for j, file_temp in enumerate(files):
-                    file = Image.open(file_temp.name)
-                    image = pad_image(file)
-                    image = image.resize((resolution, resolution))
-                    extension = file_temp.name.split(".")[1]
-                    image = image.convert('RGB')
-                    image.save(f'instance_images/{prompt}_({j+1}).jpg', format="JPEG", quality = 100)
-                    file_counter += 1
-    
-    os.makedirs('output_model',exist_ok=True)
-    uses_custom = inputs[-1] 
-    type_of_thing = inputs[-4]
-    remove_attribution_after = inputs[-6]
-    experimental_face_improvement = inputs[-9]
-    
-    if(uses_custom):
-        Training_Steps = int(inputs[-3])
-        Train_text_encoder_for = int(inputs[-2])
-    else:
-        if(type_of_thing == "object"):
-            Train_text_encoder_for=30
-            
-        elif(type_of_thing == "style"):
-            Train_text_encoder_for=15
-            
-        elif(type_of_thing == "person"):
-            Train_text_encoder_for=70
-        
-        Training_Steps = file_counter*150
-        if(type_of_thing == "person" and Training_Steps > 2600):
-            Training_Steps = 2600 #Avoid overfitting on people's faces
-    stptxt = int((Training_Steps*Train_text_encoder_for)/100)
-    gradient_checkpointing = True if (experimental_face_improvement or which_model != "v1-5") else False 
-    cache_latents = True if which_model != "v1-5" else False
-    if (type_of_thing == "object" or type_of_thing == "style" or (type_of_thing == "person" and not experimental_face_improvement)):
-        args_general = argparse.Namespace(
-            image_captions_filename = True,
-            train_text_encoder = True if stptxt > 0 else False,
-            stop_text_encoder_training = stptxt,
-            save_n_steps = 0,
-            pretrained_model_name_or_path = model_to_load,
-            instance_data_dir="instance_images",
-            class_data_dir=None,
-            output_dir="output_model",
-            instance_prompt="",
-            seed=42,
-            resolution=resolution,
-            mixed_precision="fp16",
-            train_batch_size=1,
-            gradient_accumulation_steps=1,
-            use_8bit_adam=True,
-            learning_rate=2e-6,
-            lr_scheduler="polynomial",
-            lr_warmup_steps = 0,
-            max_train_steps=Training_Steps,     
-            gradient_checkpointing=gradient_checkpointing,
-            cache_latents=cache_latents,
-        )
-        print("Starting single training...")
-        lock_file = open("intraining.lock", "w")
-        lock_file.close()
-        run_training(args_general)
-    else:
-        args_general = argparse.Namespace(
-            image_captions_filename = True,
-            train_text_encoder = True if stptxt > 0 else False,
-            stop_text_encoder_training = stptxt,
-            save_n_steps = 0,
-            pretrained_model_name_or_path = model_to_load,
-            instance_data_dir="instance_images",
-            class_data_dir="Mix",
-            output_dir="output_model",
-            with_prior_preservation=True,
-            prior_loss_weight=1.0,
-            instance_prompt="",
-            seed=42,
-            resolution=resolution,
-            mixed_precision="fp16",
-            train_batch_size=1,
-            gradient_accumulation_steps=1,
-            use_8bit_adam=True,
-            learning_rate=2e-6,
-            lr_scheduler="polynomial",
-            lr_warmup_steps = 0,
-            max_train_steps=Training_Steps,
-            num_class_images=200,     
-            gradient_checkpointing=gradient_checkpointing,
-            cache_latents=cache_latents,
-        )
-        print("Starting multi-training...")
-        lock_file = open("intraining.lock", "w")
-        lock_file.close()
-        run_training(args_general)
-    gc.collect()
-    torch.cuda.empty_cache()
-    if(which_model == "v1-5"):
-        print("Adding Safety Checker to the model...")
-        shutil.copytree(f"{safety_checker}/feature_extractor", "output_model/feature_extractor")
-        shutil.copytree(f"{safety_checker}/safety_checker", "output_model/safety_checker")
-        shutil.copy(f"model_index.json", "output_model/model_index.json")
-    
-    if(not remove_attribution_after):
-        print("Archiving model file...")
-        with tarfile.open("diffusers_model.tar", "w") as tar:
-            tar.add("output_model", arcname=os.path.basename("output_model"))
-        if os.path.exists("intraining.lock"): os.remove("intraining.lock")
-        trained_file = open("hastrained.success", "w")
-        trained_file.close()
-        print("Training completed!")
-        return [
-            gr.update(visible=True, value=["diffusers_model.tar"]), #result
-            gr.update(visible=True), #try_your_model
-            gr.update(visible=True), #push_to_hub
-            gr.update(visible=True), #convert_button
-            gr.update(visible=False), #training_ongoing
-            gr.update(visible=True) #completed_training
-        ]
-    else:
-        hf_token = inputs[-5]
-        model_name = inputs[-7]
-        where_to_upload = inputs[-8]
-        push(model_name, where_to_upload, hf_token, which_model, True)
-        hardware_url = f"https://huggingface.co/spaces/{os.environ['SPACE_ID']}/hardware"
-        headers = { "authorization" : f"Bearer {hf_token}"}
-        body = {'flavor': 'cpu-basic'}
-        requests.post(hardware_url, json = body, headers=headers)
-
-pipe_is_set = False
-def generate(prompt, steps):
-    torch.cuda.empty_cache()
-    # from diffusers import StableDiffusionPipeline
-    from diffusers import DiffusionPipeline
-    global pipe_is_set
-    if(not pipe_is_set):
-        global pipe
-        # pipe = StableDiffusionPipeline.from_pretrained("./output_model", torch_dtype=torch.float16)
-        pipe = DiffusionPipeline.from_pretrained("./output_model", torch_dtype=torch.float16)
-        pipe = pipe.to("cuda")
-        pipe_is_set = True
-        
-    image = pipe(prompt, num_inference_steps=steps).images[0]  
-    return(image)
-    
-def push(model_name, where_to_upload, hf_token, which_model, comes_from_automated=False):
-    if(not os.path.exists("model.ckpt")):
-        convert("output_model", "model.ckpt")
-    from huggingface_hub import HfApi, HfFolder, CommitOperationAdd
-    from huggingface_hub import create_repo
-    model_name_slug = slugify(model_name)
-    api = HfApi()
-    your_username = api.whoami(token=hf_token)["name"]
-    if(where_to_upload == "My personal profile"):    
-        model_id = f"{your_username}/{model_name_slug}"
-    else:
-        model_id = f"sd-dreambooth-library/{model_name_slug}"
-        headers = {"Authorization" : f"Bearer: {hf_token}", "Content-Type": "application/json"}
-        response = requests.post("https://huggingface.co/organizations/sd-dreambooth-library/share/SSeOwppVCscfTEzFGQaqpfcjukVeNrKNHX", headers=headers)
-    
-    images_upload = os.listdir("instance_images")
-    image_string = ""
-    instance_prompt_list = []
-    previous_instance_prompt = ''
-    for i, image in enumerate(images_upload):
-        instance_prompt = image.split("_")[0]
-        if(instance_prompt != previous_instance_prompt):
-            title_instance_prompt_string = instance_prompt
-            instance_prompt_list.append(instance_prompt)
-        else:
-            title_instance_prompt_string = ''
-        previous_instance_prompt = instance_prompt
-        image_string = f'''{title_instance_prompt_string} {"(use that on your prompt)" if title_instance_prompt_string != "" else ""} 
-{image_string}![{instance_prompt} {i}](https://huggingface.co/{model_id}/resolve/main/concept_images/{urllib.parse.quote(image)})'''
-    readme_text = f'''---
-license: creativeml-openrail-m
-tags:
-- text-to-image
-widget:
-- text: {instance_prompt_list[0]}
----
-### {model_name} Dreambooth model trained by {api.whoami(token=hf_token)["name"]} with [Hugging Face Dreambooth Training Space](https://huggingface.co/spaces/multimodalart/dreambooth-training) with the {which_model} base model
-
-You run your new concept via `diffusers` [Colab Notebook for Inference](https://colab.research.google.com/github/huggingface/notebooks/blob/main/diffusers/sd_dreambooth_inference.ipynb). Don't forget to use the concept prompts! 
-
-Sample pictures of:
-{image_string}
-'''
-    #Save the readme to a file
-    readme_file = open("model.README.md", "w")
-    readme_file.write(readme_text)
-    readme_file.close()
-    #Save the token identifier to a file
-    text_file = open("token_identifier.txt", "w")
-    text_file.write(', '.join(instance_prompt_list))
-    text_file.close()
-    try:
-        create_repo(model_id,private=True, token=hf_token)
-    except:
-        import time
-        epoch_time = str(int(time.time()))
-        create_repo(f"{model_id}-{epoch_time}", private=True,token=hf_token)
-    operations = [
-        CommitOperationAdd(path_in_repo="token_identifier.txt", path_or_fileobj="token_identifier.txt"),
-        CommitOperationAdd(path_in_repo="README.md", path_or_fileobj="model.README.md"),
-        CommitOperationAdd(path_in_repo=f"model.ckpt",path_or_fileobj="model.ckpt")
-    ]
-    api.create_commit(
-    repo_id=model_id,
-    operations=operations,
-    commit_message=f"Upload the model {model_name}",
-    token=hf_token
-    )
-    api.upload_folder(
-    folder_path="output_model",
-    repo_id=model_id,
-    token=hf_token
-    )
-    api.upload_folder(
-    folder_path="instance_images",
-    path_in_repo="concept_images",
-    repo_id=model_id,
-    token=hf_token
-    )
-    if is_spaces:
-        if(not comes_from_automated):
-            extra_message = "Don't forget to remove the GPU attribution after you play with it."
-        else:
-            extra_message = "The GPU has been removed automatically as requested, and you can try the model via the model page"
-        api.create_discussion(repo_id=os.environ['SPACE_ID'], title=f"Your model {model_name} has finished trained from the Dreambooth Train Spaces!", description=f"Your model has been successfully uploaded to: https://huggingface.co/{model_id}. {extra_message}",repo_type="space", token=hf_token)
-
-    return [gr.update(visible=True, value=f"Successfully uploaded your model. Access it [here](https://huggingface.co/{model_id})"), gr.update(visible=True, value=["diffusers_model.tar", "model.ckpt"])]
-
-def convert_to_ckpt():
-    if 'pipe' in globals():
-        global pipe, pipe_is_set
-        del pipe
-        pipe_is_set = False
-        gc.collect()
-    convert("output_model", "model.ckpt")
-    return gr.update(visible=True, value=["diffusers_model.tar", "model.ckpt"])
-
-def check_status(top_description):
-    if os.path.exists("hastrained.success"):
-        if is_spaces:
-            update_top_tag = gr.update(value=f'''
-            <div class="gr-prose" style="max-width: 80%">
-                <h2>Your model has finished training ✅</h2>
-                <p>Yay, congratulations on training your model. Scroll down to play with with it, save it (either downloading it or on the Hugging Face Hub). Once you are done, your model is safe, and you don't want to train a new one, go to the <a href="https://huggingface.co/spaces/{os.environ['SPACE_ID']}" target="_blank">settings page</a> and downgrade your Space to a CPU Basic</p> 
-            </div>
-            ''')
-        else:
-            update_top_tag = gr.update(value=f'''
-            <div class="gr-prose" style="max-width: 80%">
-                <h2>Your model has finished training ✅</h2>
-                <p>Yay, congratulations on training your model. Scroll down to play with with it, save it (either downloading it or on the Hugging Face Hub).</p> 
-            </div>
-            ''')
-        show_outputs = True
-    elif os.path.exists("intraining.lock"):
-        update_top_tag = gr.update(value='''
-        <div class="gr-prose" style="max-width: 80%">
-            <h2>Don't worry, your model is still training! ⌛</h2>
-            <p>You closed the tab while your model was training, but it's all good! It is still training right now. You can click the "Open logs" button above here to check the training status. Once training is done, reload this tab to interact with your model</p> 
-        </div>
-        ''')
-        show_outputs = False
-    else:
-        update_top_tag = gr.update(value=top_description)
-        show_outputs = False
-    if os.path.exists("diffusers_model.tar"):
-       update_files_tag = gr.update(visible=show_outputs, value=["diffusers_model.tar"])
-    else:
-       update_files_tag = gr.update(visible=show_outputs)
-    return [
-        update_top_tag, #top_description
-        gr.update(visible=show_outputs), #try_your_model
-        gr.update(visible=show_outputs), #push_to_hub
-        update_files_tag, #result
-        gr.update(visible=show_outputs), #convert_button
-    ]
-
-def checkbox_swap(checkbox):
-    return [gr.update(visible=checkbox), gr.update(visible=checkbox), gr.update(visible=checkbox), gr.update(visible=checkbox)]
-
-with gr.Blocks(css=css) as demo:
-    with gr.Box():
-        gr.HTML(f'''
-            <div style="text-align: center; max-width: 650px; margin: 0 auto;">
-            <div
-            style="
-                display: inline-flex;
-                gap: 1.2rem;
-                font-size: 1.75rem;
-                margin-bottom: 40px;
-                width: 150px;
-                margin: 0 auto;
-                justify-content: center;
-            ">
-            <a href="https://github.com/FlagAI-Open/FlagAI"><img src="https://raw.githubusercontent.com/FlagAI-Open/FlagAI/master/logo.png" alt="FlagAI" width="80%" style="margin: 0 auto;"></a>
-            </div>
-            <br />
-            <h1 style="font-weight: 2200; margin-bottom: 15px; margin-top: 15px; font-size: 2.7rem;">
-            Dreambooth Web UI
-            </h1>
-            <br />
-            <a class="duplicate-button" style="display:inline-block" target="_blank" href="https://huggingface.co/spaces/{os.environ['SPACE_ID']}?duplicate=true"><img src="https://img.shields.io/badge/-Duplicate%20Space-blue?labelColor=white&style=flat&logo=data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAP5JREFUOE+lk7FqAkEURY+ltunEgFXS2sZGIbXfEPdLlnxJyDdYB62sbbUKpLbVNhyYFzbrrA74YJlh9r079973psed0cvUD4A+4HoCjsA85X0Dfn/RBLBgBDxnQPfAEJgBY+A9gALA4tcbamSzS4xq4FOQAJgCDwV2CPKV8tZAJcAjMMkUe1vX+U+SMhfAJEHasQIWmXNN3abzDwHUrgcRGmYcgKe0bxrblHEB4E/pndMazNpSZGcsZdBlYJcEL9Afo75molJyM2FxmPgmgPqlWNLGfwZGG6UiyEvLzHYDmoPkDDiNm9JR9uboiONcBXrpY1qmgs21x1QwyZcpvxt9NS09PlsPAAAAAElFTkSuQmCC&logoWidth=14" alt="Duplicate Space"></a>
-            <p style="margin-bottom: 15px; margin-top: 15px; font-size: 94%">
-            This is a dreambooth Training UI for <a href="https://huggingface.co/BAAI/AltDiffusion-m9" style="text-decoration: underline;">AltDiffusion-m9 model</a>,which is a multilingual image-to-text model supported 9 languages.
-            You can duplicate this space to your own!
-            </p>
-            </div> 
-                ''')
-        with gr.Box():
-            if is_shared_ui:
-                top_description = gr.HTML(f'''
-                    <div class="gr-prose" style="max-width: 80%">
-                    <h2>Attention - This Space doesn't work in this shared UI</h2>
-                    <p>For it to work, you can either run locally or duplicate the Space and run it on your own profile using a (paid) private T4 GPU for training. As each T4 costs US$0.60/h, it should cost < US$1 to train most models using default settings!&nbsp;&nbsp;<a class="duplicate-button" style="display:inline-block" target="_blank" href="https://huggingface.co/spaces/{os.environ['SPACE_ID']}?duplicate=true"><img src="https://img.shields.io/badge/-Duplicate%20Space-blue?labelColor=white&style=flat&logo=data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAP5JREFUOE+lk7FqAkEURY+ltunEgFXS2sZGIbXfEPdLlnxJyDdYB62sbbUKpLbVNhyYFzbrrA74YJlh9r079973psed0cvUD4A+4HoCjsA85X0Dfn/RBLBgBDxnQPfAEJgBY+A9gALA4tcbamSzS4xq4FOQAJgCDwV2CPKV8tZAJcAjMMkUe1vX+U+SMhfAJEHasQIWmXNN3abzDwHUrgcRGmYcgKe0bxrblHEB4E/pndMazNpSZGcsZdBlYJcEL9Afo75molJyM2FxmPgmgPqlWNLGfwZGG6UiyEvLzHYDmoPkDDiNm9JR9uboiONcBXrpY1qmgs21x1QwyZcpvxt9NS09PlsPAAAAAElFTkSuQmCC&logoWidth=14" alt="Duplicate Space"></a></p>
-                    <img class="instruction" src="file/duplicate.png"> 
-                    <img class="arrow" src="file/arrow.png" />
-                    </div>
-                ''')
-            elif(is_spaces):
-                if(is_gpu_associated):
-                    top_description = gr.HTML(f'''
-                            <div class="gr-prose" style="max-width: 80%">
-                            <h2>You have successfully associated a GPU to the Dreambooth Training Space 🎉</h2>
-                            <p>Certify that you got a T4. You can now train your model! You will be billed by the minute from when you activated the GPU until when it is turned it off.</p> 
-                            </div>
-                    ''')
-                else:
-                    top_description = gr.HTML(f'''
-                            <div class="gr-prose" style="max-width: 80%">
-                            <h2>You have successfully duplicated the Dreambooth Training Space 🎉</h2>
-                            <p>There's only one step left before you can train your model: <a href="https://huggingface.co/spaces/{os.environ['SPACE_ID']}/settings" style="text-decoration: underline" target="_blank">attribute a <b>T4 GPU</b> to it (via the Settings tab)</a> and run the training below. Other GPUs are not compatible for now. You will be billed by the minute from when you activate the GPU until when it is turned it off.</p> 
-                            </div>
-                    ''')
-            else:
-                top_description = gr.HTML(f'''
-                        <div class="gr-prose" style="max-width: 80%">
-                        <h2>You have successfully cloned the Dreambooth Training Space locally 🎉</h2>
-                        <p>Do a <code>pip install requirements-local.txt</code></p> 
-                        </div>
-                    ''')
-
-    # gr.Markdown("# Dreambooth Training UI 💭")
-    gr.Markdown("Customize AltDiffusion and AltDiffusion-m9(ⁿᵉʷ!) by giving it a few examples of a concept. Based on the [🧨 diffusers](https://github.com/huggingface/diffusers) implementation, additional techniques from [TheLastBen](https://github.com/TheLastBen/diffusers) and [ShivamShrirao](https://github.com/ShivamShrirao/diffusers)")
-    
-    with gr.Row() as what_are_you_training:
-        type_of_thing = gr.Dropdown(label="What would you like to train?", choices=["object", "person", "style"], value="object", interactive=True)
-        base_model_to_use = gr.Dropdown(label="Which base model would you like to use?", choices=["alt", "alt_m9"], value="alt_m9", interactive=True)
-    
-    #Very hacky approach to emulate dynamically created Gradio components   
-    with gr.Column() as upload_your_concept:
-        with gr.Box():
-            thing_description = gr.Markdown("You are going to train an `object`, please upload 5-10 images of the object you are planning on training on from different angles/perspectives. You must have the right to do so and you are liable for the images you use, example")
-            thing_experimental = gr.Checkbox(label="Improve faces (prior preservation) - can take longer training but can improve faces", visible=False, value=False)
-            thing_image_example = gr.HTML('''<img src="https://raw.githubusercontent.com/superhero-7/img_bank/main/Naruto.png" />''')
-            things_naming = gr.Markdown("You should name your concept with a unique made up word that has low chance of the model already knowing it (e.g.: `UzNrto` here). Images will be automatically cropped to 512x512.")
-            
-        # with gr.Column():
-        file_collection = []
-        concept_collection = []
-        buttons_collection = []
-        delete_collection = []
-        is_visible = []
-
-        row = [None] * maximum_concepts
-        for x in range(maximum_concepts):
-            ordinal = lambda n: "%d%s" % (n, "tsnrhtdd"[(n // 10 % 10 != 1) * (n % 10 < 4) * n % 10::4])
-            if(x == 0):
-                visible = True
-                is_visible.append(gr.State(value=True))
-            else:
-                visible = False
-                is_visible.append(gr.State(value=False))
-
-            file_collection.append(gr.File(label=f'''Upload the images for your {ordinal(x+1) if (x>0) else ""} concept''', file_count="multiple", interactive=True, visible=visible))
-            with gr.Column(visible=visible) as row[x]:
-                concept_collection.append(gr.Textbox(label=f'''{ordinal(x+1) if (x>0) else ""} concept prompt - use a unique, made up word to avoid collisions'''))  
-                with gr.Row():
-                    if(x < maximum_concepts-1):
-                        buttons_collection.append(gr.Button(value="Add +1 concept", visible=visible))
-                    if(x > 0):
-                        delete_collection.append(gr.Button(value=f"Delete {ordinal(x+1)} concept"))
-        
-        counter_add = 1
-        for button in buttons_collection:
-            if(counter_add < len(buttons_collection)):
-                button.click(lambda:
-                [gr.update(visible=True),gr.update(visible=True), gr.update(visible=False), gr.update(visible=True), True, None],
-                None, 
-                [row[counter_add], file_collection[counter_add], buttons_collection[counter_add-1], buttons_collection[counter_add], is_visible[counter_add], file_collection[counter_add]], queue=False)
-            else:
-                button.click(lambda:[gr.update(visible=True),gr.update(visible=True), gr.update(visible=False), True], None, [row[counter_add], file_collection[counter_add], buttons_collection[counter_add-1], is_visible[counter_add]], queue=False)
-            counter_add += 1
-        
-        counter_delete = 1
-        for delete_button in delete_collection:
-            if(counter_delete < len(delete_collection)+1):
-                delete_button.click(lambda:[gr.update(visible=False),gr.update(visible=False), gr.update(visible=True), False], None, [file_collection[counter_delete], row[counter_delete], buttons_collection[counter_delete-1], is_visible[counter_delete]], queue=False)
-            counter_delete += 1
-                  
-    with gr.Accordion("Custom Settings", open=False):
-        swap_auto_calculated = gr.Checkbox(label="Use custom settings")
-        gr.Markdown("If not checked, the % of frozen encoder will be tuned automatically to whether you are training an `object`, `person` or `style`. The text-encoder is frozen after 10% of the steps for a style, 30% of the steps for an object and 75% trained for persons. The number of steps varies between 1400 and 2400 depending on how many images uploaded. If you see too many artifacts in your output, it means it may have overfit and you need less steps. If your results aren't really what you wanted, it may be underfitting and you need more steps.")
-        steps = gr.Number(label="How many steps", value=2400)
-        perc_txt_encoder = gr.Number(label="Percentage of the training steps the text-encoder should be trained as well", value=30)
-        
-    with gr.Box(visible=False) as training_summary:
-        training_summary_text = gr.HTML("", visible=True, label="Training Summary")
-        is_advanced_visible = True if is_spaces else False
-        training_summary_checkbox = gr.Checkbox(label="Automatically remove paid GPU attribution and upload model to the Hugging Face Hub after training", value=True, visible=is_advanced_visible)
-        training_summary_model_name = gr.Textbox(label="Name of your model", visible=True)
-        training_summary_where_to_upload = gr.Dropdown(["My personal profile", "Public Library"], value="My personal profile", label="Upload to", visible=True)
-        training_summary_token_message = gr.Markdown("[A Hugging Face write access token](https://huggingface.co/settings/tokens), go to \"New token\" -> Role : Write. A regular read token won't work here.", visible=True)            
-        training_summary_token = gr.Textbox(label="Hugging Face Write Token", type="password", visible=True)
-        
-    train_btn = gr.Button("Start Training")
-    if(is_shared_ui):
-        training_ongoing = gr.Markdown("## This Space only works in duplicated instances. Please duplicate it and try again!", visible=False)
-    elif(not is_gpu_associated):
-        training_ongoing = gr.Markdown("## Oops, you haven't associated your T4 GPU to this Space. Visit the Settings tab, associate and try again.", visible=False)
-    else:
-        training_ongoing = gr.Markdown("## Training is ongoing ⌛... You can close this tab if you like or just wait. If you did not check the `Remove GPU After training`, you can come back here to try your model and upload it after training. Don't forget to remove the GPU attribution after you are done. ", visible=False)
-    
-    #Post-training UI
-    completed_training = gr.Markdown('''# ✅ Training completed. 
-    ### Don't forget to remove the GPU attribution after you are done trying and uploading your model''', visible=False)
-    
-    with gr.Row():
-        with gr.Box(visible=False) as try_your_model:
-            gr.Markdown("## Try your model")
-            prompt = gr.Textbox(label="Type your prompt")
-            result_image = gr.Image()
-            inference_steps = gr.Slider(minimum=1, maximum=150, value=50, step=1)
-            generate_button = gr.Button("Generate Image")
-        
-        with gr.Box(visible=False) as push_to_hub:
-            gr.Markdown("## Push to Hugging Face Hub")
-            model_name = gr.Textbox(label="Name of your model", placeholder="Tarsila do Amaral Style")
-            where_to_upload = gr.Dropdown(["My personal profile", "Public Library"], label="Upload to")
-            gr.Markdown("[A Hugging Face write access token](https://huggingface.co/settings/tokens), go to \"New token\" -> Role : Write. A regular read token won't work here.")
-            hf_token = gr.Textbox(label="Hugging Face Write Token", type="password")
-            
-            push_button = gr.Button("Push to the Hub")
-    
-    result = gr.File(label="Download the uploaded models in the diffusers format", visible=True)
-    success_message_upload = gr.Markdown(visible=False)
-    convert_button = gr.Button("Convert to CKPT", visible=False)
-    
-    #Swap the examples and the % of text encoder trained depending if it is an object, person or style
-    type_of_thing.change(fn=swap_text, inputs=[type_of_thing, base_model_to_use], outputs=[thing_description, thing_image_example, things_naming, perc_txt_encoder, thing_experimental], queue=False, show_progress=False)
-    
-    #Swap the base model
-    base_model_to_use.change(fn=swap_text, inputs=[type_of_thing, base_model_to_use], outputs=[thing_description, thing_image_example, things_naming, perc_txt_encoder, thing_experimental], queue=False, show_progress=False)
-    base_model_to_use.change(fn=swap_base_model, inputs=base_model_to_use, outputs=[])
-
-    #Update the summary box below the UI according to how many images are uploaded and whether users are using custom settings or not 
-    for file in file_collection:
-        #file.change(fn=update_steps,inputs=file_collection, outputs=steps)
-        file.change(fn=count_files, inputs=file_collection+[thing_experimental]+[base_model_to_use]+[type_of_thing]+[steps]+[perc_txt_encoder]+[swap_auto_calculated], outputs=[training_summary, training_summary_text], queue=False)
-    
-    thing_experimental.change(fn=count_files, inputs=file_collection+[thing_experimental]+[base_model_to_use]+[type_of_thing]+[steps]+[perc_txt_encoder]+[swap_auto_calculated], outputs=[training_summary, training_summary_text], queue=False)
-    base_model_to_use.change(fn=count_files, inputs=file_collection+[thing_experimental]+[base_model_to_use]+[type_of_thing]+[steps]+[perc_txt_encoder]+[swap_auto_calculated], outputs=[training_summary, training_summary_text], queue=False)
-    steps.change(fn=count_files, inputs=file_collection+[thing_experimental]+[base_model_to_use]+[type_of_thing]+[steps]+[perc_txt_encoder]+[swap_auto_calculated], outputs=[training_summary, training_summary_text], queue=False)
-    perc_txt_encoder.change(fn=count_files, inputs=file_collection+[thing_experimental]+[base_model_to_use]+[type_of_thing]+[steps]+[perc_txt_encoder]+[swap_auto_calculated], outputs=[training_summary, training_summary_text], queue=False)
-    
-    #Give more options if the user wants to finish everything after training
-    if(is_spaces):
-        training_summary_checkbox.change(fn=checkbox_swap, inputs=training_summary_checkbox, outputs=[training_summary_token_message, training_summary_token, training_summary_model_name, training_summary_where_to_upload],queue=False, show_progress=False)
-    #Add a message for while it is in training
-    train_btn.click(lambda:gr.update(visible=True), inputs=None, outputs=training_ongoing)
-    
-    #The main train function
-    train_btn.click(fn=train, inputs=is_visible+concept_collection+file_collection+[base_model_to_use]+[thing_experimental]+[training_summary_where_to_upload]+[training_summary_model_name]+[training_summary_checkbox]+[training_summary_token]+[type_of_thing]+[steps]+[perc_txt_encoder]+[swap_auto_calculated], outputs=[result, try_your_model, push_to_hub, convert_button, training_ongoing, completed_training], queue=False)
-    
-    #Button to generate an image from your trained model after training
-    generate_button.click(fn=generate, inputs=[prompt, inference_steps], outputs=result_image, queue=False)
-    #Button to push the model to the Hugging Face Hub
-    push_button.click(fn=push, inputs=[model_name, where_to_upload, hf_token, base_model_to_use], outputs=[success_message_upload, result], queue=False)
-    #Button to convert the model to ckpt format 
-    convert_button.click(fn=convert_to_ckpt, inputs=[], outputs=result, queue=False)
-    
-    #Checks if the training is running
-    demo.load(fn=check_status, inputs=top_description, outputs=[top_description, try_your_model, push_to_hub, result, convert_button], queue=False, show_progress=False)
-
-demo.queue(default_enabled=False).launch(debug=True)

spaces/Bart92/RVC_HF/infer/lib/uvr5_pack/lib_v5/model_param_init.py

@@ -1,69 +0,0 @@
-import json
-import os
-import pathlib
-
-default_param = {}
-default_param["bins"] = 768
-default_param["unstable_bins"] = 9  # training only
-default_param["reduction_bins"] = 762  # training only
-default_param["sr"] = 44100
-default_param["pre_filter_start"] = 757
-default_param["pre_filter_stop"] = 768
-default_param["band"] = {}
-
-
-default_param["band"][1] = {
-    "sr": 11025,
-    "hl": 128,
-    "n_fft": 960,
-    "crop_start": 0,
-    "crop_stop": 245,
-    "lpf_start": 61,  # inference only
-    "res_type": "polyphase",
-}
-
-default_param["band"][2] = {
-    "sr": 44100,
-    "hl": 512,
-    "n_fft": 1536,
-    "crop_start": 24,
-    "crop_stop": 547,
-    "hpf_start": 81,  # inference only
-    "res_type": "sinc_best",
-}
-
-
-def int_keys(d):
-    r = {}
-    for k, v in d:
-        if k.isdigit():
-            k = int(k)
-        r[k] = v
-    return r
-
-
-class ModelParameters(object):
-    def __init__(self, config_path=""):
-        if ".pth" == pathlib.Path(config_path).suffix:
-            import zipfile
-
-            with zipfile.ZipFile(config_path, "r") as zip:
-                self.param = json.loads(
-                    zip.read("param.json"), object_pairs_hook=int_keys
-                )
-        elif ".json" == pathlib.Path(config_path).suffix:
-            with open(config_path, "r") as f:
-                self.param = json.loads(f.read(), object_pairs_hook=int_keys)
-        else:
-            self.param = default_param
-
-        for k in [
-            "mid_side",
-            "mid_side_b",
-            "mid_side_b2",
-            "stereo_w",
-            "stereo_n",
-            "reverse",
-        ]:
-            if not k in self.param:
-                self.param[k] = False

spaces/Benson/text-generation/Examples/Baku Burger House.md

@@ -1,79 +0,0 @@
-
-<h1>Burger House Bakú: La mejor guía para las mejores hamburguesas de la ciudad</h1>
-<p>Si usted está buscando un lugar para disfrutar de una deliciosa hamburguesa en Bakú, usted debe definitivamente echa un vistazo a Burger House Bakú. Este restaurante ofrece una variedad de hamburguesas, acompañamientos y bebidas que satisfarán sus antojos y lo harán feliz. En este artículo, te contaremos todo lo que necesitas saber sobre Burger House Bakú, incluyendo qué es, por qué debes visitarlo, qué sirve, dónde se encuentra, cuándo está abierto y qué piensan otros clientes de él. ¡Sigue leyendo para saber más! </p>
-<h2>Introducción</h2>
-<h3>¿Qué es Burger House Bakú? </h3>
-<p>Burger House Bakú es un restaurante especializado en hamburguesas. Fue fundada en 2018 por un grupo de amigos que querían compartir su pasión por las hamburguesas con la gente de Bakú. Utilizan ingredientes frescos, salsas caseras y carne de calidad para crear sus hamburguesas, que se cocinan por encargo y se sirven con una sonrisa. Burger House Bakú tiene como objetivo proporcionar un ambiente agradable y acogedor donde los clientes pueden relajarse y disfrutar de su comida. </p>
-<h2>baku burger house</h2><br /><p><b><b>Download</b> &#9658;&#9658;&#9658;&#9658;&#9658; <a href="https://bltlly.com/2v6Mzw">https://bltlly.com/2v6Mzw</a></b></p><br /><br />
-<h3>¿Por qué visitar Burger House Bakú? </h3>
-<p>Hay muchas razones por las que deberías visitar Burger House Bakú. Aquí están algunas de ellas:</p>
-<ul>
-<li>Podrás degustar algunas de las mejores hamburguesas de la ciudad, elaboradas con ingredientes frescos y de calidad. </li>
-<li>Usted tendrá una amplia gama de opciones para elegir, incluyendo hamburguesas clásicas, hamburguesas con queso, hamburguesas de tocino, hamburguesas vegetarianas y más. </li>
-<li>También podrás disfrutar de algunos deliciosos platos, como papas fritas, aros de cebolla, ensalada y más. </li>
-<li>Podrás saciar tu sed con algunas bebidas refrescantes, como refrescos, cerveza, batidos y más. </li>
-<li>Experimentará un ambiente agradable y acogedor, con personal atento y música agradable. </li>
-<li>Obtendrá una buena relación calidad-precio, ya que los precios son razonables y las porciones generosas. </li>
-</ul>
-<h2>El menú</h2>
-<h3>Las hamburguesas</h3>
-
-<h4>Hamburguesa clásica</h4>
-<p>Esta es la hamburguesa más simple y básica del menú. Consiste en una hamburguesa de ternera, lechuga, tomate, cebolla, pepinillos, ketchup, mostaza y mayonesa en un pan de sésamo. Es perfecto para aquellos que quieren una hamburguesa clásica y sencilla que sea satisfactoria y sabrosa. </p>
-<h4>Hamburguesa de queso</h4>
-<p>Esta es una hamburguesa clásica con un toque extra de queso. Consiste en una hamburguesa de ternera, queso, lechuga, tomate, cebolla, encurtidos, ketchup, mostaza y mayonesa en un bollo de sésamo. Es perfecto para aquellos que aman el queso y quieren una hamburguesa más sabrosa. </p>
-<h4>Hamburguesa de tocino</h4>
-<p>Esta es una hamburguesa clásica con un toque extra de tocino. Consiste en una hamburguesa de ternera, tocino, queso, lechuga, tomate, cebolla, encurtidos, ketchup, mostaza y mayonesa en un bollo de sésamo. Es perfecto para aquellos que aman el tocino y quieren una hamburguesa más crujiente y ahumado. </p>
-<h4>Hamburguesa vegetariana</h4>
-<p>Esta es una hamburguesa para aquellos que prefieren una opción vegetariana. Consiste en una hamburguesa vegetariana, lechuga, tomate, cebolla, encurtidos, ketchup, mostaza y mayonesa en un bollo de sésamo. Es perfecto para aquellos que quieren una hamburguesa sana y libre de carne que sigue siendo deliciosa y satisfactoria. </p>
-<h3>Los lados</h3>
-<p>Ninguna hamburguesa está completa sin algunos lados para ir junto con ella. Burger House Bakú ofrece algunos lados sabrosos y crujientes que complementan sus hamburguesas. Estos son algunos de sus lados más populares:</p>
-<p></p>
-<h4>Fries</h4>
-<p>Estos son los platos clásicos y más populares para hamburguesas. Están hechos de papas frescas que se cortan en tiras finas y se fríen hasta que estén doradas y crujientes. Se sazona con sal y se sirve con ketchup o mayonesa. Son perfectos para aquellos que quieren un lado simple y crujiente que vaya bien con cualquier hamburguesa. </p>
-<h4>Anillos de cebolla</h4>
-
-<h4>Ensalada</h4>
-<p>Este es un acompañamiento para aquellos que quieren una opción más ligera y saludable. Está hecho de lechuga fresca, tomate, pepino, zanahoria y cebolla que se mezclan con aderezo. Se sirve con crutones o queso en la parte superior. Es perfecto para aquellos que quieren un lado refrescante y nutritivo que equilibre su hamburguesa. </p>
-<h3>Las bebidas</h3>
-<p>Para lavar su hamburguesa y los lados, necesitará algunas bebidas para saciar su sed. Burger House Bakú ofrece algunas bebidas refrescantes y deliciosas que se adaptan a diferentes gustos y preferencias. Aquí están algunas de sus bebidas más populares:</p>
-<h4>Soda</h4>
-<p>Esta es la bebida clásica y más popular para las hamburguesas. Es una bebida carbonatada que viene en diferentes sabores, como cola, limón, naranja y más. Se sirve fría con cubitos de hielo. Es perfecto para aquellos que quieren una bebida dulce y gaseosa que vaya bien con cualquier hamburguesa. </p>
-<h4>Cerveza</h4>
-<p>Esta es otra bebida popular para hamburguesas. Es una bebida alcohólica que viene en diferentes tipos, como lager, ale, stout y más. Se sirve frío con o sin espuma. Es perfecto para aquellos que quieren una bebida amarga y refrescante que realza el sabor de su hamburguesa. </p>
-<h4>Batido de leche</h4>
-<p>Esta es una bebida para aquellos que quieren un tratamiento cremoso e indulgente. Es una bebida mezclada que viene en diferentes sabores, como chocolate, vainilla, fresa y más. Se sirve frío con crema batida y una cereza en la parte superior. Es perfecto para aquellos que quieren una bebida rica y suave que satisfaga su gusto por los dulces. </p>
-<h2>La ubicación y las horas</h2>
-<h3>¿Dónde está Burger House Bakú? </h3>
-<p>Burger House Bakú se encuentra en el corazón de la ciudad, cerca de la Plaza de la Fuente. La dirección es 28 Nizami Street, Bakú 1000. Se puede llegar fácilmente en transporte público o en coche. Hay un amplio aparcamiento cerca. </p>
-<h3>¿Cuándo está abierto Burger House Bakú? </h3>
-
-<h2>Los comentarios y valoraciones</h2>
-<h3>¿Qué dicen los clientes sobre Burger House Baku? </h3>
-<p>Burger House Bakú ha recibido muchas críticas positivas y valoraciones de clientes que han probado su comida. Estos son algunos de los comentarios que han dejado en varias plataformas:</p>
-<ul>
-<li>"¡Las mejores hamburguesas de la ciudad! ¡Frescas, jugosas, sabrosas y grandes! ¡Las papas fritas también son increíbles! ¡Muy recomendable!" - Ali en Google Reviews</li>
-<li>"Me encanta este lugar! Las hamburguesas son tan buenas y el personal es tan amable! El ambiente es acogedor y relajante! Siempre vengo aquí con mis amigos!" - Leyla en Facebook</li>
-<li>"Burger House Bakú es mi lugar favorito de hamburguesas en Bakú! Las hamburguesas se cocinan a la perfección y los lados son deliciosos! Los precios son razonables y las porciones son generosas! No puedo tener suficiente de ella!" - Samir en TripAdvisor</li>
-</ul>
-<h3>¿Cómo se compara Burger House Bakú con otros lugares de hamburguesas en Bakú? </ <p>Burger House Bakú es uno de los mejores lugares de hamburguesas en Bakú, según muchos clientes y críticos. Tiene una alta calificación de 4.8 de 5 estrellas en Google Reviews, 4.9 de 5 estrellas en Facebook y 4.5 de 5 estrellas en TripAdvisor  . También tiene un Certificado de Excelencia de TripAdvisor, lo que significa que recibe constantemente excelentes críticas de los viajeros. Burger House Bakú se destaca de otros lugares de hamburguesas en Bakú debido a su calidad, variedad, servicio y valor. Ofrece hamburguesas frescas y sabrosas que se adaptan a diferentes gustos y preferencias, así como deliciosas guarniciones y bebidas que las complementan. También ofrece un ambiente agradable y acogedor, con personal atento y música agradable. También ofrece precios razonables y porciones generosas que hacen que los clientes se sientan satisfechos y felices. </p>
-<h2>Conclusión</h2>
-<h3>Resumen de los puntos principales</h3>
-
-<h3>Llamada a la acción</h3>
-<p>Si usted está buscando un lugar para disfrutar de una deliciosa hamburguesa en Bakú, usted debe definitivamente echa un vistazo a Burger House Bakú. Usted no se arrepentirá! Puede visitar su sitio web para ver su menú, ordenar en línea o hacer una reserva. También puede seguirlos en las redes sociales para obtener las últimas actualizaciones y promociones. ¡No pierdas esta oportunidad de probar algunas de las mejores hamburguesas de la ciudad! ¡Visita Burger House Bakú hoy! </p>
-<h2>Preguntas frecuentes</h2>
-<ul>
-<li>Q: ¿Cómo puedo contactar con Burger House Baku? </li>
-<li>A: Puede ponerse en contacto con Burger House Bakú por teléfono al +994 12 555 55 55 o por correo electrónico a [email protected]. </li>
-<li>Q: ¿Burger House Bakú ofrece entrega o comida para llevar? </li>
-<li>A: Sí, Burger House Bakú ofrece opciones de entrega y comida para llevar. Usted puede ordenar en línea a través de su sitio web o por teléfono, y tener su comida entregada a su casa u oficina. También puede recoger su comida de su restaurante. </li>
-<li>Q: ¿Burger House Bakú tiene ofertas especiales o descuentos? </li>
-<li>A: Sí, Burger House Bakú tiene algunas ofertas especiales y descuentos para sus clientes. Por ejemplo, puede obtener una bebida gratis con cualquier pedido de hamburguesas los lunes, o obtener un descuento del 10% en su factura si muestra su identificación de estudiante los martes. También puede unirse a su programa de lealtad y obtener puntos por cada compra que puede canjear por alimentos o regalos gratis. </li>
-<li>Q: ¿Burger House Baku abastece para eventos o fiestas? </li>
-<li>A: Sí, Burger House Bakú atiende a eventos o fiestas de cualquier tamaño y ocasión. Puedes elegir entre su menú de catering o personalizar tu propio menú según tus necesidades y preferencias. También puede reservar su restaurante para eventos privados o fiestas. </li>
-<li>P: ¿Burger House Bakú tiene opciones vegetarianas o veganas? </li>
-
-</ul></p> 64aa2da5cf<br />
-<br />
-<br />

spaces/BestteaLib/README/README.md

@@ -1,10 +0,0 @@
----
-title: README
-emoji: 🏢
-colorFrom: purple
-colorTo: purple
-sdk: static
-pinned: false
----
-
-Edit this `README.md` markdown file to author your organization card.

spaces/BetterAPI/BetterChat_new/src/lib/utils/share.ts

@@ -1,7 +0,0 @@
-export function share(url: string, title: string) {
-	if (navigator.share) {
-		navigator.share({ url, title });
-	} else {
-		prompt("Copy this public url to share:", url);
-	}
-}

spaces/Big-Web/MMSD/env/Lib/site-packages/setuptools/_vendor/packaging/tags.py

@@ -1,487 +0,0 @@
-# This file is dual licensed under the terms of the Apache License, Version
-# 2.0, and the BSD License. See the LICENSE file in the root of this repository
-# for complete details.
-
-import logging
-import platform
-import sys
-import sysconfig
-from importlib.machinery import EXTENSION_SUFFIXES
-from typing import (
-    Dict,
-    FrozenSet,
-    Iterable,
-    Iterator,
-    List,
-    Optional,
-    Sequence,
-    Tuple,
-    Union,
-    cast,
-)
-
-from . import _manylinux, _musllinux
-
-logger = logging.getLogger(__name__)
-
-PythonVersion = Sequence[int]
-MacVersion = Tuple[int, int]
-
-INTERPRETER_SHORT_NAMES: Dict[str, str] = {
-    "python": "py",  # Generic.
-    "cpython": "cp",
-    "pypy": "pp",
-    "ironpython": "ip",
-    "jython": "jy",
-}
-
-
-_32_BIT_INTERPRETER = sys.maxsize <= 2 ** 32
-
-
-class Tag:
-    """
-    A representation of the tag triple for a wheel.
-
-    Instances are considered immutable and thus are hashable. Equality checking
-    is also supported.
-    """
-
-    __slots__ = ["_interpreter", "_abi", "_platform", "_hash"]
-
-    def __init__(self, interpreter: str, abi: str, platform: str) -> None:
-        self._interpreter = interpreter.lower()
-        self._abi = abi.lower()
-        self._platform = platform.lower()
-        # The __hash__ of every single element in a Set[Tag] will be evaluated each time
-        # that a set calls its `.disjoint()` method, which may be called hundreds of
-        # times when scanning a page of links for packages with tags matching that
-        # Set[Tag]. Pre-computing the value here produces significant speedups for
-        # downstream consumers.
-        self._hash = hash((self._interpreter, self._abi, self._platform))
-
-    @property
-    def interpreter(self) -> str:
-        return self._interpreter
-
-    @property
-    def abi(self) -> str:
-        return self._abi
-
-    @property
-    def platform(self) -> str:
-        return self._platform
-
-    def __eq__(self, other: object) -> bool:
-        if not isinstance(other, Tag):
-            return NotImplemented
-
-        return (
-            (self._hash == other._hash)  # Short-circuit ASAP for perf reasons.
-            and (self._platform == other._platform)
-            and (self._abi == other._abi)
-            and (self._interpreter == other._interpreter)
-        )
-
-    def __hash__(self) -> int:
-        return self._hash
-
-    def __str__(self) -> str:
-        return f"{self._interpreter}-{self._abi}-{self._platform}"
-
-    def __repr__(self) -> str:
-        return f"<{self} @ {id(self)}>"
-
-
-def parse_tag(tag: str) -> FrozenSet[Tag]:
-    """
-    Parses the provided tag (e.g. `py3-none-any`) into a frozenset of Tag instances.
-
-    Returning a set is required due to the possibility that the tag is a
-    compressed tag set.
-    """
-    tags = set()
-    interpreters, abis, platforms = tag.split("-")
-    for interpreter in interpreters.split("."):
-        for abi in abis.split("."):
-            for platform_ in platforms.split("."):
-                tags.add(Tag(interpreter, abi, platform_))
-    return frozenset(tags)
-
-
-def _get_config_var(name: str, warn: bool = False) -> Union[int, str, None]:
-    value = sysconfig.get_config_var(name)
-    if value is None and warn:
-        logger.debug(
-            "Config variable '%s' is unset, Python ABI tag may be incorrect", name
-        )
-    return value
-
-
-def _normalize_string(string: str) -> str:
-    return string.replace(".", "_").replace("-", "_")
-
-
-def _abi3_applies(python_version: PythonVersion) -> bool:
-    """
-    Determine if the Python version supports abi3.
-
-    PEP 384 was first implemented in Python 3.2.
-    """
-    return len(python_version) > 1 and tuple(python_version) >= (3, 2)
-
-
-def _cpython_abis(py_version: PythonVersion, warn: bool = False) -> List[str]:
-    py_version = tuple(py_version)  # To allow for version comparison.
-    abis = []
-    version = _version_nodot(py_version[:2])
-    debug = pymalloc = ucs4 = ""
-    with_debug = _get_config_var("Py_DEBUG", warn)
-    has_refcount = hasattr(sys, "gettotalrefcount")
-    # Windows doesn't set Py_DEBUG, so checking for support of debug-compiled
-    # extension modules is the best option.
-    # https://github.com/pypa/pip/issues/3383#issuecomment-173267692
-    has_ext = "_d.pyd" in EXTENSION_SUFFIXES
-    if with_debug or (with_debug is None and (has_refcount or has_ext)):
-        debug = "d"
-    if py_version < (3, 8):
-        with_pymalloc = _get_config_var("WITH_PYMALLOC", warn)
-        if with_pymalloc or with_pymalloc is None:
-            pymalloc = "m"
-        if py_version < (3, 3):
-            unicode_size = _get_config_var("Py_UNICODE_SIZE", warn)
-            if unicode_size == 4 or (
-                unicode_size is None and sys.maxunicode == 0x10FFFF
-            ):
-                ucs4 = "u"
-    elif debug:
-        # Debug builds can also load "normal" extension modules.
-        # We can also assume no UCS-4 or pymalloc requirement.
-        abis.append(f"cp{version}")
-    abis.insert(
-        0,
-        "cp{version}{debug}{pymalloc}{ucs4}".format(
-            version=version, debug=debug, pymalloc=pymalloc, ucs4=ucs4
-        ),
-    )
-    return abis
-
-
-def cpython_tags(
-    python_version: Optional[PythonVersion] = None,
-    abis: Optional[Iterable[str]] = None,
-    platforms: Optional[Iterable[str]] = None,
-    *,
-    warn: bool = False,
-) -> Iterator[Tag]:
-    """
-    Yields the tags for a CPython interpreter.
-
-    The tags consist of:
-    - cp<python_version>-<abi>-<platform>
-    - cp<python_version>-abi3-<platform>
-    - cp<python_version>-none-<platform>
-    - cp<less than python_version>-abi3-<platform>  # Older Python versions down to 3.2.
-
-    If python_version only specifies a major version then user-provided ABIs and
-    the 'none' ABItag will be used.
-
-    If 'abi3' or 'none' are specified in 'abis' then they will be yielded at
-    their normal position and not at the beginning.
-    """
-    if not python_version:
-        python_version = sys.version_info[:2]
-
-    interpreter = f"cp{_version_nodot(python_version[:2])}"
-
-    if abis is None:
-        if len(python_version) > 1:
-            abis = _cpython_abis(python_version, warn)
-        else:
-            abis = []
-    abis = list(abis)
-    # 'abi3' and 'none' are explicitly handled later.
-    for explicit_abi in ("abi3", "none"):
-        try:
-            abis.remove(explicit_abi)
-        except ValueError:
-            pass
-
-    platforms = list(platforms or platform_tags())
-    for abi in abis:
-        for platform_ in platforms:
-            yield Tag(interpreter, abi, platform_)
-    if _abi3_applies(python_version):
-        yield from (Tag(interpreter, "abi3", platform_) for platform_ in platforms)
-    yield from (Tag(interpreter, "none", platform_) for platform_ in platforms)
-
-    if _abi3_applies(python_version):
-        for minor_version in range(python_version[1] - 1, 1, -1):
-            for platform_ in platforms:
-                interpreter = "cp{version}".format(
-                    version=_version_nodot((python_version[0], minor_version))
-                )
-                yield Tag(interpreter, "abi3", platform_)
-
-
-def _generic_abi() -> Iterator[str]:
-    abi = sysconfig.get_config_var("SOABI")
-    if abi:
-        yield _normalize_string(abi)
-
-
-def generic_tags(
-    interpreter: Optional[str] = None,
-    abis: Optional[Iterable[str]] = None,
-    platforms: Optional[Iterable[str]] = None,
-    *,
-    warn: bool = False,
-) -> Iterator[Tag]:
-    """
-    Yields the tags for a generic interpreter.
-
-    The tags consist of:
-    - <interpreter>-<abi>-<platform>
-
-    The "none" ABI will be added if it was not explicitly provided.
-    """
-    if not interpreter:
-        interp_name = interpreter_name()
-        interp_version = interpreter_version(warn=warn)
-        interpreter = "".join([interp_name, interp_version])
-    if abis is None:
-        abis = _generic_abi()
-    platforms = list(platforms or platform_tags())
-    abis = list(abis)
-    if "none" not in abis:
-        abis.append("none")
-    for abi in abis:
-        for platform_ in platforms:
-            yield Tag(interpreter, abi, platform_)
-
-
-def _py_interpreter_range(py_version: PythonVersion) -> Iterator[str]:
-    """
-    Yields Python versions in descending order.
-
-    After the latest version, the major-only version will be yielded, and then
-    all previous versions of that major version.
-    """
-    if len(py_version) > 1:
-        yield f"py{_version_nodot(py_version[:2])}"
-    yield f"py{py_version[0]}"
-    if len(py_version) > 1:
-        for minor in range(py_version[1] - 1, -1, -1):
-            yield f"py{_version_nodot((py_version[0], minor))}"
-
-
-def compatible_tags(
-    python_version: Optional[PythonVersion] = None,
-    interpreter: Optional[str] = None,
-    platforms: Optional[Iterable[str]] = None,
-) -> Iterator[Tag]:
-    """
-    Yields the sequence of tags that are compatible with a specific version of Python.
-
-    The tags consist of:
-    - py*-none-<platform>
-    - <interpreter>-none-any  # ... if `interpreter` is provided.
-    - py*-none-any
-    """
-    if not python_version:
-        python_version = sys.version_info[:2]
-    platforms = list(platforms or platform_tags())
-    for version in _py_interpreter_range(python_version):
-        for platform_ in platforms:
-            yield Tag(version, "none", platform_)
-    if interpreter:
-        yield Tag(interpreter, "none", "any")
-    for version in _py_interpreter_range(python_version):
-        yield Tag(version, "none", "any")
-
-
-def _mac_arch(arch: str, is_32bit: bool = _32_BIT_INTERPRETER) -> str:
-    if not is_32bit:
-        return arch
-
-    if arch.startswith("ppc"):
-        return "ppc"
-
-    return "i386"
-
-
-def _mac_binary_formats(version: MacVersion, cpu_arch: str) -> List[str]:
-    formats = [cpu_arch]
-    if cpu_arch == "x86_64":
-        if version < (10, 4):
-            return []
-        formats.extend(["intel", "fat64", "fat32"])
-
-    elif cpu_arch == "i386":
-        if version < (10, 4):
-            return []
-        formats.extend(["intel", "fat32", "fat"])
-
-    elif cpu_arch == "ppc64":
-        # TODO: Need to care about 32-bit PPC for ppc64 through 10.2?
-        if version > (10, 5) or version < (10, 4):
-            return []
-        formats.append("fat64")
-
-    elif cpu_arch == "ppc":
-        if version > (10, 6):
-            return []
-        formats.extend(["fat32", "fat"])
-
-    if cpu_arch in {"arm64", "x86_64"}:
-        formats.append("universal2")
-
-    if cpu_arch in {"x86_64", "i386", "ppc64", "ppc", "intel"}:
-        formats.append("universal")
-
-    return formats
-
-
-def mac_platforms(
-    version: Optional[MacVersion] = None, arch: Optional[str] = None
-) -> Iterator[str]:
-    """
-    Yields the platform tags for a macOS system.
-
-    The `version` parameter is a two-item tuple specifying the macOS version to
-    generate platform tags for. The `arch` parameter is the CPU architecture to
-    generate platform tags for. Both parameters default to the appropriate value
-    for the current system.
-    """
-    version_str, _, cpu_arch = platform.mac_ver()
-    if version is None:
-        version = cast("MacVersion", tuple(map(int, version_str.split(".")[:2])))
-    else:
-        version = version
-    if arch is None:
-        arch = _mac_arch(cpu_arch)
-    else:
-        arch = arch
-
-    if (10, 0) <= version and version < (11, 0):
-        # Prior to Mac OS 11, each yearly release of Mac OS bumped the
-        # "minor" version number.  The major version was always 10.
-        for minor_version in range(version[1], -1, -1):
-            compat_version = 10, minor_version
-            binary_formats = _mac_binary_formats(compat_version, arch)
-            for binary_format in binary_formats:
-                yield "macosx_{major}_{minor}_{binary_format}".format(
-                    major=10, minor=minor_version, binary_format=binary_format
-                )
-
-    if version >= (11, 0):
-        # Starting with Mac OS 11, each yearly release bumps the major version
-        # number.   The minor versions are now the midyear updates.
-        for major_version in range(version[0], 10, -1):
-            compat_version = major_version, 0
-            binary_formats = _mac_binary_formats(compat_version, arch)
-            for binary_format in binary_formats:
-                yield "macosx_{major}_{minor}_{binary_format}".format(
-                    major=major_version, minor=0, binary_format=binary_format
-                )
-
-    if version >= (11, 0):
-        # Mac OS 11 on x86_64 is compatible with binaries from previous releases.
-        # Arm64 support was introduced in 11.0, so no Arm binaries from previous
-        # releases exist.
-        #
-        # However, the "universal2" binary format can have a
-        # macOS version earlier than 11.0 when the x86_64 part of the binary supports
-        # that version of macOS.
-        if arch == "x86_64":
-            for minor_version in range(16, 3, -1):
-                compat_version = 10, minor_version
-                binary_formats = _mac_binary_formats(compat_version, arch)
-                for binary_format in binary_formats:
-                    yield "macosx_{major}_{minor}_{binary_format}".format(
-                        major=compat_version[0],
-                        minor=compat_version[1],
-                        binary_format=binary_format,
-                    )
-        else:
-            for minor_version in range(16, 3, -1):
-                compat_version = 10, minor_version
-                binary_format = "universal2"
-                yield "macosx_{major}_{minor}_{binary_format}".format(
-                    major=compat_version[0],
-                    minor=compat_version[1],
-                    binary_format=binary_format,
-                )
-
-
-def _linux_platforms(is_32bit: bool = _32_BIT_INTERPRETER) -> Iterator[str]:
-    linux = _normalize_string(sysconfig.get_platform())
-    if is_32bit:
-        if linux == "linux_x86_64":
-            linux = "linux_i686"
-        elif linux == "linux_aarch64":
-            linux = "linux_armv7l"
-    _, arch = linux.split("_", 1)
-    yield from _manylinux.platform_tags(linux, arch)
-    yield from _musllinux.platform_tags(arch)
-    yield linux
-
-
-def _generic_platforms() -> Iterator[str]:
-    yield _normalize_string(sysconfig.get_platform())
-
-
-def platform_tags() -> Iterator[str]:
-    """
-    Provides the platform tags for this installation.
-    """
-    if platform.system() == "Darwin":
-        return mac_platforms()
-    elif platform.system() == "Linux":
-        return _linux_platforms()
-    else:
-        return _generic_platforms()
-
-
-def interpreter_name() -> str:
-    """
-    Returns the name of the running interpreter.
-    """
-    name = sys.implementation.name
-    return INTERPRETER_SHORT_NAMES.get(name) or name
-
-
-def interpreter_version(*, warn: bool = False) -> str:
-    """
-    Returns the version of the running interpreter.
-    """
-    version = _get_config_var("py_version_nodot", warn=warn)
-    if version:
-        version = str(version)
-    else:
-        version = _version_nodot(sys.version_info[:2])
-    return version
-
-
-def _version_nodot(version: PythonVersion) -> str:
-    return "".join(map(str, version))
-
-
-def sys_tags(*, warn: bool = False) -> Iterator[Tag]:
-    """
-    Returns the sequence of tag triples for the running interpreter.
-
-    The order of the sequence corresponds to priority order for the
-    interpreter, from most to least important.
-    """
-
-    interp_name = interpreter_name()
-    if interp_name == "cp":
-        yield from cpython_tags(warn=warn)
-    else:
-        yield from generic_tags()
-
-    if interp_name == "pp":
-        yield from compatible_tags(interpreter="pp3")
-    else:
-        yield from compatible_tags()

spaces/CVPR/Dual-Key_Backdoor_Attacks/datagen/detectron2/demo/demo.py

@@ -1,159 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
-import argparse
-import glob
-import multiprocessing as mp
-import os
-import time
-import cv2
-import tqdm
-
-from detectron2.config import get_cfg
-from detectron2.data.detection_utils import read_image
-from detectron2.utils.logger import setup_logger
-
-from predictor import VisualizationDemo
-
-# constants
-WINDOW_NAME = "COCO detections"
-
-
-def setup_cfg(args):
-    # load config from file and command-line arguments
-    cfg = get_cfg()
-    cfg.merge_from_file(args.config_file)
-    cfg.merge_from_list(args.opts)
-    # Set score_threshold for builtin models
-    cfg.MODEL.RETINANET.SCORE_THRESH_TEST = args.confidence_threshold
-    cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = args.confidence_threshold
-    cfg.MODEL.PANOPTIC_FPN.COMBINE.INSTANCES_CONFIDENCE_THRESH = args.confidence_threshold
-    cfg.freeze()
-    return cfg
-
-
-def get_parser():
-    parser = argparse.ArgumentParser(description="Detectron2 demo for builtin models")
-    parser.add_argument(
-        "--config-file",
-        default="configs/quick_schedules/mask_rcnn_R_50_FPN_inference_acc_test.yaml",
-        metavar="FILE",
-        help="path to config file",
-    )
-    parser.add_argument("--webcam", action="store_true", help="Take inputs from webcam.")
-    parser.add_argument("--video-input", help="Path to video file.")
-    parser.add_argument(
-        "--input",
-        nargs="+",
-        help="A list of space separated input images; "
-        "or a single glob pattern such as 'directory/*.jpg'",
-    )
-    parser.add_argument(
-        "--output",
-        help="A file or directory to save output visualizations. "
-        "If not given, will show output in an OpenCV window.",
-    )
-
-    parser.add_argument(
-        "--confidence-threshold",
-        type=float,
-        default=0.5,
-        help="Minimum score for instance predictions to be shown",
-    )
-    parser.add_argument(
-        "--opts",
-        help="Modify config options using the command-line 'KEY VALUE' pairs",
-        default=[],
-        nargs=argparse.REMAINDER,
-    )
-    return parser
-
-
-if __name__ == "__main__":
-    mp.set_start_method("spawn", force=True)
-    args = get_parser().parse_args()
-    setup_logger(name="fvcore")
-    logger = setup_logger()
-    logger.info("Arguments: " + str(args))
-
-    cfg = setup_cfg(args)
-
-    demo = VisualizationDemo(cfg)
-
-    if args.input:
-        if len(args.input) == 1:
-            args.input = glob.glob(os.path.expanduser(args.input[0]))
-            assert args.input, "The input path(s) was not found"
-        for path in tqdm.tqdm(args.input, disable=not args.output):
-            # use PIL, to be consistent with evaluation
-            img = read_image(path, format="BGR")
-            start_time = time.time()
-            predictions, visualized_output = demo.run_on_image(img)
-            logger.info(
-                "{}: {} in {:.2f}s".format(
-                    path,
-                    "detected {} instances".format(len(predictions["instances"]))
-                    if "instances" in predictions
-                    else "finished",
-                    time.time() - start_time,
-                )
-            )
-
-            if args.output:
-                if os.path.isdir(args.output):
-                    assert os.path.isdir(args.output), args.output
-                    out_filename = os.path.join(args.output, os.path.basename(path))
-                else:
-                    assert len(args.input) == 1, "Please specify a directory with args.output"
-                    out_filename = args.output
-                visualized_output.save(out_filename)
-            else:
-                cv2.namedWindow(WINDOW_NAME, cv2.WINDOW_NORMAL)
-                cv2.imshow(WINDOW_NAME, visualized_output.get_image()[:, :, ::-1])
-                if cv2.waitKey(0) == 27:
-                    break  # esc to quit
-    elif args.webcam:
-        assert args.input is None, "Cannot have both --input and --webcam!"
-        cam = cv2.VideoCapture(0)
-        for vis in tqdm.tqdm(demo.run_on_video(cam)):
-            cv2.namedWindow(WINDOW_NAME, cv2.WINDOW_NORMAL)
-            cv2.imshow(WINDOW_NAME, vis)
-            if cv2.waitKey(1) == 27:
-                break  # esc to quit
-        cv2.destroyAllWindows()
-    elif args.video_input:
-        video = cv2.VideoCapture(args.video_input)
-        width = int(video.get(cv2.CAP_PROP_FRAME_WIDTH))
-        height = int(video.get(cv2.CAP_PROP_FRAME_HEIGHT))
-        frames_per_second = video.get(cv2.CAP_PROP_FPS)
-        num_frames = int(video.get(cv2.CAP_PROP_FRAME_COUNT))
-        basename = os.path.basename(args.video_input)
-
-        if args.output:
-            if os.path.isdir(args.output):
-                output_fname = os.path.join(args.output, basename)
-                output_fname = os.path.splitext(output_fname)[0] + ".mkv"
-            else:
-                output_fname = args.output
-            assert not os.path.isfile(output_fname), output_fname
-            output_file = cv2.VideoWriter(
-                filename=output_fname,
-                # some installation of opencv may not support x264 (due to its license),
-                # you can try other format (e.g. MPEG)
-                fourcc=cv2.VideoWriter_fourcc(*"x264"),
-                fps=float(frames_per_second),
-                frameSize=(width, height),
-                isColor=True,
-            )
-        assert os.path.isfile(args.video_input)
-        for vis_frame in tqdm.tqdm(demo.run_on_video(video), total=num_frames):
-            if args.output:
-                output_file.write(vis_frame)
-            else:
-                cv2.namedWindow(basename, cv2.WINDOW_NORMAL)
-                cv2.imshow(basename, vis_frame)
-                if cv2.waitKey(1) == 27:
-                    break  # esc to quit
-        video.release()
-        if args.output:
-            output_file.release()
-        else:
-            cv2.destroyAllWindows()

spaces/CVPR/LIVE/thrust/CONTRIBUTING.md

@@ -1,490 +0,0 @@
-# Table of Contents
-
-1. [Contributing to Thrust](#contributing-to-thrust)
-1. [CMake Options](#cmake-options)
-1. [Development Model](#development-model)
-
-# Contributing to Thrust
-
-Thrust uses Github to manage all open-source development, including bug
-tracking, pull requests, and design discussions. This document details how to get
-started as a Thrust contributor.
-
-An overview of this process is:
-
-1. [Clone the Thrust repository](#clone-the-thrust-repository)
-1. [Setup a fork of Thrust](#setup-a-fork-of-thrust)
-1. [Setup your environment](#setup-your-environment)
-1. [Create a development branch](#create-a-development-branch)
-1. [Local development loop](#local-development-loop)
-1. [Push development branch to your fork](#push-development-branch-to-your-fork)
-1. [Create pull request](#create-pull-request)
-1. [Address feedback and update pull request](#address-feedback-and-update-pull-request)
-1. [When your PR is approved...](#when-your-pr-is-approved)
-
-## Clone the Thrust Repository
-
-To get started, clone the main repository to your local computer. Thrust should
-be cloned recursively to setup the CUB submodule (required for `CUDA`
-acceleration).
-
-```
-git clone --recursive https://github.com/thrust/thrust.git
-cd thrust
-```
-
-## Setup a Fork of Thrust
-
-You'll need a fork of Thrust on Github to create a pull request. To setup your
-fork:
-
-1. Create a Github account (if needed)
-2. Go to [the Thrust Github page](https://github.com/thrust/thrust)
-3. Click "Fork" and follow any prompts that appear.
-
-Once your fork is created, setup a new remote repo in your local Thrust clone:
-
-```
-git remote add github-fork [email protected]:<GITHUB_USERNAME>/thrust.git
-```
-
-If you need to modify CUB, too, go to
-[the CUB Github page](https://github.com/thrust/cub) and repeat this process.
-Create CUB's `github-fork` remote in the `thrust/dependencies/cub` submodule.
-
-## Setup Your Environment
-
-### Git Environment
-
-If you haven't already, this is a good time to tell git who you are. This
-information is used to fill out authorship information on your git commits.
-
-```
-git config --global user.name "John Doe"
-git config --global user.email [email protected]
-```
-
-### Configure CMake builds
-
-Thrust uses [CMake](https://www.cmake.org) for its developer build system. To
-configure, build, and test your checkout of Thrust:
-
-```
-# Create build directory:
-mkdir build
-cd build
-
-# Configure -- use one of the following:
-cmake ..   # Command line interface.
-ccmake ..  # ncurses GUI (Linux only)
-cmake-gui  # Graphical UI, set source/build directories in the app
-
-# Build:
-cmake --build . -j <num jobs>   # invokes make (or ninja, etc)
-
-# Run tests and examples:
-ctest
-```
-
-See [CMake Options](#cmake-options) for details on customizing the build.
-
-## Create a Development Branch
-
-All work should be done in a development branch (also called a "topic branch")
-and not directly in the `master` branch. This makes it easier to manage multiple
-in-progress patches at once, and provides a descriptive label for your patch
-as it passes through the review system.
-
-To create a new branch based on the current `master`:
-
-```
-# Checkout local master branch:
-cd /path/to/thrust/sources
-git checkout master
-
-# Sync local master branch with github:
-git pull
-
-# Create a new branch named `my_descriptive_branch_name` based on master:
-git checkout -b my_descriptive_branch_name
-
-# Verify that the branch has been created and is currently checked out:
-git branch
-```
-
-Thrust branch names should follow a particular pattern:
-
-- For new features, name the branch `feature/<name>`
-- For bugfixes associated with a github issue, use `bug/github/<bug-description>-<bug-id>`
-  - Internal nvidia and gitlab bugs should use `nvidia` or `gitlab` in place of
-    `github`.
-
-If you plan to work on CUB as part of your patch, repeat this process in the
-`thrust/dependencies/cub` submodule.
-
-## Local Development Loop
-
-### Edit, Build, Test, Repeat
-
-Once the topic branch is created, you're all set to start working on Thrust
-code. Make some changes, then build and test them:
-
-```
-# Implement changes:
-cd /path/to/thrust/sources
-emacs thrust/some_file.h # or whatever editor you prefer
-
-# Create / update a unit test for your changes:
-emacs testing/some_test.cu
-
-# Check that everything builds and tests pass:
-cd /path/to/thrust/build/directory
-cmake --build . -j <num jobs>
-ctest
-```
-
-### Creating a Commit
-
-Once you're satisfied with your patch, commit your changes:
-
-#### Thrust-only Changes
-
-```
-# Manually add changed files and create a commit:
-cd /path/to/thrust
-git add thrust/some_file.h
-git add testing/some_test.cu
-git commit
-
-# Or, if possible, use git-gui to review your changes while building your patch:
-git gui
-```
-
-#### Thrust and CUB Changes
-
-```
-# Create CUB patch first:
-cd /path/to/thrust/dependencies/cub
-# Manually add changed files and create a commit:
-git add cub/some_file.cuh
-git commit
-
-# Create Thrust patch, including submodule update:
-cd /path/to/thrust/
-git add dependencies/cub # Updates submodule info
-git add thrust/some_file.h
-git add testing/some_test.cu
-git commit
-
-# Or, if possible, use git-gui to review your changes while building your patch:
-cd /path/to/thrust/dependencies/cub
-git gui
-cd /path/to/thrust
-git gui # Include dependencies/cub as part of your commit
-
-```
-
-#### Writing a Commit Message
-
-Your commit message will communicate the purpose and rationale behind your
-patch to other developers, and will be used to populate the initial description
-of your Github pull request.
-
-When writing a commit message, the following standard format should be used,
-since tools in the git ecosystem are designed to parse this correctly:
-
-```
-First line of commit message is a short summary (<80 char)
-<Second line left blank>
-Detailed description of change begins on third line. This portion can
-span multiple lines, try to manually wrap them at something reasonable.
-
-Blank lines can be used to separate multiple paragraphs in the description.
-
-If your patch is associated with another pull request or issue in the main
-Thrust repository, you should reference it with a `#` symbol, e.g.
-#1023 for issue 1023.
-
-For issues / pull requests in a different github repo, reference them using
-the full syntax, e.g. thrust/cub#4 for issue 4 in the thrust/cub repo.
-
-Markdown is recommended for formatting more detailed messages, as these will
-be nicely rendered on Github, etc.
-```
-
-## Push Development Branch to your Fork
-
-Once you've committed your changes to a local development branch, it's time to
-push them to your fork:
-
-```
-cd /path/to/thrust/checkout
-git checkout my_descriptive_branch_name # if not already checked out
-git push --set-upstream github-fork my_descriptive_branch_name
-```
-
-`--set-upstream github-fork` tells git that future pushes/pulls on this branch
-should target your `github-fork` remote by default.
-
-If have CUB changes to commit as part of your patch, repeat this process in the
-`thrust/dependencies/cub` submodule.
-
-## Create Pull Request
-
-To create a pull request for your freshly pushed branch, open your github fork
-in a browser by going to `https://www.github.com/<GITHUB_USERNAME>/thrust`. A
-prompt may automatically appear asking you to create a pull request if you've
-recently pushed a branch.
-
-If there's no prompt, go to "Code" > "Branches" and click the appropriate
-"New pull request" button for your branch.
-
-If you would like a specific developer to review your patch, feel free to
-request them as a reviewer at this time.
-
-The Thrust team will review your patch, test it on NVIDIA's internal CI, and
-provide feedback.
-
-
-If have CUB changes to commit as part of your patch, repeat this process with
-your CUB branch and fork.
-
-## Address Feedback and Update Pull Request
-
-If the reviewers request changes to your patch, use the following process to
-update the pull request:
-
-```
-# Make changes:
-cd /path/to/thrust/sources
-git checkout my_descriptive_branch_name
-emacs thrust/some_file.h
-emacs testing/some_test.cu
-
-# Build + test
-cd /path/to/thrust/build/directory
-cmake --build . -j <num jobs>
-ctest
-
-# Amend commit:
-cd /path/to/thrust/sources
-git add thrust/some_file.h
-git add testing/some_test.cu
-git commit --amend
-# Or
-git gui # Check the "Amend Last Commit" box
-
-# Update the branch on your fork:
-git push -f
-```
-
-At this point, the pull request should show your recent changes.
-
-If have CUB changes to commit as part of your patch, repeat this process in the
-`thrust/dependencies/cub` submodule, and be sure to include any CUB submodule
-updates as part of your commit.
-
-## When Your PR is Approved
-
-Once your pull request is approved by the Thrust team, no further action is
-needed from you. We will handle integrating it since we must coordinate changes
-to `master` with NVIDIA's internal perforce repository.
-
-# CMake Options
-
-A Thrust build is configured using CMake options. These may be passed to CMake
-using
-
-```
-cmake -D<option_name>=<value> /path/to/thrust/sources
-```
-
-or configured interactively with the `ccmake` or `cmake-gui` interfaces.
-
-Thrust supports two build modes. By default, a single configuration is built
-that targets a specific host system, device system, and C++ dialect.
-When `THRUST_ENABLE_MULTICONFIG` is `ON`, multiple configurations
-targeting a variety of systems and dialects are generated.
-
-The CMake options are divided into these categories:
-
-1. [Generic CMake Options](#generic-cmake-options): Options applicable to all
-   Thrust builds.
-1. [Single Config CMake Options](#single-config-cmake-options) Options
-   applicable only when `THRUST_ENABLE_MULTICONFIG` is disabled.
-1. [Multi Config CMake Options](#multi-config-cmake-options) Options applicable
-   only when `THRUST_ENABLE_MULTICONFIG` is enabled.
-1. [CUDA Specific CMake Options](#cuda-specific-cmake-options) Options that
-   control CUDA compilation. Only available when one or more configurations
-   targets the CUDA system.
-1. [TBB Specific CMake Options](#tbb-specific-cmake-options) Options that
-   control TBB compilation. Only available when one or more configurations
-   targets the TBB system.
-
-## Generic CMake Options
-
-- `CMAKE_BUILD_TYPE={Release, Debug, RelWithDebInfo, MinSizeRel}`
-  - Standard CMake build option. Default: `RelWithDebInfo`
-- `THRUST_ENABLE_HEADER_TESTING={ON, OFF}`
-  - Whether to test compile public headers. Default is `ON`.
-- `THRUST_ENABLE_TESTING={ON, OFF}`
-  - Whether to build unit tests. Default is `ON`.
-- `THRUST_ENABLE_EXAMPLES={ON, OFF}`
-  - Whether to build examples. Default is `ON`.
-- `THRUST_ENABLE_MULTICONFIG={ON, OFF}`
-  - Toggles single-config and multi-config modes. Default is `OFF` (single config).
-- `THRUST_ENABLE_EXAMPLE_FILECHECK={ON, OFF}`
-  - Enable validation of example outputs using the LLVM FileCheck utility.
-    Default is `OFF`.
-
-## Single Config CMake Options
-
-- `THRUST_HOST_SYSTEM={CPP, TBB, OMP}`
-  - Selects the host system. Default: `CPP`
-- `THRUST_DEVICE_SYSTEM={CUDA, TBB, OMP, CPP}`
-  - Selects the device system. Default: `CUDA`
-- `THRUST_CPP_DIALECT={11, 14, 17}`
-  - Selects the C++ standard dialect to use. Default is `14` (C++14).
-
-## Multi Config CMake Options
-
-- `THRUST_MULTICONFIG_ENABLE_DIALECT_CPPXX={ON, OFF}`
-  - Toggle whether a specific C++ dialect will be targeted.
-  - Possible values of `XX` are `{11, 14, 17}`.
-  - By default, only C++14 is enabled.
-- `THRUST_MULTICONFIG_ENABLE_SYSTEM_XXXX={ON, OFF}`
-  - Toggle whether a specific system will be targeted.
-  - Possible values of `XXXX` are `{CPP, CUDA, TBB, OMP}`
-  - By default, only `CPP` and `CUDA` are enabled.
-- `THRUST_MULTICONFIG_WORKLOAD={SMALL, MEDIUM, LARGE, FULL}`
-  - Restricts the host/device combinations that will be targeted.
-  - By default, the `SMALL` workload is used.
-  - The full cross product of `host x device` systems results in 12
-    configurations, some of which are more important than others.
-    This option can be used to prune some of the less important ones.
-  - `SMALL`: (3 configs) Minimal coverage and validation of each device system against the `CPP` host.
-  - `MEDIUM`: (6 configs) Cheap extended coverage.
-  - `LARGE`: (8 configs) Expensive extended coverage. Includes all useful build configurations.
-  - `FULL`: (12 configs) The complete cross product of all possible build configurations.
-
-| Config   | Workloads | Value      | Expense   | Note                         |
-|----------|-----------|------------|-----------|------------------------------|
-| CPP/CUDA | `F L M S` | Essential  | Expensive | Validates CUDA against CPP   |
-| CPP/OMP  | `F L M S` | Essential  | Cheap     | Validates OMP against CPP    |
-| CPP/TBB  | `F L M S` | Essential  | Cheap     | Validates TBB against CPP    |
-| CPP/CPP  | `F L M  ` | Important  | Cheap     | Tests CPP as device          |
-| OMP/OMP  | `F L M  ` | Important  | Cheap     | Tests OMP as host            |
-| TBB/TBB  | `F L M  ` | Important  | Cheap     | Tests TBB as host            |
-| TBB/CUDA | `F L    ` | Important  | Expensive | Validates TBB/CUDA interop   |
-| OMP/CUDA | `F L    ` | Important  | Expensive | Validates OMP/CUDA interop   |
-| TBB/OMP  | `F      ` | Not useful | Cheap     | Mixes CPU-parallel systems   |
-| OMP/TBB  | `F      ` | Not useful | Cheap     | Mixes CPU-parallel systems   |
-| TBB/CPP  | `F      ` | Not Useful | Cheap     | Parallel host, serial device |
-| OMP/CPP  | `F      ` | Not Useful | Cheap     | Parallel host, serial device |
-
-## CUDA Specific CMake Options
-
-- `THRUST_INCLUDE_CUB_CMAKE={ON, OFF}`
-  - If enabled, the CUB project will be built as part of Thrust. Default is
-    `OFF`.
-  - This adds CUB tests, etc. Useful for working on both CUB and Thrust
-    simultaneously.
-  - CUB configurations will be generated for each C++ dialect targeted by
-    the current Thrust build.
-- `THRUST_ENABLE_COMPUTE_XX={ON, OFF}`
-  - Controls the targeted CUDA architecture(s)
-  - Multiple options may be selected when using NVCC as the CUDA compiler.
-  - Valid values of `XX` are:
-    `{35, 37, 50, 52, 53, 60, 61, 62, 70, 72, 75, 80}`
-  - Default value depends on `THRUST_DISABLE_ARCH_BY_DEFAULT`:
-- `THRUST_ENABLE_COMPUTE_FUTURE={ON, OFF}`
-  - If enabled, CUDA objects will target the most recent virtual architecture
-    in addition to the real architectures specified by the
-    `THRUST_ENABLE_COMPUTE_XX` options.
-  - Default value depends on `THRUST_DISABLE_ARCH_BY_DEFAULT`:
-- `THRUST_DISABLE_ARCH_BY_DEFAULT={ON, OFF}`
-  - When `ON`, all `THRUST_ENABLE_COMPUTE_*` options are initially `OFF`.
-  - Default: `OFF` (meaning all architectures are enabled by default)
-- `THRUST_ENABLE_TESTS_WITH_RDC={ON, OFF}`
-  - Whether to enable Relocatable Device Code when building tests.
-    Default is `OFF`.
-- `THRUST_ENABLE_EXAMPLES_WITH_RDC={ON, OFF}`
-  - Whether to enable Relocatable Device Code when building examples.
-    Default is `OFF`.
-
-## TBB Specific CMake Options
-
-- `THRUST_TBB_ROOT=<path to tbb root>`
-  - When the TBB system is requested, set this to the root of the TBB installation
-    (e.g. the location of `lib/`, `bin/` and `include/` for the TBB libraries).
-
-# Development Model
-
-The following is a description of the basic development process that Thrust follows. This is a living
-document that will evolve as our process evolves.
-
-Thrust is distributed in three ways:
-
-   * On GitHub.
-   * In the NVIDIA HPC SDK.
-   * In the CUDA Toolkit.
-
-## Trunk Based Development
-
-Thrust uses [trunk based development](https://trunkbaseddevelopment.com). There is a single long-lived
-branch called `master`. Engineers may create branches for feature development. Such branches always
-merge into `master`. There are no release branches. Releases are produced by taking a snapshot of
-`master` ("snapping"). After a release has been snapped from `master`, it will never be changed.
-
-## Repositories
-
-As Thrust is developed both on GitHub and internally at NVIDIA, there are three main places where code lives:
-
-   * The Source of Truth, the [public Thrust repository](https://github.com/thrust/thrust), referred to as
-     `github` later in this document.
-   * An internal GitLab repository, referred to as `gitlab` later in this document.
-   * An internal Perforce repository, referred to as `perforce` later in this document.
-
-## Versioning
-
-Thrust has its own versioning system for releases, independent of the versioning scheme of the NVIDIA
-HPC SDK or the CUDA Toolkit.
-
-Today, Thrust version numbers have a specific [semantic meaning](https://semver.org/).
-Releases prior to 1.10.0 largely, but not strictly, followed these semantic meanings.
-
-The version number for a Thrust release uses the following format: `MMM.mmm.ss-ppp`, where:
-
-   * `THRUST_VERSION_MAJOR`/`MMM`: Major version, up to 3 decimal digits. It is incremented
-     when changes that are API-backwards-incompatible are made.
-   * `THRUST_VERSION_MINOR`/`mmm`: Minor version, up to 3 decimal digits. It is incremented when
-     breaking API, ABI, or semantic changes are made.
-   * `THRUST_VERSION_SUBMINOR`/`ss`: Subminor version, up to 2 decimal digits. It is incremented
-     when notable new features or bug fixes or features that are API-backwards-compatible are made.
-   * `THRUST_PATCH_NUMBER`/`ppp`: Patch number, up to 3 decimal digits. It is incremented if any
-     change in the repo whatsoever is made and no other version component has been incremented.
-
-The `<thrust/version.h>` header defines `THRUST_*` macros for all of the version components mentioned
-above. Additionally, a `THRUST_VERSION` macro is defined, which is an integer literal containing all
-of the version components except for `THRUST_PATCH_NUMBER`.
-
-## Branches and Tags
-
-The following tag names are used in the Thrust project:
-
-  * `github/nvhpc-X.Y`: the tag that directly corresponds to what has been shipped in the NVIDIA HPC SDK release X.Y.
-  * `github/cuda-X.Y`: the tag that directly corresponds to what has been shipped in the CUDA Toolkit release X.Y.
-  * `github/A.B.C`: the tag that directly corresponds to a Thrust version A.B.C.
-
-The following branch names are used in the Thrust project:
-
-  * `github/master`: the Source of Truth development branch of Thrust.
-  * `github/old-master`: the old Source of Truth branch, before unification of public and internal repositories.
-  * `github/feature/<name>`: feature branch for a feature under development.
-  * `github/bug/<bug-system>/<bug-description>-<bug-id>`: bug fix branch, where `bug-system` is `github` or `nvidia`.
-  * `gitlab/master`: mirror of `github/master`.
-  * `perforce/private`: mirrored `github/master`, plus files necessary for internal NVIDIA testing systems.
-
-On the rare occasion that we cannot do work in the open, for example when developing a change specific to an
-unreleased product, these branches may exist on `gitlab` instead of `github`. By default, everything should be
-in the open on `github` unless there is a strong motivation for it to not be open.

spaces/CVPR/LIVE/thrust/testing/omp/nvcc_independence.cpp

@@ -1,75 +0,0 @@
-#include <unittest/unittest.h>
-#include <thrust/device_ptr.h>
-#include <thrust/transform.h>
-#include <thrust/reduce.h>
-#include <thrust/scan.h>
-#include <thrust/sort.h>
-#include <thrust/system_error.h>
-
-void TestNvccIndependenceTransform(void)
-{
-  typedef int T;
-  const int n = 10;
-
-  thrust::host_vector<T>   h_input = unittest::random_integers<T>(n);
-  thrust::device_vector<T> d_input = h_input;
-
-  thrust::host_vector<T>   h_output(n);
-  thrust::device_vector<T> d_output(n);
-
-  thrust::transform(h_input.begin(), h_input.end(), h_output.begin(), thrust::negate<T>());
-  thrust::transform(d_input.begin(), d_input.end(), d_output.begin(), thrust::negate<T>());
-  
-  ASSERT_EQUAL(h_output, d_output);
-}
-DECLARE_UNITTEST(TestNvccIndependenceTransform);
-
-void TestNvccIndependenceReduce(void)
-{
-  typedef int T;
-  const int n = 10;
-
-  thrust::host_vector<T>   h_data = unittest::random_integers<T>(n);
-  thrust::device_vector<T> d_data = h_data;
-
-  T init = 13;
-
-  T h_result = thrust::reduce(h_data.begin(), h_data.end(), init);
-  T d_result = thrust::reduce(d_data.begin(), d_data.end(), init);
-
-  ASSERT_ALMOST_EQUAL(h_result, d_result);
-}
-DECLARE_UNITTEST(TestNvccIndependenceReduce);
-
-void TestNvccIndependenceExclusiveScan(void)
-{
-  typedef int T;
-  const int n = 10;
-
-  thrust::host_vector<T>   h_input = unittest::random_integers<T>(n);
-  thrust::device_vector<T> d_input = h_input;
-
-  thrust::host_vector<T>   h_output(n);
-  thrust::device_vector<T> d_output(n);
-  
-  thrust::inclusive_scan(h_input.begin(), h_input.end(), h_output.begin());
-  thrust::inclusive_scan(d_input.begin(), d_input.end(), d_output.begin());
-  ASSERT_EQUAL(d_output, h_output);
-}
-DECLARE_UNITTEST(TestNvccIndependenceExclusiveScan);
-
-void TestNvccIndependenceSort(void)
-{
-  typedef int T;
-  const int n = 10;
-
-  thrust::host_vector<T>   h_data = unittest::random_integers<T>(n);
-  thrust::device_vector<T> d_data = h_data;
-
-  thrust::sort(h_data.begin(), h_data.end(), thrust::less<T>());
-  thrust::sort(d_data.begin(), d_data.end(), thrust::less<T>());
-
-  ASSERT_EQUAL(h_data, d_data);
-}
-DECLARE_UNITTEST(TestNvccIndependenceSort);
-

spaces/CVPR/LIVE/thrust/thrust/system/cuda/detail/equal.h

@@ -1,74 +0,0 @@
-/******************************************************************************
- * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the NVIDIA CORPORATION nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- ******************************************************************************/
-#pragma once
-
-
-#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
-#include <thrust/system/cuda/config.h>
-
-#include <thrust/system/cuda/detail/mismatch.h>
-
-namespace thrust
-{
-namespace cuda_cub {
-
-template <class Derived,
-          class InputIt1,
-          class InputIt2,
-          class BinaryPred>
-bool __host__ __device__
-equal(execution_policy<Derived>& policy,
-      InputIt1                   first1,
-      InputIt1                   last1,
-      InputIt2                   first2,
-      BinaryPred                 binary_pred)
-{
-  return cuda_cub::mismatch(policy, first1, last1, first2, binary_pred).first == last1;
-}
-
-template <class Derived,
-          class InputIt1,
-          class InputIt2>
-bool __host__ __device__
-equal(execution_policy<Derived>& policy,
-      InputIt1                   first1,
-      InputIt1                   last1,
-      InputIt2                   first2)
-{
-  typedef typename thrust::iterator_value<InputIt1>::type InputType1;
-  return cuda_cub::equal(policy,
-                         first1,
-                         last1,
-                         first2,
-                         equal_to<InputType1>());
-}
-
-
-
-} // namespace cuda_cub
-} // end namespace thrust
-#endif

spaces/Caoyunkang/Segment-Any-Anomaly/GroundingDINO/groundingdino/models/GroundingDINO/backbone/position_encoding.py

@@ -1,186 +0,0 @@
-# ------------------------------------------------------------------------
-# Grounding DINO
-# url: https://github.com/IDEA-Research/GroundingDINO
-# Copyright (c) 2023 IDEA. All Rights Reserved.
-# Licensed under the Apache License, Version 2.0 [see LICENSE for details]
-# ------------------------------------------------------------------------
-# DINO
-# Copyright (c) 2022 IDEA. All Rights Reserved.
-# Licensed under the Apache License, Version 2.0 [see LICENSE for details]
-# ------------------------------------------------------------------------
-# Conditional DETR
-# Copyright (c) 2021 Microsoft. All Rights Reserved.
-# Licensed under the Apache License, Version 2.0 [see LICENSE for details]
-# ------------------------------------------------------------------------
-# Copied from DETR (https://github.com/facebookresearch/detr)
-# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
-# ------------------------------------------------------------------------
-
-"""
-Various positional encodings for the transformer.
-"""
-import math
-
-import torch
-from torch import nn
-
-from groundingdino.util.misc import NestedTensor
-
-
-class PositionEmbeddingSine(nn.Module):
-    """
-    This is a more standard version of the position embedding, very similar to the one
-    used by the Attention is all you need paper, generalized to work on images.
-    """
-
-    def __init__(self, num_pos_feats=64, temperature=10000, normalize=False, scale=None):
-        super().__init__()
-        self.num_pos_feats = num_pos_feats
-        self.temperature = temperature
-        self.normalize = normalize
-        if scale is not None and normalize is False:
-            raise ValueError("normalize should be True if scale is passed")
-        if scale is None:
-            scale = 2 * math.pi
-        self.scale = scale
-
-    def forward(self, tensor_list: NestedTensor):
-        x = tensor_list.tensors
-        mask = tensor_list.mask
-        assert mask is not None
-        not_mask = ~mask
-        y_embed = not_mask.cumsum(1, dtype=torch.float32)
-        x_embed = not_mask.cumsum(2, dtype=torch.float32)
-        if self.normalize:
-            eps = 1e-6
-            # if os.environ.get("SHILONG_AMP", None) == '1':
-            #     eps = 1e-4
-            # else:
-            #     eps = 1e-6
-            y_embed = y_embed / (y_embed[:, -1:, :] + eps) * self.scale
-            x_embed = x_embed / (x_embed[:, :, -1:] + eps) * self.scale
-
-        dim_t = torch.arange(self.num_pos_feats, dtype=torch.float32, device=x.device)
-        dim_t = self.temperature ** (2 * (dim_t // 2) / self.num_pos_feats)
-
-        pos_x = x_embed[:, :, :, None] / dim_t
-        pos_y = y_embed[:, :, :, None] / dim_t
-        pos_x = torch.stack(
-            (pos_x[:, :, :, 0::2].sin(), pos_x[:, :, :, 1::2].cos()), dim=4
-        ).flatten(3)
-        pos_y = torch.stack(
-            (pos_y[:, :, :, 0::2].sin(), pos_y[:, :, :, 1::2].cos()), dim=4
-        ).flatten(3)
-        pos = torch.cat((pos_y, pos_x), dim=3).permute(0, 3, 1, 2)
-        return pos
-
-
-class PositionEmbeddingSineHW(nn.Module):
-    """
-    This is a more standard version of the position embedding, very similar to the one
-    used by the Attention is all you need paper, generalized to work on images.
-    """
-
-    def __init__(
-        self, num_pos_feats=64, temperatureH=10000, temperatureW=10000, normalize=False, scale=None
-    ):
-        super().__init__()
-        self.num_pos_feats = num_pos_feats
-        self.temperatureH = temperatureH
-        self.temperatureW = temperatureW
-        self.normalize = normalize
-        if scale is not None and normalize is False:
-            raise ValueError("normalize should be True if scale is passed")
-        if scale is None:
-            scale = 2 * math.pi
-        self.scale = scale
-
-    def forward(self, tensor_list: NestedTensor):
-        x = tensor_list.tensors
-        mask = tensor_list.mask
-        assert mask is not None
-        not_mask = ~mask
-        y_embed = not_mask.cumsum(1, dtype=torch.float32)
-        x_embed = not_mask.cumsum(2, dtype=torch.float32)
-
-        # import ipdb; ipdb.set_trace()
-
-        if self.normalize:
-            eps = 1e-6
-            y_embed = y_embed / (y_embed[:, -1:, :] + eps) * self.scale
-            x_embed = x_embed / (x_embed[:, :, -1:] + eps) * self.scale
-
-        dim_tx = torch.arange(self.num_pos_feats, dtype=torch.float32, device=x.device)
-        dim_tx = self.temperatureW ** (2 * (torch.div(dim_tx, 2, rounding_mode='floor')) / self.num_pos_feats)
-        pos_x = x_embed[:, :, :, None] / dim_tx
-
-        dim_ty = torch.arange(self.num_pos_feats, dtype=torch.float32, device=x.device)
-        dim_ty = self.temperatureH ** (2 * (torch.div(dim_ty, 2, rounding_mode='floor')) / self.num_pos_feats)
-        pos_y = y_embed[:, :, :, None] / dim_ty
-
-        pos_x = torch.stack(
-            (pos_x[:, :, :, 0::2].sin(), pos_x[:, :, :, 1::2].cos()), dim=4
-        ).flatten(3)
-        pos_y = torch.stack(
-            (pos_y[:, :, :, 0::2].sin(), pos_y[:, :, :, 1::2].cos()), dim=4
-        ).flatten(3)
-        pos = torch.cat((pos_y, pos_x), dim=3).permute(0, 3, 1, 2)
-
-        # import ipdb; ipdb.set_trace()
-
-        return pos
-
-
-class PositionEmbeddingLearned(nn.Module):
-    """
-    Absolute pos embedding, learned.
-    """
-
-    def __init__(self, num_pos_feats=256):
-        super().__init__()
-        self.row_embed = nn.Embedding(50, num_pos_feats)
-        self.col_embed = nn.Embedding(50, num_pos_feats)
-        self.reset_parameters()
-
-    def reset_parameters(self):
-        nn.init.uniform_(self.row_embed.weight)
-        nn.init.uniform_(self.col_embed.weight)
-
-    def forward(self, tensor_list: NestedTensor):
-        x = tensor_list.tensors
-        h, w = x.shape[-2:]
-        i = torch.arange(w, device=x.device)
-        j = torch.arange(h, device=x.device)
-        x_emb = self.col_embed(i)
-        y_emb = self.row_embed(j)
-        pos = (
-            torch.cat(
-                [
-                    x_emb.unsqueeze(0).repeat(h, 1, 1),
-                    y_emb.unsqueeze(1).repeat(1, w, 1),
-                ],
-                dim=-1,
-            )
-            .permute(2, 0, 1)
-            .unsqueeze(0)
-            .repeat(x.shape[0], 1, 1, 1)
-        )
-        return pos
-
-
-def build_position_encoding(args):
-    N_steps = args.hidden_dim // 2
-    if args.position_embedding in ("v2", "sine"):
-        # TODO find a better way of exposing other arguments
-        position_embedding = PositionEmbeddingSineHW(
-            N_steps,
-            temperatureH=args.pe_temperatureH,
-            temperatureW=args.pe_temperatureW,
-            normalize=True,
-        )
-    elif args.position_embedding in ("v3", "learned"):
-        position_embedding = PositionEmbeddingLearned(N_steps)
-    else:
-        raise ValueError(f"not supported {args.position_embedding}")
-
-    return position_embedding

spaces/CikeyQI/Yunzai/Yunzai/plugins/ws-plugin/components/Client.js

@@ -1,446 +0,0 @@
-import WebSocket, { WebSocketServer } from 'ws'
-import { getApiData, makeGSUidSendMsg, lifecycle, heartbeat, setMsgMap } from '../model/index.js'
-import { Version, Config } from './index.js'
-import express from "express"
-import http from "http"
-import fetch from 'node-fetch'
-
-export default class Client {
-    constructor({ name, address, type, reconnectInterval, maxReconnectAttempts, accessToken, uin = Bot.uin, closed = false }) {
-        this.name = name;
-        this.address = address;
-        this.type = type;
-        this.reconnectInterval = reconnectInterval;
-        this.maxReconnectAttempts = maxReconnectAttempts;
-        this.accessToken = accessToken;
-        this.uin = Number(uin)
-        this.ws = null
-        this.status = 0
-        this.closed = closed
-    }
-
-    reconnectCount = 1
-
-    timer = null
-
-    stopReconnect = false
-
-    createWs() {
-        try {
-            const headers = {
-                'X-Self-ID': this.uin,
-                'X-Client-Role': 'Universal',
-                'User-Agent': `ws-plugin/${Version.version}`
-            }
-            if (this.accessToken) headers["Authorization"] = 'Token ' + this.accessToken
-            this.ws = new WebSocket(this.address, { headers })
-        } catch (error) {
-            logger.error(`[ws-plugin] 出错了,可能是ws地址填错了~\nws名字: ${this.name}\n地址: ${this.address}\n类型: 1`)
-            return
-        }
-        this.ws.on('open', async () => {
-            logger.mark(`[ws-plugin] ${this.name} 已连接`);
-            if (this.status == 3 && this.reconnectCount > 1 && Config.reconnectToMaster) {
-                await this.sendMasterMsg(`${this.name} 重连成功~`)
-            } else if (this.status == 0 && Config.firstconnectToMaster) {
-                await this.sendMasterMsg(`${this.name} 连接成功~`)
-            }
-            this.ws.send(lifecycle(this.uin))
-            this.status = 1
-            this.reconnectCount = 1
-            if (Config.heartbeatInterval > 0) {
-                this.timer = setInterval(async () => {
-                    this.ws.send(heartbeat(this.uin))
-                }, Config.heartbeatInterval * 1000)
-            }
-        })
-        this.ws.on('message', async (event) => {
-            let data
-            if (Buffer.isBuffer(event)) {
-                data = JSON.parse(event.toString())
-            } else {
-                data = JSON.parse(event.data);
-            }
-            let result = await this.getData(data.action, data.params, data.echo)
-            this.ws.send(JSON.stringify(result));
-        })
-        this.ws.on('close', async code => {
-            logger.warn(`[ws-plugin] ${this.name} 连接已关闭`);
-            clearInterval(this.timer)
-            if (Config.disconnectToMaster && this.reconnectCount == 1 && this.status == 1) {
-                await this.sendMasterMsg(`${this.name} 已断开连接...`)
-            } else if (Config.firstconnectToMaster && this.reconnectCount == 1 && this.status == 0) {
-                await this.sendMasterMsg(`${this.name} 连接失败...`)
-            }
-            this.status = 3
-            if (!this.stopReconnect && ((this.reconnectCount < this.maxReconnectAttempts) || this.maxReconnectAttempts <= 0)) {
-                if (code === 1005) {
-                    logger.warn(`[ws-plugin] ${this.name} 连接异常,停止重连`);
-                    this.status = 0
-                } else {
-                    logger.warn(`[ws-plugin] ${this.name} 开始尝试重新连接第${this.reconnectCount}次`);
-                    this.reconnectCount++
-                    setTimeout(() => {
-                        this.createWs()
-                    }, this.reconnectInterval * 1000);
-                }
-            } else {
-                this.stopReconnect = false
-                this.status = 0
-                logger.warn(`[ws-plugin] ${this.name} 达到最大重连次数或关闭连接,停止重连`);
-            }
-        })
-        this.ws.on('error', (event) => {
-            logger.error(`[ws-plugin] ${this.name} 连接失败\n${event}`);
-        })
-    }
-
-    createServer() {
-        const parts = this.address.split(':');
-        this.host = parts[0];
-        this.port = parts[1];
-        this.arr = []
-        this.express = express()
-        this.server = http.createServer(this.express)
-        this.server.on("upgrade", (req, socket, head) => {
-            if (this.accessToken) {
-                const token = req.headers['authorization']?.replace('Token ', '')
-                if (!token) {
-                    socket.write('HTTP/1.1 401 Unauthorized\r\n\r\n');
-                    socket.destroy();
-                    return
-                } else if (this.accessToken != token) {
-                    socket.write('HTTP/1.1 403 Forbidden\r\n\r\n');
-                    socket.destroy();
-                    return;
-                }
-            }
-            this.wss.handleUpgrade(req, socket, head, conn => {
-                if (req.url === '/') {
-                    conn.id = req.headers["sec-websocket-key"]
-                    let time = null
-                    conn.send(lifecycle(this.uin))
-                    if (Config.heartbeatInterval > 0) {
-                        time = setInterval(async () => {
-                            conn.send(heartbeat(this.uin))
-                        }, Config.heartbeatInterval * 1000)
-                    }
-                    logger.mark(`[ws-plugin] ${this.name} 接受 WebSocket 连接: ${req.connection.remoteAddress}`);
-                    conn.on("error", (event) => {
-                        logger.error(`[ws-plugin] ${this.name} 接受 WebSocket 连接时出现错误: ${event}`)
-                    })
-                    conn.on("close", () => {
-                        if (this.stopReconnect = false) {
-                            logger.warn(`[ws-plugin] ${this.name} 关闭 WebSocket 连接`);
-                        }
-                        this.arr = this.arr.filter(i => i.id != req.headers["sec-websocket-key"])
-                        clearInterval(time)
-                    })
-                    conn.on("message", async event => {
-                        const data = JSON.parse(event)
-                        const result = await this.getData(data.action, data.params, data.echo)
-                        conn.send(JSON.stringify(result));
-                    })
-                    this.arr.push(conn)
-                } else if (req.url === '/api' || req.url === '/api/') {
-                    logger.mark(`[ws-plugin] ${this.name} 接受 WebSocket api 连接: ${req.connection.remoteAddress}`);
-                    conn.on("error", (event) => {
-                        logger.error(`[ws-plugin] ${this.name} 接受 WebSocket api 连接时出现错误: ${event}`)
-                    })
-                    conn.on("close", () => {
-                        if (this.stopReconnect = false) {
-                            logger.warn(`[ws-plugin] ${this.name} 关闭 WebSocket api 连接`);
-                        }
-                    })
-                    conn.on("message", async event => {
-                        const data = JSON.parse(event)
-                        const result = await this.getData(data.action, data.params, data.echo)
-                        conn.send(JSON.stringify(result));
-                    })
-                } else if (req.url === '/event' || req.url === '/event/') {
-                    conn.id = req.headers["sec-websocket-key"]
-                    let time = null
-                    conn.send(lifecycle(this.uin))
-                    if (Config.heartbeatInterval > 0) {
-                        time = setInterval(async () => {
-                            conn.send(heartbeat(this.uin))
-                        }, Config.heartbeatInterval * 1000)
-                    }
-                    logger.mark(`[ws-plugin] ${this.name} 接受 WebSocket event 连接: ${req.connection.remoteAddress}`);
-                    conn.on("error", (event) => {
-                        logger.error(`[ws-plugin] ${this.name} 接受 WebSocket event 连接时出现错误: ${event}`)
-                    })
-                    conn.on("close", () => {
-                        if (this.stopReconnect = false) {
-                            logger.warn(`[ws-plugin] ${this.name} 关闭 WebSocket event 连接`);
-                        }
-                        this.arr = this.arr.filter(i => i.id != req.headers["sec-websocket-key"])
-                        clearInterval(time)
-                    })
-                    this.arr.push(conn)
-                }
-            })
-
-        })
-        this.ws = {
-            send: (msg) => {
-                for (const i of this.arr) {
-                    i.send(msg)
-                }
-            },
-            close: () => {
-                this.server.close()
-                logger.warn(`[ws-plugin] CQ WebSocket 服务器已关闭: ${this.host}:${this.port}`)
-                for (const i of this.arr) {
-                    i.close()
-                }
-            }
-        }
-        this.server.on('error', error => {
-            logger.error(`[ws-plugin] ${this.name} CQ WebSocket 服务器启动失败: ${this.host}:${this.port}`)
-            logger.error(error)
-        })
-        this.wss = new WebSocketServer({ noServer: true })
-        this.server.listen(this.port, this.host, () => {
-            this.status = 1
-            logger.mark(`[ws-plugin] CQ WebSocket 服务器已启动: ${this.host}:${this.port}`)
-        })
-    }
-
-    createGSUidWs() {
-        try {
-            this.ws = new WebSocket(this.address)
-        } catch (error) {
-            logger.error(`[ws-plugin] 出错了,可能是ws地址填错了~\nws名字: ${this.name}\n地址: ${this.address}\n类型: 3`)
-            return
-        }
-        this.ws.on('open', async () => {
-            logger.mark(`[ws-plugin] ${this.name} 已连接`);
-            if (this.status == 3 && this.reconnectCount > 1 && Config.reconnectToMaster) {
-                await this.sendMasterMsg(`${this.name} 重连成功~`)
-            } else if (this.status == 0 && Config.firstconnectToMaster) {
-                await this.sendMasterMsg(`${this.name} 连接成功~`)
-            }
-            this.status = 1
-            this.reconnectCount = 1
-        })
-
-        this.ws.on('message', async event => {
-            const data = JSON.parse(event.toString());
-            const { sendMsg, quote } = await makeGSUidSendMsg(data)
-            if (sendMsg.length > 0) {
-                let sendRet, group_id, user_id
-                // const bot = Version.isTrss ? Bot[data.bot_self_id] : Bot
-                const bot = Bot[data.bot_self_id] || Bot
-                switch (data.target_type) {
-                    case 'group':
-                    case 'channel':
-                        group_id = data.target_id
-                        sendRet = await bot.pickGroup(group_id).sendMsg(sendMsg, quote)
-                        break;
-                    case 'direct':
-                        user_id = data.target_id
-                        sendRet = await bot.pickFriend(user_id).sendMsg(sendMsg, quote)
-                        break;
-                    default:
-                        break;
-                }
-                if (sendRet.rand) {
-                    setMsgMap({
-                        message_id: sendRet.message_id,
-                        time: sendRet.time,
-                        seq: sendRet.seq,
-                        rand: sendRet.rand,
-                        user_id: user_id,
-                        group_id: group_id,
-                        onebot_id: Math.floor(Math.random() * Math.pow(2, 32)) | 0,
-                    })
-                }
-                logger.mark(`[ws-plugin] 连接名字:${this.name} 处理完成`)
-            }
-        })
-
-        this.ws.on('close', async code => {
-            logger.warn(`[ws-plugin] ${this.name} 连接已关闭`);
-            if (Config.disconnectToMaster && this.reconnectCount == 1 && this.status == 1) {
-                await this.sendMasterMsg(`${this.name} 已断开连接...`)
-            } else if (Config.firstconnectToMaster && this.reconnectCount == 1 && this.status == 0) {
-                await this.sendMasterMsg(`${this.name} 连接失败...`)
-            }
-            this.status = 3
-            if (!this.stopReconnect && ((this.reconnectCount < this.maxReconnectAttempts) || this.maxReconnectAttempts <= 0)) {
-                if (code === 1005) {
-                    logger.warn(`[ws-plugin] ${this.name} 连接异常,停止重连`);
-                    this.status = 0
-                } else {
-                    logger.warn(`[ws-plugin] ${this.name} 开始尝试重新连接第 ${this.reconnectCount} 次`);
-                    this.reconnectCount++
-                    setTimeout(() => {
-                        this.createGSUidWs()
-                    }, this.reconnectInterval * 1000);
-                }
-            } else {
-                this.stopReconnect = false
-                this.status = 0
-                logger.warn(`[ws-plugin] ${this.name} 达到最大重连次数或关闭连接,停止重连`);
-            }
-        })
-
-        this.ws.on('error', (event) => {
-            logger.error(`[ws-plugin] ${this.name} 连接失败\n${event}`);
-        })
-    }
-
-    createHttp() {
-        const parts = this.address.split(':');
-        this.host = parts[0];
-        this.port = parts[1];
-        this.express = express();
-        this.server = http.createServer(this.express);
-        this.express.use(express.json({ limit: '50mb' }));
-        this.express.use(express.urlencoded({ extended: true, limit: '50mb' }));
-        this.express.use((req, res, next) => this.authorization(req, res, next))
-
-        this.express.get('/:action', async (req, res) => {
-            const { action } = req.params;
-            const { query: params } = req;
-            const data = await this.getData(action, params)
-            res.status(200).json(data || {})
-        });
-
-        this.express.post('/:action', async (req, res) => {
-            const { action } = req.params;
-            const { body: params } = req;
-            const data = await this.getData(action, params)
-            res.status(200).json(data || {})
-        });
-
-        this.express.post('/', async (req, res) => {
-            const { action, params } = req.body;
-            const data = await this.getData(action, params)
-            res.status(200).json(data || {})
-        });
-
-        this.server.on('error', error => {
-            logger.error(`[ws-plugin] ${this.name} 正向HTTP 服务器启动失败: ${this.host}:${this.port}`)
-            logger.error(error)
-        })
-        this.server.listen(this.port, this.host, () => {
-            this.status = 1
-            logger.mark(`[ws-plugin] HTTP 服务器已启动: ${this.host}:${this.port}`)
-        })
-        this.ws = {
-            close: () => {
-                this.server.close()
-                logger.warn(`[ws-plugin] 正向HTTP 服务器已关闭: ${this.host}:${this.port}`)
-            }
-        }
-    }
-
-    createHttpPost() {
-        if (!this.address.startsWith('http')) {
-            this.address = 'http://' + this.address
-        }
-        this.status = 1
-        // 心跳咕一下
-        this.ws = {
-            send: body => {
-                fetch(this.address, {
-                    method: 'POST',
-                    headers: {
-                        'content-type': 'application/json',
-                        'x-self-id': this.uin,
-                        'user-agent': `ws-plugin/${Version.version}`
-                    },
-                    body
-                })
-            }
-        }
-    }
-
-    close() {
-        this.stopReconnect = true
-        if (this.status == 1) {
-            this.ws?.close?.()
-            this.status = 0
-        }
-    }
-
-    authorization(req, res, next) {
-        let code = null
-        const token = req.headers['authorization']?.replace?.(/^(Token|Bearer) /, '') || req.query.access_token
-        if (this.accessToken) {
-            if (!token) {
-                code = 401
-            } else if (this.accessToken != token) {
-                code = 403
-            }
-        }
-        if (code) {
-            res.status(code).end()
-            return
-        }
-        next()
-    }
-
-    async getData(action, params, echo) {
-        let result
-        try {
-            const data = await getApiData(action, params, this.name, this.uin);
-            result = {
-                status: 'ok',
-                retcode: 0,
-                data,
-                echo
-            }
-        } catch (error) {
-            if (!error.noLog) logger.error('ws-plugin出现错误', error)
-            result = {
-                status: 'failed',
-                retcode: -1,
-                msg: error.message,
-                wording: 'ws-plugin获取信息失败',
-                echo
-            }
-        } finally {
-            return result
-        }
-    }
-
-    async sendMasterMsg(msg) {
-        // const bot = Version.isTrss ? Bot[this.uin] : Bot
-        const bot = Bot[this.uin] || Bot
-        let masterQQ = []
-        const master = Version.isTrss ? Config.master[this.uin] : Config.masterQQ
-        if (Config.howToMaster > 0) {
-            masterQQ.push(master?.[Config.howToMaster - 1])
-        } else if (Config.howToMaster == 0) {
-            masterQQ.push(...master)
-        }
-        for (const i of masterQQ) {
-            if (!i) continue
-            let result
-            try {
-                result = await bot?.pickFriend?.(i)?.sendMsg?.(msg) || true
-            } catch (error) {
-                result = true
-            }
-            if (result) {
-                logger.mark(`[ws-plugin] 连接名字:${this.name} 通知主人:${i} 处理完成`)
-            } else {
-                const timer = setInterval(async () => {
-                    try {
-                        result = await bot?.pickFriend?.(i)?.sendMsg?.(msg) || true
-                    } catch (error) {
-                        result = true
-                    }
-                    if (result) {
-                        clearInterval(timer)
-                        logger.mark(`[ws-plugin] 连接名字:${this.name} 通知主人:${i} 处理完成`)
-                    }
-                }, 5000)
-            }
-        }
-    }
-
-}

spaces/CrucibleAI/ControlNetMediaPipeFaceSD21/ldm/modules/encoders/modules.py

@@ -1,226 +0,0 @@
-import torch
-import torch.nn as nn
-from torch.utils.checkpoint import checkpoint
-
-from transformers import T5Tokenizer, T5EncoderModel, CLIPTokenizer, CLIPTextModel
-
-import open_clip
-from ldm.util import default, count_params
-
-
-default_device = torch.device("cpu" if not torch.cuda.is_available() else "cuda")
-
-
-class AbstractEncoder(nn.Module):
-    def __init__(self):
-        super().__init__()
-
-    def encode(self, *args, **kwargs):
-        raise NotImplementedError
-
-
-class IdentityEncoder(AbstractEncoder):
-
-    def encode(self, x):
-        return x
-
-
-class ClassEmbedder(nn.Module):
-    def __init__(self, embed_dim, n_classes=1000, key='class', ucg_rate=0.1):
-        super().__init__()
-        self.key = key
-        self.embedding = nn.Embedding(n_classes, embed_dim)
-        self.n_classes = n_classes
-        self.ucg_rate = ucg_rate
-
-    def forward(self, batch, key=None, disable_dropout=False):
-        if key is None:
-            key = self.key
-        # this is for use in crossattn
-        c = batch[key][:, None]
-        if self.ucg_rate > 0. and not disable_dropout:
-            mask = 1. - torch.bernoulli(torch.ones_like(c) * self.ucg_rate)
-            c = mask * c + (1-mask) * torch.ones_like(c)*(self.n_classes-1)
-            c = c.long()
-        c = self.embedding(c)
-        return c
-
-    def get_unconditional_conditioning(self, bs, device=None):
-        if device is None:
-            device = default_device
-        uc_class = self.n_classes - 1  # 1000 classes --> 0 ... 999, one extra class for ucg (class 1000)
-        uc = torch.ones((bs,), device=device) * uc_class
-        uc = {self.key: uc}
-        return uc
-
-
-def disabled_train(self, mode=True):
-    """Overwrite model.train with this function to make sure train/eval mode
-    does not change anymore."""
-    return self
-
-
-class FrozenT5Embedder(AbstractEncoder):
-    """Uses the T5 transformer encoder for text"""
-    def __init__(self, version="google/t5-v1_1-large", device=None, max_length=77, freeze=True):  # others are google/t5-v1_1-xl and google/t5-v1_1-xxl
-        super().__init__()
-        if device is None:
-            device = default_device
-        self.tokenizer = T5Tokenizer.from_pretrained(version)
-        self.transformer = T5EncoderModel.from_pretrained(version)
-        self.device = device
-        self.max_length = max_length   # TODO: typical value?
-        if freeze:
-            self.freeze()
-
-    def freeze(self):
-        self.transformer = self.transformer.eval()
-        #self.train = disabled_train
-        for param in self.parameters():
-            param.requires_grad = False
-
-    def forward(self, text):
-        batch_encoding = self.tokenizer(text, truncation=True, max_length=self.max_length, return_length=True,
-                                        return_overflowing_tokens=False, padding="max_length", return_tensors="pt")
-        tokens = batch_encoding["input_ids"].to(self.device)
-        outputs = self.transformer(input_ids=tokens)
-
-        z = outputs.last_hidden_state
-        return z
-
-    def encode(self, text):
-        return self(text)
-
-
-class FrozenCLIPEmbedder(AbstractEncoder):
-    """Uses the CLIP transformer encoder for text (from huggingface)"""
-    LAYERS = [
-        "last",
-        "pooled",
-        "hidden"
-    ]
-    def __init__(self, version="openai/clip-vit-large-patch14", device=None, max_length=77,
-                 freeze=True, layer="last", layer_idx=None):  # clip-vit-base-patch32
-        super().__init__()
-        if device is None:
-            device = default_device
-        assert layer in self.LAYERS
-        self.tokenizer = CLIPTokenizer.from_pretrained(version)
-        self.transformer = CLIPTextModel.from_pretrained(version)
-        self.device = device
-        self.max_length = max_length
-        if freeze:
-            self.freeze()
-        self.layer = layer
-        self.layer_idx = layer_idx
-        if layer == "hidden":
-            assert layer_idx is not None
-            assert 0 <= abs(layer_idx) <= 12
-
-    def freeze(self):
-        self.transformer = self.transformer.eval()
-        #self.train = disabled_train
-        for param in self.parameters():
-            param.requires_grad = False
-
-    def forward(self, text):
-        batch_encoding = self.tokenizer(text, truncation=True, max_length=self.max_length, return_length=True,
-                                        return_overflowing_tokens=False, padding="max_length", return_tensors="pt")
-        tokens = batch_encoding["input_ids"].to(self.device)
-        outputs = self.transformer(input_ids=tokens, output_hidden_states=self.layer=="hidden")
-        if self.layer == "last":
-            z = outputs.last_hidden_state
-        elif self.layer == "pooled":
-            z = outputs.pooler_output[:, None, :]
-        else:
-            z = outputs.hidden_states[self.layer_idx]
-        return z
-
-    def encode(self, text):
-        return self(text)
-
-
-class FrozenOpenCLIPEmbedder(AbstractEncoder):
-    """
-    Uses the OpenCLIP transformer encoder for text
-    """
-    LAYERS = [
-        #"pooled",
-        "last",
-        "penultimate"
-    ]
-    def __init__(self, arch="ViT-H-14", version="laion2b_s32b_b79k", device=None, max_length=77,
-                 freeze=True, layer="last"):
-        super().__init__()
-        if device is None:
-            device = default_device
-        assert layer in self.LAYERS
-        model, _, _ = open_clip.create_model_and_transforms(arch, device=torch.device('cpu'), pretrained=version)
-        del model.visual
-        self.model = model
-
-        self.device = device
-        self.max_length = max_length
-        if freeze:
-            self.freeze()
-        self.layer = layer
-        if self.layer == "last":
-            self.layer_idx = 0
-        elif self.layer == "penultimate":
-            self.layer_idx = 1
-        else:
-            raise NotImplementedError()
-
-    def freeze(self):
-        self.model = self.model.eval()
-        for param in self.parameters():
-            param.requires_grad = False
-
-    def forward(self, text):
-        tokens = open_clip.tokenize(text)
-        z = self.encode_with_transformer(tokens.to(self.device))
-        return z
-
-    def encode_with_transformer(self, text):
-        x = self.model.token_embedding(text)  # [batch_size, n_ctx, d_model]
-        x = x + self.model.positional_embedding
-        x = x.permute(1, 0, 2)  # NLD -> LND
-        x = self.text_transformer_forward(x, attn_mask=self.model.attn_mask)
-        x = x.permute(1, 0, 2)  # LND -> NLD
-        x = self.model.ln_final(x)
-        return x
-
-    def text_transformer_forward(self, x: torch.Tensor, attn_mask = None):
-        for i, r in enumerate(self.model.transformer.resblocks):
-            if i == len(self.model.transformer.resblocks) - self.layer_idx:
-                break
-            if self.model.transformer.grad_checkpointing and not torch.jit.is_scripting():
-                x = checkpoint(r, x, attn_mask)
-            else:
-                x = r(x, attn_mask=attn_mask)
-        return x
-
-    def encode(self, text):
-        return self(text)
-
-
-class FrozenCLIPT5Encoder(AbstractEncoder):
-    def __init__(self, clip_version="openai/clip-vit-large-patch14", t5_version="google/t5-v1_1-xl", device=None,
-                 clip_max_length=77, t5_max_length=77):
-        super().__init__()
-        if device is None:
-            device = default_device
-        self.clip_encoder = FrozenCLIPEmbedder(clip_version, device, max_length=clip_max_length)
-        self.t5_encoder = FrozenT5Embedder(t5_version, device, max_length=t5_max_length)
-        print(f"{self.clip_encoder.__class__.__name__} has {count_params(self.clip_encoder)*1.e-6:.2f} M parameters, "
-              f"{self.t5_encoder.__class__.__name__} comes with {count_params(self.t5_encoder)*1.e-6:.2f} M params.")
-
-    def encode(self, text):
-        return self(text)
-
-    def forward(self, text):
-        clip_z = self.clip_encoder.encode(text)
-        t5_z = self.t5_encoder.encode(text)
-        return [clip_z, t5_z]
-
-

spaces/Curranj/GPT-QRI/app.py

@@ -1,78 +0,0 @@
-import sklearn
-import sqlite3
-import numpy as np
-from sklearn.metrics.pairwise import cosine_similarity
-import openai
-import os
-import gradio as gr
-
-
-openai.api_key = os.environ["Secret"] 
-
-def find_closest_neighbors(vector1, dictionary_of_vectors):
-    """
-    Takes a vector and a dictionary of vectors and returns the three closest neighbors
-    """
-    vector = openai.Embedding.create(
-        input=vector1,
-        engine="text-embedding-ada-002"
-    )['data'][0]['embedding']
-
-    vector = np.array(vector)
-
-    cosine_similarities = {}
-    for key, value in dictionary_of_vectors.items():
-        cosine_similarities[key] = cosine_similarity(vector.reshape(1, -1), value.reshape(1, -1))[0][0]
-
-    sorted_cosine_similarities = sorted(cosine_similarities.items(), key=lambda x: x[1], reverse=True)
-    match_list = sorted_cosine_similarities[0:4]
-
-    return match_list
-
-def predict(message, history):
-    # Connect to the database
-    conn = sqlite3.connect('QRIdatabase7.db')
-    cursor = conn.cursor()
-    cursor.execute('''SELECT text, embedding FROM chunks''')
-    rows = cursor.fetchall()
-
-    dictionary_of_vectors = {}
-    for row in rows:
-        text = row[0]
-        embedding_str = row[1]
-        embedding = np.fromstring(embedding_str, sep=' ')
-        dictionary_of_vectors[text] = embedding
-    conn.close()
-
-    # Find the closest neighbors
-    match_list = find_closest_neighbors(message, dictionary_of_vectors)
-    context = ''
-    for match in match_list:
-        context += str(match[0])
-    context = context[:-1500]
-
-    prep = f"This is an OpenAI model tuned to answer questions specific to the Qualia Research institute, a research institute that focuses on consciousness. Here is some question-specific context, and then the Question to answer, related to consciousness, the human experience, and phenomenology: {context}. Here is a question specific to QRI and consciousness in general Q:  {message}  A: "
-
-    history_openai_format = []
-    for human, assistant in history:
-        history_openai_format.append({"role": "user", "content": human })
-        history_openai_format.append({"role": "assistant", "content":assistant})
-    history_openai_format.append({"role": "user", "content": prep})
-
-    response = openai.ChatCompletion.create(
-        model='gpt-3.5-turbo',
-        messages= history_openai_format,         
-        temperature=1.0,
-        stream=True
-    )
-    
-    partial_message = ""
-    for chunk in response:
-        if len(chunk['choices'][0]['delta']) != 0:
-            partial_message = partial_message + chunk['choices'][0]['delta']['content']
-            yield partial_message 
-
-demo = gr.ChatInterface(predict).queue()
-
-if __name__ == "__main__":
-    demo.launch()

spaces/DAMO-NLP-SG/Video-LLaMA/video_llama/datasets/builders/__init__.py

@@ -1,77 +0,0 @@
-"""
- Copyright (c) 2022, salesforce.com, inc.
- All rights reserved.
- SPDX-License-Identifier: BSD-3-Clause
- For full license text, see the LICENSE_Lavis file in the repo root or https://opensource.org/licenses/BSD-3-Clause
-"""
-
-from video_llama.datasets.builders.base_dataset_builder import load_dataset_config
-from video_llama.datasets.builders.image_text_pair_builder import (
-    CCSBUBuilder,
-    LaionBuilder,
-    CCSBUAlignBuilder
-)
-from video_llama.datasets.builders.video_caption_builder import WebvidBuilder
-from video_llama.common.registry import registry
-from video_llama.datasets.builders.instruct_builder import WebvidInstruct_Builder,LlavaInstruct_Builder
-__all__ = [
-    "CCSBUBuilder",
-    "LaionBuilder",
-    "CCSBUAlignBuilder",
-    "WebvidBuilder",
-    "LlavaInstruct_Builder",
-    "WebvidInstruct_Builder"
-    
-]
-
-
-def load_dataset(name, cfg_path=None, vis_path=None, data_type=None):
-    """
-    Example
-
-    >>> dataset = load_dataset("coco_caption", cfg=None)
-    >>> splits = dataset.keys()
-    >>> print([len(dataset[split]) for split in splits])
-
-    """
-    if cfg_path is None:
-        cfg = None
-    else:
-        cfg = load_dataset_config(cfg_path)
-
-    try:
-        builder = registry.get_builder_class(name)(cfg)
-    except TypeError:
-        print(
-            f"Dataset {name} not found. Available datasets:\n"
-            + ", ".join([str(k) for k in dataset_zoo.get_names()])
-        )
-        exit(1)
-
-    if vis_path is not None:
-        if data_type is None:
-            # use default data type in the config
-            data_type = builder.config.data_type
-
-        assert (
-            data_type in builder.config.build_info
-        ), f"Invalid data_type {data_type} for {name}."
-
-        builder.config.build_info.get(data_type).storage = vis_path
-
-    dataset = builder.build_datasets()
-    return dataset
-
-
-class DatasetZoo:
-    def __init__(self) -> None:
-        self.dataset_zoo = {
-            k: list(v.DATASET_CONFIG_DICT.keys())
-            for k, v in sorted(registry.mapping["builder_name_mapping"].items())
-        }
-
-    def get_names(self):
-        return list(self.dataset_zoo.keys())
-
-
-dataset_zoo = DatasetZoo()

spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/PIL/ImageDraw.py

@@ -1,1038 +0,0 @@
-#
-# The Python Imaging Library
-# $Id$
-#
-# drawing interface operations
-#
-# History:
-# 1996-04-13 fl   Created (experimental)
-# 1996-08-07 fl   Filled polygons, ellipses.
-# 1996-08-13 fl   Added text support
-# 1998-06-28 fl   Handle I and F images
-# 1998-12-29 fl   Added arc; use arc primitive to draw ellipses
-# 1999-01-10 fl   Added shape stuff (experimental)
-# 1999-02-06 fl   Added bitmap support
-# 1999-02-11 fl   Changed all primitives to take options
-# 1999-02-20 fl   Fixed backwards compatibility
-# 2000-10-12 fl   Copy on write, when necessary
-# 2001-02-18 fl   Use default ink for bitmap/text also in fill mode
-# 2002-10-24 fl   Added support for CSS-style color strings
-# 2002-12-10 fl   Added experimental support for RGBA-on-RGB drawing
-# 2002-12-11 fl   Refactored low-level drawing API (work in progress)
-# 2004-08-26 fl   Made Draw() a factory function, added getdraw() support
-# 2004-09-04 fl   Added width support to line primitive
-# 2004-09-10 fl   Added font mode handling
-# 2006-06-19 fl   Added font bearing support (getmask2)
-#
-# Copyright (c) 1997-2006 by Secret Labs AB
-# Copyright (c) 1996-2006 by Fredrik Lundh
-#
-# See the README file for information on usage and redistribution.
-#
-
-import math
-import numbers
-
-from . import Image, ImageColor
-
-"""
-A simple 2D drawing interface for PIL images.
-<p>
-Application code should use the <b>Draw</b> factory, instead of
-directly.
-"""
-
-
-class ImageDraw:
-    font = None
-
-    def __init__(self, im, mode=None):
-        """
-        Create a drawing instance.
-
-        :param im: The image to draw in.
-        :param mode: Optional mode to use for color values.  For RGB
-           images, this argument can be RGB or RGBA (to blend the
-           drawing into the image).  For all other modes, this argument
-           must be the same as the image mode.  If omitted, the mode
-           defaults to the mode of the image.
-        """
-        im.load()
-        if im.readonly:
-            im._copy()  # make it writeable
-        blend = 0
-        if mode is None:
-            mode = im.mode
-        if mode != im.mode:
-            if mode == "RGBA" and im.mode == "RGB":
-                blend = 1
-            else:
-                msg = "mode mismatch"
-                raise ValueError(msg)
-        if mode == "P":
-            self.palette = im.palette
-        else:
-            self.palette = None
-        self._image = im
-        self.im = im.im
-        self.draw = Image.core.draw(self.im, blend)
-        self.mode = mode
-        if mode in ("I", "F"):
-            self.ink = self.draw.draw_ink(1)
-        else:
-            self.ink = self.draw.draw_ink(-1)
-        if mode in ("1", "P", "I", "F"):
-            # FIXME: fix Fill2 to properly support matte for I+F images
-            self.fontmode = "1"
-        else:
-            self.fontmode = "L"  # aliasing is okay for other modes
-        self.fill = False
-
-    def getfont(self):
-        """
-        Get the current default font.
-
-        To set the default font for this ImageDraw instance::
-
-            from PIL import ImageDraw, ImageFont
-            draw.font = ImageFont.truetype("Tests/fonts/FreeMono.ttf")
-
-        To set the default font for all future ImageDraw instances::
-
-            from PIL import ImageDraw, ImageFont
-            ImageDraw.ImageDraw.font = ImageFont.truetype("Tests/fonts/FreeMono.ttf")
-
-        If the current default font is ``None``,
-        it is initialized with ``ImageFont.load_default()``.
-
-        :returns: An image font."""
-        if not self.font:
-            # FIXME: should add a font repository
-            from . import ImageFont
-
-            self.font = ImageFont.load_default()
-        return self.font
-
-    def _getink(self, ink, fill=None):
-        if ink is None and fill is None:
-            if self.fill:
-                fill = self.ink
-            else:
-                ink = self.ink
-        else:
-            if ink is not None:
-                if isinstance(ink, str):
-                    ink = ImageColor.getcolor(ink, self.mode)
-                if self.palette and not isinstance(ink, numbers.Number):
-                    ink = self.palette.getcolor(ink, self._image)
-                ink = self.draw.draw_ink(ink)
-            if fill is not None:
-                if isinstance(fill, str):
-                    fill = ImageColor.getcolor(fill, self.mode)
-                if self.palette and not isinstance(fill, numbers.Number):
-                    fill = self.palette.getcolor(fill, self._image)
-                fill = self.draw.draw_ink(fill)
-        return ink, fill
-
-    def arc(self, xy, start, end, fill=None, width=1):
-        """Draw an arc."""
-        ink, fill = self._getink(fill)
-        if ink is not None:
-            self.draw.draw_arc(xy, start, end, ink, width)
-
-    def bitmap(self, xy, bitmap, fill=None):
-        """Draw a bitmap."""
-        bitmap.load()
-        ink, fill = self._getink(fill)
-        if ink is None:
-            ink = fill
-        if ink is not None:
-            self.draw.draw_bitmap(xy, bitmap.im, ink)
-
-    def chord(self, xy, start, end, fill=None, outline=None, width=1):
-        """Draw a chord."""
-        ink, fill = self._getink(outline, fill)
-        if fill is not None:
-            self.draw.draw_chord(xy, start, end, fill, 1)
-        if ink is not None and ink != fill and width != 0:
-            self.draw.draw_chord(xy, start, end, ink, 0, width)
-
-    def ellipse(self, xy, fill=None, outline=None, width=1):
-        """Draw an ellipse."""
-        ink, fill = self._getink(outline, fill)
-        if fill is not None:
-            self.draw.draw_ellipse(xy, fill, 1)
-        if ink is not None and ink != fill and width != 0:
-            self.draw.draw_ellipse(xy, ink, 0, width)
-
-    def line(self, xy, fill=None, width=0, joint=None):
-        """Draw a line, or a connected sequence of line segments."""
-        ink = self._getink(fill)[0]
-        if ink is not None:
-            self.draw.draw_lines(xy, ink, width)
-            if joint == "curve" and width > 4:
-                if not isinstance(xy[0], (list, tuple)):
-                    xy = [tuple(xy[i : i + 2]) for i in range(0, len(xy), 2)]
-                for i in range(1, len(xy) - 1):
-                    point = xy[i]
-                    angles = [
-                        math.degrees(math.atan2(end[0] - start[0], start[1] - end[1]))
-                        % 360
-                        for start, end in ((xy[i - 1], point), (point, xy[i + 1]))
-                    ]
-                    if angles[0] == angles[1]:
-                        # This is a straight line, so no joint is required
-                        continue
-
-                    def coord_at_angle(coord, angle):
-                        x, y = coord
-                        angle -= 90
-                        distance = width / 2 - 1
-                        return tuple(
-                            p + (math.floor(p_d) if p_d > 0 else math.ceil(p_d))
-                            for p, p_d in (
-                                (x, distance * math.cos(math.radians(angle))),
-                                (y, distance * math.sin(math.radians(angle))),
-                            )
-                        )
-
-                    flipped = (
-                        angles[1] > angles[0] and angles[1] - 180 > angles[0]
-                    ) or (angles[1] < angles[0] and angles[1] + 180 > angles[0])
-                    coords = [
-                        (point[0] - width / 2 + 1, point[1] - width / 2 + 1),
-                        (point[0] + width / 2 - 1, point[1] + width / 2 - 1),
-                    ]
-                    if flipped:
-                        start, end = (angles[1] + 90, angles[0] + 90)
-                    else:
-                        start, end = (angles[0] - 90, angles[1] - 90)
-                    self.pieslice(coords, start - 90, end - 90, fill)
-
-                    if width > 8:
-                        # Cover potential gaps between the line and the joint
-                        if flipped:
-                            gap_coords = [
-                                coord_at_angle(point, angles[0] + 90),
-                                point,
-                                coord_at_angle(point, angles[1] + 90),
-                            ]
-                        else:
-                            gap_coords = [
-                                coord_at_angle(point, angles[0] - 90),
-                                point,
-                                coord_at_angle(point, angles[1] - 90),
-                            ]
-                        self.line(gap_coords, fill, width=3)
-
-    def shape(self, shape, fill=None, outline=None):
-        """(Experimental) Draw a shape."""
-        shape.close()
-        ink, fill = self._getink(outline, fill)
-        if fill is not None:
-            self.draw.draw_outline(shape, fill, 1)
-        if ink is not None and ink != fill:
-            self.draw.draw_outline(shape, ink, 0)
-
-    def pieslice(self, xy, start, end, fill=None, outline=None, width=1):
-        """Draw a pieslice."""
-        ink, fill = self._getink(outline, fill)
-        if fill is not None:
-            self.draw.draw_pieslice(xy, start, end, fill, 1)
-        if ink is not None and ink != fill and width != 0:
-            self.draw.draw_pieslice(xy, start, end, ink, 0, width)
-
-    def point(self, xy, fill=None):
-        """Draw one or more individual pixels."""
-        ink, fill = self._getink(fill)
-        if ink is not None:
-            self.draw.draw_points(xy, ink)
-
-    def polygon(self, xy, fill=None, outline=None, width=1):
-        """Draw a polygon."""
-        ink, fill = self._getink(outline, fill)
-        if fill is not None:
-            self.draw.draw_polygon(xy, fill, 1)
-        if ink is not None and ink != fill and width != 0:
-            if width == 1:
-                self.draw.draw_polygon(xy, ink, 0, width)
-            else:
-                # To avoid expanding the polygon outwards,
-                # use the fill as a mask
-                mask = Image.new("1", self.im.size)
-                mask_ink = self._getink(1)[0]
-
-                fill_im = mask.copy()
-                draw = Draw(fill_im)
-                draw.draw.draw_polygon(xy, mask_ink, 1)
-
-                ink_im = mask.copy()
-                draw = Draw(ink_im)
-                width = width * 2 - 1
-                draw.draw.draw_polygon(xy, mask_ink, 0, width)
-
-                mask.paste(ink_im, mask=fill_im)
-
-                im = Image.new(self.mode, self.im.size)
-                draw = Draw(im)
-                draw.draw.draw_polygon(xy, ink, 0, width)
-                self.im.paste(im.im, (0, 0) + im.size, mask.im)
-
-    def regular_polygon(
-        self, bounding_circle, n_sides, rotation=0, fill=None, outline=None, width=1
-    ):
-        """Draw a regular polygon."""
-        xy = _compute_regular_polygon_vertices(bounding_circle, n_sides, rotation)
-        self.polygon(xy, fill, outline, width)
-
-    def rectangle(self, xy, fill=None, outline=None, width=1):
-        """Draw a rectangle."""
-        ink, fill = self._getink(outline, fill)
-        if fill is not None:
-            self.draw.draw_rectangle(xy, fill, 1)
-        if ink is not None and ink != fill and width != 0:
-            self.draw.draw_rectangle(xy, ink, 0, width)
-
-    def rounded_rectangle(
-        self, xy, radius=0, fill=None, outline=None, width=1, *, corners=None
-    ):
-        """Draw a rounded rectangle."""
-        if isinstance(xy[0], (list, tuple)):
-            (x0, y0), (x1, y1) = xy
-        else:
-            x0, y0, x1, y1 = xy
-        if x1 < x0:
-            msg = "x1 must be greater than or equal to x0"
-            raise ValueError(msg)
-        if y1 < y0:
-            msg = "y1 must be greater than or equal to y0"
-            raise ValueError(msg)
-        if corners is None:
-            corners = (True, True, True, True)
-
-        d = radius * 2
-
-        full_x, full_y = False, False
-        if all(corners):
-            full_x = d >= x1 - x0 - 1
-            if full_x:
-                # The two left and two right corners are joined
-                d = x1 - x0
-            full_y = d >= y1 - y0 - 1
-            if full_y:
-                # The two top and two bottom corners are joined
-                d = y1 - y0
-            if full_x and full_y:
-                # If all corners are joined, that is a circle
-                return self.ellipse(xy, fill, outline, width)
-
-        if d == 0 or not any(corners):
-            # If the corners have no curve,
-            # or there are no corners,
-            # that is a rectangle
-            return self.rectangle(xy, fill, outline, width)
-
-        r = d // 2
-        ink, fill = self._getink(outline, fill)
-
-        def draw_corners(pieslice):
-            if full_x:
-                # Draw top and bottom halves
-                parts = (
-                    ((x0, y0, x0 + d, y0 + d), 180, 360),
-                    ((x0, y1 - d, x0 + d, y1), 0, 180),
-                )
-            elif full_y:
-                # Draw left and right halves
-                parts = (
-                    ((x0, y0, x0 + d, y0 + d), 90, 270),
-                    ((x1 - d, y0, x1, y0 + d), 270, 90),
-                )
-            else:
-                # Draw four separate corners
-                parts = []
-                for i, part in enumerate(
-                    (
-                        ((x0, y0, x0 + d, y0 + d), 180, 270),
-                        ((x1 - d, y0, x1, y0 + d), 270, 360),
-                        ((x1 - d, y1 - d, x1, y1), 0, 90),
-                        ((x0, y1 - d, x0 + d, y1), 90, 180),
-                    )
-                ):
-                    if corners[i]:
-                        parts.append(part)
-            for part in parts:
-                if pieslice:
-                    self.draw.draw_pieslice(*(part + (fill, 1)))
-                else:
-                    self.draw.draw_arc(*(part + (ink, width)))
-
-        if fill is not None:
-            draw_corners(True)
-
-            if full_x:
-                self.draw.draw_rectangle((x0, y0 + r + 1, x1, y1 - r - 1), fill, 1)
-            else:
-                self.draw.draw_rectangle((x0 + r + 1, y0, x1 - r - 1, y1), fill, 1)
-            if not full_x and not full_y:
-                left = [x0, y0, x0 + r, y1]
-                if corners[0]:
-                    left[1] += r + 1
-                if corners[3]:
-                    left[3] -= r + 1
-                self.draw.draw_rectangle(left, fill, 1)
-
-                right = [x1 - r, y0, x1, y1]
-                if corners[1]:
-                    right[1] += r + 1
-                if corners[2]:
-                    right[3] -= r + 1
-                self.draw.draw_rectangle(right, fill, 1)
-        if ink is not None and ink != fill and width != 0:
-            draw_corners(False)
-
-            if not full_x:
-                top = [x0, y0, x1, y0 + width - 1]
-                if corners[0]:
-                    top[0] += r + 1
-                if corners[1]:
-                    top[2] -= r + 1
-                self.draw.draw_rectangle(top, ink, 1)
-
-                bottom = [x0, y1 - width + 1, x1, y1]
-                if corners[3]:
-                    bottom[0] += r + 1
-                if corners[2]:
-                    bottom[2] -= r + 1
-                self.draw.draw_rectangle(bottom, ink, 1)
-            if not full_y:
-                left = [x0, y0, x0 + width - 1, y1]
-                if corners[0]:
-                    left[1] += r + 1
-                if corners[3]:
-                    left[3] -= r + 1
-                self.draw.draw_rectangle(left, ink, 1)
-
-                right = [x1 - width + 1, y0, x1, y1]
-                if corners[1]:
-                    right[1] += r + 1
-                if corners[2]:
-                    right[3] -= r + 1
-                self.draw.draw_rectangle(right, ink, 1)
-
-    def _multiline_check(self, text):
-        split_character = "\n" if isinstance(text, str) else b"\n"
-
-        return split_character in text
-
-    def _multiline_split(self, text):
-        split_character = "\n" if isinstance(text, str) else b"\n"
-
-        return text.split(split_character)
-
-    def _multiline_spacing(self, font, spacing, stroke_width):
-        return (
-            self.textbbox((0, 0), "A", font, stroke_width=stroke_width)[3]
-            + stroke_width
-            + spacing
-        )
-
-    def text(
-        self,
-        xy,
-        text,
-        fill=None,
-        font=None,
-        anchor=None,
-        spacing=4,
-        align="left",
-        direction=None,
-        features=None,
-        language=None,
-        stroke_width=0,
-        stroke_fill=None,
-        embedded_color=False,
-        *args,
-        **kwargs,
-    ):
-        """Draw text."""
-        if self._multiline_check(text):
-            return self.multiline_text(
-                xy,
-                text,
-                fill,
-                font,
-                anchor,
-                spacing,
-                align,
-                direction,
-                features,
-                language,
-                stroke_width,
-                stroke_fill,
-                embedded_color,
-            )
-
-        if embedded_color and self.mode not in ("RGB", "RGBA"):
-            msg = "Embedded color supported only in RGB and RGBA modes"
-            raise ValueError(msg)
-
-        if font is None:
-            font = self.getfont()
-
-        def getink(fill):
-            ink, fill = self._getink(fill)
-            if ink is None:
-                return fill
-            return ink
-
-        def draw_text(ink, stroke_width=0, stroke_offset=None):
-            mode = self.fontmode
-            if stroke_width == 0 and embedded_color:
-                mode = "RGBA"
-            coord = []
-            start = []
-            for i in range(2):
-                coord.append(int(xy[i]))
-                start.append(math.modf(xy[i])[0])
-            try:
-                mask, offset = font.getmask2(
-                    text,
-                    mode,
-                    direction=direction,
-                    features=features,
-                    language=language,
-                    stroke_width=stroke_width,
-                    anchor=anchor,
-                    ink=ink,
-                    start=start,
-                    *args,
-                    **kwargs,
-                )
-                coord = coord[0] + offset[0], coord[1] + offset[1]
-            except AttributeError:
-                try:
-                    mask = font.getmask(
-                        text,
-                        mode,
-                        direction,
-                        features,
-                        language,
-                        stroke_width,
-                        anchor,
-                        ink,
-                        start=start,
-                        *args,
-                        **kwargs,
-                    )
-                except TypeError:
-                    mask = font.getmask(text)
-            if stroke_offset:
-                coord = coord[0] + stroke_offset[0], coord[1] + stroke_offset[1]
-            if mode == "RGBA":
-                # font.getmask2(mode="RGBA") returns color in RGB bands and mask in A
-                # extract mask and set text alpha
-                color, mask = mask, mask.getband(3)
-                color.fillband(3, (ink >> 24) & 0xFF)
-                x, y = coord
-                self.im.paste(color, (x, y, x + mask.size[0], y + mask.size[1]), mask)
-            else:
-                self.draw.draw_bitmap(coord, mask, ink)
-
-        ink = getink(fill)
-        if ink is not None:
-            stroke_ink = None
-            if stroke_width:
-                stroke_ink = getink(stroke_fill) if stroke_fill is not None else ink
-
-            if stroke_ink is not None:
-                # Draw stroked text
-                draw_text(stroke_ink, stroke_width)
-
-                # Draw normal text
-                draw_text(ink, 0)
-            else:
-                # Only draw normal text
-                draw_text(ink)
-
-    def multiline_text(
-        self,
-        xy,
-        text,
-        fill=None,
-        font=None,
-        anchor=None,
-        spacing=4,
-        align="left",
-        direction=None,
-        features=None,
-        language=None,
-        stroke_width=0,
-        stroke_fill=None,
-        embedded_color=False,
-    ):
-        if direction == "ttb":
-            msg = "ttb direction is unsupported for multiline text"
-            raise ValueError(msg)
-
-        if anchor is None:
-            anchor = "la"
-        elif len(anchor) != 2:
-            msg = "anchor must be a 2 character string"
-            raise ValueError(msg)
-        elif anchor[1] in "tb":
-            msg = "anchor not supported for multiline text"
-            raise ValueError(msg)
-
-        widths = []
-        max_width = 0
-        lines = self._multiline_split(text)
-        line_spacing = self._multiline_spacing(font, spacing, stroke_width)
-        for line in lines:
-            line_width = self.textlength(
-                line, font, direction=direction, features=features, language=language
-            )
-            widths.append(line_width)
-            max_width = max(max_width, line_width)
-
-        top = xy[1]
-        if anchor[1] == "m":
-            top -= (len(lines) - 1) * line_spacing / 2.0
-        elif anchor[1] == "d":
-            top -= (len(lines) - 1) * line_spacing
-
-        for idx, line in enumerate(lines):
-            left = xy[0]
-            width_difference = max_width - widths[idx]
-
-            # first align left by anchor
-            if anchor[0] == "m":
-                left -= width_difference / 2.0
-            elif anchor[0] == "r":
-                left -= width_difference
-
-            # then align by align parameter
-            if align == "left":
-                pass
-            elif align == "center":
-                left += width_difference / 2.0
-            elif align == "right":
-                left += width_difference
-            else:
-                msg = 'align must be "left", "center" or "right"'
-                raise ValueError(msg)
-
-            self.text(
-                (left, top),
-                line,
-                fill,
-                font,
-                anchor,
-                direction=direction,
-                features=features,
-                language=language,
-                stroke_width=stroke_width,
-                stroke_fill=stroke_fill,
-                embedded_color=embedded_color,
-            )
-            top += line_spacing
-
-    def textlength(
-        self,
-        text,
-        font=None,
-        direction=None,
-        features=None,
-        language=None,
-        embedded_color=False,
-    ):
-        """Get the length of a given string, in pixels with 1/64 precision."""
-        if self._multiline_check(text):
-            msg = "can't measure length of multiline text"
-            raise ValueError(msg)
-        if embedded_color and self.mode not in ("RGB", "RGBA"):
-            msg = "Embedded color supported only in RGB and RGBA modes"
-            raise ValueError(msg)
-
-        if font is None:
-            font = self.getfont()
-        mode = "RGBA" if embedded_color else self.fontmode
-        return font.getlength(text, mode, direction, features, language)
-
-    def textbbox(
-        self,
-        xy,
-        text,
-        font=None,
-        anchor=None,
-        spacing=4,
-        align="left",
-        direction=None,
-        features=None,
-        language=None,
-        stroke_width=0,
-        embedded_color=False,
-    ):
-        """Get the bounding box of a given string, in pixels."""
-        if embedded_color and self.mode not in ("RGB", "RGBA"):
-            msg = "Embedded color supported only in RGB and RGBA modes"
-            raise ValueError(msg)
-
-        if self._multiline_check(text):
-            return self.multiline_textbbox(
-                xy,
-                text,
-                font,
-                anchor,
-                spacing,
-                align,
-                direction,
-                features,
-                language,
-                stroke_width,
-                embedded_color,
-            )
-
-        if font is None:
-            font = self.getfont()
-        mode = "RGBA" if embedded_color else self.fontmode
-        bbox = font.getbbox(
-            text, mode, direction, features, language, stroke_width, anchor
-        )
-        return bbox[0] + xy[0], bbox[1] + xy[1], bbox[2] + xy[0], bbox[3] + xy[1]
-
-    def multiline_textbbox(
-        self,
-        xy,
-        text,
-        font=None,
-        anchor=None,
-        spacing=4,
-        align="left",
-        direction=None,
-        features=None,
-        language=None,
-        stroke_width=0,
-        embedded_color=False,
-    ):
-        if direction == "ttb":
-            msg = "ttb direction is unsupported for multiline text"
-            raise ValueError(msg)
-
-        if anchor is None:
-            anchor = "la"
-        elif len(anchor) != 2:
-            msg = "anchor must be a 2 character string"
-            raise ValueError(msg)
-        elif anchor[1] in "tb":
-            msg = "anchor not supported for multiline text"
-            raise ValueError(msg)
-
-        widths = []
-        max_width = 0
-        lines = self._multiline_split(text)
-        line_spacing = self._multiline_spacing(font, spacing, stroke_width)
-        for line in lines:
-            line_width = self.textlength(
-                line,
-                font,
-                direction=direction,
-                features=features,
-                language=language,
-                embedded_color=embedded_color,
-            )
-            widths.append(line_width)
-            max_width = max(max_width, line_width)
-
-        top = xy[1]
-        if anchor[1] == "m":
-            top -= (len(lines) - 1) * line_spacing / 2.0
-        elif anchor[1] == "d":
-            top -= (len(lines) - 1) * line_spacing
-
-        bbox = None
-
-        for idx, line in enumerate(lines):
-            left = xy[0]
-            width_difference = max_width - widths[idx]
-
-            # first align left by anchor
-            if anchor[0] == "m":
-                left -= width_difference / 2.0
-            elif anchor[0] == "r":
-                left -= width_difference
-
-            # then align by align parameter
-            if align == "left":
-                pass
-            elif align == "center":
-                left += width_difference / 2.0
-            elif align == "right":
-                left += width_difference
-            else:
-                msg = 'align must be "left", "center" or "right"'
-                raise ValueError(msg)
-
-            bbox_line = self.textbbox(
-                (left, top),
-                line,
-                font,
-                anchor,
-                direction=direction,
-                features=features,
-                language=language,
-                stroke_width=stroke_width,
-                embedded_color=embedded_color,
-            )
-            if bbox is None:
-                bbox = bbox_line
-            else:
-                bbox = (
-                    min(bbox[0], bbox_line[0]),
-                    min(bbox[1], bbox_line[1]),
-                    max(bbox[2], bbox_line[2]),
-                    max(bbox[3], bbox_line[3]),
-                )
-
-            top += line_spacing
-
-        if bbox is None:
-            return xy[0], xy[1], xy[0], xy[1]
-        return bbox
-
-
-def Draw(im, mode=None):
-    """
-    A simple 2D drawing interface for PIL images.
-
-    :param im: The image to draw in.
-    :param mode: Optional mode to use for color values.  For RGB
-       images, this argument can be RGB or RGBA (to blend the
-       drawing into the image).  For all other modes, this argument
-       must be the same as the image mode.  If omitted, the mode
-       defaults to the mode of the image.
-    """
-    try:
-        return im.getdraw(mode)
-    except AttributeError:
-        return ImageDraw(im, mode)
-
-
-# experimental access to the outline API
-try:
-    Outline = Image.core.outline
-except AttributeError:
-    Outline = None
-
-
-def getdraw(im=None, hints=None):
-    """
-    (Experimental) A more advanced 2D drawing interface for PIL images,
-    based on the WCK interface.
-
-    :param im: The image to draw in.
-    :param hints: An optional list of hints.
-    :returns: A (drawing context, drawing resource factory) tuple.
-    """
-    # FIXME: this needs more work!
-    # FIXME: come up with a better 'hints' scheme.
-    handler = None
-    if not hints or "nicest" in hints:
-        try:
-            from . import _imagingagg as handler
-        except ImportError:
-            pass
-    if handler is None:
-        from . import ImageDraw2 as handler
-    if im:
-        im = handler.Draw(im)
-    return im, handler
-
-
-def floodfill(image, xy, value, border=None, thresh=0):
-    """
-    (experimental) Fills a bounded region with a given color.
-
-    :param image: Target image.
-    :param xy: Seed position (a 2-item coordinate tuple). See
-        :ref:`coordinate-system`.
-    :param value: Fill color.
-    :param border: Optional border value.  If given, the region consists of
-        pixels with a color different from the border color.  If not given,
-        the region consists of pixels having the same color as the seed
-        pixel.
-    :param thresh: Optional threshold value which specifies a maximum
-        tolerable difference of a pixel value from the 'background' in
-        order for it to be replaced. Useful for filling regions of
-        non-homogeneous, but similar, colors.
-    """
-    # based on an implementation by Eric S. Raymond
-    # amended by yo1995 @20180806
-    pixel = image.load()
-    x, y = xy
-    try:
-        background = pixel[x, y]
-        if _color_diff(value, background) <= thresh:
-            return  # seed point already has fill color
-        pixel[x, y] = value
-    except (ValueError, IndexError):
-        return  # seed point outside image
-    edge = {(x, y)}
-    # use a set to keep record of current and previous edge pixels
-    # to reduce memory consumption
-    full_edge = set()
-    while edge:
-        new_edge = set()
-        for x, y in edge:  # 4 adjacent method
-            for s, t in ((x + 1, y), (x - 1, y), (x, y + 1), (x, y - 1)):
-                # If already processed, or if a coordinate is negative, skip
-                if (s, t) in full_edge or s < 0 or t < 0:
-                    continue
-                try:
-                    p = pixel[s, t]
-                except (ValueError, IndexError):
-                    pass
-                else:
-                    full_edge.add((s, t))
-                    if border is None:
-                        fill = _color_diff(p, background) <= thresh
-                    else:
-                        fill = p != value and p != border
-                    if fill:
-                        pixel[s, t] = value
-                        new_edge.add((s, t))
-        full_edge = edge  # discard pixels processed
-        edge = new_edge
-
-
-def _compute_regular_polygon_vertices(bounding_circle, n_sides, rotation):
-    """
-    Generate a list of vertices for a 2D regular polygon.
-
-    :param bounding_circle: The bounding circle is a tuple defined
-        by a point and radius. The polygon is inscribed in this circle.
-        (e.g. ``bounding_circle=(x, y, r)`` or ``((x, y), r)``)
-    :param n_sides: Number of sides
-        (e.g. ``n_sides=3`` for a triangle, ``6`` for a hexagon)
-    :param rotation: Apply an arbitrary rotation to the polygon
-        (e.g. ``rotation=90``, applies a 90 degree rotation)
-    :return: List of regular polygon vertices
-        (e.g. ``[(25, 50), (50, 50), (50, 25), (25, 25)]``)
-
-    How are the vertices computed?
-    1. Compute the following variables
-        - theta: Angle between the apothem & the nearest polygon vertex
-        - side_length: Length of each polygon edge
-        - centroid: Center of bounding circle (1st, 2nd elements of bounding_circle)
-        - polygon_radius: Polygon radius (last element of bounding_circle)
-        - angles: Location of each polygon vertex in polar grid
-            (e.g. A square with 0 degree rotation => [225.0, 315.0, 45.0, 135.0])
-
-    2. For each angle in angles, get the polygon vertex at that angle
-        The vertex is computed using the equation below.
-            X= xcos(φ) + ysin(φ)
-            Y= −xsin(φ) + ycos(φ)
-
-        Note:
-            φ = angle in degrees
-            x = 0
-            y = polygon_radius
-
-        The formula above assumes rotation around the origin.
-        In our case, we are rotating around the centroid.
-        To account for this, we use the formula below
-            X = xcos(φ) + ysin(φ) + centroid_x
-            Y = −xsin(φ) + ycos(φ) + centroid_y
-    """
-    # 1. Error Handling
-    # 1.1 Check `n_sides` has an appropriate value
-    if not isinstance(n_sides, int):
-        msg = "n_sides should be an int"
-        raise TypeError(msg)
-    if n_sides < 3:
-        msg = "n_sides should be an int > 2"
-        raise ValueError(msg)
-
-    # 1.2 Check `bounding_circle` has an appropriate value
-    if not isinstance(bounding_circle, (list, tuple)):
-        msg = "bounding_circle should be a tuple"
-        raise TypeError(msg)
-
-    if len(bounding_circle) == 3:
-        *centroid, polygon_radius = bounding_circle
-    elif len(bounding_circle) == 2:
-        centroid, polygon_radius = bounding_circle
-    else:
-        msg = (
-            "bounding_circle should contain 2D coordinates "
-            "and a radius (e.g. (x, y, r) or ((x, y), r) )"
-        )
-        raise ValueError(msg)
-
-    if not all(isinstance(i, (int, float)) for i in (*centroid, polygon_radius)):
-        msg = "bounding_circle should only contain numeric data"
-        raise ValueError(msg)
-
-    if not len(centroid) == 2:
-        msg = "bounding_circle centre should contain 2D coordinates (e.g. (x, y))"
-        raise ValueError(msg)
-
-    if polygon_radius <= 0:
-        msg = "bounding_circle radius should be > 0"
-        raise ValueError(msg)
-
-    # 1.3 Check `rotation` has an appropriate value
-    if not isinstance(rotation, (int, float)):
-        msg = "rotation should be an int or float"
-        raise ValueError(msg)
-
-    # 2. Define Helper Functions
-    def _apply_rotation(point, degrees, centroid):
-        return (
-            round(
-                point[0] * math.cos(math.radians(360 - degrees))
-                - point[1] * math.sin(math.radians(360 - degrees))
-                + centroid[0],
-                2,
-            ),
-            round(
-                point[1] * math.cos(math.radians(360 - degrees))
-                + point[0] * math.sin(math.radians(360 - degrees))
-                + centroid[1],
-                2,
-            ),
-        )
-
-    def _compute_polygon_vertex(centroid, polygon_radius, angle):
-        start_point = [polygon_radius, 0]
-        return _apply_rotation(start_point, angle, centroid)
-
-    def _get_angles(n_sides, rotation):
-        angles = []
-        degrees = 360 / n_sides
-        # Start with the bottom left polygon vertex
-        current_angle = (270 - 0.5 * degrees) + rotation
-        for _ in range(0, n_sides):
-            angles.append(current_angle)
-            current_angle += degrees
-            if current_angle > 360:
-                current_angle -= 360
-        return angles
-
-    # 3. Variable Declarations
-    angles = _get_angles(n_sides, rotation)
-
-    # 4. Compute Vertices
-    return [
-        _compute_polygon_vertex(centroid, polygon_radius, angle) for angle in angles
-    ]
-
-
-def _color_diff(color1, color2):
-    """
-    Uses 1-norm distance to calculate difference between two values.
-    """
-    if isinstance(color2, tuple):
-        return sum(abs(color1[i] - color2[i]) for i in range(0, len(color2)))
-    else:
-        return abs(color1 - color2)

spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/fastapi/openapi/docs.py

@@ -1,203 +0,0 @@
-import json
-from typing import Any, Dict, Optional
-
-from fastapi.encoders import jsonable_encoder
-from starlette.responses import HTMLResponse
-
-swagger_ui_default_parameters = {
-    "dom_id": "#swagger-ui",
-    "layout": "BaseLayout",
-    "deepLinking": True,
-    "showExtensions": True,
-    "showCommonExtensions": True,
-}
-
-
-def get_swagger_ui_html(
-    *,
-    openapi_url: str,
-    title: str,
-    swagger_js_url: str = "https://cdn.jsdelivr.net/npm/swagger-ui-dist@5/swagger-ui-bundle.js",
-    swagger_css_url: str = "https://cdn.jsdelivr.net/npm/swagger-ui-dist@5/swagger-ui.css",
-    swagger_favicon_url: str = "https://fastapi.tiangolo.com/img/favicon.png",
-    oauth2_redirect_url: Optional[str] = None,
-    init_oauth: Optional[Dict[str, Any]] = None,
-    swagger_ui_parameters: Optional[Dict[str, Any]] = None,
-) -> HTMLResponse:
-    current_swagger_ui_parameters = swagger_ui_default_parameters.copy()
-    if swagger_ui_parameters:
-        current_swagger_ui_parameters.update(swagger_ui_parameters)
-
-    html = f"""
-    <!DOCTYPE html>
-    <html>
-    <head>
-    <link type="text/css" rel="stylesheet" href="{swagger_css_url}">
-    <link rel="shortcut icon" href="{swagger_favicon_url}">
-    <title>{title}</title>
-    </head>
-    <body>
-    <div id="swagger-ui">
-    </div>
-    <script src="{swagger_js_url}"></script>
-    <!-- `SwaggerUIBundle` is now available on the page -->
-    <script>
-    const ui = SwaggerUIBundle({{
-        url: '{openapi_url}',
-    """
-
-    for key, value in current_swagger_ui_parameters.items():
-        html += f"{json.dumps(key)}: {json.dumps(jsonable_encoder(value))},\n"
-
-    if oauth2_redirect_url:
-        html += f"oauth2RedirectUrl: window.location.origin + '{oauth2_redirect_url}',"
-
-    html += """
-    presets: [
-        SwaggerUIBundle.presets.apis,
-        SwaggerUIBundle.SwaggerUIStandalonePreset
-        ],
-    })"""
-
-    if init_oauth:
-        html += f"""
-        ui.initOAuth({json.dumps(jsonable_encoder(init_oauth))})
-        """
-
-    html += """
-    </script>
-    </body>
-    </html>
-    """
-    return HTMLResponse(html)
-
-
-def get_redoc_html(
-    *,
-    openapi_url: str,
-    title: str,
-    redoc_js_url: str = "https://cdn.jsdelivr.net/npm/redoc@next/bundles/redoc.standalone.js",
-    redoc_favicon_url: str = "https://fastapi.tiangolo.com/img/favicon.png",
-    with_google_fonts: bool = True,
-) -> HTMLResponse:
-    html = f"""
-    <!DOCTYPE html>
-    <html>
-    <head>
-    <title>{title}</title>
-    <!-- needed for adaptive design -->
-    <meta charset="utf-8"/>
-    <meta name="viewport" content="width=device-width, initial-scale=1">
-    """
-    if with_google_fonts:
-        html += """
-    <link href="https://fonts.googleapis.com/css?family=Montserrat:300,400,700|Roboto:300,400,700" rel="stylesheet">
-    """
-    html += f"""
-    <link rel="shortcut icon" href="{redoc_favicon_url}">
-    <!--
-    ReDoc doesn't change outer page styles
-    -->
-    <style>
-      body {{
-        margin: 0;
-        padding: 0;
-      }}
-    </style>
-    </head>
-    <body>
-    <noscript>
-        ReDoc requires Javascript to function. Please enable it to browse the documentation.
-    </noscript>
-    <redoc spec-url="{openapi_url}"></redoc>
-    <script src="{redoc_js_url}"> </script>
-    </body>
-    </html>
-    """
-    return HTMLResponse(html)
-
-
-def get_swagger_ui_oauth2_redirect_html() -> HTMLResponse:
-    # copied from https://github.com/swagger-api/swagger-ui/blob/v4.14.0/dist/oauth2-redirect.html
-    html = """
-    <!doctype html>
-    <html lang="en-US">
-    <head>
-        <title>Swagger UI: OAuth2 Redirect</title>
-    </head>
-    <body>
-    <script>
-        'use strict';
-        function run () {
-            var oauth2 = window.opener.swaggerUIRedirectOauth2;
-            var sentState = oauth2.state;
-            var redirectUrl = oauth2.redirectUrl;
-            var isValid, qp, arr;
-
-            if (/code|token|error/.test(window.location.hash)) {
-                qp = window.location.hash.substring(1).replace('?', '&');
-            } else {
-                qp = location.search.substring(1);
-            }
-
-            arr = qp.split("&");
-            arr.forEach(function (v,i,_arr) { _arr[i] = '"' + v.replace('=', '":"') + '"';});
-            qp = qp ? JSON.parse('{' + arr.join() + '}',
-                    function (key, value) {
-                        return key === "" ? value : decodeURIComponent(value);
-                    }
-            ) : {};
-
-            isValid = qp.state === sentState;
-
-            if ((
-              oauth2.auth.schema.get("flow") === "accessCode" ||
-              oauth2.auth.schema.get("flow") === "authorizationCode" ||
-              oauth2.auth.schema.get("flow") === "authorization_code"
-            ) && !oauth2.auth.code) {
-                if (!isValid) {
-                    oauth2.errCb({
-                        authId: oauth2.auth.name,
-                        source: "auth",
-                        level: "warning",
-                        message: "Authorization may be unsafe, passed state was changed in server. The passed state wasn't returned from auth server."
-                    });
-                }
-
-                if (qp.code) {
-                    delete oauth2.state;
-                    oauth2.auth.code = qp.code;
-                    oauth2.callback({auth: oauth2.auth, redirectUrl: redirectUrl});
-                } else {
-                    let oauthErrorMsg;
-                    if (qp.error) {
-                        oauthErrorMsg = "["+qp.error+"]: " +
-                            (qp.error_description ? qp.error_description+ ". " : "no accessCode received from the server. ") +
-                            (qp.error_uri ? "More info: "+qp.error_uri : "");
-                    }
-
-                    oauth2.errCb({
-                        authId: oauth2.auth.name,
-                        source: "auth",
-                        level: "error",
-                        message: oauthErrorMsg || "[Authorization failed]: no accessCode received from the server."
-                    });
-                }
-            } else {
-                oauth2.callback({auth: oauth2.auth, token: qp, isValid: isValid, redirectUrl: redirectUrl});
-            }
-            window.close();
-        }
-
-        if (document.readyState !== 'loading') {
-            run();
-        } else {
-            document.addEventListener('DOMContentLoaded', function () {
-                run();
-            });
-        }
-    </script>
-    </body>
-    </html>
-        """
-    return HTMLResponse(content=html)

spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/fontTools/designspaceLib/statNames.py

@@ -1,252 +0,0 @@
-"""Compute name information for a given location in user-space coordinates
-using STAT data. This can be used to fill-in automatically the names of an
-instance:
-
-.. code:: python
-
-    instance = doc.instances[0]
-    names = getStatNames(doc, instance.getFullUserLocation(doc))
-    print(names.styleNames)
-"""
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import Dict, Optional, Tuple, Union
-import logging
-
-from fontTools.designspaceLib import (
-    AxisDescriptor,
-    AxisLabelDescriptor,
-    DesignSpaceDocument,
-    DesignSpaceDocumentError,
-    DiscreteAxisDescriptor,
-    SimpleLocationDict,
-    SourceDescriptor,
-)
-
-LOGGER = logging.getLogger(__name__)
-
-# TODO(Python 3.8): use Literal
-# RibbiStyleName = Union[Literal["regular"], Literal["bold"], Literal["italic"], Literal["bold italic"]]
-RibbiStyle = str
-BOLD_ITALIC_TO_RIBBI_STYLE = {
-    (False, False): "regular",
-    (False, True): "italic",
-    (True, False): "bold",
-    (True, True): "bold italic",
-}
-
-
-@dataclass
-class StatNames:
-    """Name data generated from the STAT table information."""
-
-    familyNames: Dict[str, str]
-    styleNames: Dict[str, str]
-    postScriptFontName: Optional[str]
-    styleMapFamilyNames: Dict[str, str]
-    styleMapStyleName: Optional[RibbiStyle]
-
-
-def getStatNames(
-    doc: DesignSpaceDocument, userLocation: SimpleLocationDict
-) -> StatNames:
-    """Compute the family, style, PostScript names of the given ``userLocation``
-    using the document's STAT information.
-
-    Also computes localizations.
-
-    If not enough STAT data is available for a given name, either its dict of
-    localized names will be empty (family and style names), or the name will be
-    None (PostScript name).
-
-    .. versionadded:: 5.0
-    """
-    familyNames: Dict[str, str] = {}
-    defaultSource: Optional[SourceDescriptor] = doc.findDefault()
-    if defaultSource is None:
-        LOGGER.warning("Cannot determine default source to look up family name.")
-    elif defaultSource.familyName is None:
-        LOGGER.warning(
-            "Cannot look up family name, assign the 'familyname' attribute to the default source."
-        )
-    else:
-        familyNames = {
-            "en": defaultSource.familyName,
-            **defaultSource.localisedFamilyName,
-        }
-
-    styleNames: Dict[str, str] = {}
-    # If a free-standing label matches the location, use it for name generation.
-    label = doc.labelForUserLocation(userLocation)
-    if label is not None:
-        styleNames = {"en": label.name, **label.labelNames}
-    # Otherwise, scour the axis labels for matches.
-    else:
-        # Gather all languages in which at least one translation is provided
-        # Then build names for all these languages, but fallback to English
-        # whenever a translation is missing.
-        labels = _getAxisLabelsForUserLocation(doc.axes, userLocation)
-        if labels:
-            languages = set(
-                language for label in labels for language in label.labelNames
-            )
-            languages.add("en")
-            for language in languages:
-                styleName = " ".join(
-                    label.labelNames.get(language, label.defaultName)
-                    for label in labels
-                    if not label.elidable
-                )
-                if not styleName and doc.elidedFallbackName is not None:
-                    styleName = doc.elidedFallbackName
-                styleNames[language] = styleName
-
-    if "en" not in familyNames or "en" not in styleNames:
-        # Not enough information to compute PS names of styleMap names
-        return StatNames(
-            familyNames=familyNames,
-            styleNames=styleNames,
-            postScriptFontName=None,
-            styleMapFamilyNames={},
-            styleMapStyleName=None,
-        )
-
-    postScriptFontName = f"{familyNames['en']}-{styleNames['en']}".replace(" ", "")
-
-    styleMapStyleName, regularUserLocation = _getRibbiStyle(doc, userLocation)
-
-    styleNamesForStyleMap = styleNames
-    if regularUserLocation != userLocation:
-        regularStatNames = getStatNames(doc, regularUserLocation)
-        styleNamesForStyleMap = regularStatNames.styleNames
-
-    styleMapFamilyNames = {}
-    for language in set(familyNames).union(styleNames.keys()):
-        familyName = familyNames.get(language, familyNames["en"])
-        styleName = styleNamesForStyleMap.get(language, styleNamesForStyleMap["en"])
-        styleMapFamilyNames[language] = (familyName + " " + styleName).strip()
-
-    return StatNames(
-        familyNames=familyNames,
-        styleNames=styleNames,
-        postScriptFontName=postScriptFontName,
-        styleMapFamilyNames=styleMapFamilyNames,
-        styleMapStyleName=styleMapStyleName,
-    )
-
-
-def _getSortedAxisLabels(
-    axes: list[Union[AxisDescriptor, DiscreteAxisDescriptor]],
-) -> Dict[str, list[AxisLabelDescriptor]]:
-    """Returns axis labels sorted by their ordering, with unordered ones appended as
-    they are listed."""
-
-    # First, get the axis labels with explicit ordering...
-    sortedAxes = sorted(
-        (axis for axis in axes if axis.axisOrdering is not None),
-        key=lambda a: a.axisOrdering,
-    )
-    sortedLabels: Dict[str, list[AxisLabelDescriptor]] = {
-        axis.name: axis.axisLabels for axis in sortedAxes
-    }
-
-    # ... then append the others in the order they appear.
-    # NOTE: This relies on Python 3.7+ dict's preserved insertion order.
-    for axis in axes:
-        if axis.axisOrdering is None:
-            sortedLabels[axis.name] = axis.axisLabels
-
-    return sortedLabels
-
-
-def _getAxisLabelsForUserLocation(
-    axes: list[Union[AxisDescriptor, DiscreteAxisDescriptor]],
-    userLocation: SimpleLocationDict,
-) -> list[AxisLabelDescriptor]:
-    labels: list[AxisLabelDescriptor] = []
-
-    allAxisLabels = _getSortedAxisLabels(axes)
-    if allAxisLabels.keys() != userLocation.keys():
-        LOGGER.warning(
-            f"Mismatch between user location '{userLocation.keys()}' and available "
-            f"labels for '{allAxisLabels.keys()}'."
-        )
-
-    for axisName, axisLabels in allAxisLabels.items():
-        userValue = userLocation[axisName]
-        label: Optional[AxisLabelDescriptor] = next(
-            (
-                l
-                for l in axisLabels
-                if l.userValue == userValue
-                or (
-                    l.userMinimum is not None
-                    and l.userMaximum is not None
-                    and l.userMinimum <= userValue <= l.userMaximum
-                )
-            ),
-            None,
-        )
-        if label is None:
-            LOGGER.debug(
-                f"Document needs a label for axis '{axisName}', user value '{userValue}'."
-            )
-        else:
-            labels.append(label)
-
-    return labels
-
-
-def _getRibbiStyle(
-    self: DesignSpaceDocument, userLocation: SimpleLocationDict
-) -> Tuple[RibbiStyle, SimpleLocationDict]:
-    """Compute the RIBBI style name of the given user location,
-    return the location of the matching Regular in the RIBBI group.
-
-    .. versionadded:: 5.0
-    """
-    regularUserLocation = {}
-    axes_by_tag = {axis.tag: axis for axis in self.axes}
-
-    bold: bool = False
-    italic: bool = False
-
-    axis = axes_by_tag.get("wght")
-    if axis is not None:
-        for regular_label in axis.axisLabels:
-            if (
-                regular_label.linkedUserValue == userLocation[axis.name]
-                # In the "recursive" case where both the Regular has
-                # linkedUserValue pointing the Bold, and the Bold has
-                # linkedUserValue pointing to the Regular, only consider the
-                # first case: Regular (e.g. 400) has linkedUserValue pointing to
-                # Bold (e.g. 700, higher than Regular)
-                and regular_label.userValue < regular_label.linkedUserValue
-            ):
-                regularUserLocation[axis.name] = regular_label.userValue
-                bold = True
-                break
-
-    axis = axes_by_tag.get("ital") or axes_by_tag.get("slnt")
-    if axis is not None:
-        for upright_label in axis.axisLabels:
-            if (
-                upright_label.linkedUserValue == userLocation[axis.name]
-                # In the "recursive" case where both the Upright has
-                # linkedUserValue pointing the Italic, and the Italic has
-                # linkedUserValue pointing to the Upright, only consider the
-                # first case: Upright (e.g. ital=0, slant=0) has
-                # linkedUserValue pointing to Italic (e.g ital=1, slant=-12 or
-                # slant=12 for backwards italics, in any case higher than
-                # Upright in absolute value, hence the abs() below.
-                and abs(upright_label.userValue) < abs(upright_label.linkedUserValue)
-            ):
-                regularUserLocation[axis.name] = upright_label.userValue
-                italic = True
-                break
-
-    return BOLD_ITALIC_TO_RIBBI_STYLE[bold, italic], {
-        **userLocation,
-        **regularUserLocation,
-    }