Update parquet files (step 36 of 249)

spaces/1acneusushi/gradio-2dmoleculeeditor/data/Graphisoft ArchiCAD 16 Build 3006 X64 Crack Goodies Learn How to Use the Software and Enhance Your Projects.md

@@ -1,141 +0,0 @@
-<br />
-<h1>Graphisoft ArchiCAD 16 Build 3006 X64 Crack Goodies: A Comprehensive Guide</h1>
- <p>If you are looking for a way to enhance your architectural design and modeling experience with Graphisoft ArchiCAD 16, you might be interested in downloading and installing the crack goodies for this software. In this article, we will explain what Graphisoft ArchiCAD 16 is, what are the goodies for it, how to download and install them, and how to use them effectively. We will also answer some of the frequently asked questions about the crack goodies. By the end of this article, you will have a clear understanding of what Graphisoft ArchiCAD 16 Build 3006 X64 Crack Goodies are and how to use them.</p>
- <h2>What is Graphisoft ArchiCAD 16?</h2>
- <h3>A brief introduction to ArchiCAD</h3>
- <p>Archicad is a software developed by Graphisoft that allows architects, designers, engineers, and builders to create and manage building information models (BIM) in a virtual environment. Archicad enables users to design, document, visualize, analyze, collaborate, and simulate building projects from concept to construction. Archicad supports various file formats, such as DWG, DXF, IFC, PDF, SKP, OBJ, STL, etc., and integrates with other software tools, such as AutoCAD, Revit, SketchUp, Rhino, Grasshopper, etc.</p>
-<h2>Graphisoft ArchiCAD 16 Build 3006 X64 Crack Goodies</h2><br /><p><b><b>Download</b> &#9658; <a href="https://byltly.com/2uKyTu">https://byltly.com/2uKyTu</a></b></p><br /><br />
- <h3>The features and benefits of ArchiCAD 16</h3>
- <p>Archicad 16 is the latest version of Archicad that was released in June 2012. It introduces several new features and improvements that make it more powerful, flexible, and user-friendly than previous versions. Some of the main features and benefits of Archicad 16 are:</p>
- <ul>
-<li><b>Morph Tool:</b> This tool allows users to create free-form elements with any shape and geometry without any limitations. Users can edit, sculpt, reshape, merge, subtract, or intersect morph elements with other elements or surfaces.</li>
-<li><b>BIM Components:</b> This feature enables users to access a large library of parametric objects that can be customized and modified according to their needs. Users can also create their own objects or import them from other sources.</li>
-<li><b>Built-in Energy Evaluation:</b> This feature allows users to perform energy analysis and optimization on their building models based on various criteria, such as climate data, building materials, orientation, insulation, ventilation, etc.</li>
-<li><b>Improved Teamwork:</b> This feature enhances the collaboration and communication among team members working on the same project. Users can share their models with other users via BIM Server or BIM Cloud services.</li>
-<li><b>Improved Performance:</b> This feature improves the speed and stability of Archicad by optimizing its memory usage, graphics engine, file management system, etc.</li>
-</ul>
- <h2>What are the goodies for Archicad 16?</h2>
- <h3>The definition and purpose of goodies</h3>
- <p>Goodies are additional tools or add-ons that extend the functionality of Archicad. They are developed by Graphisoft or third-party developers to provide users with more options and features that are not included in the standard version of Archicad. Goodies can be downloaded from Graphisoft's website or other sources for free or for a fee.</p>
- <h3>The types and examples of goodies for Archicad 16</h3>
- <p>There are various types of goodies for Archicad 16 that serve different purposes and functions. Some of the most popular and useful goodies for Archicad 16 are:</p>
- <ul>
-<li><b>Accessories:</b> These are objects that can be placed in the model to enhance its appearance or functionality. Examples of accessories are doors, windows, furniture, lamps, plants, etc.</li>
-<li><b>Add-Ons:</b> These are programs that run within Archicad or as separate applications that add new features or capabilities to Archicad. Examples of add-ons are MEP Modeler (for mechanical, electrical, and plumbing systems), EcoDesigner (for environmental analysis), Cinema4D (for rendering), etc.</li>
-<li><b>CADImage Tools:</b> These are tools that improve the productivity and efficiency of users by automating certain tasks or providing shortcuts. Examples of CADImage tools are Detail Elements (for creating detailed drawings), Keynotes (for adding notes and labels), Master Script (for scripting commands), etc.</li>
-<li><b>GDL Objects:</b> These are parametric objects that can be created or modified using GDL (Geometric Description Language), a scripting language specific to Archicad. Examples of GDL objects are stairs, roofs, railings, columns, beams, etc.</li>
-<li><b>Libraries:</b> These are collections of objects that can be used in the model. Examples of libraries are standard parts (such as bolts, nuts, screws), symbols (such as electrical outlets), textures (such as wood grains), etc.</li>
-<li><b>Patches:</b> These are updates or fixes that improve the performance or stability of Archicad or resolve some issues or bugs. Examples of patches are hotfixes (for minor issues), service packs (for major issues), updates (for new features).</li>
-</ul>
- <h2>How to download and install Graphisoft ArchiCAD 16 Build 3006 X64 Crack Goodies?</h2>
- <h3>The requirements and precautions for downloading and installing the crack goodies</h3>
- <p>Before downloading and installing the crack goodies for Archicad 16 Build 3006 X64, you need to make sure that you have the following requirements:</p>
- <ul>
-<li>A computer running Windows XP/Vista/7/8/10 with a 64-bit processor.</li>
-<li>A licensed copy of Graphisoft ArchiCAD 16 Build 3006 X64 installed on your computer.</li>
-<li>A reliable internet connection.</li>
-<li>A backup of your important files and data.</li>
-</ul>
- <p>You also need to be aware of some precautions when downloading and installing the crack goodies:</p>
- <ul>
-<li>The crack goodies are not official products from Graphisoft or endorsed by them. They may contain viruses, malware, spyware, or other harmful components that may damage your computer or compromise your security.</li>
-<li>The crack goodies may not work properly with your version of ArchiCAD or cause conflicts with other programs or devices on your computer.</li>
-<li>The crack goodies may violate the terms and conditions of your license agreement with Graphisoft or infringe on their intellectual property rights. You may face legal consequences if you use them without permission.</li>
-</ul>
- <p>Therefore, you should download and install the crack goodies at your own risk and discretion. We do not take any responsibility for any problems or damages that may occur as a result of using them.</p>
- <h3>The step-by-step instructions for downloading and installing the crack goodies</h3>
- <p>If you have decided to download and install the crack goodies for ArchiCAD 16 Build 3006 X64, you can follow these steps:</p>
-<p>Graphisoft ArchiCAD 16 X64 Crack Download<br />
-ArchiCAD 16 Build 3006 64 Bit Crack Free<br />
-Graphisoft ArchiCAD 16 Crack Goodies Torrent<br />
-ArchiCAD 16 X64 Crack Goodies NPM<br />
-Graphisoft ArchiCAD 16 Build 3006 Crack Zip<br />
-ArchiCAD 16 64 Bit Crack Goodies Download<br />
-Graphisoft ArchiCAD 16 X64 Crack Goodies Opensea<br />
-ArchiCAD 16 Build 3006 Crack Free Download<br />
-Graphisoft ArchiCAD 16 Crack Goodies Clubitup<br />
-ArchiCAD 16 X64 Crack Goodies Libraries.io<br />
-Graphisoft ArchiCAD 16 Build 3006 X64 Keygen<br />
-ArchiCAD 16 64 Bit Keygen Goodies Free<br />
-Graphisoft ArchiCAD 16 Keygen Goodies Download<br />
-ArchiCAD 16 X64 Keygen Goodies NPM<br />
-Graphisoft ArchiCAD 16 Build 3006 Keygen Zip<br />
-ArchiCAD 16 64 Bit Keygen Goodies Torrent<br />
-Graphisoft ArchiCAD 16 X64 Keygen Goodies Opensea<br />
-ArchiCAD 16 Build 3006 Keygen Free Download<br />
-Graphisoft ArchiCAD 16 Keygen Goodies Clubitup<br />
-ArchiCAD 16 X64 Keygen Goodies Libraries.io<br />
-Graphisoft ArchiCAD 16 Build 3006 X64 Serial Number<br />
-ArchiCAD 16 64 Bit Serial Number Goodies Free<br />
-Graphisoft ArchiCAD 16 Serial Number Goodies Download<br />
-ArchiCAD 16 X64 Serial Number Goodies NPM<br />
-Graphisoft ArchiCAD 16 Build 3006 Serial Number Zip<br />
-ArchiCAD 16 64 Bit Serial Number Goodies Torrent<br />
-Graphisoft ArchiCAD 16 X64 Serial Number Goodies Opensea<br />
-ArchiCAD 16 Build 3006 Serial Number Free Download<br />
-Graphisoft ArchiCAD 16 Serial Number Goodies Clubitup<br />
-ArchiCAD 16 X64 Serial Number Goodies Libraries.io<br />
-Graphisoft ArchiCAD 16 Build 3006 X64 License Key<br />
-ArchiCAD 16 64 Bit License Key Goodies Free<br />
-Graphisoft ArchiCAD 16 License Key Goodies Download<br />
-ArchiCAD 16 X64 License Key Goodies NPM<br />
-Graphisoft ArchiCAD 16 Build 3006 License Key Zip<br />
-ArchiCAD 16 64 Bit License Key Goodies Torrent<br />
-Graphisoft ArchiCAD 16 X64 License Key Goodies Opensea<br />
-ArchiCAD 16 Build 3006 License Key Free Download<br />
-Graphisoft ArchiCAD 16 License Key Goodies Clubitup<br />
-ArchiCAD 16 X64 License Key Goodies Libraries.io<br />
-Graphisoft ArchiCAD 16 Build 3006 X64 Activation Code<br />
-ArchiCAD</p>
- <ol>
-<li>Go to <a href="https://trello.com/c/uOp5fFN2/11-graphisoft-archicad-16-build-3006-x64-crack-goodies">this link</a>, which is one of the sources where you can find the crack goodies.</li>
-<li>Select one of the download links provided on the page. You may need to complete some surveys or offers before you can access the download link.</li>
-<li>Download the zip file containing the crack goodies to your computer.</li>
-<li>Extract the zip file using a program that can open zip files, such as WinZip, WinRAR, 7-Zip, etc.</li>
-<li>Open the extracted folder and run the setup.exe file to install the crack goodies on your computer.</li>
-<li>Follow the on-screen instructions to complete the installation process.</li>
-<li>Restart your computer if prompted.</li>
-</ol>
- <p>Congratulations! You have successfully downloaded and installed the crack goodies for ArchiCAD 16 Build 3006 X64 on your computer.</p>
- <h2>How to use Graphisoft ArchiCAD 16 Build 3006 X64 Crack Goodies?</h2>
- <h3>The tips and tricks for using the crack goodies effectively</h3>
- <p>Now that you have installed the crack goodies for ArchiCAD 16 Build 3006 X64, you can start using them to enhance your ArchiCAD experience. Here are some tips and tricks for using the crack goodies effectively:</p>
- <ul>
-<li>Make sure you have a valid license for ArchiCAD 16 before using the crack goodies. The crack goodies are not meant to bypass the license verification or activation process of ArchiCAD. They are only meant to provide additional features and functions that are not available in the standard version of ArchiCAD.</li>
-<li>Check the compatibility and requirements of each crack goodie before using it. Some crack goodies may not work with certain versions or editions of ArchiCAD or Windows. Some crack goodies may also require additional software or hardware components to function properly.</li>
-<li>Read the documentation and instructions of each crack goodie carefully before using it. Some crack goodies may have specific settings or options that need to be configured or adjusted before using them. Some crack goodies may also have limitations or restrictions that need to be considered or respected when using them.</li>
-<li>Use the crack goodies wisely and responsibly. Do not use the crack goodies for illegal or unethical purposes, such as pirating, hacking, cheating, etc. Do not use the crack goodies to harm or damage your computer or other people's computers or data. Do not use the crack goodies to violate or infringe on Graphisoft's or other parties' intellectual property rights or terms and conditions.</li>
-</ul>
- <h3>The common problems and solutions for using the crack goodies</h3>
- <p>While using the crack goodies for ArchiCAD 16 Build 3006 X64, you may encounter some problems or issues that may affect your ArchiCAD performance or functionality. Here are some of the common problems and solutions for using the crack goodies:</p>
- <ul>
-<li><b>Problem:</b> The crack goodies do not work or show up in ArchiCAD.</li>
-<li><b>Solution:</b> Make sure you have installed the crack goodies correctly and completely. Make sure you have restarted your computer after installing the crack goodies. Make sure you have run ArchiCAD as an administrator. Make sure you have enabled or activated the crack goodies in ArchiCAD's settings or preferences.</li>
-<li><b>Problem:</b> The crack goodies cause errors or crashes in ArchiCAD.</li>
-<li><b>Solution:</b> Make sure you have updated your ArchiCAD and Windows to the latest versions. Make sure you have installed the latest patches or fixes for ArchiCAD and Windows. Make sure you have scanned your computer for viruses, malware, spyware, or other harmful components. Make sure you have enough disk space, memory, and CPU resources for running ArchiCAD and the crack goodies smoothly.</li>
-<li><b>Problem:</b> The crack goodies conflict with other programs or devices on your computer.</li>
-<li><b>Solution:</b> Make sure you have closed or disabled any unnecessary programs or devices that may interfere with ArchiCAD and the crack goodies. Make sure you have updated your drivers and firmware for your hardware components. Make sure you have configured your firewall and antivirus settings to allow ArchiCAD and the crack goodies to run without any restrictions.</li>
-</ul>
- <h2>Conclusion</h2>
- <p>In this article, we have explained what Graphisoft ArchiCAD 16 Build 3006 X64 Crack Goodies are, what are their features and benefits, how to download and install them, and how to use them effectively. We hope this article has been helpful and informative for you. If you have any questions or feedback, please feel free to leave a comment below.</p>
- <h2>FAQs</h2>
- <p>Here are some of the frequently asked questions about Graphisoft ArchiCAD 16 Build 3006 X64 Crack Goodies:</p>
- <ol>
-<li><b>Q: Where can I find more information about Graphisoft ArchiCAD 16?</b></li>
-<li><b>A: You can visit Graphisoft's official website at <a href="https://graphisoft.com/archicad">https://graphisoft.com/archicad</a>, where you can find more details about ArchiCAD 16's features, specifications, system requirements, tutorials, support, etc.</b></li>
-<li><b>Q: Where can I find more information about Graphisoft ArchiCAD 16 Goodies?</b></li>
-<li><b>A: You can visit Graphisoft's official website at <a href="https://graphisoft.com/downloads/goodies/AC16">https://graphisoft.com/downloads/goodies/AC16</a>, where you can find more details about each goodie's description, compatibility, installation, usage, etc.</b></li>
-<li><b>Q: Where can I find more sources for downloading Graphisoft ArchiCAD 16 Build 3006 X64 Crack Goodies?</b></li>
-<li><b>A: You can search online for other sources that offer download links for Graphisoft ArchiCAD 16 Build 3006 X64 Crack Goodies. However, be careful when downloading from unknown or untrusted sources, as they may contain harmful or malicious components that may damage your computer or compromise your security.</b></li>
-<li><b>Q: How can I uninstall Graphisoft ArchiCAD 16 Build 3006 X64 Crack Goodies?</b></li>
-<li><b>A: You can uninstall Graphisoft ArchiCAD 16 Build 3006 X64 Crack Goodies by following these steps:</b></li>
-<ul>
-<li>Go to Control Panel > Programs > Programs and Features.</li>
-<li>Select Graphisoft ArchiCAD 16 Build 3006 X64 Crack Goodies from the list of programs and click Uninstall.</li>
-<li>Follow the on-screen instructions to complete the uninstallation process.</li>
-<li>Delete any leftover files or folders related to Graphisoft ArchiCAD 16 Build 3006 X64 Crack Goodies from your computer.</li>
-</ul>
-</ol>
- </p> 0a6ba089eb<br />
-<br />
-<br />

spaces/1gistliPinn/ChatGPT4/Examples/Download !LINK! Ebook Cooperative Learning Anita Lie.md

@@ -1,28 +0,0 @@
-<br />
-<h1>How to Download Ebook Cooperative Learning by Anita Lie</h1>
-<p>Cooperative learning is an instructional strategy that enables small groups of students to work together on a common assignment[^3^]. It has many benefits for students, such as enhancing social skills, academic achievement, and motivation. If you are interested in learning more about cooperative learning, you may want to read the ebook Cooperative Learning by Anita Lie.</p>
-<h2>download ebook cooperative learning anita lie</h2><br /><p><b><b>Download File</b> &raquo;&raquo;&raquo; <a href="https://imgfil.com/2uxXil">https://imgfil.com/2uxXil</a></b></p><br /><br />
-<p>Anita Lie is a professor at Widya Mandala Catholic University in Indonesia, who specializes in teacher professional development, language learning, and education policy[^2^]. She has written several books and articles on cooperative learning, such as Cooperative Learning: Theory, Research and Practice (2002) and Cooperative Learning in Asia and the Pacific (2008).</p>
-<p>In her ebook Cooperative Learning, she provides a comprehensive overview of the principles, methods, and applications of cooperative learning in various contexts. She also offers practical tips and examples for teachers who want to implement cooperative learning in their classrooms.</p>
-<p>If you want to download the ebook Cooperative Learning by Anita Lie, you can follow these steps:</p>
-<ol>
-<li>Go to <a href="https://docs.google.com/file/d/0BwsQDG-7Lin1UWRMSUFVVHZxb1E/edit">this link</a>, which is a Google Drive file that contains the ebook in PDF format[^1^]. You may need to sign in to your Google account to access the file.</li>
-<li>Click on the download icon at the top right corner of the screen. You can choose to download the file as PDF or other formats.</li>
-<li>Save the file to your device or cloud storage. You can then open it with any PDF reader or ebook app.</li>
-</ol>
-<p>That's it! You have successfully downloaded the ebook Cooperative Learning by Anita Lie. You can now enjoy reading it and learning more about cooperative learning. Happy reading!</p>
-
-<p>Cooperative learning is not a new concept in education. It has been used for centuries in various cultures and traditions, such as the African Ubuntu philosophy, the Chinese Confucianism, and the Native American tribal councils. However, it was not until the 1970s that cooperative learning gained popularity in the Western world, thanks to the pioneering work of researchers such as David Johnson, Roger Johnson, and Robert Slavin.</p>
-<p></p>
-<p>Cooperative learning is based on the idea that learning is a social process that involves interaction, communication, and collaboration among peers. It differs from traditional learning, which is often individualistic, competitive, and teacher-centered. Cooperative learning requires students to work in small groups of two to six members, who share a common goal, have individual accountability, and use interpersonal skills. The teacher's role is to facilitate the group work, monitor the progress, and provide feedback and evaluation.</p>
-<p>Cooperative learning has many advantages for students of all ages and levels. Some of the benefits are:</p>
-<ul>
-<li>It improves academic achievement by increasing student engagement, motivation, and retention of information.</li>
-<li>It develops social skills by fostering positive interdependence, cooperation, and respect among group members.</li>
-<li>It enhances self-esteem by providing opportunities for peer support, feedback, and recognition.</li>
-<li>It promotes diversity by exposing students to different perspectives, cultures, and backgrounds.</li>
-<li>It prepares students for the future by developing skills such as problem-solving, critical thinking, creativity, and teamwork.</li>
-</ul>
-<p>Cooperative learning is not a one-size-fits-all approach. It can be adapted to different subjects, curricula, and contexts. There are many types of cooperative learning methods, such as jigsaw, think-pair-share, numbered heads together, round robin, and learning together. Each method has its own structure, procedure, and purpose. Teachers can choose the method that best suits their objectives and students' needs.</p> d5da3c52bf<br />
-<br />
-<br />

spaces/1pelhydcardo/ChatGPT-prompt-generator/assets/2020 O L English Paper Pdf Download.md

@@ -1,77 +0,0 @@
-
-<h1>How to download 2020 O/L English paper PDF</h1>
-<p>If you are preparing for your Ordinary Level (O/L) examination in Sri Lanka or Cambridge International General Certificate of Secondary Education (IGCSE) examination in other countries, you might be wondering how to get hold of the 2020 O/L English paper PDF. The O/L English paper is one of the most important papers in your exam as it tests your language skills in reading, writing, speaking, and listening. In this article, we will explain what the O/L English paper is, why it is important, and how to download it from various sources.</p>
-<h2>2020 o l english paper pdf download</h2><br /><p><b><b>Download File</b> &#9733; <a href="https://urlin.us/2uT2LQ">https://urlin.us/2uT2LQ</a></b></p><br /><br />
- <h2>What is the O/L English paper?</h2>
-<p>The O/L English paper is a compulsory paper for all candidates who sit for the O/L examination in Sri Lanka or the IGCSE examination in other countries. The O/L English paper consists of two parts: Paper 1 and Paper 2. Paper 1 is a written paper that assesses the candidates' reading and writing skills. It has three sections: Section A (Reading Comprehension), Section B (Summary Writing), and Section C (Essay Writing). Paper 2 is an oral paper that assesses the candidates' speaking and listening skills. It has two components: Component 1 (Speaking) and Component 2 (Listening). The O/L English paper aims to test the candidates' ability to use English effectively for communication, study, and work purposes.</p>
- <h3>Why is the O/L English paper important?</h3>
-<p>The O/L English paper is important for several reasons. First, it helps the candidates to improve their communication skills in English, which is a widely used language in the world. By taking the O/L English paper, the candidates can enhance their vocabulary, grammar, pronunciation, and fluency in English. Second, it helps the candidates to improve their academic performance in other subjects. By taking the O/L English paper, the candidates can develop their reading, writing, speaking, and listening skills in English, which are essential for learning and understanding different topics and concepts in other subjects. Third, it helps the candidates to improve their career prospects in the future. By taking the O/L English paper, the candidates can demonstrate their proficiency in English, which is a valuable skill for many jobs and professions in various fields and industries.</p>
- <h4>How to prepare for the O/L English paper?</h4>
-<p>There are many ways to prepare for the O/L English paper. Here are some general tips that can help you to study for the O/L English paper effectively:</p>
-<ul>
-<li>Review the syllabus: The syllabus outlines the aims, objectives, content, and assessment of the O/L English paper. It also provides sample questions, marking schemes, and performance descriptors for each part of the paper. You can download the syllabus from the official website of the Department of Examinations or Cambridge International.  By reviewing the syllabus, you can familiarize yourself with the structure, format, and expectations of the O/L English paper.</li>
-<li>Practise past papers: Past papers are actual papers that were used in previous O/L or IGCSE examinations. They contain questions that cover various topics and skills that are relevant to the O/L English paper. You can download past papers from various sources, such as the official website of the Department of Examinations or Cambridge International, or other websites or platforms that offer educational resources. By practising past papers, you can test your knowledge, understanding, and application of English in different contexts and situations.</li>
-<li>Take online lessons: Online lessons are interactive sessions that are conducted by qualified teachers or tutors who have experience and expertise in teaching English for O/L or IGCSE examinations. They provide guidance, feedback, and support to help you improve your language skills and prepare for the O/L English paper. You can find online lessons from various sources, such as online learning platforms, websites, or apps that offer educational services. By taking online lessons, you can learn from experts, ask questions, and get personalized attention.</li>
-</ul> <h2>How to download 2020 O/L English paper PDF from official sources?</h2>
-<p>One of the best ways to download the 2020 O/L English paper PDF is to use the official sources that are authorized and recognized by the Department of Examinations or Cambridge International. These sources are reliable and accurate, and they provide the latest and most updated versions of the O/L English paper PDF. There are two main official sources that you can use to download the 2020 O/L English paper PDF: the Department of Examinations website and the Cambridge International website.</p>
- <h3>How to download 2020 O/L English paper PDF from the Department of Examinations website?</h3>
-<p>The Department of Examinations website is the official website of the government agency that is responsible for conducting and administering the O/L examination in Sri Lanka. It provides various information and services related to the O/L examination, such as syllabuses, timetables, results, and past papers. You can download the 2020 O/L English paper PDF from the Department of Examinations website by following these steps:</p>
-<ol>
-<li>Go to the Department of Examinations website at <a href="">http://www.doenets.lk</a>.</li>
-<li>Click on the "Examination" tab on the top menu bar and select "G.C.E. (O/L)" from the drop-down list.</li>
-<li>Click on the "Past Papers" link on the left sidebar and select "2020" from the year list.</li>
-<li>Scroll down to find "English Language" from the subject list and click on the "Download" button next to it.</li>
-<li>A new window will open with the 2020 O/L English paper PDF file. You can either view it online or save it to your device by clicking on the "Download" icon on the top right corner.</li>
-</ol>
- <h4>Advantages and disadvantages of downloading from the Department of Examinations website?</h4>
-<p>Downloading from the Department of Examinations website has some advantages and disadvantages. Here are some of them:</p>
-<p></p>
-<table>
-<tr><th>Advantages</th><th>Disadvantages</th></tr>
-<tr><td>- It is free of charge.</td><td>- It may not be available at all times due to high traffic or maintenance.</td></tr>
-<tr><td>- It is reliable and authentic as it is provided by the official authority.</td><td>- It may have slow speed or low quality due to limited bandwidth or resources.</td></tr>
-<tr><td>- It is updated and current as it reflects the latest changes or revisions in the syllabus or format.</td><td>- It may not have all the past papers or marking schemes for every year or subject.</td></tr>
-</table> online.</li>
-</ol>
- <h4>Advantages and disadvantages of downloading from PaperHub?</h4>
-<p>Downloading from PaperHub has some advantages and disadvantages. Here are some of them:</p>
-<table>
-<tr><th>Advantages</th><th>Disadvantages</th></tr>
-<tr><td>- It is easy and convenient as it does not require registration or payment.</td><td>- It may have limited content or variety as it depends on the availability and contribution of the users.</td></tr>
-<tr><td>- It is user-friendly and interactive as it allows users to rate, comment, and share the files.</td><td>- It may have ads or banners that may distract or annoy the users.</td></tr>
-<tr><td>- It is fast and efficient as it has a simple and clear interface and a powerful search engine.</td><td>- It may have errors or mistakes as it does not verify or validate the files.</td></tr>
-</table>
- <h3>How to download 2020 O/L English paper PDF from Pastpapers Wiki?</h3>
-<p>Pastpapers Wiki is a website that provides past papers, marking schemes, notes, and more for free. It covers various subjects and levels, including O/L and IGCSE. You can download the 2020 O/L English paper PDF from Pastpapers Wiki by following these steps:</p>
-<ol>
-<li>Go to Pastpapers Wiki website at <a href="">https://pastpapers.wiki</a>.</li>
-<li>Click on the "O/L" tab on the top menu bar and select "English" from the subject list.</li>
-<li>Click on the "2020" link on the left sidebar and select "English Language" from the paper list.</li>
-<li>A new page will open with the 2020 O/L English paper PDF files for Paper 1 and Paper 2. You can either click on the "Download" button next to each file or click on the file name to view it online.</li>
-</ol>
- <h4>Advantages and disadvantages of downloading from Pastpapers Wiki?</h4>
-<p>Downloading from Pastpapers Wiki has some advantages and disadvantages. Here are some of them:</p>
-<table>
-<tr><th>Advantages</th><th>Disadvantages</th></tr>
-<tr><td>- It is extensive and updated as it has a large collection of past papers and marking schemes for every year and subject.</td><td>- It may have pop-ups or redirects that may lead to unwanted or harmful websites.</td></tr>
-<tr><td>- It is helpful and informative as it provides notes, guides, tips, and tricks for each paper.</td><td>- It may have broken links or missing files that may cause inconvenience or frustration.</td></tr>
-<tr><td>- It is secure and safe as it uses SSL encryption and HTTPS protocol to protect the users' data and privacy.</td><td>- It may not be compatible with some devices or browsers as it uses JavaScript and cookies to function properly.</td></tr>
-</table>
- <h2>Conclusion</h2>
-<p>In conclusion, downloading the 2020 O/L English paper PDF is a useful and effective way to prepare for your O/L examination in Sri Lanka or IGCSE examination in other countries. The 2020 O/L English paper PDF can help you to improve your language skills, academic performance, and career prospects. You can download the 2020 O/L English paper PDF from various sources, such as the official sources of the Department of Examinations or Cambridge International, or other sources like PaperHub or Pastpapers Wiki. However, you should be aware of the advantages and disadvantages of each source, and choose the one that suits your needs and preferences. We hope that this article has provided you with some valuable information and guidance on how to download the 2020 O/L English paper PDF. We wish you all the best for your O/L examination!</p>
- <h2>FAQs</h2>
-<p>Here are some frequently asked questions and answers related to downloading the 2020 O/L English paper PDF:</p>
-<ol>
-<li><b>Q: How can I download the 2020 O/L English paper PDF without internet connection?</b></li>
-<li>A: If you do not have internet connection, you can download the 2020 O/L English paper PDF from a friend, a teacher, a library, or a computer lab that has internet access. You can use a USB flash drive, a CD-ROM, or an email attachment to transfer the file to your device. Alternatively, you can print out the 2020 O/L English paper PDF from a printer that has internet access.</li>
-<li><b>Q: How can I download the 2020 O/L English paper PDF with answers?</b></li>
-<li>A: If you want to download the 2020 O/L English paper PDF with answers, you need to download the marking scheme or the examiner report for the 2020 O/L English paper. The marking scheme or the examiner report provides the answers, the marks, and the feedback for each question in the paper. You can download the marking scheme or the examiner report from the same sources that you download the 2020 O/L English paper PDF, such as the official sources of the Department of Examinations or Cambridge International, or other sources like PaperHub or Pastpapers Wiki. However, you should note that some sources may not have the marking scheme or the examiner report for every paper or year.</li>
-<li><b>Q: How can I download the 2020 O/L English paper PDF in other languages?</b></li>
-<li>A: If you want to download the 2020 O/L English paper PDF in other languages, you need to use a translation tool or service that can convert the PDF file from English to your preferred language. You can use online translation tools or services, such as Google Translate, Microsoft Translator, or DeepL, that can translate the PDF file automatically and instantly. However, you should be aware that online translation tools or services may not be accurate or reliable, and they may lose some meaning or context in the translation process. Alternatively, you can use offline translation tools or services, such as dictionaries, books, or tutors, that can translate the PDF file manually and carefully. However, you should be aware that offline translation tools or services may not be available or accessible, and they may take some time or cost some money in the translation process.</li>
-<li><b>Q: How can I download the 2020 O/L English paper PDF for free?</b></li>
-<li>A: If you want to download the 2020 O/L English paper PDF for free, you need to use sources that do not charge any fee or require any payment for downloading the PDF file. You can use sources that are free of charge, such as the Department of Examinations website, PaperHub, or Pastpapers Wiki, that provide the 2020 O/L English paper PDF for free. However, you should be aware that free sources may have some limitations or drawbacks, such as low quality, limited availability, ads, errors, etc. Alternatively, you can use sources that offer free trials or discounts, such as Cambridge International website or online learning platforms, that provide the 2020 O/L English paper PDF for free for a limited time or with some conditions. However, you should be aware that free trials or discounts may have some restrictions or obligations, such as registration, expiration, cancellation, etc.</li>
-<li><b>Q: How can I download the 2020 O/L English paper PDF legally?</b></li>
-<li>A: If you want to download the 2020 O/L English paper PDF legally, you need to use sources that respect and follow the intellectual property rights and laws of the creators and owners of the PDF file. You can use sources that are authorized and recognized by the Department of Examinations or Cambridge International, such as their official websites, that provide the 2020 O/L English paper PDF legally. However, you should be aware that authorized and recognized sources may require registration and payment as they are only accessible to teachers or students who are affiliated with them. Alternatively, you can use sources that are licensed and permitted by the Department of Examinations or Cambridge International, such as other websites or platforms that offer educational resources legally. However, you should be aware that licensed and permitted sources may have some terms and conditions that you need to agree and comply with, such as attribution, non-commercial use, etc.</li>
-</ol></p> 197e85843d<br />
-<br />
-<br />

spaces/1pelhydcardo/ChatGPT-prompt-generator/assets/Adobe Illustrator CC 2019 Create Amazing Vector Art and Illustrations.md

@@ -1,106 +0,0 @@
-
-<h1>How to Download and Install Adobe Illustrator CC 2019 Kuyhaa</h1>
-<p>If you are looking for a powerful and versatile graphic design software, you might want to try Adobe Illustrator CC 2019. This is the latest version of the industry-standard vector graphics app that lets you create logos, icons, drawings, typography, and complex illustrations for any medium. In this article, we will show you how to download and install Adobe Illustrator CC 2019 kuyhaa, which is a free and full version of the software that you can use without any limitations.</p>
-<h2>What is Adobe Illustrator and what is it used for?</h2>
-<p>Adobe Illustrator is a graphic design application that works with vector graphics. Vector graphics are made of points, lines, shapes, and curves based on mathematical formulas rather than pixels. This means that they can be scaled up or down without losing any quality or detail. Vector graphics are ideal for creating graphics that need to be printed on different sizes or displayed on different devices.</p>
-<h2>download adobe illustrator cc 2019 kuyhaa</h2><br /><p><b><b>DOWNLOAD</b> &#10042;&#10042;&#10042; <a href="https://urlin.us/2uSYJo">https://urlin.us/2uSYJo</a></b></p><br /><br />
-<h3>Adobe Illustrator features and benefits</h3>
-<p>Adobe Illustrator has over 1,300 unique features and functions that allow you to create stunning and professional graphics. Some of its core capabilities include:</p>
-<ul>
-<li>The ability to draw freehand with a variety of digital brushes, pencils, and pens.</li>
-<li>Advanced color options, such as gradients, patterns, swatches, and color themes.</li>
-<li>A Layers panel that lets you organize and edit your design elements across different layers.</li>
-<li>A Properties panel that gives you quick access to the most relevant settings and controls for your selected object.</li>
-<li>A Content-Aware Crop tool that automatically fills in the gaps when you resize or rotate your artwork.</li>
-<li>A Puppet Warp tool that lets you transform your artwork by dragging pins on specific points.</li>
-<li>A Global Edit option that lets you edit multiple instances of a symbol or text at once.</li>
-<li>A Freeform Gradient tool that lets you create natural-looking color blends by placing points of color anywhere on your object.</li>
-<li>A Perspective Grid tool that lets you create realistic depth and distance by applying perspective to your artwork.</li>
-<li>A Shape Builder tool that lets you combine, subtract, or intersect multiple shapes with ease.</li>
-</ul>
-<h3>Adobe Illustrator system requirements</h3>
-<p>Before you download and install Adobe Illustrator CC 2019 kuyhaa, make sure that your computer meets the minimum system requirements for the software. Here are the specifications for Windows:</p>
-<table>
-<tr><th>Processor</th><th>Memory</th><th>Hard disk space</th><th>Operating system</th><th>Graphics card</th></tr>
-<tr><td>Intel Pentium 4 or AMD Athlon 64 processor (or faster)</td><td>4 GB of RAM (8 GB recommended)</td><td>2 GB of available hard disk space for installation; additional free space required during installation</td><td>Windows 7 (64-bit) with Service Pack 1 or Windows 10 (64-bit)</td><td>OpenGL 4.x compatible graphics card with at least 1 GB of VRAM</td></tr>
-</table>
- <h2>How to download Adobe Illustrator CC 2019 kuyhaa</h2>
-<p>To download Adobe Illustrator CC 2019 kuyhaa, you need to follow these steps:</p>
-<h3>Step 1: Visit the Google Drive link</h3>
-<p>The first step is to visit the Google Drive link where the Adobe Illustrator CC 2019 kuyhaa file is stored. You can access the link by clicking [here]. This will take you to a page where you can see the file name and size.</p>
-<h3>Step 2: Download the Adobe.Illustrator.CC.2019.v23.0.0.530x64.exe file</h3>
-<p>The next step is to download the file to your computer. To do this, you need to click on the download icon at the top right corner of the page. This will open a pop-up window where you can choose to save the file to your preferred location or open it with a program. We recommend that you save the file to your desktop or downloads folder for easy access.</p>
-<h3>Step 3: Extract the file using WinRAR or 7-Zip</h3>
-<p>The last step in downloading Adobe Illustrator CC 2019 kuyhaa is to extract the file using a compression software such as WinRAR or 7-Zip. The file is compressed in a .rar format, which means that it contains multiple files and folders inside it. To extract the file, you need to right-click on it and choose "Extract Here" or "Extract to Adobe.Illustrator.CC.2019.v23.0.0.530x64". This will create a new folder with the same name as the file, where you can find all the files and folders related to Adobe Illustrator CC 2019 kuyhaa.</p>
- <h2>How to install Adobe Illustrator CC 2019 kuyhaa</h2>
-<p>Now that you have downloaded and extracted Adobe Illustrator CC 2019 kuyhaa, you are ready to install it on your computer. To install Adobe Illustrator CC 2019 kuyhaa, you need to follow these steps:</p>
-<h3>Step 1: Run the setup.exe file as administrator</h3>
-<p>The first step in installing Adobe Illustrator CC 2019 kuyhaa is to run the setup.exe file as administrator. To do this, you need to go to the folder where you extracted the file and find the setup.exe file. Then, you need to right-click on it and choose "Run as administrator". This will launch the installation wizard, which will guide you through the installation process.</p>
-<p>download adobe illustrator cc 2019 full version<br />
-download adobe illustrator cc 2019 google drive<br />
-download adobe illustrator cc 2019 crack<br />
-download adobe illustrator cc 2019 free<br />
-download adobe illustrator cc 2019 offline installer<br />
-download adobe illustrator cc 2019 for windows 10<br />
-download adobe illustrator cc 2019 portable<br />
-download adobe illustrator cc 2019 64 bit<br />
-download adobe illustrator cc 2019 mac<br />
-download adobe illustrator cc 2019 bagas31<br />
-download adobe illustrator cc 2019 patch<br />
-download adobe illustrator cc 2019 setup<br />
-download adobe illustrator cc 2019 keygen<br />
-download adobe illustrator cc 2019 serial number<br />
-download adobe illustrator cc 2019 activation code<br />
-download adobe illustrator cc 2019 with crack<br />
-download adobe illustrator cc 2019 highly compressed<br />
-download adobe illustrator cc 2019 mega<br />
-download adobe illustrator cc 2019 latest version<br />
-download adobe illustrator cc 2019 update<br />
-download adobe illustrator cc 2019 trial<br />
-download adobe illustrator cc 2019 preactivated<br />
-download adobe illustrator cc 2019 repack<br />
-download adobe illustrator cc 2019 rar<br />
-download adobe illustrator cc 2019 zip<br />
-download adobe illustrator cc 2019 torrent<br />
-download adobe illustrator cc 2019 direct link<br />
-download adobe illustrator cc 2019 from official site<br />
-download adobe illustrator cc 2019 iso file<br />
-download adobe illustrator cc 2019 license key<br />
-how to download adobe illustrator cc 2019 for free<br />
-how to download adobe illustrator cc 2019 crack version<br />
-how to install adobe illustrator cc 2019 after downloading<br />
-how to activate adobe illustrator cc 2019 without internet<br />
-how to use adobe illustrator cc 2019 tutorial pdf<br />
-how to update adobe illustrator cc 2019 to latest version<br />
-how to uninstall adobe illustrator cc 2019 completely<br />
-how to fix adobe illustrator cc 2019 not opening error<br />
-how to speed up adobe illustrator cc 2019 performance<br />
-how to change language in adobe illustrator cc 2019</p>
-<h3>Step 2: Choose the language and destination folder</h3>
-<p>The next step in installing Adobe Illustrator CC 2019 kuyhaa is to choose the language and destination folder for the software. You can choose from several languages, such as English, French, German, Spanish, Italian, Portuguese, Russian, Turkish, Arabic, Chinese, Japanese, Korean, and more. You can also change the destination folder where you want to install Adobe Illustrator CC 2019 kuyhaa on your computer. By default, it will be installed in C:\Program Files\Adobe\Adobe Illustrator CC 2019\. You can click on "Browse" to select a different folder if you wish.</p>
-<h3>Step 3: Wait for the installation to complete</h3>
-<p>The third step in installing Adobe Illustrator CC 2019 kuyhaa is to wait for the installation to complete. This may take several minutes depending on your computer speed and internet connection. You can see the progress of the installation on a green bar at the bottom of the wizard window. You can also see the details of what is being installed on your computer on a list at the right side of the window.</p>
-<h3>Step 4: Launch Adobe Illustrator CC 2019 from the desktop shortcut</h3>
-<p>The final step in installing Adobe Illustrator CC 2019 kuyhaa is to launch it from the desktop shortcut. Once the installation is complete, you will see a message that says "Installation successful". You will also see a checkbox that says "Launch Adobe Illustrator CC". If you want to start using Adobe Illustrator CC 2019 right away, you can leave this checkbox checked and click on "Finish". This will close the installation wizard and open Adobe Illustrator CC 2019 on your computer. Alternatively, you can uncheck this checkbox and click on "Finish". This will close the installation wizard and create a desktop shortcut for Adobe Illustrator CC 2019 on your computer. You can double-click on this shortcut anytime you want to use Adobe Illustrator CC 2019.</p>
- <h2>Conclusion</h2>
-<p>In this article, we have shown you how to download and install Adobe Illustrator CC 2019 kuyhaa, which is a free and full version of the graphic design software that you can use without any limitations. We have explained what Adobe Illustrator is and what it is used for, and we have provided a step-by-step guide on how to download and install it on your computer. We hope that this article has been helpful and informative for you, and that you enjoy using Adobe Illustrator CC 2019 kuyhaa for your graphic design projects.</p>
-<h2>FAQs</h2>
-<p>Here are some frequently asked questions about Adobe Illustrator CC 2019 kuyhaa:</p>
-<h3>Q: Is Adobe Illustrator CC 2019 kuyhaa safe to download and install?</h3>
-<p>A: Yes, Adobe Illustrator CC 2019 kuyhaa is safe to download and install, as long as you follow the instructions in this article and use the Google Drive link that we have provided. This link is from a trusted source and does not contain any viruses, malware, or spyware. However, you should always scan any file that you download from the internet with an antivirus software before opening it, just to be on the safe side.</p>
-<h3>Q: Do I need to activate Adobe Illustrator CC 2019 kuyhaa after installing it?</h3>
-<p>A: No, you do not need to activate Adobe Illustrator CC 2019 kuyhaa after installing it. This is because Adobe Illustrator CC 2019 kuyhaa is a pre-activated version of the software, which means that it does not require any serial number, license key, or crack to run. You can use it without any restrictions or limitations.</p>
-<h3>Q: Can I update Adobe Illustrator CC 2019 kuyhaa to the latest version?</h3>
-<p>A: No, you cannot update Adobe Illustrator CC 2019 kuyhaa to the latest version. This is because Adobe Illustrator CC 2019 kuyhaa is a standalone version of the software, which means that it does not connect to the internet or the Adobe servers. Therefore, it does not receive any updates or patches from Adobe. If you want to use the latest version of Adobe Illustrator, you will need to purchase a subscription from the official website.</p>
-<h3>Q: Can I use Adobe Illustrator CC 2019 kuyhaa with other Adobe products?</h3>
-<p>A: Yes, you can use Adobe Illustrator CC 2019 kuyhaa with other Adobe products, such as Photoshop, InDesign, After Effects, Premiere Pro, and more. You can import and export files between these applications and work seamlessly on your projects. However, you may encounter some compatibility issues if you use different versions of these products.</p>
-<h3>Q: How can I uninstall Adobe Illustrator CC 2019 kuyhaa from my computer?</h3>
-<p>A: If you want to uninstall Adobe Illustrator CC 2019 kuyhaa from your computer, you can follow these steps:</p>
-<ol>
-<li>Go to the Control Panel and click on "Uninstall a program".</li>
-<li>Find and select "Adobe Illustrator CC 2019" from the list of programs and click on "Uninstall".</li>
-<li>Follow the instructions on the screen to complete the uninstallation process.</li>
-<li>Delete the folder where you installed Adobe Illustrator CC 2019 kuyhaa from your computer.</li>
-</ol></p> 197e85843d<br />
-<br />
-<br />

spaces/1phancelerku/anime-remove-background/Baixe o FIFA Mobile Dinheiro Infinito APK e jogue com os melhores times do mundo.md

@@ -1,87 +0,0 @@
-
-<h1>FIFA Mobile Dinheiro Infinito APK Download Mediafıre: How to Get Unlimited Coins and Gems in FIFA Mobile</h1>
- <p>FIFA Mobile is one of the most popular soccer games for mobile devices, with over 100 million downloads on Google Play. The game allows you to build your ultimate team of soccer stars, compete in various modes, and relive the world's greatest soccer tournament, the FIFA World Cup. However, if you want to enjoy all the features and content that FIFA Mobile has to offer, you will need a lot of coins and gems, which are the in-game currencies. Coins and gems can be used to buy players, items, packs, upgrades, and more. But earning coins and gems can be time-consuming and challenging, especially if you don't want to spend real money on them.</p>
-<h2>fifa mobile dinheiro infinito apk download mediafıre</h2><br /><p><b><b>Download</b> &middot;&middot;&middot; <a href="https://jinyurl.com/2uNRzt">https://jinyurl.com/2uNRzt</a></b></p><br /><br />
- <p>That's why some players look for ways to get unlimited coins and gems in FIFA Mobile. One of the most common methods is to download a modded version of the game, such as FIFA Mobile Dinheiro Infinito APK. This is an APK file that claims to offer unlimited coins and gems in FIFA Mobile. But is it really worth it? How does it work? And what are the risks involved? In this article, we will answer these questions and more.</p>
- <h2>What is FIFA Mobile Dinheiro Infinito APK?</h2>
- <p>FIFA Mobile Dinheiro Infinito APK is a modified version of FIFA Mobile that supposedly gives you unlimited coins and gems in the game. It is not an official app from EA Sports or Google Play, but rather a third-party app that can be downloaded from Mediafıre, a file-sharing website. The name "Dinheiro Infinito" means "Infinite Money" in Portuguese, which suggests and risking legal actions from EA Sports or Google Play.</li>
-<li>FIFA Mobile Dinheiro Infinito APK is not a reliable app. It may not work properly or cause errors, glitches, bugs, or crashes in the game. It may also not be compatible with the latest updates or versions of FIFA Mobile.</li>
-<li>FIFA Mobile Dinheiro Infinito APK is not a fair app. It gives you an unfair advantage over other players who play FIFA Mobile legitimately. It also ruins the balance and integrity of the game.</li>
-<li>FIFA Mobile Dinheiro Infinito APK is not a secure app. It may expose your account or device to hackers, scammers, or other malicious users who can steal your coins, gems, players, items, or personal information. It may also get your account banned or suspended by EA Sports for using cheats or hacks in FIFA Mobile.</li>
-</ul>
- <h2>Is FIFA Mobile Dinheiro Infinito APK Worth It?</h2>
- <p>After weighing the benefits and risks of using FIFA Mobile Dinheiro Infinito APK, you may wonder if it is worth it or not. The answer depends on your personal preference and risk tolerance. However, we do not recommend using FIFA Mobile Dinheiro Infinito APK for the following reasons:</p>
- <ul>
-<li>It is not safe to use. It may harm your device or compromise your personal information.</li>
-<li>It is not legal to use. It may get you in trouble with EA Sports or Google Play.</li>
-<li>It is not reliable to use. It may not work as expected or cause problems in the game.</li>
-<li>It is not fair to use. It may give you an unfair advantage over other players or ruin the game experience for everyone.</li>
-<li>It is not secure to use. It may expose your account or device to hackers, scammers, or other malicious users.</li>
-</ul>
- <p>Instead of using FIFA Mobile Dinheiro Infinito APK, we suggest you play FIFA Mobile the way it was meant to be played: with skill, strategy, and fun. You can still enjoy FIFA Mobile without using cheats or hacks. You can still earn coins and gems by playing the game, completing tasks, watching ads, participating in events, or buying them with real money if you want to support the developers. You can still build your ultimate team of soccer stars by scouting, trading, upgrading, and managing your players. You can still compete in various modes and events by challenging yourself, improving your skills, and learning from other players.</p>
-<p>fifa mobile mod apk dinheiro infinito atualizado via mediafire<br />
-fifa 2021 mobile moedas infinitas download mediafire<br />
-fifa mobile hack apk dinheiro infinito mediafire<br />
-fifa mobile 2022 dinheiro infinito apk baixar mediafire<br />
-fifa mobile apk mod moedas infinitas mediafire<br />
-fifa mobile dinheiro infinito download mediafire 2021<br />
-fifa mobile mod apk unlimited money mediafire<br />
-fifa 2021 mobile coins unlimited download mediafire<br />
-fifa mobile hack apk unlimited coins mediafire<br />
-fifa mobile 2022 unlimited money apk download mediafire<br />
-fifa mobile apk mod coins unlimited mediafire<br />
-fifa mobile unlimited coins download mediafire 2021<br />
-fifa mobile mod apk dinheiro infinito e pontos mediafire<br />
-fifa 2021 mobile moedas e pontos infinitos download mediafire<br />
-fifa mobile hack apk dinheiro e pontos infinitos mediafire<br />
-fifa mobile 2022 dinheiro e pontos infinitos apk baixar mediafire<br />
-fifa mobile apk mod moedas e pontos infinitos mediafire<br />
-fifa mobile dinheiro e pontos infinitos download mediafire 2021<br />
-fifa mobile mod apk dinheiro infinito offline mediafire<br />
-fifa 2021 mobile moedas infinitas offline download mediafire<br />
-fifa mobile hack apk dinheiro infinito offline mediafire<br />
-fifa mobile 2022 dinheiro infinito offline apk baixar mediafire<br />
-fifa mobile apk mod moedas infinitas offline mediafire<br />
-fifa mobile dinheiro infinito offline download mediafire 2021<br />
-fifa mobile mod apk dinheiro infinito atualizado 2021 mediafire<br />
-fifa 2021 mobile moedas infinitas atualizado 2021 download mediafire<br />
-fifa mobile hack apk dinheiro infinito atualizado 2021 mediafire<br />
-fifa mobile 2022 dinheiro infinito atualizado 2021 apk baixar mediafire<br />
-fifa mobile apk mod moedas infinitas atualizado 2021 mediafire<br />
-fifa mobile dinheiro infinito atualizado 2021 download mediafire</p>
- <h2>Conclusion</h2>
- <p>FIFA Mobile Dinheiro Infinito APK is a modded version of FIFA Mobile that claims to offer unlimited coins and gems in the game. However, it is not a safe, legal, reliable, fair, or secure app to use. It may cause more harm than good to your device, account, and game experience. Therefore, we do not recommend using FIFA Mobile Dinheiro Infinito APK for getting unlimited coins and gems in FIFA Mobile.</p>
- <p>If you want to enjoy FIFA Mobile without using cheats or hacks, you can follow these tips:</p>
- <ul>
-<li>Play the game regularly and complete tasks to earn coins and gems.</li>
-<li>Watch ads or participate in events to get extra coins and gems.</li>
-<li>Buy coins and gems with real money if you want to support the developers and get more content.</li>
-<li>Scout, trade, upgrade, and manage your players to build your ultimate team.</li>
-<li>Challenge yourself, improve your skills, and learn from other players to compete in various modes and events.</li>
-</ul>
- <p>We hope this article has helped you understand more about FIFA Mobile Dinheiro Infinito APK and why you should avoid using it. If you have any questions or feedback, please feel free to leave a comment below. Thank you for reading!</p>
- <h2>FAQs</h2>
- <h3>Is FIFA Mobile Dinheiro Infinito APK safe to use?</h3>
- <p>No, it is not safe to use. FIFA Mobile Dinheiro Infinito APK is a third-party app that may contain malware, viruses, spyware, or other harmful software that can damage your device or steal your personal information.</p>
- <h3>Is FIFA Mobile Dinheiro Infinito APK legal to use?</h3>
- <p>No, it is not legal to use. FIFA Mobile Dinheiro Infinito APK violates the terms of service and policies of EA Sports and Google Play. By using FIFA Mobile Dinheiro Infinito APK, you are breaking the law and risking legal actions from EA Sports or Google Play.</p>
- <h3>How can I get coins and gems in FIFA Mobile without using FIFA Mobile Dinheiro Infinito APK?</h3>
- <p>You can get coins and gems in FIFA Mobile without using FIFA Mobile Dinheiro Infinito APK by playing the game, com completing tasks, watching ads, participating in events, or buying them with real money if you want to support the developers and get more content.</p>
- <h3>What are some alternatives to FIFA Mobile Dinheiro Infinito APK?</h3>
- <p>Some alternatives to FIFA Mobile Dinheiro Infinito APK are other modded versions or hacks for FIFA Mobile that are available online. However, we do not recommend using any of them, as they may also be unsafe, illegal, unreliable, unfair, or insecure to use. Some examples of these alternatives are:</p>
- <ul>
-<li>FIFA Mobile Mod APK</li>
-<li>FIFA Mobile Hack APK</li>
-<li>FIFA Mobile Unlimited Coins and Gems APK</li>
-<li>FIFA Mobile Generator</li>
-<li>FIFA Mobile Cheats</li>
-</ul>
- <h3>Where can I find more information about FIFA Mobile Dinheiro Infinito APK?</h3>
- <p>If you want to find more information about FIFA Mobile Dinheiro Infinito APK, you can search for it on Google or YouTube. However, be careful of the sources and links that you click on, as they may be fake, misleading, or malicious. Some possible sources of information are:</p>
- <ul>
-<li>[FIFA Mobile Dinheiro Infinito APK Download Mediafıre]</li>
-<li>[FIFA Mobile Dinheiro Infinito APK Tutorial]</li>
-<li>[FIFA Mobile Dinheiro Infinito APK Review]</li>
-</ul></p> 197e85843d<br />
-<br />
-<br />

spaces/2023Liu2023/bingo/src/components/turn-counter.tsx

@@ -1,23 +0,0 @@
-import React from 'react'
-import { Throttling } from '@/lib/bots/bing/types'
-
-export interface TurnCounterProps {
-  throttling?: Throttling
-}
-
-export function TurnCounter({ throttling }: TurnCounterProps) {
-  if (!throttling) {
-    return null
-  }
-
-  return (
-    <div className="turn-counter">
-      <div className="text">
-        <span>{throttling.numUserMessagesInConversation}</span>
-        <span> 共 </span>
-        <span>{throttling.maxNumUserMessagesInConversation}</span>
-      </div>
-      <div className="indicator"></div>
-    </div>
-  )
-}

spaces/4Taps/SadTalker/src/audio2pose_models/res_unet.py

@@ -1,65 +0,0 @@
-import torch
-import torch.nn as nn
-from src.audio2pose_models.networks import ResidualConv, Upsample
-
-
-class ResUnet(nn.Module):
-    def __init__(self, channel=1, filters=[32, 64, 128, 256]):
-        super(ResUnet, self).__init__()
-
-        self.input_layer = nn.Sequential(
-            nn.Conv2d(channel, filters[0], kernel_size=3, padding=1),
-            nn.BatchNorm2d(filters[0]),
-            nn.ReLU(),
-            nn.Conv2d(filters[0], filters[0], kernel_size=3, padding=1),
-        )
-        self.input_skip = nn.Sequential(
-            nn.Conv2d(channel, filters[0], kernel_size=3, padding=1)
-        )
-
-        self.residual_conv_1 = ResidualConv(filters[0], filters[1], stride=(2,1), padding=1)
-        self.residual_conv_2 = ResidualConv(filters[1], filters[2], stride=(2,1), padding=1)
-
-        self.bridge = ResidualConv(filters[2], filters[3], stride=(2,1), padding=1)
-
-        self.upsample_1 = Upsample(filters[3], filters[3], kernel=(2,1), stride=(2,1))
-        self.up_residual_conv1 = ResidualConv(filters[3] + filters[2], filters[2], stride=1, padding=1)
-
-        self.upsample_2 = Upsample(filters[2], filters[2], kernel=(2,1), stride=(2,1))
-        self.up_residual_conv2 = ResidualConv(filters[2] + filters[1], filters[1], stride=1, padding=1)
-
-        self.upsample_3 = Upsample(filters[1], filters[1], kernel=(2,1), stride=(2,1))
-        self.up_residual_conv3 = ResidualConv(filters[1] + filters[0], filters[0], stride=1, padding=1)
-
-        self.output_layer = nn.Sequential(
-            nn.Conv2d(filters[0], 1, 1, 1),
-            nn.Sigmoid(),
-        )
-
-    def forward(self, x):
-        # Encode
-        x1 = self.input_layer(x) + self.input_skip(x)
-        x2 = self.residual_conv_1(x1)
-        x3 = self.residual_conv_2(x2)
-        # Bridge
-        x4 = self.bridge(x3)
-
-        # Decode
-        x4 = self.upsample_1(x4)
-        x5 = torch.cat([x4, x3], dim=1)
-
-        x6 = self.up_residual_conv1(x5)
-
-        x6 = self.upsample_2(x6)
-        x7 = torch.cat([x6, x2], dim=1)
-
-        x8 = self.up_residual_conv2(x7)
-
-        x8 = self.upsample_3(x8)
-        x9 = torch.cat([x8, x1], dim=1)
-
-        x10 = self.up_residual_conv3(x9)
-
-        output = self.output_layer(x10)
-
-        return output

spaces/801artistry/RVC801/utils/dependency.py

@@ -1,170 +0,0 @@
-import os
-import csv
-import shutil
-import tarfile
-import subprocess
-from pathlib import Path
-from datetime import datetime
-
-def install_packages_but_jank_af():
-    packages = ['build-essential', 'python3-dev', 'ffmpeg', 'aria2']
-    pip_packages = ['pip', 'setuptools', 'wheel', 'httpx==0.23.0', 'faiss-gpu', 'fairseq', 'gradio==3.34.0',
-                    'ffmpeg', 'ffmpeg-python', 'praat-parselmouth', 'pyworld', 'numpy==1.23.5',
-                    'numba==0.56.4', 'librosa==0.9.2', 'mega.py', 'gdown', 'onnxruntime', 'pyngrok==4.1.12',
-                    'gTTS', 'elevenlabs', 'wget', 'tensorboardX', 'unidecode', 'huggingface-hub', 'stftpitchshift==1.5.1', 
-                    'yt-dlp', 'pedalboard', 'pathvalidate', 'nltk', 'edge-tts', 'git+https://github.com/suno-ai/bark.git', 'python-dotenv' , 'av']
-
-    print("Updating and installing system packages...")
-    for package in packages:
-        print(f"Installing {package}...")
-        subprocess.check_call(['apt-get', 'install', '-qq', '-y', package])
-
-    print("Updating and installing pip packages...")
-    subprocess.check_call(['pip', 'install', '--upgrade'] + pip_packages)
-
-    print('Packages up to date.')
-
-
-def setup_environment(ForceUpdateDependencies, ForceTemporaryStorage):
-    # Mounting Google Drive
-    if not ForceTemporaryStorage:
-        from google.colab import drive
-
-        if not os.path.exists('/content/drive'):
-            drive.mount('/content/drive')
-        else:
-            print('Drive is already mounted. Proceeding...')
-
-    # Function to install dependencies with progress
-    def install_packages():
-        packages = ['build-essential', 'python3-dev', 'ffmpeg', 'aria2']
-        pip_packages = ['pip', 'setuptools', 'wheel', 'httpx==0.23.0', 'faiss-gpu', 'fairseq', 'gradio==3.34.0',
-                        'ffmpeg', 'ffmpeg-python', 'praat-parselmouth', 'pyworld', 'numpy==1.23.5',
-                        'numba==0.56.4', 'librosa==0.9.2', 'mega.py', 'gdown', 'onnxruntime', 'pyngrok==4.1.12',
-                        'gTTS', 'elevenlabs', 'wget', 'tensorboardX', 'unidecode', 'huggingface-hub', 'stftpitchshift==1.5.1', 
-                        'yt-dlp', 'pedalboard', 'pathvalidate', 'nltk', 'edge-tts', 'git+https://github.com/suno-ai/bark.git', 'python-dotenv' , 'av']
-
-        print("Updating and installing system packages...")
-        for package in packages:
-            print(f"Installing {package}...")
-            subprocess.check_call(['apt-get', 'install', '-qq', '-y', package])
-
-        print("Updating and installing pip packages...")
-        subprocess.check_call(['pip', 'install', '--upgrade'] + pip_packages)
-
-
-        print('Packages up to date.')
-
-    # Function to scan a directory and writes filenames and timestamps
-    def scan_and_write(base_path, output_file):
-        with open(output_file, 'w', newline='') as f:
-            writer = csv.writer(f)
-            for dirpath, dirs, files in os.walk(base_path):
-                for filename in files:
-                    fname = os.path.join(dirpath, filename)
-                    try:
-                        mtime = os.path.getmtime(fname)
-                        writer.writerow([fname, mtime])
-                    except Exception as e:
-                        print(f'Skipping irrelevant nonexistent file {fname}: {str(e)}')
-        print(f'Finished recording filesystem timestamps to {output_file}.')
-
-    # Function to compare files
-    def compare_files(old_file, new_file):
-        old_files = {}
-        new_files = {}
-
-        with open(old_file, 'r') as f:
-            reader = csv.reader(f)
-            old_files = {rows[0]:rows[1] for rows in reader}
-
-        with open(new_file, 'r') as f:
-            reader = csv.reader(f)
-            new_files = {rows[0]:rows[1] for rows in reader}
-
-        removed_files = old_files.keys() - new_files.keys()
-        added_files = new_files.keys() - old_files.keys()
-        unchanged_files = old_files.keys() & new_files.keys()
-
-        changed_files = {f for f in unchanged_files if old_files[f] != new_files[f]}
-
-        for file in removed_files:
-            print(f'File has been removed: {file}')
-
-        for file in changed_files:
-            print(f'File has been updated: {file}')
-
-        return list(added_files) + list(changed_files)
-
-    # Check if CachedRVC.tar.gz exists
-    if ForceTemporaryStorage:
-        file_path = '/content/CachedRVC.tar.gz'
-    else:
-        file_path = '/content/drive/MyDrive/RVC_Cached/CachedRVC.tar.gz'
-
-    content_file_path = '/content/CachedRVC.tar.gz'
-    extract_path = '/'
-
-    if not os.path.exists(file_path):
-        folder_path = os.path.dirname(file_path)
-        os.makedirs(folder_path, exist_ok=True)
-        print('No cached dependency install found. Attempting to download GitHub backup..')
-
-        try:
-            download_url = "https://github.com/kalomaze/QuickMangioFixes/releases/download/release3/CachedRVC.tar.gz"
-            subprocess.run(["wget", "-O", file_path, download_url])
-            print('Download completed successfully!')
-        except Exception as e:
-            print('Download failed:', str(e))
-
-            # Delete the failed download file
-            if os.path.exists(file_path):
-                os.remove(file_path)
-            print('Failed download file deleted. Continuing manual backup..')
-
-    if Path(file_path).exists():
-        if ForceTemporaryStorage:
-            print('Finished downloading CachedRVC.tar.gz.')
-        else:
-            print('CachedRVC.tar.gz found on Google Drive. Proceeding to copy and extract...')
-
-        # Check if ForceTemporaryStorage is True and skip copying if it is
-        if ForceTemporaryStorage:
-            pass
-        else:
-            shutil.copy(file_path, content_file_path)
-
-        print('Beginning backup copy operation...')
-
-        with tarfile.open(content_file_path, 'r:gz') as tar:
-            for member in tar.getmembers():
-                target_path = os.path.join(extract_path, member.name)
-                try:
-                    tar.extract(member, extract_path)
-                except Exception as e:
-                    print('Failed to extract a file (this isn\'t normal)... forcing an update to compensate')
-                    ForceUpdateDependencies = True
-            print(f'Extraction of {content_file_path} to {extract_path} completed.')
-
-        if ForceUpdateDependencies:
-            install_packages()
-            ForceUpdateDependencies = False
-    else:
-        print('CachedRVC.tar.gz not found. Proceeding to create an index of all current files...')
-        scan_and_write('/usr/', '/content/usr_files.csv')
-
-        install_packages()
-
-        scan_and_write('/usr/', '/content/usr_files_new.csv')
-        changed_files = compare_files('/content/usr_files.csv', '/content/usr_files_new.csv')
-
-        with tarfile.open('/content/CachedRVC.tar.gz', 'w:gz') as new_tar:
-            for file in changed_files:
-                new_tar.add(file)
-                print(f'Added to tar: {file}')
-
-        os.makedirs('/content/drive/MyDrive/RVC_Cached', exist_ok=True)
-        shutil.copy('/content/CachedRVC.tar.gz', '/content/drive/MyDrive/RVC_Cached/CachedRVC.tar.gz')
-        print('Updated CachedRVC.tar.gz copied to Google Drive.')
-        print('Dependencies fully up to date; future runs should be faster.')
-

spaces/AIConsultant/MusicGen/tests/modules/__init__.py

@@ -1,5 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-#
-# This source code is licensed under the license found in the
-# LICENSE file in the root directory of this source tree.

spaces/AMR-KELEG/ALDi/README.md

@@ -1,13 +0,0 @@
----
-title: ALDi
-emoji: ☕
-colorFrom: indigo
-colorTo: purple
-sdk: streamlit
-sdk_version: 1.27.2
-app_file: app.py
-pinned: true
-tags: [Arabic]
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/ASJMO/freegpt/client/css/field.css

@@ -1,11 +0,0 @@
-.field {
-	display: flex;
-	align-items: center;
-	padding: 4px;
-}
-
-@media screen and (max-width: 990px) {
-	.field {
-		flex-wrap: nowrap;
-	}
-}

spaces/AchyuthGamer/OpenGPT/g4f/Provider/Providers/Zeabur.py

@@ -1,50 +0,0 @@
-import os
-import requests
-from ...typing import sha256, Dict, get_type_hints
-
-url = "https://gptleg.zeabur.app"
-model = ['gpt-3.5-turbo', 'gpt-3.5-turbo-0301',
-         'gpt-3.5-turbo-16k', 'gpt-4', 'gpt-4-0613']
-supports_stream = True
-needs_auth = False
-
-
-def _create_completion(model: str, messages: list, stream: bool, **kwargs):
-    headers = {
-        'Authority': 'chat.dfehub.com',
-        'Content-Type': 'application/json',
-        'Method': 'POST',
-        'Path': '/api/openai/v1/chat/completions',
-        'Scheme': 'https',
-        'Accept': 'text/event-stream',
-        'Accept-Language': 'pt-BR,pt;q=0.9,en-US;q=0.8,en;q=0.7,zh-CN;q=0.6,zh;q=0.5',
-        'Content-Type': 'application/json',
-        'Origin': 'https://gptleg.zeabur.app',
-        'Referer': 'https://gptleg.zeabur.app/',
-        'Sec-Ch-Ua': '"Not.A/Brand";v="8", "Chromium";v="114", "Google Chrome";v="114"',
-        'Sec-Ch-Ua-Mobile': '?0',
-        'Sec-Ch-Ua-Platform': '"Windows"',
-        'Sec-Fetch-Dest': 'empty',
-        'Sec-Fetch-Mode': 'cors',
-        'Sec-Fetch-Site': 'same-origin',
-        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36',
-        'X-Requested-With': 'XMLHttpRequest',
-    }
-
-    data = {
-        'model': model,
-        'temperature': 0.7,
-        'max_tokens': '16000',
-        'presence_penalty': 0,
-        'messages': messages,
-    }
-
-    response = requests.post(url + '/api/openai/v1/chat/completions',
-                             headers=headers, json=data, stream=stream)
-
-    yield response.json()['choices'][0]['message']['content']
-
-
-params = f'g4f.Providers.{os.path.basename(__file__)[:-3]} supports: ' + \
-    '(%s)' % ', '.join(
-        [f"{name}: {get_type_hints(_create_completion)[name].__name__}" for name in _create_completion.__code__.co_varnames[:_create_completion.__code__.co_argcount]])

spaces/Adapter/T2I-Adapter/ldm/modules/extra_condition/openpose/hand.py

@@ -1,77 +0,0 @@
-import cv2
-import json
-import math
-import matplotlib
-import matplotlib.pyplot as plt
-import numpy as np
-import time
-import torch
-from scipy.ndimage.filters import gaussian_filter
-from skimage.measure import label
-
-from . import util
-from .model import handpose_model
-
-
-class Hand(object):
-
-    def __init__(self, model_path):
-        self.model = handpose_model()
-        if torch.cuda.is_available():
-            self.model = self.model.cuda()
-            print('cuda')
-        model_dict = util.transfer(self.model, torch.load(model_path))
-        self.model.load_state_dict(model_dict)
-        self.model.eval()
-
-    def __call__(self, oriImg):
-        scale_search = [0.5, 1.0, 1.5, 2.0]
-        # scale_search = [0.5]
-        boxsize = 368
-        stride = 8
-        padValue = 128
-        thre = 0.05
-        multiplier = [x * boxsize / oriImg.shape[0] for x in scale_search]
-        heatmap_avg = np.zeros((oriImg.shape[0], oriImg.shape[1], 22))
-        # paf_avg = np.zeros((oriImg.shape[0], oriImg.shape[1], 38))
-
-        for m in range(len(multiplier)):
-            scale = multiplier[m]
-            imageToTest = cv2.resize(oriImg, (0, 0), fx=scale, fy=scale, interpolation=cv2.INTER_CUBIC)
-            imageToTest_padded, pad = util.padRightDownCorner(imageToTest, stride, padValue)
-            im = np.transpose(np.float32(imageToTest_padded[:, :, :, np.newaxis]), (3, 2, 0, 1)) / 256 - 0.5
-            im = np.ascontiguousarray(im)
-
-            data = torch.from_numpy(im).float()
-            if torch.cuda.is_available():
-                data = data.cuda()
-            # data = data.permute([2, 0, 1]).unsqueeze(0).float()
-            with torch.no_grad():
-                output = self.model(data).cpu().numpy()
-                # output = self.model(data).numpy()q
-
-            # extract outputs, resize, and remove padding
-            heatmap = np.transpose(np.squeeze(output), (1, 2, 0))  # output 1 is heatmaps
-            heatmap = cv2.resize(heatmap, (0, 0), fx=stride, fy=stride, interpolation=cv2.INTER_CUBIC)
-            heatmap = heatmap[:imageToTest_padded.shape[0] - pad[2], :imageToTest_padded.shape[1] - pad[3], :]
-            heatmap = cv2.resize(heatmap, (oriImg.shape[1], oriImg.shape[0]), interpolation=cv2.INTER_CUBIC)
-
-            heatmap_avg += heatmap / len(multiplier)
-
-        all_peaks = []
-        for part in range(21):
-            map_ori = heatmap_avg[:, :, part]
-            one_heatmap = gaussian_filter(map_ori, sigma=3)
-            binary = np.ascontiguousarray(one_heatmap > thre, dtype=np.uint8)
-            # 全部小于阈值
-            if np.sum(binary) == 0:
-                all_peaks.append([0, 0])
-                continue
-            label_img, label_numbers = label(binary, return_num=True, connectivity=binary.ndim)
-            max_index = np.argmax([np.sum(map_ori[label_img == i]) for i in range(1, label_numbers + 1)]) + 1
-            label_img[label_img != max_index] = 0
-            map_ori[label_img == 0] = 0
-
-            y, x = util.npmax(map_ori)
-            all_peaks.append([x, y])
-        return np.array(all_peaks)

spaces/AgentVerse/agentVerse/agentverse/llms/openai.py

@@ -1,346 +0,0 @@
-import logging
-import json
-import ast
-import os
-import numpy as np
-from aiohttp import ClientSession
-from typing import Dict, List, Optional, Union
-from tenacity import retry, stop_after_attempt, wait_exponential
-
-from pydantic import BaseModel, Field
-
-from agentverse.llms.base import LLMResult
-from agentverse.logging import logger
-from agentverse.message import Message
-
-from . import llm_registry
-from .base import BaseChatModel, BaseCompletionModel, BaseModelArgs
-from .utils.jsonrepair import JsonRepair
-
-try:
-    import openai
-    from openai.error import OpenAIError
-except ImportError:
-    is_openai_available = False
-    logging.warning("openai package is not installed")
-else:
-    # openai.proxy = os.environ.get("http_proxy")
-    # if openai.proxy is None:
-    #     openai.proxy = os.environ.get("HTTP_PROXY")
-    if os.environ.get("OPENAI_API_KEY") != None:
-        openai.api_key = os.environ.get("OPENAI_API_KEY")
-        is_openai_available = True
-    elif os.environ.get("AZURE_OPENAI_API_KEY") != None:
-        openai.api_type = "azure"
-        openai.api_key = os.environ.get("AZURE_OPENAI_API_KEY")
-        openai.api_base = os.environ.get("AZURE_OPENAI_API_BASE")
-        openai.api_version = "2023-05-15"
-        is_openai_available = True
-    else:
-        logging.warning(
-            "OpenAI API key is not set. Please set the environment variable OPENAI_API_KEY"
-        )
-        is_openai_available = False
-
-
-class OpenAIChatArgs(BaseModelArgs):
-    model: str = Field(default="gpt-3.5-turbo")
-    deployment_id: str = Field(default=None)
-    max_tokens: int = Field(default=2048)
-    temperature: float = Field(default=1.0)
-    top_p: int = Field(default=1)
-    n: int = Field(default=1)
-    stop: Optional[Union[str, List]] = Field(default=None)
-    presence_penalty: int = Field(default=0)
-    frequency_penalty: int = Field(default=0)
-
-
-# class OpenAICompletionArgs(OpenAIChatArgs):
-#     model: str = Field(default="text-davinci-003")
-#     suffix: str = Field(default="")
-#     best_of: int = Field(default=1)
-
-
-# @llm_registry.register("text-davinci-003")
-# class OpenAICompletion(BaseCompletionModel):
-#     args: OpenAICompletionArgs = Field(default_factory=OpenAICompletionArgs)
-
-#     def __init__(self, max_retry: int = 3, **kwargs):
-#         args = OpenAICompletionArgs()
-#         args = args.dict()
-#         for k, v in args.items():
-#             args[k] = kwargs.pop(k, v)
-#         if len(kwargs) > 0:
-#             logging.warning(f"Unused arguments: {kwargs}")
-#         super().__init__(args=args, max_retry=max_retry)
-
-#     def generate_response(self, prompt: str) -> LLMResult:
-#         response = openai.Completion.create(prompt=prompt, **self.args.dict())
-#         return LLMResult(
-#             content=response["choices"][0]["text"],
-#             send_tokens=response["usage"]["prompt_tokens"],
-#             recv_tokens=response["usage"]["completion_tokens"],
-#             total_tokens=response["usage"]["total_tokens"],
-#         )
-
-#     async def agenerate_response(self, prompt: str) -> LLMResult:
-#         response = await openai.Completion.acreate(prompt=prompt, **self.args.dict())
-#         return LLMResult(
-#             content=response["choices"][0]["text"],
-#             send_tokens=response["usage"]["prompt_tokens"],
-#             recv_tokens=response["usage"]["completion_tokens"],
-#             total_tokens=response["usage"]["total_tokens"],
-#         )
-
-
-@llm_registry.register("gpt-35-turbo")
-@llm_registry.register("gpt-3.5-turbo")
-@llm_registry.register("gpt-4")
-class OpenAIChat(BaseChatModel):
-    args: OpenAIChatArgs = Field(default_factory=OpenAIChatArgs)
-
-    total_prompt_tokens: int = 0
-    total_completion_tokens: int = 0
-
-    def __init__(self, max_retry: int = 3, **kwargs):
-        args = OpenAIChatArgs()
-        args = args.dict()
-        for k, v in args.items():
-            args[k] = kwargs.pop(k, v)
-        if len(kwargs) > 0:
-            logging.warning(f"Unused arguments: {kwargs}")
-        super().__init__(args=args, max_retry=max_retry)
-
-    # def _construct_messages(self, history: List[Message]):
-    #     return history + [{"role": "user", "content": query}]
-    @retry(
-        stop=stop_after_attempt(20),
-        wait=wait_exponential(multiplier=1, min=4, max=10),
-        reraise=True,
-    )
-    def generate_response(
-        self,
-        prepend_prompt: str = "",
-        history: List[dict] = [],
-        append_prompt: str = "",
-        functions: List[dict] = [],
-    ) -> LLMResult:
-        messages = self.construct_messages(prepend_prompt, history, append_prompt)
-        logger.log_prompt(messages)
-        try:
-            # Execute function call
-            if functions != []:
-                response = openai.ChatCompletion.create(
-                    messages=messages,
-                    functions=functions,
-                    **self.args.dict(),
-                )
-                if response["choices"][0]["message"].get("function_call") is not None:
-                    self.collect_metrics(response)
-                    return LLMResult(
-                        content=response["choices"][0]["message"].get("content", ""),
-                        function_name=response["choices"][0]["message"][
-                            "function_call"
-                        ]["name"],
-                        function_arguments=ast.literal_eval(
-                            response["choices"][0]["message"]["function_call"][
-                                "arguments"
-                            ]
-                        ),
-                        send_tokens=response["usage"]["prompt_tokens"],
-                        recv_tokens=response["usage"]["completion_tokens"],
-                        total_tokens=response["usage"]["total_tokens"],
-                    )
-                else:
-                    self.collect_metrics(response)
-                    return LLMResult(
-                        content=response["choices"][0]["message"]["content"],
-                        send_tokens=response["usage"]["prompt_tokens"],
-                        recv_tokens=response["usage"]["completion_tokens"],
-                        total_tokens=response["usage"]["total_tokens"],
-                    )
-
-            else:
-                response = openai.ChatCompletion.create(
-                    messages=messages,
-                    **self.args.dict(),
-                )
-                self.collect_metrics(response)
-                return LLMResult(
-                    content=response["choices"][0]["message"]["content"],
-                    send_tokens=response["usage"]["prompt_tokens"],
-                    recv_tokens=response["usage"]["completion_tokens"],
-                    total_tokens=response["usage"]["total_tokens"],
-                )
-        except (OpenAIError, KeyboardInterrupt, json.decoder.JSONDecodeError) as error:
-            raise
-
-    @retry(
-        stop=stop_after_attempt(20),
-        wait=wait_exponential(multiplier=1, min=4, max=10),
-        reraise=True,
-    )
-    async def agenerate_response(
-        self,
-        prepend_prompt: str = "",
-        history: List[dict] = [],
-        append_prompt: str = "",
-        functions: List[dict] = [],
-    ) -> LLMResult:
-        messages = self.construct_messages(prepend_prompt, history, append_prompt)
-        logger.log_prompt(messages)
-
-        try:
-            if functions != []:
-                async with ClientSession(trust_env=True) as session:
-                    openai.aiosession.set(session)
-                    response = await openai.ChatCompletion.acreate(
-                        messages=messages,
-                        functions=functions,
-                        **self.args.dict(),
-                    )
-                if response["choices"][0]["message"].get("function_call") is not None:
-                    function_name = response["choices"][0]["message"]["function_call"][
-                        "name"
-                    ]
-                    valid_function = False
-                    if function_name.startswith("function."):
-                        function_name = function_name.replace("function.", "")
-                    elif function_name.startswith("functions."):
-                        function_name = function_name.replace("functions.", "")
-                    for function in functions:
-                        if function["name"] == function_name:
-                            valid_function = True
-                            break
-                    if not valid_function:
-                        logger.warn(
-                            f"The returned function name {function_name} is not in the list of valid functions. Retrying..."
-                        )
-                        raise ValueError(
-                            f"The returned function name {function_name} is not in the list of valid functions."
-                        )
-                    try:
-                        arguments = ast.literal_eval(
-                            response["choices"][0]["message"]["function_call"][
-                                "arguments"
-                            ]
-                        )
-                    except:
-                        try:
-                            arguments = ast.literal_eval(
-                                JsonRepair(
-                                    response["choices"][0]["message"]["function_call"][
-                                        "arguments"
-                                    ]
-                                ).repair()
-                            )
-                        except:
-                            logger.warn(
-                                "The returned argument in function call is not valid json. Retrying..."
-                            )
-                            raise ValueError(
-                                "The returned argument in function call is not valid json."
-                            )
-                    self.collect_metrics(response)
-                    return LLMResult(
-                        function_name=function_name,
-                        function_arguments=arguments,
-                        send_tokens=response["usage"]["prompt_tokens"],
-                        recv_tokens=response["usage"]["completion_tokens"],
-                        total_tokens=response["usage"]["total_tokens"],
-                    )
-
-                else:
-                    self.collect_metrics(response)
-                    return LLMResult(
-                        content=response["choices"][0]["message"]["content"],
-                        send_tokens=response["usage"]["prompt_tokens"],
-                        recv_tokens=response["usage"]["completion_tokens"],
-                        total_tokens=response["usage"]["total_tokens"],
-                    )
-
-            else:
-                async with ClientSession(trust_env=True) as session:
-                    openai.aiosession.set(session)
-                    response = await openai.ChatCompletion.acreate(
-                        messages=messages,
-                        **self.args.dict(),
-                    )
-                self.collect_metrics(response)
-                return LLMResult(
-                    content=response["choices"][0]["message"]["content"],
-                    send_tokens=response["usage"]["prompt_tokens"],
-                    recv_tokens=response["usage"]["completion_tokens"],
-                    total_tokens=response["usage"]["total_tokens"],
-                )
-        except (OpenAIError, KeyboardInterrupt, json.decoder.JSONDecodeError) as error:
-            raise
-
-    def construct_messages(
-        self, prepend_prompt: str, history: List[dict], append_prompt: str
-    ):
-        messages = []
-        if prepend_prompt != "":
-            messages.append({"role": "system", "content": prepend_prompt})
-        if len(history) > 0:
-            messages += history
-        if append_prompt != "":
-            messages.append({"role": "user", "content": append_prompt})
-        return messages
-
-    def collect_metrics(self, response):
-        self.total_prompt_tokens += response["usage"]["prompt_tokens"]
-        self.total_completion_tokens += response["usage"]["completion_tokens"]
-
-    def get_spend(self) -> int:
-        input_cost_map = {
-            "gpt-3.5-turbo": 0.0015,
-            "gpt-3.5-turbo-16k": 0.003,
-            "gpt-3.5-turbo-0613": 0.0015,
-            "gpt-3.5-turbo-16k-0613": 0.003,
-            "gpt-4": 0.03,
-            "gpt-4-0613": 0.03,
-            "gpt-4-32k": 0.06,
-        }
-
-        output_cost_map = {
-            "gpt-3.5-turbo": 0.002,
-            "gpt-3.5-turbo-16k": 0.004,
-            "gpt-3.5-turbo-0613": 0.002,
-            "gpt-3.5-turbo-16k-0613": 0.004,
-            "gpt-4": 0.06,
-            "gpt-4-0613": 0.06,
-            "gpt-4-32k": 0.12,
-        }
-
-        model = self.args.model
-        if model not in input_cost_map or model not in output_cost_map:
-            raise ValueError(f"Model type {model} not supported")
-
-        return (
-            self.total_prompt_tokens * input_cost_map[model] / 1000.0
-            + self.total_completion_tokens * output_cost_map[model] / 1000.0
-        )
-
-
-@retry(
-    stop=stop_after_attempt(3),
-    wait=wait_exponential(multiplier=1, min=4, max=10),
-    reraise=True,
-)
-def get_embedding(text: str, attempts=3) -> np.array:
-    try:
-        text = text.replace("\n", " ")
-        if openai.api_type == "azure":
-            embedding = openai.Embedding.create(
-                input=[text], deployment_id="text-embedding-ada-002"
-            )["data"][0]["embedding"]
-        else:
-            embedding = openai.Embedding.create(
-                input=[text], model="text-embedding-ada-002"
-            )["data"][0]["embedding"]
-        return tuple(embedding)
-    except Exception as e:
-        attempt += 1
-        logger.error(f"Error {e} when requesting openai models. Retrying")
-        raise

spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/plugins/filechooser.js

@@ -1,3 +0,0 @@
-import OpenFileChooser from './behaviors/filechooser/Open.js';
-import FileChooser from './gameobjects/dom/filechooser/FileChooser.js';
-export { OpenFileChooser, FileChooser };

spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/templates/ui/gridbuttons/AddChildMethods.js

@@ -1,18 +0,0 @@
-import GridSizer from '../gridsizer/GridSizer.js';
-
-const SizerAdd = GridSizer.prototype.add;
-
-export default {
-    addButton(gameObject, columnIndex, rowIndex) {
-        SizerAdd.call(this, gameObject, columnIndex, rowIndex, undefined, 0, this.buttonsExpand);
-        this.buttonGroup.add(gameObject);
-        return this;
-    },
-
-    addButtons(gameObjects, rowThenColumn) {
-        for (var i = 0, cnt = gameObjects; i < cnt; i++) {
-            this.addButton(gameObjects[i], undefined, rowThenColumn);
-        }
-        return this;
-    }
-}

spaces/Aki004/herta-so-vits/modules/mel_processing.py

@@ -1,112 +0,0 @@
-import math
-import os
-import random
-import torch
-from torch import nn
-import torch.nn.functional as F
-import torch.utils.data
-import numpy as np
-import librosa
-import librosa.util as librosa_util
-from librosa.util import normalize, pad_center, tiny
-from scipy.signal import get_window
-from scipy.io.wavfile import read
-from librosa.filters import mel as librosa_mel_fn
-
-MAX_WAV_VALUE = 32768.0
-
-
-def dynamic_range_compression_torch(x, C=1, clip_val=1e-5):
-    """
-    PARAMS
-    ------
-    C: compression factor
-    """
-    return torch.log(torch.clamp(x, min=clip_val) * C)
-
-
-def dynamic_range_decompression_torch(x, C=1):
-    """
-    PARAMS
-    ------
-    C: compression factor used to compress
-    """
-    return torch.exp(x) / C
-
-
-def spectral_normalize_torch(magnitudes):
-    output = dynamic_range_compression_torch(magnitudes)
-    return output
-
-
-def spectral_de_normalize_torch(magnitudes):
-    output = dynamic_range_decompression_torch(magnitudes)
-    return output
-
-
-mel_basis = {}
-hann_window = {}
-
-
-def spectrogram_torch(y, n_fft, sampling_rate, hop_size, win_size, center=False):
-    if torch.min(y) < -1.:
-        print('min value is ', torch.min(y))
-    if torch.max(y) > 1.:
-        print('max value is ', torch.max(y))
-
-    global hann_window
-    dtype_device = str(y.dtype) + '_' + str(y.device)
-    wnsize_dtype_device = str(win_size) + '_' + dtype_device
-    if wnsize_dtype_device not in hann_window:
-        hann_window[wnsize_dtype_device] = torch.hann_window(win_size).to(dtype=y.dtype, device=y.device)
-
-    y = torch.nn.functional.pad(y.unsqueeze(1), (int((n_fft-hop_size)/2), int((n_fft-hop_size)/2)), mode='reflect')
-    y = y.squeeze(1)
-
-    spec = torch.stft(y, n_fft, hop_length=hop_size, win_length=win_size, window=hann_window[wnsize_dtype_device],
-                      center=center, pad_mode='reflect', normalized=False, onesided=True, return_complex=False)
-
-    spec = torch.sqrt(spec.pow(2).sum(-1) + 1e-6)
-    return spec
-
-
-def spec_to_mel_torch(spec, n_fft, num_mels, sampling_rate, fmin, fmax):
-    global mel_basis
-    dtype_device = str(spec.dtype) + '_' + str(spec.device)
-    fmax_dtype_device = str(fmax) + '_' + dtype_device
-    if fmax_dtype_device not in mel_basis:
-        mel = librosa_mel_fn(sr=sampling_rate, n_fft=n_fft, n_mels=num_mels, fmin=fmin, fmax=fmax)
-        mel_basis[fmax_dtype_device] = torch.from_numpy(mel).to(dtype=spec.dtype, device=spec.device)
-    spec = torch.matmul(mel_basis[fmax_dtype_device], spec)
-    spec = spectral_normalize_torch(spec)
-    return spec
-
-
-def mel_spectrogram_torch(y, n_fft, num_mels, sampling_rate, hop_size, win_size, fmin, fmax, center=False):
-    if torch.min(y) < -1.:
-        print('min value is ', torch.min(y))
-    if torch.max(y) > 1.:
-        print('max value is ', torch.max(y))
-
-    global mel_basis, hann_window
-    dtype_device = str(y.dtype) + '_' + str(y.device)
-    fmax_dtype_device = str(fmax) + '_' + dtype_device
-    wnsize_dtype_device = str(win_size) + '_' + dtype_device
-    if fmax_dtype_device not in mel_basis:
-        mel = librosa_mel_fn(sr=sampling_rate, n_fft=n_fft, n_mels=num_mels, fmin=fmin, fmax=fmax)
-        mel_basis[fmax_dtype_device] = torch.from_numpy(mel).to(dtype=y.dtype, device=y.device)
-    if wnsize_dtype_device not in hann_window:
-        hann_window[wnsize_dtype_device] = torch.hann_window(win_size).to(dtype=y.dtype, device=y.device)
-
-    y = torch.nn.functional.pad(y.unsqueeze(1), (int((n_fft-hop_size)/2), int((n_fft-hop_size)/2)), mode='reflect')
-    y = y.squeeze(1)
-
-    spec = torch.stft(y, n_fft, hop_length=hop_size, win_length=win_size, window=hann_window[wnsize_dtype_device],
-                      center=center, pad_mode='reflect', normalized=False, onesided=True, return_complex=False)
-
-    spec = torch.sqrt(spec.pow(2).sum(-1) + 1e-6)
-
-    spec = torch.matmul(mel_basis[fmax_dtype_device], spec)
-    spec = spectral_normalize_torch(spec)
-
-    return spec

spaces/Amrrs/DragGan-Inversion/stylegan_human/torch_utils/ops/bias_act.cpp

@@ -1,101 +0,0 @@
-// Copyright (c) SenseTime Research. All rights reserved.
-
-// Copyright (c) 2021, NVIDIA CORPORATION.  All rights reserved.
-//
-// NVIDIA CORPORATION and its licensors retain all intellectual property
-// and proprietary rights in and to this software, related documentation
-// and any modifications thereto.  Any use, reproduction, disclosure or
-// distribution of this software and related documentation without an express
-// license agreement from NVIDIA CORPORATION is strictly prohibited.
-
-#include <torch/extension.h>
-#include <ATen/cuda/CUDAContext.h>
-#include <c10/cuda/CUDAGuard.h>
-#include "bias_act.h"
-
-//------------------------------------------------------------------------
-
-static bool has_same_layout(torch::Tensor x, torch::Tensor y)
-{
-    if (x.dim() != y.dim())
-        return false;
-    for (int64_t i = 0; i < x.dim(); i++)
-    {
-        if (x.size(i) != y.size(i))
-            return false;
-        if (x.size(i) >= 2 && x.stride(i) != y.stride(i))
-            return false;
-    }
-    return true;
-}
-
-//------------------------------------------------------------------------
-
-static torch::Tensor bias_act(torch::Tensor x, torch::Tensor b, torch::Tensor xref, torch::Tensor yref, torch::Tensor dy, int grad, int dim, int act, float alpha, float gain, float clamp)
-{
-    // Validate arguments.
-    TORCH_CHECK(x.is_cuda(), "x must reside on CUDA device");
-    TORCH_CHECK(b.numel() == 0 || (b.dtype() == x.dtype() && b.device() == x.device()), "b must have the same dtype and device as x");
-    TORCH_CHECK(xref.numel() == 0 || (xref.sizes() == x.sizes() && xref.dtype() == x.dtype() && xref.device() == x.device()), "xref must have the same shape, dtype, and device as x");
-    TORCH_CHECK(yref.numel() == 0 || (yref.sizes() == x.sizes() && yref.dtype() == x.dtype() && yref.device() == x.device()), "yref must have the same shape, dtype, and device as x");
-    TORCH_CHECK(dy.numel() == 0 || (dy.sizes() == x.sizes() && dy.dtype() == x.dtype() && dy.device() == x.device()), "dy must have the same dtype and device as x");
-    TORCH_CHECK(x.numel() <= INT_MAX, "x is too large");
-    TORCH_CHECK(b.dim() == 1, "b must have rank 1");
-    TORCH_CHECK(b.numel() == 0 || (dim >= 0 && dim < x.dim()), "dim is out of bounds");
-    TORCH_CHECK(b.numel() == 0 || b.numel() == x.size(dim), "b has wrong number of elements");
-    TORCH_CHECK(grad >= 0, "grad must be non-negative");
-
-    // Validate layout.
-    TORCH_CHECK(x.is_non_overlapping_and_dense(), "x must be non-overlapping and dense");
-    TORCH_CHECK(b.is_contiguous(), "b must be contiguous");
-    TORCH_CHECK(xref.numel() == 0 || has_same_layout(xref, x), "xref must have the same layout as x");
-    TORCH_CHECK(yref.numel() == 0 || has_same_layout(yref, x), "yref must have the same layout as x");
-    TORCH_CHECK(dy.numel() == 0 || has_same_layout(dy, x), "dy must have the same layout as x");
-
-    // Create output tensor.
-    const at::cuda::OptionalCUDAGuard device_guard(device_of(x));
-    torch::Tensor y = torch::empty_like(x);
-    TORCH_CHECK(has_same_layout(y, x), "y must have the same layout as x");
-
-    // Initialize CUDA kernel parameters.
-    bias_act_kernel_params p;
-    p.x     = x.data_ptr();
-    p.b     = (b.numel()) ? b.data_ptr() : NULL;
-    p.xref  = (xref.numel()) ? xref.data_ptr() : NULL;
-    p.yref  = (yref.numel()) ? yref.data_ptr() : NULL;
-    p.dy    = (dy.numel()) ? dy.data_ptr() : NULL;
-    p.y     = y.data_ptr();
-    p.grad  = grad;
-    p.act   = act;
-    p.alpha = alpha;
-    p.gain  = gain;
-    p.clamp = clamp;
-    p.sizeX = (int)x.numel();
-    p.sizeB = (int)b.numel();
-    p.stepB = (b.numel()) ? (int)x.stride(dim) : 1;
-
-    // Choose CUDA kernel.
-    void* kernel;
-    AT_DISPATCH_FLOATING_TYPES_AND_HALF(x.scalar_type(), "upfirdn2d_cuda", [&]
-    {
-        kernel = choose_bias_act_kernel<scalar_t>(p);
-    });
-    TORCH_CHECK(kernel, "no CUDA kernel found for the specified activation func");
-
-    // Launch CUDA kernel.
-    p.loopX = 4;
-    int blockSize = 4 * 32;
-    int gridSize = (p.sizeX - 1) / (p.loopX * blockSize) + 1;
-    void* args[] = {&p};
-    AT_CUDA_CHECK(cudaLaunchKernel(kernel, gridSize, blockSize, args, 0, at::cuda::getCurrentCUDAStream()));
-    return y;
-}
-
-//------------------------------------------------------------------------
-
-PYBIND11_MODULE(TORCH_EXTENSION_NAME, m)
-{
-    m.def("bias_act", &bias_act);
-}
-
-//------------------------------------------------------------------------

spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/docs/source/ko/optimization/opt_overview.md

@@ -1,17 +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.
--->
-
-# 개요
-
-노이즈가 많은 출력에서 적은 출력으로 만드는 과정으로 고품질 생성 모델의 출력을 만드는 각각의 반복되는 스텝은 많은 계산이 필요합니다. 🧨 Diffuser의 목표 중 하나는 모든 사람이 이 기술을 널리 이용할 수 있도록 하는 것이며, 여기에는 소비자 및 특수 하드웨어에서 빠른 추론을 가능하게 하는 것을 포함합니다. 
-
-이 섹션에서는 추론 속도를 최적화하고 메모리 소비를 줄이기 위한 반정밀(half-precision) 가중치 및 sliced attention과 같은 팁과 요령을 다룹니다. 또한 [`torch.compile`](https://pytorch.org/tutorials/intermediate/torch_compile_tutorial.html) 또는 [ONNX Runtime](https://onnxruntime.ai/docs/)을 사용하여 PyTorch 코드의 속도를 높이고, [xFormers](https://facebookresearch.github.io/xformers/)를 사용하여 memory-efficient attention을 활성화하는 방법을 배울 수 있습니다. Apple Silicon, Intel 또는 Habana 프로세서와 같은 특정 하드웨어에서 추론을 실행하기 위한 가이드도 있습니다.

spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/src/diffusers/pipelines/shap_e/renderer.py

@@ -1,1050 +0,0 @@
-# Copyright 2023 Open AI and The HuggingFace Team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import math
-from dataclasses import dataclass
-from typing import Dict, Optional, Tuple
-
-import numpy as np
-import torch
-import torch.nn.functional as F
-from torch import nn
-
-from ...configuration_utils import ConfigMixin, register_to_config
-from ...models import ModelMixin
-from ...utils import BaseOutput
-from .camera import create_pan_cameras
-
-
-def sample_pmf(pmf: torch.Tensor, n_samples: int) -> torch.Tensor:
-    r"""
-    Sample from the given discrete probability distribution with replacement.
-
-    The i-th bin is assumed to have mass pmf[i].
-
-    Args:
-        pmf: [batch_size, *shape, n_samples, 1] where (pmf.sum(dim=-2) == 1).all()
-        n_samples: number of samples
-
-    Return:
-        indices sampled with replacement
-    """
-
-    *shape, support_size, last_dim = pmf.shape
-    assert last_dim == 1
-
-    cdf = torch.cumsum(pmf.view(-1, support_size), dim=1)
-    inds = torch.searchsorted(cdf, torch.rand(cdf.shape[0], n_samples, device=cdf.device))
-
-    return inds.view(*shape, n_samples, 1).clamp(0, support_size - 1)
-
-
-def posenc_nerf(x: torch.Tensor, min_deg: int = 0, max_deg: int = 15) -> torch.Tensor:
-    """
-    Concatenate x and its positional encodings, following NeRF.
-
-    Reference: https://arxiv.org/pdf/2210.04628.pdf
-    """
-    if min_deg == max_deg:
-        return x
-
-    scales = 2.0 ** torch.arange(min_deg, max_deg, dtype=x.dtype, device=x.device)
-    *shape, dim = x.shape
-    xb = (x.reshape(-1, 1, dim) * scales.view(1, -1, 1)).reshape(*shape, -1)
-    assert xb.shape[-1] == dim * (max_deg - min_deg)
-    emb = torch.cat([xb, xb + math.pi / 2.0], axis=-1).sin()
-    return torch.cat([x, emb], dim=-1)
-
-
-def encode_position(position):
-    return posenc_nerf(position, min_deg=0, max_deg=15)
-
-
-def encode_direction(position, direction=None):
-    if direction is None:
-        return torch.zeros_like(posenc_nerf(position, min_deg=0, max_deg=8))
-    else:
-        return posenc_nerf(direction, min_deg=0, max_deg=8)
-
-
-def _sanitize_name(x: str) -> str:
-    return x.replace(".", "__")
-
-
-def integrate_samples(volume_range, ts, density, channels):
-    r"""
-    Function integrating the model output.
-
-    Args:
-        volume_range: Specifies the integral range [t0, t1]
-        ts: timesteps
-        density: torch.Tensor [batch_size, *shape, n_samples, 1]
-        channels: torch.Tensor [batch_size, *shape, n_samples, n_channels]
-    returns:
-        channels: integrated rgb output weights: torch.Tensor [batch_size, *shape, n_samples, 1] (density
-        *transmittance)[i] weight for each rgb output at [..., i, :]. transmittance: transmittance of this volume
-    )
-    """
-
-    # 1. Calculate the weights
-    _, _, dt = volume_range.partition(ts)
-    ddensity = density * dt
-
-    mass = torch.cumsum(ddensity, dim=-2)
-    transmittance = torch.exp(-mass[..., -1, :])
-
-    alphas = 1.0 - torch.exp(-ddensity)
-    Ts = torch.exp(torch.cat([torch.zeros_like(mass[..., :1, :]), -mass[..., :-1, :]], dim=-2))
-    # This is the probability of light hitting and reflecting off of
-    # something at depth [..., i, :].
-    weights = alphas * Ts
-
-    # 2. Integrate channels
-    channels = torch.sum(channels * weights, dim=-2)
-
-    return channels, weights, transmittance
-
-
-def volume_query_points(volume, grid_size):
-    indices = torch.arange(grid_size**3, device=volume.bbox_min.device)
-    zs = indices % grid_size
-    ys = torch.div(indices, grid_size, rounding_mode="trunc") % grid_size
-    xs = torch.div(indices, grid_size**2, rounding_mode="trunc") % grid_size
-    combined = torch.stack([xs, ys, zs], dim=1)
-    return (combined.float() / (grid_size - 1)) * (volume.bbox_max - volume.bbox_min) + volume.bbox_min
-
-
-def _convert_srgb_to_linear(u: torch.Tensor):
-    return torch.where(u <= 0.04045, u / 12.92, ((u + 0.055) / 1.055) ** 2.4)
-
-
-def _create_flat_edge_indices(
-    flat_cube_indices: torch.Tensor,
-    grid_size: Tuple[int, int, int],
-):
-    num_xs = (grid_size[0] - 1) * grid_size[1] * grid_size[2]
-    y_offset = num_xs
-    num_ys = grid_size[0] * (grid_size[1] - 1) * grid_size[2]
-    z_offset = num_xs + num_ys
-    return torch.stack(
-        [
-            # Edges spanning x-axis.
-            flat_cube_indices[:, 0] * grid_size[1] * grid_size[2]
-            + flat_cube_indices[:, 1] * grid_size[2]
-            + flat_cube_indices[:, 2],
-            flat_cube_indices[:, 0] * grid_size[1] * grid_size[2]
-            + (flat_cube_indices[:, 1] + 1) * grid_size[2]
-            + flat_cube_indices[:, 2],
-            flat_cube_indices[:, 0] * grid_size[1] * grid_size[2]
-            + flat_cube_indices[:, 1] * grid_size[2]
-            + flat_cube_indices[:, 2]
-            + 1,
-            flat_cube_indices[:, 0] * grid_size[1] * grid_size[2]
-            + (flat_cube_indices[:, 1] + 1) * grid_size[2]
-            + flat_cube_indices[:, 2]
-            + 1,
-            # Edges spanning y-axis.
-            (
-                y_offset
-                + flat_cube_indices[:, 0] * (grid_size[1] - 1) * grid_size[2]
-                + flat_cube_indices[:, 1] * grid_size[2]
-                + flat_cube_indices[:, 2]
-            ),
-            (
-                y_offset
-                + (flat_cube_indices[:, 0] + 1) * (grid_size[1] - 1) * grid_size[2]
-                + flat_cube_indices[:, 1] * grid_size[2]
-                + flat_cube_indices[:, 2]
-            ),
-            (
-                y_offset
-                + flat_cube_indices[:, 0] * (grid_size[1] - 1) * grid_size[2]
-                + flat_cube_indices[:, 1] * grid_size[2]
-                + flat_cube_indices[:, 2]
-                + 1
-            ),
-            (
-                y_offset
-                + (flat_cube_indices[:, 0] + 1) * (grid_size[1] - 1) * grid_size[2]
-                + flat_cube_indices[:, 1] * grid_size[2]
-                + flat_cube_indices[:, 2]
-                + 1
-            ),
-            # Edges spanning z-axis.
-            (
-                z_offset
-                + flat_cube_indices[:, 0] * grid_size[1] * (grid_size[2] - 1)
-                + flat_cube_indices[:, 1] * (grid_size[2] - 1)
-                + flat_cube_indices[:, 2]
-            ),
-            (
-                z_offset
-                + (flat_cube_indices[:, 0] + 1) * grid_size[1] * (grid_size[2] - 1)
-                + flat_cube_indices[:, 1] * (grid_size[2] - 1)
-                + flat_cube_indices[:, 2]
-            ),
-            (
-                z_offset
-                + flat_cube_indices[:, 0] * grid_size[1] * (grid_size[2] - 1)
-                + (flat_cube_indices[:, 1] + 1) * (grid_size[2] - 1)
-                + flat_cube_indices[:, 2]
-            ),
-            (
-                z_offset
-                + (flat_cube_indices[:, 0] + 1) * grid_size[1] * (grid_size[2] - 1)
-                + (flat_cube_indices[:, 1] + 1) * (grid_size[2] - 1)
-                + flat_cube_indices[:, 2]
-            ),
-        ],
-        dim=-1,
-    )
-
-
-class VoidNeRFModel(nn.Module):
-    """
-    Implements the default empty space model where all queries are rendered as background.
-    """
-
-    def __init__(self, background, channel_scale=255.0):
-        super().__init__()
-        background = nn.Parameter(torch.from_numpy(np.array(background)).to(dtype=torch.float32) / channel_scale)
-
-        self.register_buffer("background", background)
-
-    def forward(self, position):
-        background = self.background[None].to(position.device)
-
-        shape = position.shape[:-1]
-        ones = [1] * (len(shape) - 1)
-        n_channels = background.shape[-1]
-        background = torch.broadcast_to(background.view(background.shape[0], *ones, n_channels), [*shape, n_channels])
-
-        return background
-
-
-@dataclass
-class VolumeRange:
-    t0: torch.Tensor
-    t1: torch.Tensor
-    intersected: torch.Tensor
-
-    def __post_init__(self):
-        assert self.t0.shape == self.t1.shape == self.intersected.shape
-
-    def partition(self, ts):
-        """
-        Partitions t0 and t1 into n_samples intervals.
-
-        Args:
-            ts: [batch_size, *shape, n_samples, 1]
-
-        Return:
-
-            lower: [batch_size, *shape, n_samples, 1] upper: [batch_size, *shape, n_samples, 1] delta: [batch_size,
-            *shape, n_samples, 1]
-
-        where
-            ts \\in [lower, upper] deltas = upper - lower
-        """
-
-        mids = (ts[..., 1:, :] + ts[..., :-1, :]) * 0.5
-        lower = torch.cat([self.t0[..., None, :], mids], dim=-2)
-        upper = torch.cat([mids, self.t1[..., None, :]], dim=-2)
-        delta = upper - lower
-        assert lower.shape == upper.shape == delta.shape == ts.shape
-        return lower, upper, delta
-
-
-class BoundingBoxVolume(nn.Module):
-    """
-    Axis-aligned bounding box defined by the two opposite corners.
-    """
-
-    def __init__(
-        self,
-        *,
-        bbox_min,
-        bbox_max,
-        min_dist: float = 0.0,
-        min_t_range: float = 1e-3,
-    ):
-        """
-        Args:
-            bbox_min: the left/bottommost corner of the bounding box
-            bbox_max: the other corner of the bounding box
-            min_dist: all rays should start at least this distance away from the origin.
-        """
-        super().__init__()
-
-        self.min_dist = min_dist
-        self.min_t_range = min_t_range
-
-        self.bbox_min = torch.tensor(bbox_min)
-        self.bbox_max = torch.tensor(bbox_max)
-        self.bbox = torch.stack([self.bbox_min, self.bbox_max])
-        assert self.bbox.shape == (2, 3)
-        assert min_dist >= 0.0
-        assert min_t_range > 0.0
-
-    def intersect(
-        self,
-        origin: torch.Tensor,
-        direction: torch.Tensor,
-        t0_lower: Optional[torch.Tensor] = None,
-        epsilon=1e-6,
-    ):
-        """
-        Args:
-            origin: [batch_size, *shape, 3]
-            direction: [batch_size, *shape, 3]
-            t0_lower: Optional [batch_size, *shape, 1] lower bound of t0 when intersecting this volume.
-            params: Optional meta parameters in case Volume is parametric
-            epsilon: to stabilize calculations
-
-        Return:
-            A tuple of (t0, t1, intersected) where each has a shape [batch_size, *shape, 1]. If a ray intersects with
-            the volume, `o + td` is in the volume for all t in [t0, t1]. If the volume is bounded, t1 is guaranteed to
-            be on the boundary of the volume.
-        """
-
-        batch_size, *shape, _ = origin.shape
-        ones = [1] * len(shape)
-        bbox = self.bbox.view(1, *ones, 2, 3).to(origin.device)
-
-        def _safe_divide(a, b, epsilon=1e-6):
-            return a / torch.where(b < 0, b - epsilon, b + epsilon)
-
-        ts = _safe_divide(bbox - origin[..., None, :], direction[..., None, :], epsilon=epsilon)
-
-        # Cases to think about:
-        #
-        #   1. t1 <= t0: the ray does not pass through the AABB.
-        #   2. t0 < t1 <= 0: the ray intersects but the BB is behind the origin.
-        #   3. t0 <= 0 <= t1: the ray starts from inside the BB
-        #   4. 0 <= t0 < t1: the ray is not inside and intersects with the BB twice.
-        #
-        # 1 and 4 are clearly handled from t0 < t1 below.
-        # Making t0 at least min_dist (>= 0) takes care of 2 and 3.
-        t0 = ts.min(dim=-2).values.max(dim=-1, keepdim=True).values.clamp(self.min_dist)
-        t1 = ts.max(dim=-2).values.min(dim=-1, keepdim=True).values
-        assert t0.shape == t1.shape == (batch_size, *shape, 1)
-        if t0_lower is not None:
-            assert t0.shape == t0_lower.shape
-            t0 = torch.maximum(t0, t0_lower)
-
-        intersected = t0 + self.min_t_range < t1
-        t0 = torch.where(intersected, t0, torch.zeros_like(t0))
-        t1 = torch.where(intersected, t1, torch.ones_like(t1))
-
-        return VolumeRange(t0=t0, t1=t1, intersected=intersected)
-
-
-class StratifiedRaySampler(nn.Module):
-    """
-    Instead of fixed intervals, a sample is drawn uniformly at random from each interval.
-    """
-
-    def __init__(self, depth_mode: str = "linear"):
-        """
-        :param depth_mode: linear samples ts linearly in depth. harmonic ensures
-            closer points are sampled more densely.
-        """
-        self.depth_mode = depth_mode
-        assert self.depth_mode in ("linear", "geometric", "harmonic")
-
-    def sample(
-        self,
-        t0: torch.Tensor,
-        t1: torch.Tensor,
-        n_samples: int,
-        epsilon: float = 1e-3,
-    ) -> torch.Tensor:
-        """
-        Args:
-            t0: start time has shape [batch_size, *shape, 1]
-            t1: finish time has shape [batch_size, *shape, 1]
-            n_samples: number of ts to sample
-        Return:
-            sampled ts of shape [batch_size, *shape, n_samples, 1]
-        """
-        ones = [1] * (len(t0.shape) - 1)
-        ts = torch.linspace(0, 1, n_samples).view(*ones, n_samples).to(t0.dtype).to(t0.device)
-
-        if self.depth_mode == "linear":
-            ts = t0 * (1.0 - ts) + t1 * ts
-        elif self.depth_mode == "geometric":
-            ts = (t0.clamp(epsilon).log() * (1.0 - ts) + t1.clamp(epsilon).log() * ts).exp()
-        elif self.depth_mode == "harmonic":
-            # The original NeRF recommends this interpolation scheme for
-            # spherical scenes, but there could be some weird edge cases when
-            # the observer crosses from the inner to outer volume.
-            ts = 1.0 / (1.0 / t0.clamp(epsilon) * (1.0 - ts) + 1.0 / t1.clamp(epsilon) * ts)
-
-        mids = 0.5 * (ts[..., 1:] + ts[..., :-1])
-        upper = torch.cat([mids, t1], dim=-1)
-        lower = torch.cat([t0, mids], dim=-1)
-        # yiyi notes: add a random seed here for testing, don't forget to remove
-        torch.manual_seed(0)
-        t_rand = torch.rand_like(ts)
-
-        ts = lower + (upper - lower) * t_rand
-        return ts.unsqueeze(-1)
-
-
-class ImportanceRaySampler(nn.Module):
-    """
-    Given the initial estimate of densities, this samples more from regions/bins expected to have objects.
-    """
-
-    def __init__(
-        self,
-        volume_range: VolumeRange,
-        ts: torch.Tensor,
-        weights: torch.Tensor,
-        blur_pool: bool = False,
-        alpha: float = 1e-5,
-    ):
-        """
-        Args:
-            volume_range: the range in which a ray intersects the given volume.
-            ts: earlier samples from the coarse rendering step
-            weights: discretized version of density * transmittance
-            blur_pool: if true, use 2-tap max + 2-tap blur filter from mip-NeRF.
-            alpha: small value to add to weights.
-        """
-        self.volume_range = volume_range
-        self.ts = ts.clone().detach()
-        self.weights = weights.clone().detach()
-        self.blur_pool = blur_pool
-        self.alpha = alpha
-
-    @torch.no_grad()
-    def sample(self, t0: torch.Tensor, t1: torch.Tensor, n_samples: int) -> torch.Tensor:
-        """
-        Args:
-            t0: start time has shape [batch_size, *shape, 1]
-            t1: finish time has shape [batch_size, *shape, 1]
-            n_samples: number of ts to sample
-        Return:
-            sampled ts of shape [batch_size, *shape, n_samples, 1]
-        """
-        lower, upper, _ = self.volume_range.partition(self.ts)
-
-        batch_size, *shape, n_coarse_samples, _ = self.ts.shape
-
-        weights = self.weights
-        if self.blur_pool:
-            padded = torch.cat([weights[..., :1, :], weights, weights[..., -1:, :]], dim=-2)
-            maxes = torch.maximum(padded[..., :-1, :], padded[..., 1:, :])
-            weights = 0.5 * (maxes[..., :-1, :] + maxes[..., 1:, :])
-        weights = weights + self.alpha
-        pmf = weights / weights.sum(dim=-2, keepdim=True)
-        inds = sample_pmf(pmf, n_samples)
-        assert inds.shape == (batch_size, *shape, n_samples, 1)
-        assert (inds >= 0).all() and (inds < n_coarse_samples).all()
-
-        t_rand = torch.rand(inds.shape, device=inds.device)
-        lower_ = torch.gather(lower, -2, inds)
-        upper_ = torch.gather(upper, -2, inds)
-
-        ts = lower_ + (upper_ - lower_) * t_rand
-        ts = torch.sort(ts, dim=-2).values
-        return ts
-
-
-@dataclass
-class MeshDecoderOutput(BaseOutput):
-    """
-    A 3D triangle mesh with optional data at the vertices and faces.
-
-    Args:
-        verts (`torch.Tensor` of shape `(N, 3)`):
-            array of vertext coordinates
-        faces (`torch.Tensor` of shape `(N, 3)`):
-            array of triangles, pointing to indices in verts.
-        vertext_channels (Dict):
-            vertext coordinates for each color channel
-    """
-
-    verts: torch.Tensor
-    faces: torch.Tensor
-    vertex_channels: Dict[str, torch.Tensor]
-
-
-class MeshDecoder(nn.Module):
-    """
-    Construct meshes from Signed distance functions (SDFs) using marching cubes method
-    """
-
-    def __init__(self):
-        super().__init__()
-        cases = torch.zeros(256, 5, 3, dtype=torch.long)
-        masks = torch.zeros(256, 5, dtype=torch.bool)
-
-        self.register_buffer("cases", cases)
-        self.register_buffer("masks", masks)
-
-    def forward(self, field: torch.Tensor, min_point: torch.Tensor, size: torch.Tensor):
-        """
-        For a signed distance field, produce a mesh using marching cubes.
-
-        :param field: a 3D tensor of field values, where negative values correspond
-                    to the outside of the shape. The dimensions correspond to the x, y, and z directions, respectively.
-        :param min_point: a tensor of shape [3] containing the point corresponding
-                        to (0, 0, 0) in the field.
-        :param size: a tensor of shape [3] containing the per-axis distance from the
-                    (0, 0, 0) field corner and the (-1, -1, -1) field corner.
-        """
-        assert len(field.shape) == 3, "input must be a 3D scalar field"
-        dev = field.device
-
-        cases = self.cases.to(dev)
-        masks = self.masks.to(dev)
-
-        min_point = min_point.to(dev)
-        size = size.to(dev)
-
-        grid_size = field.shape
-        grid_size_tensor = torch.tensor(grid_size).to(size)
-
-        # Create bitmasks between 0 and 255 (inclusive) indicating the state
-        # of the eight corners of each cube.
-        bitmasks = (field > 0).to(torch.uint8)
-        bitmasks = bitmasks[:-1, :, :] | (bitmasks[1:, :, :] << 1)
-        bitmasks = bitmasks[:, :-1, :] | (bitmasks[:, 1:, :] << 2)
-        bitmasks = bitmasks[:, :, :-1] | (bitmasks[:, :, 1:] << 4)
-
-        # Compute corner coordinates across the entire grid.
-        corner_coords = torch.empty(*grid_size, 3, device=dev, dtype=field.dtype)
-        corner_coords[range(grid_size[0]), :, :, 0] = torch.arange(grid_size[0], device=dev, dtype=field.dtype)[
-            :, None, None
-        ]
-        corner_coords[:, range(grid_size[1]), :, 1] = torch.arange(grid_size[1], device=dev, dtype=field.dtype)[
-            :, None
-        ]
-        corner_coords[:, :, range(grid_size[2]), 2] = torch.arange(grid_size[2], device=dev, dtype=field.dtype)
-
-        # Compute all vertices across all edges in the grid, even though we will
-        # throw some out later. We have (X-1)*Y*Z + X*(Y-1)*Z + X*Y*(Z-1) vertices.
-        # These are all midpoints, and don't account for interpolation (which is
-        # done later based on the used edge midpoints).
-        edge_midpoints = torch.cat(
-            [
-                ((corner_coords[:-1] + corner_coords[1:]) / 2).reshape(-1, 3),
-                ((corner_coords[:, :-1] + corner_coords[:, 1:]) / 2).reshape(-1, 3),
-                ((corner_coords[:, :, :-1] + corner_coords[:, :, 1:]) / 2).reshape(-1, 3),
-            ],
-            dim=0,
-        )
-
-        # Create a flat array of [X, Y, Z] indices for each cube.
-        cube_indices = torch.zeros(
-            grid_size[0] - 1, grid_size[1] - 1, grid_size[2] - 1, 3, device=dev, dtype=torch.long
-        )
-        cube_indices[range(grid_size[0] - 1), :, :, 0] = torch.arange(grid_size[0] - 1, device=dev)[:, None, None]
-        cube_indices[:, range(grid_size[1] - 1), :, 1] = torch.arange(grid_size[1] - 1, device=dev)[:, None]
-        cube_indices[:, :, range(grid_size[2] - 1), 2] = torch.arange(grid_size[2] - 1, device=dev)
-        flat_cube_indices = cube_indices.reshape(-1, 3)
-
-        # Create a flat array mapping each cube to 12 global edge indices.
-        edge_indices = _create_flat_edge_indices(flat_cube_indices, grid_size)
-
-        # Apply the LUT to figure out the triangles.
-        flat_bitmasks = bitmasks.reshape(-1).long()  # must cast to long for indexing to believe this not a mask
-        local_tris = cases[flat_bitmasks]
-        local_masks = masks[flat_bitmasks]
-        # Compute the global edge indices for the triangles.
-        global_tris = torch.gather(edge_indices, 1, local_tris.reshape(local_tris.shape[0], -1)).reshape(
-            local_tris.shape
-        )
-        # Select the used triangles for each cube.
-        selected_tris = global_tris.reshape(-1, 3)[local_masks.reshape(-1)]
-
-        # Now we have a bunch of indices into the full list of possible vertices,
-        # but we want to reduce this list to only the used vertices.
-        used_vertex_indices = torch.unique(selected_tris.view(-1))
-        used_edge_midpoints = edge_midpoints[used_vertex_indices]
-        old_index_to_new_index = torch.zeros(len(edge_midpoints), device=dev, dtype=torch.long)
-        old_index_to_new_index[used_vertex_indices] = torch.arange(
-            len(used_vertex_indices), device=dev, dtype=torch.long
-        )
-
-        # Rewrite the triangles to use the new indices
-        faces = torch.gather(old_index_to_new_index, 0, selected_tris.view(-1)).reshape(selected_tris.shape)
-
-        # Compute the actual interpolated coordinates corresponding to edge midpoints.
-        v1 = torch.floor(used_edge_midpoints).to(torch.long)
-        v2 = torch.ceil(used_edge_midpoints).to(torch.long)
-        s1 = field[v1[:, 0], v1[:, 1], v1[:, 2]]
-        s2 = field[v2[:, 0], v2[:, 1], v2[:, 2]]
-        p1 = (v1.float() / (grid_size_tensor - 1)) * size + min_point
-        p2 = (v2.float() / (grid_size_tensor - 1)) * size + min_point
-        # The signs of s1 and s2 should be different. We want to find
-        # t such that t*s2 + (1-t)*s1 = 0.
-        t = (s1 / (s1 - s2))[:, None]
-        verts = t * p2 + (1 - t) * p1
-
-        return MeshDecoderOutput(verts=verts, faces=faces, vertex_channels=None)
-
-
-@dataclass
-class MLPNeRFModelOutput(BaseOutput):
-    density: torch.Tensor
-    signed_distance: torch.Tensor
-    channels: torch.Tensor
-    ts: torch.Tensor
-
-
-class MLPNeRSTFModel(ModelMixin, ConfigMixin):
-    @register_to_config
-    def __init__(
-        self,
-        d_hidden: int = 256,
-        n_output: int = 12,
-        n_hidden_layers: int = 6,
-        act_fn: str = "swish",
-        insert_direction_at: int = 4,
-    ):
-        super().__init__()
-
-        # Instantiate the MLP
-
-        # Find out the dimension of encoded position and direction
-        dummy = torch.eye(1, 3)
-        d_posenc_pos = encode_position(position=dummy).shape[-1]
-        d_posenc_dir = encode_direction(position=dummy).shape[-1]
-
-        mlp_widths = [d_hidden] * n_hidden_layers
-        input_widths = [d_posenc_pos] + mlp_widths
-        output_widths = mlp_widths + [n_output]
-
-        if insert_direction_at is not None:
-            input_widths[insert_direction_at] += d_posenc_dir
-
-        self.mlp = nn.ModuleList([nn.Linear(d_in, d_out) for d_in, d_out in zip(input_widths, output_widths)])
-
-        if act_fn == "swish":
-            # self.activation = swish
-            # yiyi testing:
-            self.activation = lambda x: F.silu(x)
-        else:
-            raise ValueError(f"Unsupported activation function {act_fn}")
-
-        self.sdf_activation = torch.tanh
-        self.density_activation = torch.nn.functional.relu
-        self.channel_activation = torch.sigmoid
-
-    def map_indices_to_keys(self, output):
-        h_map = {
-            "sdf": (0, 1),
-            "density_coarse": (1, 2),
-            "density_fine": (2, 3),
-            "stf": (3, 6),
-            "nerf_coarse": (6, 9),
-            "nerf_fine": (9, 12),
-        }
-
-        mapped_output = {k: output[..., start:end] for k, (start, end) in h_map.items()}
-
-        return mapped_output
-
-    def forward(self, *, position, direction, ts, nerf_level="coarse", rendering_mode="nerf"):
-        h = encode_position(position)
-
-        h_preact = h
-        h_directionless = None
-        for i, layer in enumerate(self.mlp):
-            if i == self.config.insert_direction_at:  # 4 in the config
-                h_directionless = h_preact
-                h_direction = encode_direction(position, direction=direction)
-                h = torch.cat([h, h_direction], dim=-1)
-
-            h = layer(h)
-
-            h_preact = h
-
-            if i < len(self.mlp) - 1:
-                h = self.activation(h)
-
-        h_final = h
-        if h_directionless is None:
-            h_directionless = h_preact
-
-        activation = self.map_indices_to_keys(h_final)
-
-        if nerf_level == "coarse":
-            h_density = activation["density_coarse"]
-        else:
-            h_density = activation["density_fine"]
-
-        if rendering_mode == "nerf":
-            if nerf_level == "coarse":
-                h_channels = activation["nerf_coarse"]
-            else:
-                h_channels = activation["nerf_fine"]
-
-        elif rendering_mode == "stf":
-            h_channels = activation["stf"]
-
-        density = self.density_activation(h_density)
-        signed_distance = self.sdf_activation(activation["sdf"])
-        channels = self.channel_activation(h_channels)
-
-        # yiyi notes: I think signed_distance is not used
-        return MLPNeRFModelOutput(density=density, signed_distance=signed_distance, channels=channels, ts=ts)
-
-
-class ChannelsProj(nn.Module):
-    def __init__(
-        self,
-        *,
-        vectors: int,
-        channels: int,
-        d_latent: int,
-    ):
-        super().__init__()
-        self.proj = nn.Linear(d_latent, vectors * channels)
-        self.norm = nn.LayerNorm(channels)
-        self.d_latent = d_latent
-        self.vectors = vectors
-        self.channels = channels
-
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        x_bvd = x
-        w_vcd = self.proj.weight.view(self.vectors, self.channels, self.d_latent)
-        b_vc = self.proj.bias.view(1, self.vectors, self.channels)
-        h = torch.einsum("bvd,vcd->bvc", x_bvd, w_vcd)
-        h = self.norm(h)
-
-        h = h + b_vc
-        return h
-
-
-class ShapEParamsProjModel(ModelMixin, ConfigMixin):
-    """
-    project the latent representation of a 3D asset to obtain weights of a multi-layer perceptron (MLP).
-
-    For more details, see the original paper:
-    """
-
-    @register_to_config
-    def __init__(
-        self,
-        *,
-        param_names: Tuple[str] = (
-            "nerstf.mlp.0.weight",
-            "nerstf.mlp.1.weight",
-            "nerstf.mlp.2.weight",
-            "nerstf.mlp.3.weight",
-        ),
-        param_shapes: Tuple[Tuple[int]] = (
-            (256, 93),
-            (256, 256),
-            (256, 256),
-            (256, 256),
-        ),
-        d_latent: int = 1024,
-    ):
-        super().__init__()
-
-        # check inputs
-        if len(param_names) != len(param_shapes):
-            raise ValueError("Must provide same number of `param_names` as `param_shapes`")
-        self.projections = nn.ModuleDict({})
-        for k, (vectors, channels) in zip(param_names, param_shapes):
-            self.projections[_sanitize_name(k)] = ChannelsProj(
-                vectors=vectors,
-                channels=channels,
-                d_latent=d_latent,
-            )
-
-    def forward(self, x: torch.Tensor):
-        out = {}
-        start = 0
-        for k, shape in zip(self.config.param_names, self.config.param_shapes):
-            vectors, _ = shape
-            end = start + vectors
-            x_bvd = x[:, start:end]
-            out[k] = self.projections[_sanitize_name(k)](x_bvd).reshape(len(x), *shape)
-            start = end
-        return out
-
-
-class ShapERenderer(ModelMixin, ConfigMixin):
-    @register_to_config
-    def __init__(
-        self,
-        *,
-        param_names: Tuple[str] = (
-            "nerstf.mlp.0.weight",
-            "nerstf.mlp.1.weight",
-            "nerstf.mlp.2.weight",
-            "nerstf.mlp.3.weight",
-        ),
-        param_shapes: Tuple[Tuple[int]] = (
-            (256, 93),
-            (256, 256),
-            (256, 256),
-            (256, 256),
-        ),
-        d_latent: int = 1024,
-        d_hidden: int = 256,
-        n_output: int = 12,
-        n_hidden_layers: int = 6,
-        act_fn: str = "swish",
-        insert_direction_at: int = 4,
-        background: Tuple[float] = (
-            255.0,
-            255.0,
-            255.0,
-        ),
-    ):
-        super().__init__()
-
-        self.params_proj = ShapEParamsProjModel(
-            param_names=param_names,
-            param_shapes=param_shapes,
-            d_latent=d_latent,
-        )
-        self.mlp = MLPNeRSTFModel(d_hidden, n_output, n_hidden_layers, act_fn, insert_direction_at)
-        self.void = VoidNeRFModel(background=background, channel_scale=255.0)
-        self.volume = BoundingBoxVolume(bbox_max=[1.0, 1.0, 1.0], bbox_min=[-1.0, -1.0, -1.0])
-        self.mesh_decoder = MeshDecoder()
-
-    @torch.no_grad()
-    def render_rays(self, rays, sampler, n_samples, prev_model_out=None, render_with_direction=False):
-        """
-        Perform volumetric rendering over a partition of possible t's in the union of rendering volumes (written below
-        with some abuse of notations)
-
-            C(r) := sum(
-                transmittance(t[i]) * integrate(
-                    lambda t: density(t) * channels(t) * transmittance(t), [t[i], t[i + 1]],
-                ) for i in range(len(parts))
-            ) + transmittance(t[-1]) * void_model(t[-1]).channels
-
-        where
-
-        1) transmittance(s) := exp(-integrate(density, [t[0], s])) calculates the probability of light passing through
-        the volume specified by [t[0], s]. (transmittance of 1 means light can pass freely) 2) density and channels are
-        obtained by evaluating the appropriate part.model at time t. 3) [t[i], t[i + 1]] is defined as the range of t
-        where the ray intersects (parts[i].volume \\ union(part.volume for part in parts[:i])) at the surface of the
-        shell (if bounded). If the ray does not intersect, the integral over this segment is evaluated as 0 and
-        transmittance(t[i + 1]) := transmittance(t[i]). 4) The last term is integration to infinity (e.g. [t[-1],
-        math.inf]) that is evaluated by the void_model (i.e. we consider this space to be empty).
-
-        args:
-            rays: [batch_size x ... x 2 x 3] origin and direction. sampler: disjoint volume integrals. n_samples:
-            number of ts to sample. prev_model_outputs: model outputs from the previous rendering step, including
-
-        :return: A tuple of
-            - `channels`
-            - A importance samplers for additional fine-grained rendering
-            - raw model output
-        """
-        origin, direction = rays[..., 0, :], rays[..., 1, :]
-
-        # Integrate over [t[i], t[i + 1]]
-
-        # 1 Intersect the rays with the current volume and sample ts to integrate along.
-        vrange = self.volume.intersect(origin, direction, t0_lower=None)
-        ts = sampler.sample(vrange.t0, vrange.t1, n_samples)
-        ts = ts.to(rays.dtype)
-
-        if prev_model_out is not None:
-            # Append the previous ts now before fprop because previous
-            # rendering used a different model and we can't reuse the output.
-            ts = torch.sort(torch.cat([ts, prev_model_out.ts], dim=-2), dim=-2).values
-
-        batch_size, *_shape, _t0_dim = vrange.t0.shape
-        _, *ts_shape, _ts_dim = ts.shape
-
-        # 2. Get the points along the ray and query the model
-        directions = torch.broadcast_to(direction.unsqueeze(-2), [batch_size, *ts_shape, 3])
-        positions = origin.unsqueeze(-2) + ts * directions
-
-        directions = directions.to(self.mlp.dtype)
-        positions = positions.to(self.mlp.dtype)
-
-        optional_directions = directions if render_with_direction else None
-
-        model_out = self.mlp(
-            position=positions,
-            direction=optional_directions,
-            ts=ts,
-            nerf_level="coarse" if prev_model_out is None else "fine",
-        )
-
-        # 3. Integrate the model results
-        channels, weights, transmittance = integrate_samples(
-            vrange, model_out.ts, model_out.density, model_out.channels
-        )
-
-        # 4. Clean up results that do not intersect with the volume.
-        transmittance = torch.where(vrange.intersected, transmittance, torch.ones_like(transmittance))
-        channels = torch.where(vrange.intersected, channels, torch.zeros_like(channels))
-        # 5. integration to infinity (e.g. [t[-1], math.inf]) that is evaluated by the void_model (i.e. we consider this space to be empty).
-        channels = channels + transmittance * self.void(origin)
-
-        weighted_sampler = ImportanceRaySampler(vrange, ts=model_out.ts, weights=weights)
-
-        return channels, weighted_sampler, model_out
-
-    @torch.no_grad()
-    def decode_to_image(
-        self,
-        latents,
-        device,
-        size: int = 64,
-        ray_batch_size: int = 4096,
-        n_coarse_samples=64,
-        n_fine_samples=128,
-    ):
-        # project the the paramters from the generated latents
-        projected_params = self.params_proj(latents)
-
-        # update the mlp layers of the renderer
-        for name, param in self.mlp.state_dict().items():
-            if f"nerstf.{name}" in projected_params.keys():
-                param.copy_(projected_params[f"nerstf.{name}"].squeeze(0))
-
-        # create cameras object
-        camera = create_pan_cameras(size)
-        rays = camera.camera_rays
-        rays = rays.to(device)
-        n_batches = rays.shape[1] // ray_batch_size
-
-        coarse_sampler = StratifiedRaySampler()
-
-        images = []
-
-        for idx in range(n_batches):
-            rays_batch = rays[:, idx * ray_batch_size : (idx + 1) * ray_batch_size]
-
-            # render rays with coarse, stratified samples.
-            _, fine_sampler, coarse_model_out = self.render_rays(rays_batch, coarse_sampler, n_coarse_samples)
-            # Then, render with additional importance-weighted ray samples.
-            channels, _, _ = self.render_rays(
-                rays_batch, fine_sampler, n_fine_samples, prev_model_out=coarse_model_out
-            )
-
-            images.append(channels)
-
-        images = torch.cat(images, dim=1)
-        images = images.view(*camera.shape, camera.height, camera.width, -1).squeeze(0)
-
-        return images
-
-    @torch.no_grad()
-    def decode_to_mesh(
-        self,
-        latents,
-        device,
-        grid_size: int = 128,
-        query_batch_size: int = 4096,
-        texture_channels: Tuple = ("R", "G", "B"),
-    ):
-        # 1. project the the paramters from the generated latents
-        projected_params = self.params_proj(latents)
-
-        # 2. update the mlp layers of the renderer
-        for name, param in self.mlp.state_dict().items():
-            if f"nerstf.{name}" in projected_params.keys():
-                param.copy_(projected_params[f"nerstf.{name}"].squeeze(0))
-
-        # 3. decoding with STF rendering
-        # 3.1 query the SDF values at vertices along a regular 128**3 grid
-
-        query_points = volume_query_points(self.volume, grid_size)
-        query_positions = query_points[None].repeat(1, 1, 1).to(device=device, dtype=self.mlp.dtype)
-
-        fields = []
-
-        for idx in range(0, query_positions.shape[1], query_batch_size):
-            query_batch = query_positions[:, idx : idx + query_batch_size]
-
-            model_out = self.mlp(
-                position=query_batch, direction=None, ts=None, nerf_level="fine", rendering_mode="stf"
-            )
-            fields.append(model_out.signed_distance)
-
-        # predicted SDF values
-        fields = torch.cat(fields, dim=1)
-        fields = fields.float()
-
-        assert (
-            len(fields.shape) == 3 and fields.shape[-1] == 1
-        ), f"expected [meta_batch x inner_batch] SDF results, but got {fields.shape}"
-
-        fields = fields.reshape(1, *([grid_size] * 3))
-
-        # create grid 128 x 128 x 128
-        # - force a negative border around the SDFs to close off all the models.
-        full_grid = torch.zeros(
-            1,
-            grid_size + 2,
-            grid_size + 2,
-            grid_size + 2,
-            device=fields.device,
-            dtype=fields.dtype,
-        )
-        full_grid.fill_(-1.0)
-        full_grid[:, 1:-1, 1:-1, 1:-1] = fields
-        fields = full_grid
-
-        # apply a differentiable implementation of Marching Cubes to construct meshs
-        raw_meshes = []
-        mesh_mask = []
-
-        for field in fields:
-            raw_mesh = self.mesh_decoder(field, self.volume.bbox_min, self.volume.bbox_max - self.volume.bbox_min)
-            mesh_mask.append(True)
-            raw_meshes.append(raw_mesh)
-
-        mesh_mask = torch.tensor(mesh_mask, device=fields.device)
-        max_vertices = max(len(m.verts) for m in raw_meshes)
-
-        # 3.2. query the texture color head at each vertex of the resulting mesh.
-        texture_query_positions = torch.stack(
-            [m.verts[torch.arange(0, max_vertices) % len(m.verts)] for m in raw_meshes],
-            dim=0,
-        )
-        texture_query_positions = texture_query_positions.to(device=device, dtype=self.mlp.dtype)
-
-        textures = []
-
-        for idx in range(0, texture_query_positions.shape[1], query_batch_size):
-            query_batch = texture_query_positions[:, idx : idx + query_batch_size]
-
-            texture_model_out = self.mlp(
-                position=query_batch, direction=None, ts=None, nerf_level="fine", rendering_mode="stf"
-            )
-            textures.append(texture_model_out.channels)
-
-        # predict texture color
-        textures = torch.cat(textures, dim=1)
-
-        textures = _convert_srgb_to_linear(textures)
-        textures = textures.float()
-
-        # 3.3 augument the mesh with texture data
-        assert len(textures.shape) == 3 and textures.shape[-1] == len(
-            texture_channels
-        ), f"expected [meta_batch x inner_batch x texture_channels] field results, but got {textures.shape}"
-
-        for m, texture in zip(raw_meshes, textures):
-            texture = texture[: len(m.verts)]
-            m.vertex_channels = dict(zip(texture_channels, texture.unbind(-1)))
-
-        return raw_meshes[0]

spaces/Andy1621/uniformer_image_detection/configs/foveabox/fovea_align_r101_fpn_gn-head_4x4_2x_coco.py

@@ -1,10 +0,0 @@
-_base_ = './fovea_r50_fpn_4x4_1x_coco.py'
-model = dict(
-    pretrained='torchvision://resnet101',
-    backbone=dict(depth=101),
-    bbox_head=dict(
-        with_deform=True,
-        norm_cfg=dict(type='GN', num_groups=32, requires_grad=True)))
-# learning policy
-lr_config = dict(step=[16, 22])
-runner = dict(type='EpochBasedRunner', max_epochs=24)

spaces/AnishKumbhar/ChatBot/text-generation-webui-main/extensions/ngrok/script.py

@@ -1,36 +0,0 @@
-# Adds ngrok ingress, to use add `--extension ngrok` to the command line options
-#
-# Parameters can be customized in settings.json of webui, e.g.:
-# {"ngrok": {"basic_auth":"user:password"} }
-# or
-# {"ngrok": {"oauth_provider":"google", "oauth_allow_emails":["[email protected]"]} }
-#
-# See this example for full list of options: https://github.com/ngrok/ngrok-py/blob/main/examples/ngrok-connect-full.py
-# or the README.md in this directory.
-
-import logging
-from modules import shared
-
-# Pick up host/port command line arguments
-host = shared.args.listen_host if shared.args.listen_host and shared.args.listen else '127.0.0.1'
-port = shared.args.listen_port if shared.args.listen_port else '7860'
-
-# Default options
-options = {
-    'addr': f"{host}:{port}",
-    'authtoken_from_env': True,
-    'session_metadata': 'text-generation-webui',
-}
-
-
-def ui():
-    settings = shared.settings.get("ngrok")
-    if settings:
-        options.update(settings)
-
-    try:
-        import ngrok
-        tunnel = ngrok.connect(**options)
-        logging.info(f"Ingress established at: {tunnel.url()}")
-    except ModuleNotFoundError:
-        logging.error("===> ngrok library not found, please run `pip install -r extensions/ngrok/requirements.txt`")

spaces/AnishKumbhar/ChatBot/text-generation-webui-main/modules/models.py

@@ -1,401 +0,0 @@
-import gc
-import os
-import re
-import time
-import traceback
-from pathlib import Path
-
-import torch
-import transformers
-from accelerate import infer_auto_device_map, init_empty_weights
-from transformers import (
-    AutoConfig,
-    AutoModel,
-    AutoModelForCausalLM,
-    AutoModelForSeq2SeqLM,
-    AutoTokenizer,
-    BitsAndBytesConfig,
-    GPTQConfig
-)
-
-import modules.shared as shared
-from modules import RoPE, llama_attn_hijack, sampler_hijack
-from modules.logging_colors import logger
-from modules.models_settings import get_model_metadata
-
-transformers.logging.set_verbosity_error()
-
-local_rank = None
-if shared.args.deepspeed:
-    import deepspeed
-    from transformers.deepspeed import (
-        HfDeepSpeedConfig,
-        is_deepspeed_zero3_enabled
-    )
-
-    from modules.deepspeed_parameters import generate_ds_config
-
-    # Distributed setup
-    local_rank = shared.args.local_rank if shared.args.local_rank is not None else int(os.getenv("LOCAL_RANK", "0"))
-    world_size = int(os.getenv("WORLD_SIZE", "1"))
-    torch.cuda.set_device(local_rank)
-    deepspeed.init_distributed()
-    ds_config = generate_ds_config(shared.args.bf16, 1 * world_size, shared.args.nvme_offload_dir)
-    dschf = HfDeepSpeedConfig(ds_config)  # Keep this object alive for the Transformers integration
-
-sampler_hijack.hijack_samplers()
-
-
-def load_model(model_name, loader=None):
-    logger.info(f"Loading {model_name}...")
-    t0 = time.time()
-
-    shared.is_seq2seq = False
-    load_func_map = {
-        'Transformers': huggingface_loader,
-        'AutoGPTQ': AutoGPTQ_loader,
-        'GPTQ-for-LLaMa': GPTQ_loader,
-        'llama.cpp': llamacpp_loader,
-        'llamacpp_HF': llamacpp_HF_loader,
-        'RWKV': RWKV_loader,
-        'ExLlama': ExLlama_loader,
-        'ExLlama_HF': ExLlama_HF_loader,
-        'ExLlamav2': ExLlamav2_loader,
-        'ExLlamav2_HF': ExLlamav2_HF_loader,
-        'ctransformers': ctransformers_loader,
-        'AutoAWQ': AutoAWQ_loader,
-    }
-
-    if loader is None:
-        if shared.args.loader is not None:
-            loader = shared.args.loader
-        else:
-            loader = get_model_metadata(model_name)['loader']
-            if loader is None:
-                logger.error('The path to the model does not exist. Exiting.')
-                return None, None
-
-    shared.args.loader = loader
-    output = load_func_map[loader](model_name)
-    if type(output) is tuple:
-        model, tokenizer = output
-    else:
-        model = output
-        if model is None:
-            return None, None
-        else:
-            tokenizer = load_tokenizer(model_name, model)
-
-    # Hijack attention with xformers
-    if any((shared.args.xformers, shared.args.sdp_attention)):
-        llama_attn_hijack.hijack_llama_attention()
-
-    logger.info(f"Loaded the model in {(time.time()-t0):.2f} seconds.\n")
-    return model, tokenizer
-
-
-def load_tokenizer(model_name, model):
-    tokenizer = None
-    path_to_model = Path(f"{shared.args.model_dir}/{model_name}/")
-    if any(s in model_name.lower() for s in ['gpt-4chan', 'gpt4chan']) and Path(f"{shared.args.model_dir}/gpt-j-6B/").exists():
-        tokenizer = AutoTokenizer.from_pretrained(Path(f"{shared.args.model_dir}/gpt-j-6B/"))
-    elif path_to_model.exists():
-        if shared.args.use_fast:
-            logger.info('Loading the tokenizer with use_fast=True.')
-
-        tokenizer = AutoTokenizer.from_pretrained(
-            path_to_model,
-            trust_remote_code=shared.args.trust_remote_code,
-            use_fast=shared.args.use_fast
-        )
-
-    return tokenizer
-
-
-def huggingface_loader(model_name):
-
-    path_to_model = Path(f'{shared.args.model_dir}/{model_name}')
-    params = {
-        'low_cpu_mem_usage': True,
-        'trust_remote_code': shared.args.trust_remote_code,
-        'torch_dtype': torch.bfloat16 if shared.args.bf16 else torch.float16
-    }
-    config = AutoConfig.from_pretrained(path_to_model, trust_remote_code=params['trust_remote_code'])
-
-    if 'chatglm' in model_name.lower():
-        LoaderClass = AutoModel
-    else:
-        if config.to_dict().get('is_encoder_decoder', False):
-            LoaderClass = AutoModelForSeq2SeqLM
-            shared.is_seq2seq = True
-        else:
-            LoaderClass = AutoModelForCausalLM
-
-    # Load the model in simple 16-bit mode by default
-    if not any([shared.args.cpu, shared.args.load_in_8bit, shared.args.load_in_4bit, shared.args.auto_devices, shared.args.disk, shared.args.deepspeed, shared.args.gpu_memory is not None, shared.args.cpu_memory is not None, shared.args.compress_pos_emb > 1, shared.args.alpha_value > 1, shared.args.disable_exllama]):
-        model = LoaderClass.from_pretrained(path_to_model, **params)
-        if torch.backends.mps.is_available():
-            device = torch.device('mps')
-            model = model.to(device)
-        else:
-            model = model.cuda()
-
-    # DeepSpeed ZeRO-3
-    elif shared.args.deepspeed:
-        model = LoaderClass.from_pretrained(path_to_model, torch_dtype=params['torch_dtype'])
-        model = deepspeed.initialize(model=model, config_params=ds_config, model_parameters=None, optimizer=None, lr_scheduler=None)[0]
-        model.module.eval()  # Inference
-        logger.info(f'DeepSpeed ZeRO-3 is enabled: {is_deepspeed_zero3_enabled()}')
-
-    # Load with quantization and/or offloading
-    else:
-        if not any((shared.args.cpu, torch.cuda.is_available(), torch.backends.mps.is_available())):
-            logger.warning('torch.cuda.is_available() returned False. This means that no GPU has been detected. Falling back to CPU mode.')
-            shared.args.cpu = True
-
-        if shared.args.cpu:
-            params['torch_dtype'] = torch.float32
-        else:
-            params['device_map'] = 'auto'
-            params['max_memory'] = get_max_memory_dict()
-            if shared.args.load_in_4bit:
-                # See https://github.com/huggingface/transformers/pull/23479/files
-                # and https://huggingface.co/blog/4bit-transformers-bitsandbytes
-                quantization_config_params = {
-                    'load_in_4bit': True,
-                    'bnb_4bit_compute_dtype': eval("torch.{}".format(shared.args.compute_dtype)) if shared.args.compute_dtype in ["bfloat16", "float16", "float32"] else None,
-                    'bnb_4bit_quant_type': shared.args.quant_type,
-                    'bnb_4bit_use_double_quant': shared.args.use_double_quant,
-                }
-
-                logger.info('Using the following 4-bit params: ' + str(quantization_config_params))
-                params['quantization_config'] = BitsAndBytesConfig(**quantization_config_params)
-
-            elif shared.args.load_in_8bit:
-                if any((shared.args.auto_devices, shared.args.gpu_memory)):
-                    params['quantization_config'] = BitsAndBytesConfig(load_in_8bit=True, llm_int8_enable_fp32_cpu_offload=True)
-                else:
-                    params['quantization_config'] = BitsAndBytesConfig(load_in_8bit=True)
-
-                if params['max_memory'] is not None:
-                    with init_empty_weights():
-                        model = LoaderClass.from_config(config, trust_remote_code=params['trust_remote_code'])
-
-                    model.tie_weights()
-                    params['device_map'] = infer_auto_device_map(
-                        model,
-                        dtype=torch.int8,
-                        max_memory=params['max_memory'],
-                        no_split_module_classes=model._no_split_modules
-                    )
-
-            if shared.args.disk:
-                params['offload_folder'] = shared.args.disk_cache_dir
-
-        if shared.args.disable_exllama:
-            try:
-                gptq_config = GPTQConfig(bits=config.quantization_config.get('bits', 4), disable_exllama=True)
-                params['quantization_config'] = gptq_config
-                logger.info('Loading with ExLlama kernel disabled.')
-            except:
-                exc = traceback.format_exc()
-                logger.error('Failed to disable exllama. Does the config.json for this model contain the necessary quantization info?')
-                print(exc)
-
-        if shared.args.compress_pos_emb > 1:
-            params['rope_scaling'] = {'type': 'linear', 'factor': shared.args.compress_pos_emb}
-        elif shared.args.alpha_value > 1:
-            params['rope_scaling'] = {'type': 'dynamic', 'factor': RoPE.get_alpha_value(shared.args.alpha_value, shared.args.rope_freq_base)}
-
-        model = LoaderClass.from_pretrained(path_to_model, **params)
-
-    return model
-
-
-def llamacpp_loader(model_name):
-    from modules.llamacpp_model import LlamaCppModel
-
-    path = Path(f'{shared.args.model_dir}/{model_name}')
-    if path.is_file():
-        model_file = path
-    else:
-        model_file = list(Path(f'{shared.args.model_dir}/{model_name}').glob('*.gguf'))[0]
-
-    logger.info(f"llama.cpp weights detected: {model_file}")
-    model, tokenizer = LlamaCppModel.from_pretrained(model_file)
-    return model, tokenizer
-
-
-def llamacpp_HF_loader(model_name):
-    from modules.llamacpp_hf import LlamacppHF
-
-    for fname in [model_name, "oobabooga_llama-tokenizer", "llama-tokenizer"]:
-        path = Path(f'{shared.args.model_dir}/{fname}')
-        if all((path / file).exists() for file in ['tokenizer_config.json', 'special_tokens_map.json', 'tokenizer.model']):
-            logger.info(f'Using tokenizer from: {path}')
-            break
-    else:
-        logger.error("Could not load the model because a tokenizer in transformers format was not found. Please download oobabooga/llama-tokenizer.")
-        return None, None
-
-    if shared.args.use_fast:
-        logger.info('Loading the tokenizer with use_fast=True.')
-
-    tokenizer = AutoTokenizer.from_pretrained(
-        path,
-        trust_remote_code=shared.args.trust_remote_code,
-        use_fast=shared.args.use_fast
-    )
-
-    model = LlamacppHF.from_pretrained(model_name)
-    return model, tokenizer
-
-
-def ctransformers_loader(model_name):
-    from modules.ctransformers_model import CtransformersModel
-
-    path = Path(f'{shared.args.model_dir}/{model_name}')
-    ctrans = CtransformersModel()
-    if ctrans.model_type_is_auto():
-        model_file = path
-    else:
-        if path.is_file():
-            model_file = path
-        else:
-            entries = Path(f'{shared.args.model_dir}/{model_name}')
-            gguf = list(entries.glob('*.gguf'))
-            bin = list(entries.glob('*.bin'))
-            if len(gguf) > 0:
-                model_file = gguf[0]
-            elif len(bin) > 0:
-                model_file = bin[0]
-            else:
-                logger.error("Could not find a model for ctransformers.")
-                return None, None
-
-    logger.info(f'ctransformers weights detected: {model_file}')
-    model, tokenizer = ctrans.from_pretrained(model_file)
-    return model, tokenizer
-
-def AutoAWQ_loader(model_name):
-   from awq import AutoAWQForCausalLM
-
-   model_dir = Path(f'{shared.args.model_dir}/{model_name}')
-
-   if shared.args.deepspeed:
-       logger.warn("AutoAWQ is incompatible with deepspeed")
-
-   model = AutoAWQForCausalLM.from_quantized(
-       quant_path=model_dir,
-       max_new_tokens=shared.args.max_seq_len,
-       trust_remote_code=shared.args.trust_remote_code,
-       fuse_layers=not shared.args.no_inject_fused_attention,
-       max_memory=get_max_memory_dict(),
-       batch_size=shared.args.n_batch,
-       safetensors=not shared.args.trust_remote_code)
-
-   return model
-
-def GPTQ_loader(model_name):
-
-    # Monkey patch
-    if shared.args.monkey_patch:
-        logger.warning("Applying the monkey patch for using LoRAs with GPTQ models. It may cause undefined behavior outside its intended scope.")
-        from modules.monkey_patch_gptq_lora import load_model_llama
-
-        model, _ = load_model_llama(model_name)
-
-    # No monkey patch
-    else:
-        import modules.GPTQ_loader
-
-        model = modules.GPTQ_loader.load_quantized(model_name)
-
-    return model
-
-
-def AutoGPTQ_loader(model_name):
-    import modules.AutoGPTQ_loader
-
-    return modules.AutoGPTQ_loader.load_quantized(model_name)
-
-
-def ExLlama_loader(model_name):
-    from modules.exllama import ExllamaModel
-
-    model, tokenizer = ExllamaModel.from_pretrained(model_name)
-    return model, tokenizer
-
-
-def ExLlama_HF_loader(model_name):
-    from modules.exllama_hf import ExllamaHF
-
-    return ExllamaHF.from_pretrained(model_name)
-
-
-def ExLlamav2_loader(model_name):
-    from modules.exllamav2 import Exllamav2Model
-
-    model, tokenizer = Exllamav2Model.from_pretrained(model_name)
-    return model, tokenizer
-
-
-def ExLlamav2_HF_loader(model_name):
-    from modules.exllamav2_hf import Exllamav2HF
-
-    return Exllamav2HF.from_pretrained(model_name)
-
-
-def RWKV_loader(model_name):
-    '''
-    This loader is not currently maintained as RWKV can now be loaded
-    through the transformers library.
-    '''
-    from modules.RWKV import RWKVModel, RWKVTokenizer
-
-    model = RWKVModel.from_pretrained(Path(f'{shared.args.model_dir}/{model_name}'), dtype="fp32" if shared.args.cpu else "bf16" if shared.args.bf16 else "fp16", device="cpu" if shared.args.cpu else "cuda")
-    tokenizer = RWKVTokenizer.from_pretrained(Path(shared.args.model_dir))
-    return model, tokenizer
-
-
-def get_max_memory_dict():
-    max_memory = {}
-    if shared.args.gpu_memory:
-        memory_map = list(map(lambda x: x.strip(), shared.args.gpu_memory))
-        for i in range(len(memory_map)):
-            max_memory[i] = f'{memory_map[i]}GiB' if not re.match('.*ib$', memory_map[i].lower()) else memory_map[i]
-
-        max_cpu_memory = shared.args.cpu_memory.strip() if shared.args.cpu_memory is not None else '99GiB'
-        max_memory['cpu'] = f'{max_cpu_memory}GiB' if not re.match('.*ib$', max_cpu_memory.lower()) else max_cpu_memory
-
-    # If --auto-devices is provided standalone, try to get a reasonable value
-    # for the maximum memory of device :0
-    elif shared.args.auto_devices:
-        total_mem = (torch.cuda.get_device_properties(0).total_memory / (1024 * 1024))
-        suggestion = round((total_mem - 1000) / 1000) * 1000
-        if total_mem - suggestion < 800:
-            suggestion -= 1000
-
-        suggestion = int(round(suggestion / 1000))
-        logger.warning(f"Auto-assiging --gpu-memory {suggestion} for your GPU to try to prevent out-of-memory errors. You can manually set other values.")
-        max_memory = {0: f'{suggestion}GiB', 'cpu': f'{shared.args.cpu_memory or 99}GiB'}
-
-    return max_memory if len(max_memory) > 0 else None
-
-
-def clear_torch_cache():
-    gc.collect()
-    if not shared.args.cpu:
-        torch.cuda.empty_cache()
-
-
-def unload_model():
-    shared.model = shared.tokenizer = None
-    shared.lora_names = []
-    shared.model_dirty_from_training = False
-    clear_torch_cache()
-
-
-def reload_model():
-    unload_model()
-    shared.model, shared.tokenizer = load_model(shared.model_name)

spaces/Anonymous-sub/Rerender/app.py

@@ -1,997 +0,0 @@
-import os
-import shutil
-from enum import Enum
-
-import cv2
-import einops
-import gradio as gr
-import numpy as np
-import torch
-import torch.nn.functional as F
-import torchvision.transforms as T
-from blendmodes.blend import BlendType, blendLayers
-from PIL import Image
-from pytorch_lightning import seed_everything
-from safetensors.torch import load_file
-from skimage import exposure
-
-import src.import_util  # noqa: F401
-from ControlNet.annotator.canny import CannyDetector
-from ControlNet.annotator.hed import HEDdetector
-from ControlNet.annotator.midas import MidasDetector
-from ControlNet.annotator.util import HWC3
-from ControlNet.cldm.model import create_model, load_state_dict
-from gmflow_module.gmflow.gmflow import GMFlow
-from flow.flow_utils import get_warped_and_mask
-from sd_model_cfg import model_dict
-from src.config import RerenderConfig
-from src.controller import AttentionControl
-from src.ddim_v_hacked import DDIMVSampler
-from src.img_util import find_flat_region, numpy2tensor
-from src.video_util import (frame_to_video, get_fps, get_frame_count,
-                            prepare_frames)
-
-import huggingface_hub
-
-REPO_NAME = 'Anonymous-sub/Rerender'
-
-huggingface_hub.hf_hub_download(REPO_NAME,
-                                'pexels-koolshooters-7322716.mp4',
-                                local_dir='videos')
-huggingface_hub.hf_hub_download(
-    REPO_NAME,
-    'pexels-antoni-shkraba-8048492-540x960-25fps.mp4',
-    local_dir='videos')
-huggingface_hub.hf_hub_download(
-    REPO_NAME,
-    'pexels-cottonbro-studio-6649832-960x506-25fps.mp4',
-    local_dir='videos')
-
-inversed_model_dict = dict()
-for k, v in model_dict.items():
-    inversed_model_dict[v] = k
-
-to_tensor = T.PILToTensor()
-blur = T.GaussianBlur(kernel_size=(9, 9), sigma=(18, 18))
-device = 'cuda' if torch.cuda.is_available() else 'cpu'
-
-
-class ProcessingState(Enum):
-    NULL = 0
-    FIRST_IMG = 1
-    KEY_IMGS = 2
-
-
-MAX_KEYFRAME = float(os.environ.get('MAX_KEYFRAME', 8))
-
-
-class GlobalState:
-
-    def __init__(self):
-        self.sd_model = None
-        self.ddim_v_sampler = None
-        self.detector_type = None
-        self.detector = None
-        self.controller = None
-        self.processing_state = ProcessingState.NULL
-        flow_model = GMFlow(
-            feature_channels=128,
-            num_scales=1,
-            upsample_factor=8,
-            num_head=1,
-            attention_type='swin',
-            ffn_dim_expansion=4,
-            num_transformer_layers=6,
-        ).to(device)
-
-        checkpoint = torch.load('models/gmflow_sintel-0c07dcb3.pth',
-                                map_location=lambda storage, loc: storage)
-        weights = checkpoint['model'] if 'model' in checkpoint else checkpoint
-        flow_model.load_state_dict(weights, strict=False)
-        flow_model.eval()
-        self.flow_model = flow_model
-
-    def update_controller(self, inner_strength, mask_period, cross_period,
-                          ada_period, warp_period):
-        self.controller = AttentionControl(inner_strength, mask_period,
-                                           cross_period, ada_period,
-                                           warp_period)
-
-    def update_sd_model(self, sd_model, control_type):
-        if sd_model == self.sd_model:
-            return
-        self.sd_model = sd_model
-        model = create_model('./ControlNet/models/cldm_v15.yaml').cpu()
-        if control_type == 'HED':
-            model.load_state_dict(
-                load_state_dict(huggingface_hub.hf_hub_download(
-                    'lllyasviel/ControlNet', './models/control_sd15_hed.pth'),
-                    location=device))
-        elif control_type == 'canny':
-            model.load_state_dict(
-                load_state_dict(huggingface_hub.hf_hub_download(
-                    'lllyasviel/ControlNet', 'models/control_sd15_canny.pth'),
-                    location=device))
-        elif control_type == 'depth':
-            model.load_state_dict(
-                load_state_dict(huggingface_hub.hf_hub_download(
-                    'lllyasviel/ControlNet', 'models/control_sd15_depth.pth'),
-                    location=device))
-
-        model.to(device)
-        sd_model_path = model_dict[sd_model]
-        if len(sd_model_path) > 0:
-            repo_name = REPO_NAME
-            # check if sd_model is repo_id/name otherwise use global REPO_NAME
-            if sd_model.count('/') == 1:
-                repo_name = sd_model
-
-            model_ext = os.path.splitext(sd_model_path)[1]
-            downloaded_model = huggingface_hub.hf_hub_download(
-                repo_name, sd_model_path)
-            if model_ext == '.safetensors':
-                model.load_state_dict(load_file(downloaded_model),
-                                      strict=False)
-            elif model_ext == '.ckpt' or model_ext == '.pth':
-                model.load_state_dict(
-                    torch.load(downloaded_model)['state_dict'], strict=False)
-
-        try:
-            model.first_stage_model.load_state_dict(torch.load(
-                huggingface_hub.hf_hub_download(
-                    'stabilityai/sd-vae-ft-mse-original',
-                    'vae-ft-mse-840000-ema-pruned.ckpt'))['state_dict'],
-                strict=False)
-        except Exception:
-            print('Warning: We suggest you download the fine-tuned VAE',
-                  'otherwise the generation quality will be degraded')
-
-        self.ddim_v_sampler = DDIMVSampler(model)
-
-    def clear_sd_model(self):
-        self.sd_model = None
-        self.ddim_v_sampler = None
-        if device == 'cuda':
-            torch.cuda.empty_cache()
-
-    def update_detector(self, control_type, canny_low=100, canny_high=200):
-        if self.detector_type == control_type:
-            return
-        if control_type == 'HED':
-            self.detector = HEDdetector()
-        elif control_type == 'canny':
-            canny_detector = CannyDetector()
-            low_threshold = canny_low
-            high_threshold = canny_high
-
-            def apply_canny(x):
-                return canny_detector(x, low_threshold, high_threshold)
-
-            self.detector = apply_canny
-
-        elif control_type == 'depth':
-            midas = MidasDetector()
-
-            def apply_midas(x):
-                detected_map, _ = midas(x)
-                return detected_map
-
-            self.detector = apply_midas
-
-
-global_state = GlobalState()
-global_video_path = None
-video_frame_count = None
-
-
-def create_cfg(input_path, prompt, image_resolution, control_strength,
-               color_preserve, left_crop, right_crop, top_crop, bottom_crop,
-               control_type, low_threshold, high_threshold, ddim_steps, scale,
-               seed, sd_model, a_prompt, n_prompt, interval, keyframe_count,
-               x0_strength, use_constraints, cross_start, cross_end,
-               style_update_freq, warp_start, warp_end, mask_start, mask_end,
-               ada_start, ada_end, mask_strength, inner_strength,
-               smooth_boundary):
-    use_warp = 'shape-aware fusion' in use_constraints
-    use_mask = 'pixel-aware fusion' in use_constraints
-    use_ada = 'color-aware AdaIN' in use_constraints
-
-    if not use_warp:
-        warp_start = 1
-        warp_end = 0
-
-    if not use_mask:
-        mask_start = 1
-        mask_end = 0
-
-    if not use_ada:
-        ada_start = 1
-        ada_end = 0
-
-    input_name = os.path.split(input_path)[-1].split('.')[0]
-    frame_count = 2 + keyframe_count * interval
-    cfg = RerenderConfig()
-    cfg.create_from_parameters(
-        input_path,
-        os.path.join('result', input_name, 'blend.mp4'),
-        prompt,
-        a_prompt=a_prompt,
-        n_prompt=n_prompt,
-        frame_count=frame_count,
-        interval=interval,
-        crop=[left_crop, right_crop, top_crop, bottom_crop],
-        sd_model=sd_model,
-        ddim_steps=ddim_steps,
-        scale=scale,
-        control_type=control_type,
-        control_strength=control_strength,
-        canny_low=low_threshold,
-        canny_high=high_threshold,
-        seed=seed,
-        image_resolution=image_resolution,
-        x0_strength=x0_strength,
-        style_update_freq=style_update_freq,
-        cross_period=(cross_start, cross_end),
-        warp_period=(warp_start, warp_end),
-        mask_period=(mask_start, mask_end),
-        ada_period=(ada_start, ada_end),
-        mask_strength=mask_strength,
-        inner_strength=inner_strength,
-        smooth_boundary=smooth_boundary,
-        color_preserve=color_preserve)
-    return cfg
-
-
-def cfg_to_input(filename):
-
-    cfg = RerenderConfig()
-    cfg.create_from_path(filename)
-    keyframe_count = (cfg.frame_count - 2) // cfg.interval
-    use_constraints = [
-        'shape-aware fusion', 'pixel-aware fusion', 'color-aware AdaIN'
-    ]
-
-    sd_model = inversed_model_dict.get(cfg.sd_model, 'Stable Diffusion 1.5')
-
-    args = [
-        cfg.input_path, cfg.prompt, cfg.image_resolution, cfg.control_strength,
-        cfg.color_preserve, *cfg.crop, cfg.control_type, cfg.canny_low,
-        cfg.canny_high, cfg.ddim_steps, cfg.scale, cfg.seed, sd_model,
-        cfg.a_prompt, cfg.n_prompt, cfg.interval, keyframe_count,
-        cfg.x0_strength, use_constraints, *cfg.cross_period,
-        cfg.style_update_freq, *cfg.warp_period, *cfg.mask_period,
-        *cfg.ada_period, cfg.mask_strength, cfg.inner_strength,
-        cfg.smooth_boundary
-    ]
-    return args
-
-
-def setup_color_correction(image):
-    correction_target = cv2.cvtColor(np.asarray(image.copy()),
-                                     cv2.COLOR_RGB2LAB)
-    return correction_target
-
-
-def apply_color_correction(correction, original_image):
-    image = Image.fromarray(
-        cv2.cvtColor(
-            exposure.match_histograms(cv2.cvtColor(np.asarray(original_image),
-                                                   cv2.COLOR_RGB2LAB),
-                                      correction,
-                                      channel_axis=2),
-            cv2.COLOR_LAB2RGB).astype('uint8'))
-
-    image = blendLayers(image, original_image, BlendType.LUMINOSITY)
-
-    return image
-
-
-@torch.no_grad()
-def process(*args):
-    first_frame = process1(*args)
-
-    keypath = process2(*args)
-
-    return first_frame, keypath
-
-
-@torch.no_grad()
-def process0(*args):
-    global global_video_path
-    global_video_path = args[0]
-    return process(*args[1:])
-
-
-@torch.no_grad()
-def process1(*args):
-
-    global global_video_path
-    cfg = create_cfg(global_video_path, *args)
-    global global_state
-    global_state.update_sd_model(cfg.sd_model, cfg.control_type)
-    global_state.update_controller(cfg.inner_strength, cfg.mask_period,
-                                   cfg.cross_period, cfg.ada_period,
-                                   cfg.warp_period)
-    global_state.update_detector(cfg.control_type, cfg.canny_low,
-                                 cfg.canny_high)
-    global_state.processing_state = ProcessingState.FIRST_IMG
-
-    prepare_frames(cfg.input_path, cfg.input_dir, cfg.image_resolution,
-                   cfg.crop)
-
-    ddim_v_sampler = global_state.ddim_v_sampler
-    model = ddim_v_sampler.model
-    detector = global_state.detector
-    controller = global_state.controller
-    model.control_scales = [cfg.control_strength] * 13
-    model.to(device)
-
-    num_samples = 1
-    eta = 0.0
-    imgs = sorted(os.listdir(cfg.input_dir))
-    imgs = [os.path.join(cfg.input_dir, img) for img in imgs]
-
-    model.cond_stage_model.device = device
-
-    with torch.no_grad():
-        frame = cv2.imread(imgs[0])
-        frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
-        img = HWC3(frame)
-        H, W, C = img.shape
-
-        img_ = numpy2tensor(img)
-
-        def generate_first_img(img_, strength):
-            encoder_posterior = model.encode_first_stage(img_.to(device))
-            x0 = model.get_first_stage_encoding(encoder_posterior).detach()
-
-            detected_map = detector(img)
-            detected_map = HWC3(detected_map)
-
-            control = torch.from_numpy(
-                detected_map.copy()).float().to(device) / 255.0
-            control = torch.stack([control for _ in range(num_samples)], dim=0)
-            control = einops.rearrange(control, 'b h w c -> b c h w').clone()
-            cond = {
-                'c_concat': [control],
-                'c_crossattn': [
-                    model.get_learned_conditioning(
-                        [cfg.prompt + ', ' + cfg.a_prompt] * num_samples)
-                ]
-            }
-            un_cond = {
-                'c_concat': [control],
-                'c_crossattn':
-                [model.get_learned_conditioning([cfg.n_prompt] * num_samples)]
-            }
-            shape = (4, H // 8, W // 8)
-
-            controller.set_task('initfirst')
-            seed_everything(cfg.seed)
-
-            samples, _ = ddim_v_sampler.sample(
-                cfg.ddim_steps,
-                num_samples,
-                shape,
-                cond,
-                verbose=False,
-                eta=eta,
-                unconditional_guidance_scale=cfg.scale,
-                unconditional_conditioning=un_cond,
-                controller=controller,
-                x0=x0,
-                strength=strength)
-            x_samples = model.decode_first_stage(samples)
-            x_samples_np = (
-                einops.rearrange(x_samples, 'b c h w -> b h w c') * 127.5 +
-                127.5).cpu().numpy().clip(0, 255).astype(np.uint8)
-            return x_samples, x_samples_np
-
-        # When not preserve color, draw a different frame at first and use its
-        # color to redraw the first frame.
-        if not cfg.color_preserve:
-            first_strength = -1
-        else:
-            first_strength = 1 - cfg.x0_strength
-
-        x_samples, x_samples_np = generate_first_img(img_, first_strength)
-
-        if not cfg.color_preserve:
-            color_corrections = setup_color_correction(
-                Image.fromarray(x_samples_np[0]))
-            global_state.color_corrections = color_corrections
-            img_ = apply_color_correction(color_corrections,
-                                          Image.fromarray(img))
-            img_ = to_tensor(img_).unsqueeze(0)[:, :3] / 127.5 - 1
-            x_samples, x_samples_np = generate_first_img(
-                img_, 1 - cfg.x0_strength)
-
-        global_state.first_result = x_samples
-        global_state.first_img = img
-
-    Image.fromarray(x_samples_np[0]).save(
-        os.path.join(cfg.first_dir, 'first.jpg'))
-
-    return x_samples_np[0]
-
-
-@torch.no_grad()
-def process2(*args):
-    global global_state
-    global global_video_path
-
-    if global_state.processing_state != ProcessingState.FIRST_IMG:
-        raise gr.Error('Please generate the first key image before generating'
-                       ' all key images')
-
-    cfg = create_cfg(global_video_path, *args)
-    global_state.update_sd_model(cfg.sd_model, cfg.control_type)
-    global_state.update_detector(cfg.control_type, cfg.canny_low,
-                                 cfg.canny_high)
-    global_state.processing_state = ProcessingState.KEY_IMGS
-
-    # reset key dir
-    shutil.rmtree(cfg.key_dir)
-    os.makedirs(cfg.key_dir, exist_ok=True)
-
-    ddim_v_sampler = global_state.ddim_v_sampler
-    model = ddim_v_sampler.model
-    detector = global_state.detector
-    controller = global_state.controller
-    flow_model = global_state.flow_model
-    model.control_scales = [cfg.control_strength] * 13
-
-    num_samples = 1
-    eta = 0.0
-    firstx0 = True
-    pixelfusion = cfg.use_mask
-    imgs = sorted(os.listdir(cfg.input_dir))
-    imgs = [os.path.join(cfg.input_dir, img) for img in imgs]
-
-    first_result = global_state.first_result
-    first_img = global_state.first_img
-    pre_result = first_result
-    pre_img = first_img
-
-    for i in range(0, cfg.frame_count - 1, cfg.interval):
-        cid = i + 1
-        frame = cv2.imread(imgs[i + 1])
-        print(cid)
-        frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
-        img = HWC3(frame)
-        H, W, C = img.shape
-
-        if cfg.color_preserve or global_state.color_corrections is None:
-            img_ = numpy2tensor(img)
-        else:
-            img_ = apply_color_correction(global_state.color_corrections,
-                                          Image.fromarray(img))
-            img_ = to_tensor(img_).unsqueeze(0)[:, :3] / 127.5 - 1
-        encoder_posterior = model.encode_first_stage(img_.to(device))
-        x0 = model.get_first_stage_encoding(encoder_posterior).detach()
-
-        detected_map = detector(img)
-        detected_map = HWC3(detected_map)
-
-        control = torch.from_numpy(
-            detected_map.copy()).float().to(device) / 255.0
-        control = torch.stack([control for _ in range(num_samples)], dim=0)
-        control = einops.rearrange(control, 'b h w c -> b c h w').clone()
-        cond = {
-            'c_concat': [control],
-            'c_crossattn': [
-                model.get_learned_conditioning(
-                    [cfg.prompt + ', ' + cfg.a_prompt] * num_samples)
-            ]
-        }
-        un_cond = {
-            'c_concat': [control],
-            'c_crossattn':
-            [model.get_learned_conditioning([cfg.n_prompt] * num_samples)]
-        }
-        shape = (4, H // 8, W // 8)
-
-        cond['c_concat'] = [control]
-        un_cond['c_concat'] = [control]
-
-        image1 = torch.from_numpy(pre_img).permute(2, 0, 1).float()
-        image2 = torch.from_numpy(img).permute(2, 0, 1).float()
-        warped_pre, bwd_occ_pre, bwd_flow_pre = get_warped_and_mask(
-            flow_model, image1, image2, pre_result, False)
-        blend_mask_pre = blur(
-            F.max_pool2d(bwd_occ_pre, kernel_size=9, stride=1, padding=4))
-        blend_mask_pre = torch.clamp(blend_mask_pre + bwd_occ_pre, 0, 1)
-
-        image1 = torch.from_numpy(first_img).permute(2, 0, 1).float()
-        warped_0, bwd_occ_0, bwd_flow_0 = get_warped_and_mask(
-            flow_model, image1, image2, first_result, False)
-        blend_mask_0 = blur(
-            F.max_pool2d(bwd_occ_0, kernel_size=9, stride=1, padding=4))
-        blend_mask_0 = torch.clamp(blend_mask_0 + bwd_occ_0, 0, 1)
-
-        if firstx0:
-            mask = 1 - F.max_pool2d(blend_mask_0, kernel_size=8)
-            controller.set_warp(
-                F.interpolate(bwd_flow_0 / 8.0,
-                              scale_factor=1. / 8,
-                              mode='bilinear'), mask)
-        else:
-            mask = 1 - F.max_pool2d(blend_mask_pre, kernel_size=8)
-            controller.set_warp(
-                F.interpolate(bwd_flow_pre / 8.0,
-                              scale_factor=1. / 8,
-                              mode='bilinear'), mask)
-
-        controller.set_task('keepx0, keepstyle')
-        seed_everything(cfg.seed)
-        samples, intermediates = ddim_v_sampler.sample(
-            cfg.ddim_steps,
-            num_samples,
-            shape,
-            cond,
-            verbose=False,
-            eta=eta,
-            unconditional_guidance_scale=cfg.scale,
-            unconditional_conditioning=un_cond,
-            controller=controller,
-            x0=x0,
-            strength=1 - cfg.x0_strength)
-        direct_result = model.decode_first_stage(samples)
-
-        if not pixelfusion:
-            pre_result = direct_result
-            pre_img = img
-            viz = (
-                einops.rearrange(direct_result, 'b c h w -> b h w c') * 127.5 +
-                127.5).cpu().numpy().clip(0, 255).astype(np.uint8)
-
-        else:
-
-            blend_results = (1 - blend_mask_pre
-                             ) * warped_pre + blend_mask_pre * direct_result
-            blend_results = (
-                1 - blend_mask_0) * warped_0 + blend_mask_0 * blend_results
-
-            bwd_occ = 1 - torch.clamp(1 - bwd_occ_pre + 1 - bwd_occ_0, 0, 1)
-            blend_mask = blur(
-                F.max_pool2d(bwd_occ, kernel_size=9, stride=1, padding=4))
-            blend_mask = 1 - torch.clamp(blend_mask + bwd_occ, 0, 1)
-
-            encoder_posterior = model.encode_first_stage(blend_results)
-            xtrg = model.get_first_stage_encoding(
-                encoder_posterior).detach()  # * mask
-            blend_results_rec = model.decode_first_stage(xtrg)
-            encoder_posterior = model.encode_first_stage(blend_results_rec)
-            xtrg_rec = model.get_first_stage_encoding(
-                encoder_posterior).detach()
-            xtrg_ = (xtrg + 1 * (xtrg - xtrg_rec))  # * mask
-            blend_results_rec_new = model.decode_first_stage(xtrg_)
-            tmp = (abs(blend_results_rec_new - blend_results).mean(
-                dim=1, keepdims=True) > 0.25).float()
-            mask_x = F.max_pool2d((F.interpolate(tmp,
-                                                 scale_factor=1 / 8.,
-                                                 mode='bilinear') > 0).float(),
-                                  kernel_size=3,
-                                  stride=1,
-                                  padding=1)
-
-            mask = (1 - F.max_pool2d(1 - blend_mask, kernel_size=8)
-                    )  # * (1-mask_x)
-
-            if cfg.smooth_boundary:
-                noise_rescale = find_flat_region(mask)
-            else:
-                noise_rescale = torch.ones_like(mask)
-            masks = []
-            for i in range(cfg.ddim_steps):
-                if i <= cfg.ddim_steps * cfg.mask_period[
-                        0] or i >= cfg.ddim_steps * cfg.mask_period[1]:
-                    masks += [None]
-                else:
-                    masks += [mask * cfg.mask_strength]
-
-            # mask 3
-            # xtrg = ((1-mask_x) *
-            #         (xtrg + xtrg - xtrg_rec) + mask_x * samples) * mask
-            # mask 2
-            # xtrg = (xtrg + 1 * (xtrg - xtrg_rec)) * mask
-            xtrg = (xtrg + (1 - mask_x) * (xtrg - xtrg_rec)) * mask  # mask 1
-
-            tasks = 'keepstyle, keepx0'
-            if not firstx0:
-                tasks += ', updatex0'
-            if i % cfg.style_update_freq == 0:
-                tasks += ', updatestyle'
-            controller.set_task(tasks, 1.0)
-
-            seed_everything(cfg.seed)
-            samples, _ = ddim_v_sampler.sample(
-                cfg.ddim_steps,
-                num_samples,
-                shape,
-                cond,
-                verbose=False,
-                eta=eta,
-                unconditional_guidance_scale=cfg.scale,
-                unconditional_conditioning=un_cond,
-                controller=controller,
-                x0=x0,
-                strength=1 - cfg.x0_strength,
-                xtrg=xtrg,
-                mask=masks,
-                noise_rescale=noise_rescale)
-            x_samples = model.decode_first_stage(samples)
-            pre_result = x_samples
-            pre_img = img
-
-            viz = (einops.rearrange(x_samples, 'b c h w -> b h w c') * 127.5 +
-                   127.5).cpu().numpy().clip(0, 255).astype(np.uint8)
-
-        Image.fromarray(viz[0]).save(
-            os.path.join(cfg.key_dir, f'{cid:04d}.png'))
-
-    key_video_path = os.path.join(cfg.work_dir, 'key.mp4')
-    fps = get_fps(cfg.input_path)
-    fps //= cfg.interval
-    frame_to_video(key_video_path, cfg.key_dir, fps, False)
-
-    return key_video_path
-
-
-DESCRIPTION = '''
-## [Rerender A Video](https://github.com/williamyang1991/Rerender_A_Video)
-### This space provides the function of key frame translation. Full code for full video translation will be released upon the publication of the paper.
-### To avoid overload, we set limitations to the **maximum frame number** (8) and the maximum frame resolution (512x768). 
-### The running time of a video of size 512x640 is about 1 minute per keyframe under T4 GPU.
-### How to use:
-1. **Run 1st Key Frame**: only translate the first frame, so you can adjust the prompts/models/parameters to find your ideal output appearance before run the whole video.
-2. **Run Key Frames**: translate all the key frames based on the settings of the first frame
-3. **Run All**: **Run 1st Key Frame** and **Run Key Frames**
-4. **Run Propagation**: propogate the key frames to other frames for full video translation. This function is supported [here](https://github.com/williamyang1991/Rerender_A_Video#webui-recommended)
-### Tips: 
-1. This method cannot handle large or quick motions where the optical flow is hard to estimate. **Videos with stable motions are preferred**.
-2. Pixel-aware fusion may not work for large or quick motions.
-3. Try different color-aware AdaIN settings and even unuse it to avoid color jittering.
-4. `revAnimated_v11` model for non-photorealstic style, `realisticVisionV20_v20` model for photorealstic style.
-5. To use your own SD/LoRA model, you may clone the space and specify your model with [sd_model_cfg.py](https://huggingface.co/spaces/Anonymous-sub/Rerender/blob/main/sd_model_cfg.py).
-6. This method is based on the original SD model. You may need to [convert](https://github.com/huggingface/diffusers/blob/main/scripts/convert_diffusers_to_original_stable_diffusion.py) Diffuser/Automatic1111 models to the original one. 
-
-**This code is for research purpose and non-commercial use only.**
-
-[![Duplicate this Space](https://huggingface.co/datasets/huggingface/badges/raw/main/duplicate-this-space-sm-dark.svg)](https://huggingface.co/spaces/Anonymous-sub/Rerender?duplicate=true) for no queue on your own hardware.
-'''
-
-
-ARTICLE = r"""
-If Rerender-A-Video is helpful, please help to ⭐ the <a href='https://github.com/williamyang1991/Rerender_A_Video' target='_blank'>Github Repo</a>. Thanks! 
-[![GitHub Stars](https://img.shields.io/github/stars/williamyang1991/Rerender_A_Video?style=social)](https://github.com/williamyang1991/Rerender_A_Video)
----
-📝 **Citation**
-If our work is useful for your research, please consider citing:
-```bibtex
-@inproceedings{yang2023rerender,
- title = {Rerender A Video: Zero-Shot Text-Guided Video-to-Video Translation},
- author = {Yang, Shuai and Zhou, Yifan and Liu, Ziwei and and Loy, Chen Change},
-  booktitle = {ACM SIGGRAPH Asia Conference Proceedings},
- year = {2023},
-}
-```
-📋 **License**
-This project is licensed under <a rel="license" href="https://github.com/williamyang1991/Rerender_A_Video/blob/main/LICENSE.md">S-Lab License 1.0</a>. 
-Redistribution and use for non-commercial purposes should follow this license.
-
-📧 **Contact**
-If you have any questions, please feel free to reach me out at <b>[email protected]</b>.
-"""
-
-FOOTER = '<div align=center><img id="visitor-badge" alt="visitor badge" src="https://visitor-badge.laobi.icu/badge?page_id=williamyang1991/Rerender_A_Video" /></div>'
-
-
-block = gr.Blocks().queue()
-with block:
-    with gr.Row():
-        gr.Markdown(DESCRIPTION)
-    with gr.Row():
-        with gr.Column():
-            input_path = gr.Video(label='Input Video',
-                                  source='upload',
-                                  format='mp4',
-                                  visible=True)
-            prompt = gr.Textbox(label='Prompt')
-            seed = gr.Slider(label='Seed',
-                             minimum=0,
-                             maximum=2147483647,
-                             step=1,
-                             value=0,
-                             randomize=True)
-            run_button = gr.Button(value='Run All')
-            with gr.Row():
-                run_button1 = gr.Button(value='Run 1st Key Frame')
-                run_button2 = gr.Button(value='Run Key Frames')
-                run_button3 = gr.Button(value='Run Propagation')
-            with gr.Accordion('Advanced options for the 1st frame translation',
-                              open=False):
-                image_resolution = gr.Slider(
-                    label='Frame rsolution',
-                    minimum=256,
-                    maximum=512,
-                    value=512,
-                    step=64,
-                    info='To avoid overload, maximum 512')
-                control_strength = gr.Slider(label='ControNet strength',
-                                             minimum=0.0,
-                                             maximum=2.0,
-                                             value=1.0,
-                                             step=0.01)
-                x0_strength = gr.Slider(
-                    label='Denoising strength',
-                    minimum=0.00,
-                    maximum=1.05,
-                    value=0.75,
-                    step=0.05,
-                    info=('0: fully recover the input.'
-                          '1.05: fully rerender the input.'))
-                color_preserve = gr.Checkbox(
-                    label='Preserve color',
-                    value=True,
-                    info='Keep the color of the input video')
-                with gr.Row():
-                    left_crop = gr.Slider(label='Left crop length',
-                                          minimum=0,
-                                          maximum=512,
-                                          value=0,
-                                          step=1)
-                    right_crop = gr.Slider(label='Right crop length',
-                                           minimum=0,
-                                           maximum=512,
-                                           value=0,
-                                           step=1)
-                with gr.Row():
-                    top_crop = gr.Slider(label='Top crop length',
-                                         minimum=0,
-                                         maximum=512,
-                                         value=0,
-                                         step=1)
-                    bottom_crop = gr.Slider(label='Bottom crop length',
-                                            minimum=0,
-                                            maximum=512,
-                                            value=0,
-                                            step=1)
-                with gr.Row():
-                    control_type = gr.Dropdown(['HED', 'canny', 'depth'],
-                                               label='Control type',
-                                               value='HED')
-                    low_threshold = gr.Slider(label='Canny low threshold',
-                                              minimum=1,
-                                              maximum=255,
-                                              value=100,
-                                              step=1)
-                    high_threshold = gr.Slider(label='Canny high threshold',
-                                               minimum=1,
-                                               maximum=255,
-                                               value=200,
-                                               step=1)
-                ddim_steps = gr.Slider(label='Steps',
-                                       minimum=1,
-                                       maximum=20,
-                                       value=20,
-                                       step=1,
-                                       info='To avoid overload, maximum 20')
-                scale = gr.Slider(label='CFG scale',
-                                  minimum=0.1,
-                                  maximum=30.0,
-                                  value=7.5,
-                                  step=0.1)
-                sd_model_list = list(model_dict.keys())
-                sd_model = gr.Dropdown(sd_model_list,
-                                       label='Base model',
-                                       value='Stable Diffusion 1.5')
-                a_prompt = gr.Textbox(label='Added prompt',
-                                      value='best quality, extremely detailed')
-                n_prompt = gr.Textbox(
-                    label='Negative prompt',
-                    value=('longbody, lowres, bad anatomy, bad hands, '
-                           'missing fingers, extra digit, fewer digits, '
-                           'cropped, worst quality, low quality'))
-            with gr.Accordion('Advanced options for the key fame translation',
-                              open=False):
-                interval = gr.Slider(
-                    label='Key frame frequency (K)',
-                    minimum=1,
-                    maximum=MAX_KEYFRAME,
-                    value=1,
-                    step=1,
-                    info='Uniformly sample the key frames every K frames')
-                keyframe_count = gr.Slider(
-                    label='Number of key frames',
-                    minimum=1,
-                    maximum=MAX_KEYFRAME,
-                    value=1,
-                    step=1,
-                    info='To avoid overload, maximum 8 key frames')
-
-                use_constraints = gr.CheckboxGroup(
-                    [
-                        'shape-aware fusion', 'pixel-aware fusion',
-                        'color-aware AdaIN'
-                    ],
-                    label='Select the cross-frame contraints to be used',
-                    value=[
-                        'shape-aware fusion', 'pixel-aware fusion',
-                        'color-aware AdaIN'
-                    ]),
-                with gr.Row():
-                    cross_start = gr.Slider(
-                        label='Cross-frame attention start',
-                        minimum=0,
-                        maximum=1,
-                        value=0,
-                        step=0.05)
-                    cross_end = gr.Slider(label='Cross-frame attention end',
-                                          minimum=0,
-                                          maximum=1,
-                                          value=1,
-                                          step=0.05)
-                style_update_freq = gr.Slider(
-                    label='Cross-frame attention update frequency',
-                    minimum=1,
-                    maximum=100,
-                    value=1,
-                    step=1,
-                    info=('Update the key and value for '
-                          'cross-frame attention every N key frames (recommend N*K>=10)'
-                          ))
-                with gr.Row():
-                    warp_start = gr.Slider(label='Shape-aware fusion start',
-                                           minimum=0,
-                                           maximum=1,
-                                           value=0,
-                                           step=0.05)
-                    warp_end = gr.Slider(label='Shape-aware fusion end',
-                                         minimum=0,
-                                         maximum=1,
-                                         value=0.1,
-                                         step=0.05)
-                with gr.Row():
-                    mask_start = gr.Slider(label='Pixel-aware fusion start',
-                                           minimum=0,
-                                           maximum=1,
-                                           value=0.5,
-                                           step=0.05)
-                    mask_end = gr.Slider(label='Pixel-aware fusion end',
-                                         minimum=0,
-                                         maximum=1,
-                                         value=0.8,
-                                         step=0.05)
-                with gr.Row():
-                    ada_start = gr.Slider(label='Color-aware AdaIN start',
-                                          minimum=0,
-                                          maximum=1,
-                                          value=0.8,
-                                          step=0.05)
-                    ada_end = gr.Slider(label='Color-aware AdaIN end',
-                                        minimum=0,
-                                        maximum=1,
-                                        value=1,
-                                        step=0.05)
-                mask_strength = gr.Slider(label='Pixel-aware fusion stength',
-                                          minimum=0,
-                                          maximum=1,
-                                          value=0.5,
-                                          step=0.01)
-                inner_strength = gr.Slider(
-                    label='Pixel-aware fusion detail level',
-                    minimum=0.5,
-                    maximum=1,
-                    value=0.9,
-                    step=0.01,
-                    info='Use a low value to prevent artifacts')
-                smooth_boundary = gr.Checkbox(
-                    label='Smooth fusion boundary',
-                    value=True,
-                    info='Select to prevent artifacts at boundary')
-
-            with gr.Accordion('Example configs', open=True):
-                config_dir = 'config'
-                config_list = os.listdir(config_dir)
-                args_list = []
-                for config in config_list:
-                    try:
-                        config_path = os.path.join(config_dir, config)
-                        args = cfg_to_input(config_path)
-                        args_list.append(args)
-                    except FileNotFoundError:
-                        # The video file does not exist, skipped
-                        pass
-
-                ips = [
-                    prompt, image_resolution, control_strength, color_preserve,
-                    left_crop, right_crop, top_crop, bottom_crop, control_type,
-                    low_threshold, high_threshold, ddim_steps, scale, seed,
-                    sd_model, a_prompt, n_prompt, interval, keyframe_count,
-                    x0_strength, use_constraints[0], cross_start, cross_end,
-                    style_update_freq, warp_start, warp_end, mask_start,
-                    mask_end, ada_start, ada_end, mask_strength,
-                    inner_strength, smooth_boundary
-                ]
-
-        with gr.Column():
-            result_image = gr.Image(label='Output first frame',
-                                    type='numpy',
-                                    interactive=False)
-            result_keyframe = gr.Video(label='Output key frame video',
-                                       format='mp4',
-                                       interactive=False)
-    with gr.Row():
-        gr.Examples(examples=args_list,
-                    inputs=[input_path, *ips],
-                    fn=process0,
-                    outputs=[result_image, result_keyframe],
-                    cache_examples=True)
-
-    gr.Markdown(ARTICLE)
-    gr.Markdown(FOOTER)
-
-    def input_uploaded(path):
-        frame_count = get_frame_count(path)
-        if frame_count <= 2:
-            raise gr.Error('The input video is too short!'
-                           'Please input another video.')
-
-        default_interval = min(10, frame_count - 2)
-        max_keyframe = min((frame_count - 2) // default_interval, MAX_KEYFRAME)
-
-        global video_frame_count
-        video_frame_count = frame_count
-        global global_video_path
-        global_video_path = path
-
-        return gr.Slider.update(value=default_interval,
-                                maximum=frame_count - 2), gr.Slider.update(
-                                    value=max_keyframe, maximum=max_keyframe)
-
-    def input_changed(path):
-        frame_count = get_frame_count(path)
-        if frame_count <= 2:
-            return gr.Slider.update(maximum=1), gr.Slider.update(maximum=1)
-
-        default_interval = min(10, frame_count - 2)
-        max_keyframe = min((frame_count - 2) // default_interval, MAX_KEYFRAME)
-
-        global video_frame_count
-        video_frame_count = frame_count
-        global global_video_path
-        global_video_path = path
-
-        return gr.Slider.update(value=default_interval,
-                                maximum=frame_count - 2), \
-            gr.Slider.update(maximum=max_keyframe)
-
-    def interval_changed(interval):
-        global video_frame_count
-        if video_frame_count is None:
-            return gr.Slider.update()
-
-        max_keyframe = min((video_frame_count - 2) // interval, MAX_KEYFRAME)
-
-        return gr.Slider.update(value=max_keyframe, maximum=max_keyframe)
-
-    input_path.change(input_changed, input_path, [interval, keyframe_count])
-    input_path.upload(input_uploaded, input_path, [interval, keyframe_count])
-    interval.change(interval_changed, interval, keyframe_count)
-
-    run_button.click(fn=process,
-                     inputs=ips,
-                     outputs=[result_image, result_keyframe])
-    run_button1.click(fn=process1, inputs=ips, outputs=[result_image])
-    run_button2.click(fn=process2, inputs=ips, outputs=[result_keyframe])
-
-    def process3():
-        raise gr.Error(
-            "Coming Soon. Full code for full video translation will be "
-            "released upon the publication of the paper.")
-
-    run_button3.click(fn=process3, outputs=[result_keyframe])
-
-block.queue(concurrency_count=1, max_size=20)
-block.launch(server_name='0.0.0.0')

spaces/Anonymous-sub/Rerender/gmflow_module/scripts/submission.sh

@@ -1,67 +0,0 @@
-#!/usr/bin/env bash
-
-
-# generate prediction results for submission on sintel and kitti online servers
-
-
-# GMFlow without refinement
-
-# submission to sintel
-CUDA_VISIBLE_DEVICES=0 python main.py \
---submission \
---output_path submission/sintel-gmflow-norefine \
---val_dataset sintel \
---resume pretrained/gmflow_sintel-0c07dcb3.pth
-
-# submission to kitti
-CUDA_VISIBLE_DEVICES=0 python main.py \
---submission \
---output_path submission/kitti-gmflow-norefine \
---val_dataset kitti \
---resume pretrained/gmflow_kitti-285701a8.pth
-
-
-# you can also visualize the predictions before submission
-# CUDA_VISIBLE_DEVICES=0 python main.py \
-# --submission \
-# --output_path submission/sintel-gmflow-norefine-vis \
-# --save_vis_flow \
-# --no_save_flo \
-# --val_dataset sintel \
-# --resume pretrained/gmflow_sintel.pth
-
-
-
-
-# GMFlow with refinement
-
-# submission to sintel
-CUDA_VISIBLE_DEVICES=0 python main.py \
---submission \
---output_path submission/sintel-gmflow-withrefine \
---val_dataset sintel \
---resume pretrained/gmflow_with_refine_sintel-3ed1cf48.pth \
---padding_factor 32 \
---upsample_factor 4 \
---num_scales 2 \
---attn_splits_list 2 8 \
---corr_radius_list -1 4 \
---prop_radius_list -1 1
-
-# submission to kitti
-CUDA_VISIBLE_DEVICES=0 python main.py \
---submission \
---output_path submission/kitti-gmflow-withrefine \
---val_dataset kitti \
---resume pretrained/gmflow_with_refine_kitti-8d3b9786.pth \
---padding_factor 32 \
---upsample_factor 4 \
---num_scales 2 \
---attn_splits_list 2 8 \
---corr_radius_list -1 4 \
---prop_radius_list -1 1
-
-
-
-
-

spaces/Ariharasudhan/YoloV5/utils/loggers/wandb/README.md

@@ -1,162 +0,0 @@
-📚 This guide explains how to use **Weights & Biases** (W&B) with YOLOv5 🚀. UPDATED 29 September 2021.
-
-- [About Weights & Biases](#about-weights-&-biases)
-- [First-Time Setup](#first-time-setup)
-- [Viewing runs](#viewing-runs)
-- [Disabling wandb](#disabling-wandb)
-- [Advanced Usage: Dataset Versioning and Evaluation](#advanced-usage)
-- [Reports: Share your work with the world!](#reports)
-
-## About Weights & Biases
-
-Think of [W&B](https://wandb.ai/site?utm_campaign=repo_yolo_wandbtutorial) like GitHub for machine learning models. With a few lines of code, save everything you need to debug, compare and reproduce your models — architecture, hyperparameters, git commits, model weights, GPU usage, and even datasets and predictions.
-
-Used by top researchers including teams at OpenAI, Lyft, Github, and MILA, W&B is part of the new standard of best practices for machine learning. How W&B can help you optimize your machine learning workflows:
-
-- [Debug](https://wandb.ai/wandb/getting-started/reports/Visualize-Debug-Machine-Learning-Models--VmlldzoyNzY5MDk#Free-2) model performance in real time
-- [GPU usage](https://wandb.ai/wandb/getting-started/reports/Visualize-Debug-Machine-Learning-Models--VmlldzoyNzY5MDk#System-4) visualized automatically
-- [Custom charts](https://wandb.ai/wandb/customizable-charts/reports/Powerful-Custom-Charts-To-Debug-Model-Peformance--VmlldzoyNzY4ODI) for powerful, extensible visualization
-- [Share insights](https://wandb.ai/wandb/getting-started/reports/Visualize-Debug-Machine-Learning-Models--VmlldzoyNzY5MDk#Share-8) interactively with collaborators
-- [Optimize hyperparameters](https://docs.wandb.com/sweeps) efficiently
-- [Track](https://docs.wandb.com/artifacts) datasets, pipelines, and production models
-
-## First-Time Setup
-
-<details open>
- <summary> Toggle Details </summary>
-When you first train, W&B will prompt you to create a new account and will generate an **API key** for you. If you are an existing user you can retrieve your key from https://wandb.ai/authorize. This key is used to tell W&B where to log your data. You only need to supply your key once, and then it is remembered on the same device.
-
-W&B will create a cloud **project** (default is 'YOLOv5') for your training runs, and each new training run will be provided a unique run **name** within that project as project/name. You can also manually set your project and run name as:
-
-```shell
-$ python train.py --project ... --name ...
-```
-
-YOLOv5 notebook example: <a href="https://colab.research.google.com/github/ultralytics/yolov5/blob/master/tutorial.ipynb"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"></a> <a href="https://www.kaggle.com/ultralytics/yolov5"><img src="https://kaggle.com/static/images/open-in-kaggle.svg" alt="Open In Kaggle"></a>
-<img width="960" alt="Screen Shot 2021-09-29 at 10 23 13 PM" src="https://user-images.githubusercontent.com/26833433/135392431-1ab7920a-c49d-450a-b0b0-0c86ec86100e.png">
-
-</details>
-
-## Viewing Runs
-
-<details open>
-  <summary> Toggle Details </summary>
-Run information streams from your environment to the W&B cloud console as you train. This allows you to monitor and even cancel runs in <b>realtime</b> . All important information is logged:
-
-- Training & Validation losses
-- Metrics: Precision, Recall, [email protected], [email protected]:0.95
-- Learning Rate over time
-- A bounding box debugging panel, showing the training progress over time
-- GPU: Type, **GPU Utilization**, power, temperature, **CUDA memory usage**
-- System: Disk I/0, CPU utilization, RAM memory usage
-- Your trained model as W&B Artifact
-- Environment: OS and Python types, Git repository and state, **training command**
-
-<p align="center"><img width="900" alt="Weights & Biases dashboard" src="https://user-images.githubusercontent.com/26833433/135390767-c28b050f-8455-4004-adb0-3b730386e2b2.png"></p>
-</details>
-
-## Disabling wandb
-
-- training after running `wandb disabled` inside that directory creates no wandb run
-  ![Screenshot (84)](https://user-images.githubusercontent.com/15766192/143441777-c780bdd7-7cb4-4404-9559-b4316030a985.png)
-
-- To enable wandb again, run `wandb online`
-  ![Screenshot (85)](https://user-images.githubusercontent.com/15766192/143441866-7191b2cb-22f0-4e0f-ae64-2dc47dc13078.png)
-
-## Advanced Usage
-
-You can leverage W&B artifacts and Tables integration to easily visualize and manage your datasets, models and training evaluations. Here are some quick examples to get you started.
-
-<details open>
- <h3> 1: Train and Log Evaluation simultaneousy </h3>
-   This is an extension of the previous section, but it'll also training after uploading the dataset. <b> This also evaluation Table</b>
-   Evaluation table compares your predictions and ground truths across the validation set for each epoch. It uses the references to the already uploaded datasets,
-   so no images will be uploaded from your system more than once.
- <details open>
-  <summary> <b>Usage</b> </summary>
-   <b>Code</b> <code> $ python train.py --upload_data val</code>
-
-![Screenshot from 2021-11-21 17-40-06](https://user-images.githubusercontent.com/15766192/142761183-c1696d8c-3f38-45ab-991a-bb0dfd98ae7d.png)
-
-</details>
-
-<h3>2. Visualize and Version Datasets</h3>
- Log, visualize, dynamically query, and understand your data with <a href='https://docs.wandb.ai/guides/data-vis/tables'>W&B Tables</a>. You can use the following command to log your dataset as a W&B Table. This will generate a <code>{dataset}_wandb.yaml</code> file which can be used to train from dataset artifact.
- <details>
-  <summary> <b>Usage</b> </summary>
-   <b>Code</b> <code> $ python utils/logger/wandb/log_dataset.py --project ... --name ... --data .. </code>
-
-![Screenshot (64)](https://user-images.githubusercontent.com/15766192/128486078-d8433890-98a3-4d12-8986-b6c0e3fc64b9.png)
-
-</details>
-
-<h3> 3: Train using dataset artifact </h3>
-   When you upload a dataset as described in the first section, you get a new config file with an added `_wandb` to its name. This file contains the information that
-   can be used to train a model directly from the dataset artifact. <b> This also logs evaluation </b>
- <details>
-  <summary> <b>Usage</b> </summary>
-   <b>Code</b> <code> $ python train.py --data {data}_wandb.yaml </code>
-
-![Screenshot (72)](https://user-images.githubusercontent.com/15766192/128979739-4cf63aeb-a76f-483f-8861-1c0100b938a5.png)
-
-</details>
-
-<h3> 4: Save model checkpoints as artifacts </h3>
-  To enable saving and versioning checkpoints of your experiment, pass `--save_period n` with the base cammand, where `n` represents checkpoint interval.
-  You can also log both the dataset and model checkpoints simultaneously. If not passed, only the final model will be logged
-
-<details>
-  <summary> <b>Usage</b> </summary>
-   <b>Code</b> <code> $ python train.py --save_period 1 </code>
-
-![Screenshot (68)](https://user-images.githubusercontent.com/15766192/128726138-ec6c1f60-639d-437d-b4ee-3acd9de47ef3.png)
-
-</details>
-
-</details>
-
-<h3> 5: Resume runs from checkpoint artifacts. </h3>
-Any run can be resumed using artifacts if the <code>--resume</code> argument starts with <code>wandb-artifact://</code> prefix followed by the run path, i.e, <code>wandb-artifact://username/project/runid </code>. This doesn't require the model checkpoint to be present on the local system.
-
-<details>
-  <summary> <b>Usage</b> </summary>
-   <b>Code</b> <code> $ python train.py --resume wandb-artifact://{run_path} </code>
-
-![Screenshot (70)](https://user-images.githubusercontent.com/15766192/128728988-4e84b355-6c87-41ae-a591-14aecf45343e.png)
-
-</details>
-
-<h3> 6: Resume runs from dataset artifact & checkpoint artifacts. </h3>
- <b> Local dataset or model checkpoints are not required. This can be used to resume runs directly on a different device </b>
- The syntax is same as the previous section, but you'll need to lof both the dataset and model checkpoints as artifacts, i.e, set bot <code>--upload_dataset</code> or
- train from <code>_wandb.yaml</code> file and set <code>--save_period</code>
-
-<details>
-  <summary> <b>Usage</b> </summary>
-   <b>Code</b> <code> $ python train.py --resume wandb-artifact://{run_path} </code>
-
-![Screenshot (70)](https://user-images.githubusercontent.com/15766192/128728988-4e84b355-6c87-41ae-a591-14aecf45343e.png)
-
-</details>
-
-</details>
-
-<h3> Reports </h3>
-W&B Reports can be created from your saved runs for sharing online. Once a report is created you will receive a link you can use to publically share your results. Here is an example report created from the COCO128 tutorial trainings of all four YOLOv5 models ([link](https://wandb.ai/glenn-jocher/yolov5_tutorial/reports/YOLOv5-COCO128-Tutorial-Results--VmlldzozMDI5OTY)).
-
-<img width="900" alt="Weights & Biases Reports" src="https://user-images.githubusercontent.com/26833433/135394029-a17eaf86-c6c1-4b1d-bb80-b90e83aaffa7.png">
-
-## Environments
-
-YOLOv5 may be run in any of the following up-to-date verified environments (with all dependencies including [CUDA](https://developer.nvidia.com/cuda)/[CUDNN](https://developer.nvidia.com/cudnn), [Python](https://www.python.org/) and [PyTorch](https://pytorch.org/) preinstalled):
-
-- **Google Colab and Kaggle** notebooks with free GPU: <a href="https://colab.research.google.com/github/ultralytics/yolov5/blob/master/tutorial.ipynb"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"></a> <a href="https://www.kaggle.com/ultralytics/yolov5"><img src="https://kaggle.com/static/images/open-in-kaggle.svg" alt="Open In Kaggle"></a>
-- **Google Cloud** Deep Learning VM. See [GCP Quickstart Guide](https://github.com/ultralytics/yolov5/wiki/GCP-Quickstart)
-- **Amazon** Deep Learning AMI. See [AWS Quickstart Guide](https://github.com/ultralytics/yolov5/wiki/AWS-Quickstart)
-- **Docker Image**. See [Docker Quickstart Guide](https://github.com/ultralytics/yolov5/wiki/Docker-Quickstart) <a href="https://hub.docker.com/r/ultralytics/yolov5"><img src="https://img.shields.io/docker/pulls/ultralytics/yolov5?logo=docker" alt="Docker Pulls"></a>
-
-## Status
-
-![CI CPU testing](https://github.com/ultralytics/yolov5/workflows/CI%20CPU%20testing/badge.svg)
-
-If this badge is green, all [YOLOv5 GitHub Actions](https://github.com/ultralytics/yolov5/actions) Continuous Integration (CI) tests are currently passing. CI tests verify correct operation of YOLOv5 training ([train.py](https://github.com/ultralytics/yolov5/blob/master/train.py)), validation ([val.py](https://github.com/ultralytics/yolov5/blob/master/val.py)), inference ([detect.py](https://github.com/ultralytics/yolov5/blob/master/detect.py)) and export ([export.py](https://github.com/ultralytics/yolov5/blob/master/export.py)) on macOS, Windows, and Ubuntu every 24 hours and on every commit.

spaces/Arnaudding001/OpenAI_whisperLive/segments_test.py

@@ -1,48 +0,0 @@
-import sys
-import unittest
-
-sys.path.append('../whisper-webui')
-
-from src.segments import merge_timestamps
-
-class TestSegments(unittest.TestCase):
-    def __init__(self, *args, **kwargs):
-        super(TestSegments, self).__init__(*args, **kwargs)
-        
-    def test_merge_segments(self):
-        segments = [
-            {'start': 10.0, 'end': 20.0},
-            {'start': 22.0, 'end': 27.0},
-            {'start': 31.0, 'end': 35.0},
-            {'start': 45.0, 'end': 60.0},
-            {'start': 61.0, 'end': 65.0},
-            {'start': 68.0, 'end': 98.0},
-            {'start': 100.0, 'end': 102.0},
-            {'start': 110.0, 'end': 112.0}
-        ]
-
-        result = merge_timestamps(segments, merge_window=5, max_merge_size=30, padding_left=1, padding_right=1)
-
-        self.assertListEqual(result, [
-            {'start': 9.0, 'end': 36.0},
-            {'start': 44.0, 'end': 66.0},
-            {'start': 67.0, 'end': 99.0},
-            {'start': 99.0, 'end': 103.0},
-            {'start': 109.0, 'end': 113.0}
-        ])
-
-    def test_overlap_next(self):
-        segments = [
-            {'start': 5.0, 'end': 39.182},
-            {'start': 39.986, 'end': 40.814}
-        ]
-
-        result = merge_timestamps(segments, merge_window=5, max_merge_size=30, padding_left=1, padding_right=1)
-
-        self.assertListEqual(result, [
-            {'start': 4.0, 'end': 39.584},
-            {'start': 39.584, 'end': 41.814}
-        ])
-
-if __name__ == '__main__':
-    unittest.main()

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

@@ -1,140 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
-"""
-Utilities for bounding box manipulation and GIoU.
-"""
-import torch
-from torchvision.ops.boxes import box_area
-
-
-def box_cxcywh_to_xyxy(x):
-    x_c, y_c, w, h = x.unbind(-1)
-    b = [(x_c - 0.5 * w), (y_c - 0.5 * h), (x_c + 0.5 * w), (y_c + 0.5 * h)]
-    return torch.stack(b, dim=-1)
-
-
-def box_xyxy_to_cxcywh(x):
-    x0, y0, x1, y1 = x.unbind(-1)
-    b = [(x0 + x1) / 2, (y0 + y1) / 2, (x1 - x0), (y1 - y0)]
-    return torch.stack(b, dim=-1)
-
-
-# modified from torchvision to also return the union
-def box_iou(boxes1, boxes2):
-    area1 = box_area(boxes1)
-    area2 = box_area(boxes2)
-
-    # import ipdb; ipdb.set_trace()
-    lt = torch.max(boxes1[:, None, :2], boxes2[:, :2])  # [N,M,2]
-    rb = torch.min(boxes1[:, None, 2:], boxes2[:, 2:])  # [N,M,2]
-
-    wh = (rb - lt).clamp(min=0)  # [N,M,2]
-    inter = wh[:, :, 0] * wh[:, :, 1]  # [N,M]
-
-    union = area1[:, None] + area2 - inter
-
-    iou = inter / (union + 1e-6)
-    return iou, union
-
-
-def generalized_box_iou(boxes1, boxes2):
-    """
-    Generalized IoU from https://giou.stanford.edu/
-
-    The boxes should be in [x0, y0, x1, y1] format
-
-    Returns a [N, M] pairwise matrix, where N = len(boxes1)
-    and M = len(boxes2)
-    """
-    # degenerate boxes gives inf / nan results
-    # so do an early check
-    assert (boxes1[:, 2:] >= boxes1[:, :2]).all()
-    assert (boxes2[:, 2:] >= boxes2[:, :2]).all()
-    # except:
-    #     import ipdb; ipdb.set_trace()
-    iou, union = box_iou(boxes1, boxes2)
-
-    lt = torch.min(boxes1[:, None, :2], boxes2[:, :2])
-    rb = torch.max(boxes1[:, None, 2:], boxes2[:, 2:])
-
-    wh = (rb - lt).clamp(min=0)  # [N,M,2]
-    area = wh[:, :, 0] * wh[:, :, 1]
-
-    return iou - (area - union) / (area + 1e-6)
-
-
-# modified from torchvision to also return the union
-def box_iou_pairwise(boxes1, boxes2):
-    area1 = box_area(boxes1)
-    area2 = box_area(boxes2)
-
-    lt = torch.max(boxes1[:, :2], boxes2[:, :2])  # [N,2]
-    rb = torch.min(boxes1[:, 2:], boxes2[:, 2:])  # [N,2]
-
-    wh = (rb - lt).clamp(min=0)  # [N,2]
-    inter = wh[:, 0] * wh[:, 1]  # [N]
-
-    union = area1 + area2 - inter
-
-    iou = inter / union
-    return iou, union
-
-
-def generalized_box_iou_pairwise(boxes1, boxes2):
-    """
-    Generalized IoU from https://giou.stanford.edu/
-
-    Input:
-        - boxes1, boxes2: N,4
-    Output:
-        - giou: N, 4
-    """
-    # degenerate boxes gives inf / nan results
-    # so do an early check
-    assert (boxes1[:, 2:] >= boxes1[:, :2]).all()
-    assert (boxes2[:, 2:] >= boxes2[:, :2]).all()
-    assert boxes1.shape == boxes2.shape
-    iou, union = box_iou_pairwise(boxes1, boxes2)  # N, 4
-
-    lt = torch.min(boxes1[:, :2], boxes2[:, :2])
-    rb = torch.max(boxes1[:, 2:], boxes2[:, 2:])
-
-    wh = (rb - lt).clamp(min=0)  # [N,2]
-    area = wh[:, 0] * wh[:, 1]
-
-    return iou - (area - union) / area
-
-
-def masks_to_boxes(masks):
-    """Compute the bounding boxes around the provided masks
-
-    The masks should be in format [N, H, W] where N is the number of masks, (H, W) are the spatial dimensions.
-
-    Returns a [N, 4] tensors, with the boxes in xyxy format
-    """
-    if masks.numel() == 0:
-        return torch.zeros((0, 4), device=masks.device)
-
-    h, w = masks.shape[-2:]
-
-    y = torch.arange(0, h, dtype=torch.float)
-    x = torch.arange(0, w, dtype=torch.float)
-    y, x = torch.meshgrid(y, x)
-
-    x_mask = masks * x.unsqueeze(0)
-    x_max = x_mask.flatten(1).max(-1)[0]
-    x_min = x_mask.masked_fill(~(masks.bool()), 1e8).flatten(1).min(-1)[0]
-
-    y_mask = masks * y.unsqueeze(0)
-    y_max = y_mask.flatten(1).max(-1)[0]
-    y_min = y_mask.masked_fill(~(masks.bool()), 1e8).flatten(1).min(-1)[0]
-
-    return torch.stack([x_min, y_min, x_max, y_max], 1)
-
-
-if __name__ == "__main__":
-    x = torch.rand(5, 4)
-    y = torch.rand(3, 4)
-    iou, union = box_iou(x, y)
-    import ipdb
-
-    ipdb.set_trace()

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

@@ -1,56 +0,0 @@
-from typing import Iterable, Sequence, Tuple, cast
-
-from pip._vendor.rich._win32_console import LegacyWindowsTerm, WindowsCoordinates
-from pip._vendor.rich.segment import ControlCode, ControlType, Segment
-
-
-def legacy_windows_render(buffer: Iterable[Segment], term: LegacyWindowsTerm) -> None:
-    """Makes appropriate Windows Console API calls based on the segments in the buffer.
-
-    Args:
-        buffer (Iterable[Segment]): Iterable of Segments to convert to Win32 API calls.
-        term (LegacyWindowsTerm): Used to call the Windows Console API.
-    """
-    for text, style, control in buffer:
-        if not control:
-            if style:
-                term.write_styled(text, style)
-            else:
-                term.write_text(text)
-        else:
-            control_codes: Sequence[ControlCode] = control
-            for control_code in control_codes:
-                control_type = control_code[0]
-                if control_type == ControlType.CURSOR_MOVE_TO:
-                    _, x, y = cast(Tuple[ControlType, int, int], control_code)
-                    term.move_cursor_to(WindowsCoordinates(row=y - 1, col=x - 1))
-                elif control_type == ControlType.CARRIAGE_RETURN:
-                    term.write_text("\r")
-                elif control_type == ControlType.HOME:
-                    term.move_cursor_to(WindowsCoordinates(0, 0))
-                elif control_type == ControlType.CURSOR_UP:
-                    term.move_cursor_up()
-                elif control_type == ControlType.CURSOR_DOWN:
-                    term.move_cursor_down()
-                elif control_type == ControlType.CURSOR_FORWARD:
-                    term.move_cursor_forward()
-                elif control_type == ControlType.CURSOR_BACKWARD:
-                    term.move_cursor_backward()
-                elif control_type == ControlType.CURSOR_MOVE_TO_COLUMN:
-                    _, column = cast(Tuple[ControlType, int], control_code)
-                    term.move_cursor_to_column(column - 1)
-                elif control_type == ControlType.HIDE_CURSOR:
-                    term.hide_cursor()
-                elif control_type == ControlType.SHOW_CURSOR:
-                    term.show_cursor()
-                elif control_type == ControlType.ERASE_IN_LINE:
-                    _, mode = cast(Tuple[ControlType, int], control_code)
-                    if mode == 0:
-                        term.erase_end_of_line()
-                    elif mode == 1:
-                        term.erase_start_of_line()
-                    elif mode == 2:
-                        term.erase_line()
-                elif control_type == ControlType.SET_WINDOW_TITLE:
-                    _, title = cast(Tuple[ControlType, str], control_code)
-                    term.set_title(title)

spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/setuptools/config/_validate_pyproject/formats.py

@@ -1,259 +0,0 @@
-import logging
-import os
-import re
-import string
-import typing
-from itertools import chain as _chain
-
-_logger = logging.getLogger(__name__)
-
-# -------------------------------------------------------------------------------------
-# PEP 440
-
-VERSION_PATTERN = r"""
-    v?
-    (?:
-        (?:(?P<epoch>[0-9]+)!)?                           # epoch
-        (?P<release>[0-9]+(?:\.[0-9]+)*)                  # release segment
-        (?P<pre>                                          # pre-release
-            [-_\.]?
-            (?P<pre_l>(a|b|c|rc|alpha|beta|pre|preview))
-            [-_\.]?
-            (?P<pre_n>[0-9]+)?
-        )?
-        (?P<post>                                         # post release
-            (?:-(?P<post_n1>[0-9]+))
-            |
-            (?:
-                [-_\.]?
-                (?P<post_l>post|rev|r)
-                [-_\.]?
-                (?P<post_n2>[0-9]+)?
-            )
-        )?
-        (?P<dev>                                          # dev release
-            [-_\.]?
-            (?P<dev_l>dev)
-            [-_\.]?
-            (?P<dev_n>[0-9]+)?
-        )?
-    )
-    (?:\+(?P<local>[a-z0-9]+(?:[-_\.][a-z0-9]+)*))?       # local version
-"""
-
-VERSION_REGEX = re.compile(r"^\s*" + VERSION_PATTERN + r"\s*$", re.X | re.I)
-
-
-def pep440(version: str) -> bool:
-    return VERSION_REGEX.match(version) is not None
-
-
-# -------------------------------------------------------------------------------------
-# PEP 508
-
-PEP508_IDENTIFIER_PATTERN = r"([A-Z0-9]|[A-Z0-9][A-Z0-9._-]*[A-Z0-9])"
-PEP508_IDENTIFIER_REGEX = re.compile(f"^{PEP508_IDENTIFIER_PATTERN}$", re.I)
-
-
-def pep508_identifier(name: str) -> bool:
-    return PEP508_IDENTIFIER_REGEX.match(name) is not None
-
-
-try:
-    try:
-        from packaging import requirements as _req
-    except ImportError:  # pragma: no cover
-        # let's try setuptools vendored version
-        from setuptools._vendor.packaging import requirements as _req  # type: ignore
-
-    def pep508(value: str) -> bool:
-        try:
-            _req.Requirement(value)
-            return True
-        except _req.InvalidRequirement:
-            return False
-
-except ImportError:  # pragma: no cover
-    _logger.warning(
-        "Could not find an installation of `packaging`. Requirements, dependencies and "
-        "versions might not be validated. "
-        "To enforce validation, please install `packaging`."
-    )
-
-    def pep508(value: str) -> bool:
-        return True
-
-
-def pep508_versionspec(value: str) -> bool:
-    """Expression that can be used to specify/lock versions (including ranges)"""
-    if any(c in value for c in (";", "]", "@")):
-        # In PEP 508:
-        # conditional markers, extras and URL specs are not included in the
-        # versionspec
-        return False
-    # Let's pretend we have a dependency called `requirement` with the given
-    # version spec, then we can re-use the pep508 function for validation:
-    return pep508(f"requirement{value}")
-
-
-# -------------------------------------------------------------------------------------
-# PEP 517
-
-
-def pep517_backend_reference(value: str) -> bool:
-    module, _, obj = value.partition(":")
-    identifiers = (i.strip() for i in _chain(module.split("."), obj.split(".")))
-    return all(python_identifier(i) for i in identifiers if i)
-
-
-# -------------------------------------------------------------------------------------
-# Classifiers - PEP 301
-
-
-def _download_classifiers() -> str:
-    import ssl
-    from email.message import Message
-    from urllib.request import urlopen
-
-    url = "https://pypi.org/pypi?:action=list_classifiers"
-    context = ssl.create_default_context()
-    with urlopen(url, context=context) as response:
-        headers = Message()
-        headers["content_type"] = response.getheader("content-type", "text/plain")
-        return response.read().decode(headers.get_param("charset", "utf-8"))
-
-
-class _TroveClassifier:
-    """The ``trove_classifiers`` package is the official way of validating classifiers,
-    however this package might not be always available.
-    As a workaround we can still download a list from PyPI.
-    We also don't want to be over strict about it, so simply skipping silently is an
-    option (classifiers will be validated anyway during the upload to PyPI).
-    """
-
-    def __init__(self):
-        self.downloaded: typing.Union[None, False, typing.Set[str]] = None
-        self._skip_download = False
-        # None => not cached yet
-        # False => cache not available
-        self.__name__ = "trove_classifier"  # Emulate a public function
-
-    def _disable_download(self):
-        # This is a private API. Only setuptools has the consent of using it.
-        self._skip_download = True
-
-    def __call__(self, value: str) -> bool:
-        if self.downloaded is False or self._skip_download is True:
-            return True
-
-        if os.getenv("NO_NETWORK") or os.getenv("VALIDATE_PYPROJECT_NO_NETWORK"):
-            self.downloaded = False
-            msg = (
-                "Install ``trove-classifiers`` to ensure proper validation. "
-                "Skipping download of classifiers list from PyPI (NO_NETWORK)."
-            )
-            _logger.debug(msg)
-            return True
-
-        if self.downloaded is None:
-            msg = (
-                "Install ``trove-classifiers`` to ensure proper validation. "
-                "Meanwhile a list of classifiers will be downloaded from PyPI."
-            )
-            _logger.debug(msg)
-            try:
-                self.downloaded = set(_download_classifiers().splitlines())
-            except Exception:
-                self.downloaded = False
-                _logger.debug("Problem with download, skipping validation")
-                return True
-
-        return value in self.downloaded or value.lower().startswith("private ::")
-
-
-try:
-    from trove_classifiers import classifiers as _trove_classifiers
-
-    def trove_classifier(value: str) -> bool:
-        return value in _trove_classifiers or value.lower().startswith("private ::")
-
-except ImportError:  # pragma: no cover
-    trove_classifier = _TroveClassifier()
-
-
-# -------------------------------------------------------------------------------------
-# Non-PEP related
-
-
-def url(value: str) -> bool:
-    from urllib.parse import urlparse
-
-    try:
-        parts = urlparse(value)
-        if not parts.scheme:
-            _logger.warning(
-                "For maximum compatibility please make sure to include a "
-                "`scheme` prefix in your URL (e.g. 'http://'). "
-                f"Given value: {value}"
-            )
-            if not (value.startswith("/") or value.startswith("\\") or "@" in value):
-                parts = urlparse(f"http://{value}")
-
-        return bool(parts.scheme and parts.netloc)
-    except Exception:
-        return False
-
-
-# https://packaging.python.org/specifications/entry-points/
-ENTRYPOINT_PATTERN = r"[^\[\s=]([^=]*[^\s=])?"
-ENTRYPOINT_REGEX = re.compile(f"^{ENTRYPOINT_PATTERN}$", re.I)
-RECOMMEDED_ENTRYPOINT_PATTERN = r"[\w.-]+"
-RECOMMEDED_ENTRYPOINT_REGEX = re.compile(f"^{RECOMMEDED_ENTRYPOINT_PATTERN}$", re.I)
-ENTRYPOINT_GROUP_PATTERN = r"\w+(\.\w+)*"
-ENTRYPOINT_GROUP_REGEX = re.compile(f"^{ENTRYPOINT_GROUP_PATTERN}$", re.I)
-
-
-def python_identifier(value: str) -> bool:
-    return value.isidentifier()
-
-
-def python_qualified_identifier(value: str) -> bool:
-    if value.startswith(".") or value.endswith("."):
-        return False
-    return all(python_identifier(m) for m in value.split("."))
-
-
-def python_module_name(value: str) -> bool:
-    return python_qualified_identifier(value)
-
-
-def python_entrypoint_group(value: str) -> bool:
-    return ENTRYPOINT_GROUP_REGEX.match(value) is not None
-
-
-def python_entrypoint_name(value: str) -> bool:
-    if not ENTRYPOINT_REGEX.match(value):
-        return False
-    if not RECOMMEDED_ENTRYPOINT_REGEX.match(value):
-        msg = f"Entry point `{value}` does not follow recommended pattern: "
-        msg += RECOMMEDED_ENTRYPOINT_PATTERN
-        _logger.warning(msg)
-    return True
-
-
-def python_entrypoint_reference(value: str) -> bool:
-    module, _, rest = value.partition(":")
-    if "[" in rest:
-        obj, _, extras_ = rest.partition("[")
-        if extras_.strip()[-1] != "]":
-            return False
-        extras = (x.strip() for x in extras_.strip(string.whitespace + "[]").split(","))
-        if not all(pep508_identifier(e) for e in extras):
-            return False
-        _logger.warning(f"`{value}` - using extras for entry points is not recommended")
-    else:
-        obj = rest
-
-    module_parts = module.split(".")
-    identifiers = _chain(module_parts, obj.split(".")) if rest else module_parts
-    return all(python_identifier(i.strip()) for i in identifiers)

spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/detectron2/layers/csrc/nms_rotated/nms_rotated.h

@@ -1,39 +0,0 @@
-// Copyright (c) Facebook, Inc. and its affiliates.
-#pragma once
-#include <torch/types.h>
-
-namespace detectron2 {
-
-at::Tensor nms_rotated_cpu(
-    const at::Tensor& dets,
-    const at::Tensor& scores,
-    const double iou_threshold);
-
-#if defined(WITH_CUDA) || defined(WITH_HIP)
-at::Tensor nms_rotated_cuda(
-    const at::Tensor& dets,
-    const at::Tensor& scores,
-    const double iou_threshold);
-#endif
-
-// Interface for Python
-// inline is needed to prevent multiple function definitions when this header is
-// included by different cpps
-inline at::Tensor nms_rotated(
-    const at::Tensor& dets,
-    const at::Tensor& scores,
-    const double iou_threshold) {
-  assert(dets.device().is_cuda() == scores.device().is_cuda());
-  if (dets.device().is_cuda()) {
-#if defined(WITH_CUDA) || defined(WITH_HIP)
-    return nms_rotated_cuda(
-        dets.contiguous(), scores.contiguous(), iou_threshold);
-#else
-    AT_ERROR("Detectron2 is not compiled with GPU support!");
-#endif
-  }
-
-  return nms_rotated_cpu(dets.contiguous(), scores.contiguous(), iou_threshold);
-}
-
-} // namespace detectron2

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

@@ -1,282 +0,0 @@
-import numpy as np
-from typing import Dict, List, Optional, Tuple
-import torch
-from torch import Tensor, nn
-
-from detectron2.data.detection_utils import convert_image_to_rgb
-from detectron2.modeling import Backbone
-from detectron2.structures import Boxes, ImageList, Instances
-from detectron2.utils.events import get_event_storage
-
-from ..postprocessing import detector_postprocess
-
-
-def permute_to_N_HWA_K(tensor, K: int):
-    """
-    Transpose/reshape a tensor from (N, (Ai x K), H, W) to (N, (HxWxAi), K)
-    """
-    assert tensor.dim() == 4, tensor.shape
-    N, _, H, W = tensor.shape
-    tensor = tensor.view(N, -1, K, H, W)
-    tensor = tensor.permute(0, 3, 4, 1, 2)
-    tensor = tensor.reshape(N, -1, K)  # Size=(N,HWA,K)
-    return tensor
-
-
-class DenseDetector(nn.Module):
-    """
-    Base class for dense detector. We define a dense detector as a fully-convolutional model that
-    makes per-pixel (i.e. dense) predictions.
-    """
-
-    def __init__(
-        self,
-        backbone: Backbone,
-        head: nn.Module,
-        head_in_features: Optional[List[str]] = None,
-        *,
-        pixel_mean,
-        pixel_std,
-    ):
-        """
-        Args:
-            backbone: backbone module
-            head: head module
-            head_in_features: backbone features to use in head. Default to all backbone features.
-            pixel_mean (Tuple[float]):
-                Values to be used for image normalization (BGR order).
-                To train on images of different number of channels, set different mean & std.
-                Default values are the mean pixel value from ImageNet: [103.53, 116.28, 123.675]
-            pixel_std (Tuple[float]):
-                When using pre-trained models in Detectron1 or any MSRA models,
-                std has been absorbed into its conv1 weights, so the std needs to be set 1.
-                Otherwise, you can use [57.375, 57.120, 58.395] (ImageNet std)
-        """
-        super().__init__()
-
-        self.backbone = backbone
-        self.head = head
-        if head_in_features is None:
-            shapes = self.backbone.output_shape()
-            self.head_in_features = sorted(shapes.keys(), key=lambda x: shapes[x].stride)
-        else:
-            self.head_in_features = head_in_features
-
-        self.register_buffer("pixel_mean", torch.tensor(pixel_mean).view(-1, 1, 1), False)
-        self.register_buffer("pixel_std", torch.tensor(pixel_std).view(-1, 1, 1), False)
-
-    @property
-    def device(self):
-        return self.pixel_mean.device
-
-    def forward(self, batched_inputs: List[Dict[str, Tensor]]):
-        """
-        Args:
-            batched_inputs: a list, batched outputs of :class:`DatasetMapper` .
-                Each item in the list contains the inputs for one image.
-                For now, each item in the list is a dict that contains:
-
-                * image: Tensor, image in (C, H, W) format.
-                * instances: Instances
-
-                Other information that's included in the original dicts, such as:
-
-                * "height", "width" (int): the output resolution of the model, used in inference.
-                  See :meth:`postprocess` for details.
-
-        Returns:
-            In training, dict[str, Tensor]: mapping from a named loss to a tensor storing the
-            loss. Used during training only. In inference, the standard output format, described
-            in :doc:`/tutorials/models`.
-        """
-        images = self.preprocess_image(batched_inputs)
-        features = self.backbone(images.tensor)
-        features = [features[f] for f in self.head_in_features]
-        predictions = self.head(features)
-
-        if self.training:
-            assert not torch.jit.is_scripting(), "Not supported"
-            assert "instances" in batched_inputs[0], "Instance annotations are missing in training!"
-            gt_instances = [x["instances"].to(self.device) for x in batched_inputs]
-            return self.forward_training(images, features, predictions, gt_instances)
-        else:
-            results = self.forward_inference(images, features, predictions)
-            if torch.jit.is_scripting():
-                return results
-
-            processed_results = []
-            for results_per_image, input_per_image, image_size in zip(
-                results, batched_inputs, images.image_sizes
-            ):
-                height = input_per_image.get("height", image_size[0])
-                width = input_per_image.get("width", image_size[1])
-                r = detector_postprocess(results_per_image, height, width)
-                processed_results.append({"instances": r})
-            return processed_results
-
-    def forward_training(self, images, features, predictions, gt_instances):
-        raise NotImplementedError()
-
-    def preprocess_image(self, batched_inputs: List[Dict[str, Tensor]]):
-        """
-        Normalize, pad and batch the input images.
-        """
-        images = [x["image"].to(self.device) for x in batched_inputs]
-        images = [(x - self.pixel_mean) / self.pixel_std for x in images]
-        images = ImageList.from_tensors(images, self.backbone.size_divisibility)
-        return images
-
-    def _transpose_dense_predictions(
-        self, predictions: List[List[Tensor]], dims_per_anchor: List[int]
-    ) -> List[List[Tensor]]:
-        """
-        Transpose the dense per-level predictions.
-
-        Args:
-            predictions: a list of outputs, each is a list of per-level
-                predictions with shape (N, Ai x K, Hi, Wi), where N is the
-                number of images, Ai is the number of anchors per location on
-                level i, K is the dimension of predictions per anchor.
-            dims_per_anchor: the value of K for each predictions. e.g. 4 for
-                box prediction, #classes for classification prediction.
-
-        Returns:
-            List[List[Tensor]]: each prediction is transposed to (N, Hi x Wi x Ai, K).
-        """
-        assert len(predictions) == len(dims_per_anchor)
-        res: List[List[Tensor]] = []
-        for pred, dim_per_anchor in zip(predictions, dims_per_anchor):
-            pred = [permute_to_N_HWA_K(x, dim_per_anchor) for x in pred]
-            res.append(pred)
-        return res
-
-    def _ema_update(self, name: str, value: float, initial_value: float, momentum: float = 0.9):
-        """
-        Apply EMA update to `self.name` using `value`.
-
-        This is mainly used for loss normalizer. In Detectron1, loss is normalized by number
-        of foreground samples in the batch. When batch size is 1 per GPU, #foreground has a
-        large variance and using it lead to lower performance. Therefore we maintain an EMA of
-        #foreground to stabilize the normalizer.
-
-        Args:
-            name: name of the normalizer
-            value: the new value to update
-            initial_value: the initial value to start with
-            momentum: momentum of EMA
-
-        Returns:
-            float: the updated EMA value
-        """
-        if hasattr(self, name):
-            old = getattr(self, name)
-        else:
-            old = initial_value
-        new = old * momentum + value * (1 - momentum)
-        setattr(self, name, new)
-        return new
-
-    def _decode_per_level_predictions(
-        self,
-        anchors: Boxes,
-        pred_scores: Tensor,
-        pred_deltas: Tensor,
-        score_thresh: float,
-        topk_candidates: int,
-        image_size: Tuple[int, int],
-    ) -> Instances:
-        """
-        Decode boxes and classification predictions of one featuer level, by
-        the following steps:
-        1. filter the predictions based on score threshold and top K scores.
-        2. transform the box regression outputs
-        3. return the predicted scores, classes and boxes
-
-        Args:
-            anchors: Boxes, anchor for this feature level
-            pred_scores: HxWxA,K
-            pred_deltas: HxWxA,4
-
-        Returns:
-            Instances: with field "scores", "pred_boxes", "pred_classes".
-        """
-        # Apply two filtering to make NMS faster.
-        # 1. Keep boxes with confidence score higher than threshold
-        keep_idxs = pred_scores > score_thresh
-        pred_scores = pred_scores[keep_idxs]
-        topk_idxs = torch.nonzero(keep_idxs)  # Kx2
-
-        # 2. Keep top k top scoring boxes only
-        num_topk = min(topk_candidates, topk_idxs.size(0))
-        pred_scores, idxs = pred_scores.topk(num_topk)
-        topk_idxs = topk_idxs[idxs]
-
-        anchor_idxs, classes_idxs = topk_idxs.unbind(dim=1)
-
-        pred_boxes = self.box2box_transform.apply_deltas(
-            pred_deltas[anchor_idxs], anchors.tensor[anchor_idxs]
-        )
-        return Instances(
-            image_size, pred_boxes=Boxes(pred_boxes), scores=pred_scores, pred_classes=classes_idxs
-        )
-
-    def _decode_multi_level_predictions(
-        self,
-        anchors: List[Boxes],
-        pred_scores: List[Tensor],
-        pred_deltas: List[Tensor],
-        score_thresh: float,
-        topk_candidates: int,
-        image_size: Tuple[int, int],
-    ) -> Instances:
-        """
-        Run `_decode_per_level_predictions` for all feature levels and concat the results.
-        """
-        predictions = [
-            self._decode_per_level_predictions(
-                anchors_i,
-                box_cls_i,
-                box_reg_i,
-                self.test_score_thresh,
-                self.test_topk_candidates,
-                image_size,
-            )
-            # Iterate over every feature level
-            for box_cls_i, box_reg_i, anchors_i in zip(pred_scores, pred_deltas, anchors)
-        ]
-        return predictions[0].cat(predictions)  # 'Instances.cat' is not scriptale but this is
-
-    def visualize_training(self, batched_inputs, results):
-        """
-        A function used to visualize ground truth images and final network predictions.
-        It shows ground truth bounding boxes on the original image and up to 20
-        predicted object bounding boxes on the original image.
-
-        Args:
-            batched_inputs (list): a list that contains input to the model.
-            results (List[Instances]): a list of #images elements returned by forward_inference().
-        """
-        from detectron2.utils.visualizer import Visualizer
-
-        assert len(batched_inputs) == len(
-            results
-        ), "Cannot visualize inputs and results of different sizes"
-        storage = get_event_storage()
-        max_boxes = 20
-
-        image_index = 0  # only visualize a single image
-        img = batched_inputs[image_index]["image"]
-        img = convert_image_to_rgb(img.permute(1, 2, 0), self.input_format)
-        v_gt = Visualizer(img, None)
-        v_gt = v_gt.overlay_instances(boxes=batched_inputs[image_index]["instances"].gt_boxes)
-        anno_img = v_gt.get_image()
-        processed_results = detector_postprocess(results[image_index], img.shape[0], img.shape[1])
-        predicted_boxes = processed_results.pred_boxes.tensor.detach().cpu().numpy()
-
-        v_pred = Visualizer(img, None)
-        v_pred = v_pred.overlay_instances(boxes=predicted_boxes[0:max_boxes])
-        prop_img = v_pred.get_image()
-        vis_img = np.vstack((anno_img, prop_img))
-        vis_img = vis_img.transpose(2, 0, 1)
-        vis_name = f"Top: GT bounding boxes; Bottom: {max_boxes} Highest Scoring Results"
-        storage.put_image(vis_name, vis_img)

spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/detectron2/modeling/roi_heads/mask_head.py

@@ -1,292 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-from typing import List
-import fvcore.nn.weight_init as weight_init
-import torch
-from torch import nn
-from torch.nn import functional as F
-
-from detectron2.config import configurable
-from detectron2.layers import Conv2d, ConvTranspose2d, ShapeSpec, cat, get_norm
-from detectron2.structures import Instances
-from detectron2.utils.events import get_event_storage
-from detectron2.utils.registry import Registry
-
-__all__ = [
-    "BaseMaskRCNNHead",
-    "MaskRCNNConvUpsampleHead",
-    "build_mask_head",
-    "ROI_MASK_HEAD_REGISTRY",
-]
-
-
-ROI_MASK_HEAD_REGISTRY = Registry("ROI_MASK_HEAD")
-ROI_MASK_HEAD_REGISTRY.__doc__ = """
-Registry for mask heads, which predicts instance masks given
-per-region features.
-
-The registered object will be called with `obj(cfg, input_shape)`.
-"""
-
-
-@torch.jit.unused
-def mask_rcnn_loss(pred_mask_logits: torch.Tensor, instances: List[Instances], vis_period: int = 0):
-    """
-    Compute the mask prediction loss defined in the Mask R-CNN paper.
-
-    Args:
-        pred_mask_logits (Tensor): A tensor of shape (B, C, Hmask, Wmask) or (B, 1, Hmask, Wmask)
-            for class-specific or class-agnostic, where B is the total number of predicted masks
-            in all images, C is the number of foreground classes, and Hmask, Wmask are the height
-            and width of the mask predictions. The values are logits.
-        instances (list[Instances]): A list of N Instances, where N is the number of images
-            in the batch. These instances are in 1:1
-            correspondence with the pred_mask_logits. The ground-truth labels (class, box, mask,
-            ...) associated with each instance are stored in fields.
-        vis_period (int): the period (in steps) to dump visualization.
-
-    Returns:
-        mask_loss (Tensor): A scalar tensor containing the loss.
-    """
-    cls_agnostic_mask = pred_mask_logits.size(1) == 1
-    total_num_masks = pred_mask_logits.size(0)
-    mask_side_len = pred_mask_logits.size(2)
-    assert pred_mask_logits.size(2) == pred_mask_logits.size(3), "Mask prediction must be square!"
-
-    gt_classes = []
-    gt_masks = []
-    for instances_per_image in instances:
-        if len(instances_per_image) == 0:
-            continue
-        if not cls_agnostic_mask:
-            gt_classes_per_image = instances_per_image.gt_classes.to(dtype=torch.int64)
-            gt_classes.append(gt_classes_per_image)
-
-        gt_masks_per_image = instances_per_image.gt_masks.crop_and_resize(
-            instances_per_image.proposal_boxes.tensor, mask_side_len
-        ).to(device=pred_mask_logits.device)
-        # A tensor of shape (N, M, M), N=#instances in the image; M=mask_side_len
-        gt_masks.append(gt_masks_per_image)
-
-    if len(gt_masks) == 0:
-        return pred_mask_logits.sum() * 0
-
-    gt_masks = cat(gt_masks, dim=0)
-
-    if cls_agnostic_mask:
-        pred_mask_logits = pred_mask_logits[:, 0]
-    else:
-        indices = torch.arange(total_num_masks)
-        gt_classes = cat(gt_classes, dim=0)
-        pred_mask_logits = pred_mask_logits[indices, gt_classes]
-
-    if gt_masks.dtype == torch.bool:
-        gt_masks_bool = gt_masks
-    else:
-        # Here we allow gt_masks to be float as well (depend on the implementation of rasterize())
-        gt_masks_bool = gt_masks > 0.5
-    gt_masks = gt_masks.to(dtype=torch.float32)
-
-    # Log the training accuracy (using gt classes and 0.5 threshold)
-    mask_incorrect = (pred_mask_logits > 0.0) != gt_masks_bool
-    mask_accuracy = 1 - (mask_incorrect.sum().item() / max(mask_incorrect.numel(), 1.0))
-    num_positive = gt_masks_bool.sum().item()
-    false_positive = (mask_incorrect & ~gt_masks_bool).sum().item() / max(
-        gt_masks_bool.numel() - num_positive, 1.0
-    )
-    false_negative = (mask_incorrect & gt_masks_bool).sum().item() / max(num_positive, 1.0)
-
-    storage = get_event_storage()
-    storage.put_scalar("mask_rcnn/accuracy", mask_accuracy)
-    storage.put_scalar("mask_rcnn/false_positive", false_positive)
-    storage.put_scalar("mask_rcnn/false_negative", false_negative)
-    if vis_period > 0 and storage.iter % vis_period == 0:
-        pred_masks = pred_mask_logits.sigmoid()
-        vis_masks = torch.cat([pred_masks, gt_masks], axis=2)
-        name = "Left: mask prediction;   Right: mask GT"
-        for idx, vis_mask in enumerate(vis_masks):
-            vis_mask = torch.stack([vis_mask] * 3, axis=0)
-            storage.put_image(name + f" ({idx})", vis_mask)
-
-    mask_loss = F.binary_cross_entropy_with_logits(pred_mask_logits, gt_masks, reduction="mean")
-    return mask_loss
-
-
-def mask_rcnn_inference(pred_mask_logits: torch.Tensor, pred_instances: List[Instances]):
-    """
-    Convert pred_mask_logits to estimated foreground probability masks while also
-    extracting only the masks for the predicted classes in pred_instances. For each
-    predicted box, the mask of the same class is attached to the instance by adding a
-    new "pred_masks" field to pred_instances.
-
-    Args:
-        pred_mask_logits (Tensor): A tensor of shape (B, C, Hmask, Wmask) or (B, 1, Hmask, Wmask)
-            for class-specific or class-agnostic, where B is the total number of predicted masks
-            in all images, C is the number of foreground classes, and Hmask, Wmask are the height
-            and width of the mask predictions. The values are logits.
-        pred_instances (list[Instances]): A list of N Instances, where N is the number of images
-            in the batch. Each Instances must have field "pred_classes".
-
-    Returns:
-        None. pred_instances will contain an extra "pred_masks" field storing a mask of size (Hmask,
-            Wmask) for predicted class. Note that the masks are returned as a soft (non-quantized)
-            masks the resolution predicted by the network; post-processing steps, such as resizing
-            the predicted masks to the original image resolution and/or binarizing them, is left
-            to the caller.
-    """
-    cls_agnostic_mask = pred_mask_logits.size(1) == 1
-
-    if cls_agnostic_mask:
-        mask_probs_pred = pred_mask_logits.sigmoid()
-    else:
-        # Select masks corresponding to the predicted classes
-        num_masks = pred_mask_logits.shape[0]
-        class_pred = cat([i.pred_classes for i in pred_instances])
-        indices = torch.arange(num_masks, device=class_pred.device)
-        mask_probs_pred = pred_mask_logits[indices, class_pred][:, None].sigmoid()
-    # mask_probs_pred.shape: (B, 1, Hmask, Wmask)
-
-    num_boxes_per_image = [len(i) for i in pred_instances]
-    mask_probs_pred = mask_probs_pred.split(num_boxes_per_image, dim=0)
-
-    for prob, instances in zip(mask_probs_pred, pred_instances):
-        instances.pred_masks = prob  # (1, Hmask, Wmask)
-
-
-class BaseMaskRCNNHead(nn.Module):
-    """
-    Implement the basic Mask R-CNN losses and inference logic described in :paper:`Mask R-CNN`
-    """
-
-    @configurable
-    def __init__(self, *, loss_weight: float = 1.0, vis_period: int = 0):
-        """
-        NOTE: this interface is experimental.
-
-        Args:
-            loss_weight (float): multiplier of the loss
-            vis_period (int): visualization period
-        """
-        super().__init__()
-        self.vis_period = vis_period
-        self.loss_weight = loss_weight
-
-    @classmethod
-    def from_config(cls, cfg, input_shape):
-        return {"vis_period": cfg.VIS_PERIOD}
-
-    def forward(self, x, instances: List[Instances]):
-        """
-        Args:
-            x: input region feature(s) provided by :class:`ROIHeads`.
-            instances (list[Instances]): contains the boxes & labels corresponding
-                to the input features.
-                Exact format is up to its caller to decide.
-                Typically, this is the foreground instances in training, with
-                "proposal_boxes" field and other gt annotations.
-                In inference, it contains boxes that are already predicted.
-
-        Returns:
-            A dict of losses in training. The predicted "instances" in inference.
-        """
-        x = self.layers(x)
-        if self.training:
-            return {"loss_mask": mask_rcnn_loss(x, instances, self.vis_period) * self.loss_weight}
-        else:
-            mask_rcnn_inference(x, instances)
-            return instances
-
-    def layers(self, x):
-        """
-        Neural network layers that makes predictions from input features.
-        """
-        raise NotImplementedError
-
-
-# To get torchscript support, we make the head a subclass of `nn.Sequential`.
-# Therefore, to add new layers in this head class, please make sure they are
-# added in the order they will be used in forward().
-@ROI_MASK_HEAD_REGISTRY.register()
-class MaskRCNNConvUpsampleHead(BaseMaskRCNNHead, nn.Sequential):
-    """
-    A mask head with several conv layers, plus an upsample layer (with `ConvTranspose2d`).
-    Predictions are made with a final 1x1 conv layer.
-    """
-
-    @configurable
-    def __init__(self, input_shape: ShapeSpec, *, num_classes, conv_dims, conv_norm="", **kwargs):
-        """
-        NOTE: this interface is experimental.
-
-        Args:
-            input_shape (ShapeSpec): shape of the input feature
-            num_classes (int): the number of foreground classes (i.e. background is not
-                included). 1 if using class agnostic prediction.
-            conv_dims (list[int]): a list of N>0 integers representing the output dimensions
-                of N-1 conv layers and the last upsample layer.
-            conv_norm (str or callable): normalization for the conv layers.
-                See :func:`detectron2.layers.get_norm` for supported types.
-        """
-        super().__init__(**kwargs)
-        assert len(conv_dims) >= 1, "conv_dims have to be non-empty!"
-
-        self.conv_norm_relus = []
-
-        cur_channels = input_shape.channels
-        for k, conv_dim in enumerate(conv_dims[:-1]):
-            conv = Conv2d(
-                cur_channels,
-                conv_dim,
-                kernel_size=3,
-                stride=1,
-                padding=1,
-                bias=not conv_norm,
-                norm=get_norm(conv_norm, conv_dim),
-                activation=nn.ReLU(),
-            )
-            self.add_module("mask_fcn{}".format(k + 1), conv)
-            self.conv_norm_relus.append(conv)
-            cur_channels = conv_dim
-
-        self.deconv = ConvTranspose2d(
-            cur_channels, conv_dims[-1], kernel_size=2, stride=2, padding=0
-        )
-        self.add_module("deconv_relu", nn.ReLU())
-        cur_channels = conv_dims[-1]
-
-        self.predictor = Conv2d(cur_channels, num_classes, kernel_size=1, stride=1, padding=0)
-
-        for layer in self.conv_norm_relus + [self.deconv]:
-            weight_init.c2_msra_fill(layer)
-        # use normal distribution initialization for mask prediction layer
-        nn.init.normal_(self.predictor.weight, std=0.001)
-        if self.predictor.bias is not None:
-            nn.init.constant_(self.predictor.bias, 0)
-
-    @classmethod
-    def from_config(cls, cfg, input_shape):
-        ret = super().from_config(cfg, input_shape)
-        conv_dim = cfg.MODEL.ROI_MASK_HEAD.CONV_DIM
-        num_conv = cfg.MODEL.ROI_MASK_HEAD.NUM_CONV
-        ret.update(
-            conv_dims=[conv_dim] * (num_conv + 1),  # +1 for ConvTranspose
-            conv_norm=cfg.MODEL.ROI_MASK_HEAD.NORM,
-            input_shape=input_shape,
-        )
-        if cfg.MODEL.ROI_MASK_HEAD.CLS_AGNOSTIC_MASK:
-            ret["num_classes"] = 1
-        else:
-            ret["num_classes"] = cfg.MODEL.ROI_HEADS.NUM_CLASSES
-        return ret
-
-    def layers(self, x):
-        for layer in self:
-            x = layer(x)
-        return x
-
-
-def build_mask_head(cfg, input_shape):
-    """
-    Build a mask head defined by `cfg.MODEL.ROI_MASK_HEAD.NAME`.
-    """
-    name = cfg.MODEL.ROI_MASK_HEAD.NAME
-    return ROI_MASK_HEAD_REGISTRY.get(name)(cfg, input_shape)

spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/detectron2/utils/serialize.py

@@ -1,32 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-import cloudpickle
-
-
-class PicklableWrapper(object):
-    """
-    Wrap an object to make it more picklable, note that it uses
-    heavy weight serialization libraries that are slower than pickle.
-    It's best to use it only on closures (which are usually not picklable).
-
-    This is a simplified version of
-    https://github.com/joblib/joblib/blob/master/joblib/externals/loky/cloudpickle_wrapper.py
-    """
-
-    def __init__(self, obj):
-        while isinstance(obj, PicklableWrapper):
-            # Wrapping an object twice is no-op
-            obj = obj._obj
-        self._obj = obj
-
-    def __reduce__(self):
-        s = cloudpickle.dumps(self._obj)
-        return cloudpickle.loads, (s,)
-
-    def __call__(self, *args, **kwargs):
-        return self._obj(*args, **kwargs)
-
-    def __getattr__(self, attr):
-        # Ensure that the wrapped object can be used seamlessly as the previous object.
-        if attr not in ["_obj"]:
-            return getattr(self._obj, attr)
-        return getattr(self, attr)

spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/dev/packaging/build_wheel.sh

@@ -1,31 +0,0 @@
-#!/bin/bash
-# Copyright (c) Facebook, Inc. and its affiliates.
-set -ex
-
-ldconfig  # https://github.com/NVIDIA/nvidia-docker/issues/854
-
-script_dir="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
-. "$script_dir/pkg_helpers.bash"
-
-echo "Build Settings:"
-echo "CU_VERSION: $CU_VERSION"                 # e.g. cu101
-echo "D2_VERSION_SUFFIX: $D2_VERSION_SUFFIX"   # e.g. +cu101 or ""
-echo "PYTHON_VERSION: $PYTHON_VERSION"         # e.g. 3.6
-echo "PYTORCH_VERSION: $PYTORCH_VERSION"       # e.g. 1.4
-
-setup_cuda
-setup_wheel_python
-
-yum install ninja-build -y
-ln -sv /usr/bin/ninja-build /usr/bin/ninja || true
-
-pip_install pip numpy -U
-pip_install "torch==$PYTORCH_VERSION" \
-	-f https://download.pytorch.org/whl/"$CU_VERSION"/torch_stable.html
-
-# use separate directories to allow parallel build
-BASE_BUILD_DIR=build/$CU_VERSION-py$PYTHON_VERSION-pt$PYTORCH_VERSION
-python setup.py \
-  build -b "$BASE_BUILD_DIR" \
-  bdist_wheel -b "$BASE_BUILD_DIR/build_dist" -d "wheels/$CU_VERSION/torch$PYTORCH_VERSION"
-rm -rf "$BASE_BUILD_DIR"

spaces/Bala2-03-2003/AIBALA/README.md

@@ -1,12 +0,0 @@
----
-title: AIBALA
-emoji: 👁
-colorFrom: green
-colorTo: indigo
-sdk: gradio
-sdk_version: 3.39.0
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/Benson/text-generation/Examples/Carx Street 3 Apk.md

@@ -1,105 +0,0 @@
-
-<h1>CarX Street 3 APK: Una revisión del último juego de carreras de calle</h1>
-<p>Si usted es un fan de los juegos de carreras callejeras, es posible que haya oído hablar de CarX Street 3 APK, la última entrega de la serie CarX. Este juego se encuentra actualmente en pruebas beta abiertas y promete ofrecer una experiencia de carreras emocionante y realista en un mundo abierto dinámico. En este artículo, vamos a revisar las características, proceso de descarga, pros y contras, y preguntas frecuentes de CarX Street 3 APK.</p>
- <h2>¿Qué es CarX Street 3 APK? </h2>
-<p>CarX Street 3 APK es un juego para Android desarrollado por CarX Technologies, LLC, los creadores de CarX Drift Racing 2. Es un juego de carreras callejeras que le permite abrazar la libertad de ser un corredor callejero en el mundo abierto de Sunset City. Puedes aceptar el desafío y convertirte en la leyenda de la ciudad al competir en carreras realistas en carreteras y calles de la ciudad, así como en carreras de deriva de alta velocidad. También puede construir el coche de sus sueños utilizando la afinación de piezas que desbloquea toda la física del comportamiento del coche CarX Technology. Puedes explorar cada rincón del enorme mundo y disfrutar del dinámico cambio de día/noche. </p>
-<h2>carx street 3 apk</h2><br /><p><b><b>Download</b> > <a href="https://bltlly.com/2v6Kl5">https://bltlly.com/2v6Kl5</a></b></p><br /><br />
- <h3>Características de CarX Street 3 APK</h3>
-<p>CarX Street 3 APK tiene muchas características que lo convierten en un juego emocionante e inmersivo para los entusiastas de las carreras callejeras. Estos son algunos de ellos:</p>
- <h4>Modo de carrera</h4>
-<p>Usted puede elegir su propio camino en el modo de carrera, donde se puede conducir a la velocidad máxima o la deriva a través de turnos. Puedes unirte a clubes, derrotar jefes y demostrar a todos que eres el mejor conductor de la ciudad. También puedes comprar casas para tus coches y reunir colecciones para cada modo de carrera. Puedes cargar combustible con el combustible adecuado para la próxima carrera en las gasolineras de la ciudad. </p>
- <h4>Sintonización de coches</h4>
-<p>Puedes personalizar tu coche para que se adapte a tus preferencias y necesidades para cada carrera. Puedes intercambiar piezas y engañar a tu coche para una carrera específica. Puede actualizar el motor, la transmisión, el cuerpo, la suspensión y los neumáticos. También puede cambiar el motor de su automóvil único. </p>
- <h4>Personalización visual</h4>
-
- <h4>Física y gráficos realistas</h4>
-<p>El juego cuenta con una física impresionante y controles que te hacen sentir como si estuvieras conduciendo un coche real. Puedes admirar los modernos gráficos de alta calidad y el enorme mundo abierto que ofrece impresionantes vistas y detalles. </p>
- <h4>Exploración del mundo abierto</h4>
-<p>Puedes explorar cada rincón de Sunset City a cualquier hora del día o de la noche. Puedes descubrir lugares ocultos, atajos, rampas, saltos y secretos. También puedes interactuar con otros jugadores y PNJ de la ciudad. </p>
- <h2> Cómo descargar e instalar CarX Street 3 APK? </h2>
-<p>Si desea probar CarX Street 3 APK en su dispositivo Android, es necesario seguir estos pasos:</p>
-<p></p>
- <h3>Requisitos para CarX Street 3 APK</h3>
-<p> <p>Antes de descargar e instalar CarX Street 3 APK, es necesario asegurarse de que el dispositivo cumple con los siguientes requisitos:</p>
-<tabla>
-<tr>
-<th>Requisito</th>
-<th>Mínimo</th>
-<th>Recomendado</th>
-</tr>
-<tr>
-<td>Sistema operativo</td>
-<td>Android 6.0 o superior</td>
-<td>Android 8.0 o superior</td>
-</tr>
-<tr>
-<td>RAM</td>
-<td>2 GB</td>
-<td>4 GB o más</td>
-</tr>
-<tr>
-<td>Espacio de almacenamiento</td>
-<td>1.5 GB</td>
-<td>2 GB o más</td>
-</tr>
-<tr>
-<td>Conexión a Internet</td>
-<td>Requerido para funciones en línea</td>
-<td>Requerido para funciones en línea</td>
-</tr>
-<tr>
-<td>Servicios de Google Play</td>
-<td>Necesario para la instalación y las actualizaciones</td>
-<td>Necesario para la instalación y las actualizaciones</td>
-</tr>
-</tabla>
- <h3> Pasos para descargar e instalar CarX Street 3 APK</h3>
-<p>Para descargar e instalar CarX Street 3 APK en su dispositivo, debe seguir estos pasos:</p>
- <ol>
-<li>Vaya al sitio web oficial de CarX Technologies, LLC, [7](https://carx-online.com/), y haga clic en el botón "Descargar". </li>
-<li>Seleccione la opción "CarX Street" y elija la opción "APK". </li>
-<li>Serás redirigido a una página de descarga donde puedes elegir un enlace espejo para descargar el archivo APK. </li>
-
-<li>Es posible que tenga que habilitar la opción "Fuentes desconocidas" en la configuración del dispositivo para permitir la instalación de aplicaciones desde fuentes distintas de Google Play.</li>
-<li>Siga las instrucciones en pantalla para completar el proceso de instalación. </li>
-<li> Ahora puede iniciar el juego y disfrutar de la experiencia de carreras callejeras. </li>
-</ol>
- <h2>Pros y contras de CarX Street 3 APK</h2>
- <p>CarX Street 3 APK es un juego que tiene muchas ventajas y desventajas. Estos son algunos de ellos:</p>
- <h3>Pros de CarX Street 3 APK</h3>
- <ul>
-<li>El juego es gratis para descargar y jugar, con compras opcionales en la aplicación para características adicionales y contenido. </li>
-<li>El juego ofrece una experiencia de carreras callejeras realista e inmersiva con gráficos, física y controles de alta calidad. </li>
-<li> El juego tiene una variedad de coches, piezas y opciones de personalización que le permiten crear su propio coche único. </li>
-<li>El juego tiene un mundo abierto dinámico que puedes explorar a cualquier hora del día o de la noche, con lugares ocultos, secretos e interacciones. </li>
-<li> El juego tiene un modo de carrera que le permite elegir su propio camino, unirse a los clubes, derrotar a los jefes, y convertirse en la leyenda de Sunset City.</li>
-<li>El juego tiene un modo online que te permite competir con otros jugadores en carreras y derivas en tiempo real. </li>
- <h3>Contras de CarX Street 3 APK</h3>
- <ul>
- <li>El juego todavía está en pruebas beta abiertas, lo que significa que puede tener algunos errores, fallas y errores que afectan el juego. </li>
- <li>El juego requiere una conexión a Internet estable para las funciones en línea, que pueden consumir datos y batería. </li>
- <li>El juego puede no ser compatible con algunos dispositivos o sistemas operativos, o puede no funcionar sin problemas en dispositivos de gama baja. </li>
- <li> El juego puede tener algunos anuncios que pueden interrumpir el juego o afectar la experiencia del usuario. </li>
- <li>El juego puede tener algún contenido o características que se bloquean detrás de los muros de pago o requieren dinero real para acceder. </li>
- <h2>Conclusión</h2>
-
- <h2>Preguntas frecuentes</h2>
- <p>Aquí hay algunas preguntas frecuentes sobre CarX Street 3 APK:</p>
- <ol>
- <li><b>Es CarX Street 3 APK seguro de usar? </b></li>
- <p>CarX Street 3 APK es seguro para <p>CarX Street 3 APK es seguro de usar si lo descarga desde el sitio web oficial de CarX Technologies, LLC, [7](https://carx-online.com/). Sin embargo, si lo descarga de otras fuentes, puede correr el riesgo de obtener un archivo dañado o infectado que puede dañar su dispositivo o comprometer sus datos. Siempre debe escanear el archivo APK con un software antivirus confiable antes de instalarlo en su dispositivo. </p>
- <li><b>¿Cómo puedo actualizar CarX Street 3 APK? </b></li>
- <p>Puede actualizar CarX Street 3 APK visitando el sitio web oficial de CarX Technologies, LLC, [7](https://carx-online.com/), y descargar la última versión del archivo APK. También puede habilitar la opción de actualización automática en la configuración del dispositivo para recibir notificaciones y actualizaciones de los servicios de Google Play. Sin embargo, siempre debes hacer una copia de seguridad de tus datos y progreso antes de actualizar el juego, ya que algunas actualizaciones pueden causar problemas de compatibilidad o pérdida de datos. </p>
- <li><b>¿Puedo jugar CarX Street 3 APK sin conexión? </b></li>
- <p>No, no puede jugar CarX Street 3 APK sin conexión. El juego requiere una conexión a Internet estable para funciones en línea, como el modo multijugador, tablas de clasificación, logros y eventos. También necesitas una conexión a Internet para descargar e instalar el juego y sus actualizaciones. Si pierdes tu conexión a Internet mientras juegas, puedes experimentar retardo, problemas técnicos o desconexión. </p>
- <li><b>¿Puedo jugar CarX Street 3 APK en PC? </b></li>
-
- <li><b> ¿Cuáles son algunas alternativas a CarX Street 3 APK? </b></li>
- <p>Si usted está buscando algunas alternativas a CarX Street 3 APK, es posible que desee echa un vistazo a estos otros juegos de carreras de calle para Android:</p>
- <ul>
-<li><b>Asphalt 9: Legends</b>: Este es un juego de carreras de ritmo rápido y lleno de acción que te permite conducir algunos de los coches más prestigiosos del mundo. Puedes competir en modo individual o multijugador en impresionantes ubicaciones y pistas. También puedes personalizar tu coche con varias opciones y características. </li>
-<li><b>Need for Speed: No Limits</b>: Este es un emocionante juego de carreras de adrenalina que te permite competir por el dominio en el mundo subterráneo de las carreras callejeras. Puede construir su coche de ensueño con más de 250 piezas y personalizarlo con varias opciones. También puedes retar a otros jugadores en carreras y eventos en tiempo real. </li>
-<li><b>Real Racing 3</b>: Este es un juego de carreras realista e inmersivo que te permite conducir algunos de los coches más auténticos del mundo. Puedes competir en más de 40 circuitos en 19 lugares del mundo real. También puedes competir con otros jugadores en modos multijugador y eventos en tiempo real. </li>
-</ul></p> 64aa2da5cf<br />
-<br />
-<br />

spaces/Benson/text-generation/Examples/Descarga Gratuita De Club Gacha Ipad.md

@@ -1,76 +0,0 @@
-<br />
-<h1>Descarga gratuita de Gacha Club iPad: Una guía para fans del anime</h1>
- <p>Si eres un fan del anime, es posible que hayas oído hablar de Gacha Club, el último juego de Lunime que te permite crear tus propios personajes e historias de anime. Gacha Club es un juego gratuito, creativo y divertido que tiene millones de fans en todo el mundo. Puedes personalizar a tus personajes con miles de trajes, accesorios, peinados, armas y más. También puedes entrar en el modo estudio y crear cualquier escena que puedas imaginar con tus personajes, mascotas, objetos y fondos. Puede incluso gacha y batalla con más de 180 unidades, recoger gemas y bytes, y jugar mini-juegos. </p>
- <p>Pero, ¿cómo puedes descargar Gacha Club gratis en tu iPad? En realidad es muy fácil. Todo lo que necesitas hacer es ir a la App Store y buscar Gacha Club. Verás el icono del juego con un fondo púrpura y un lindo gato. Toque en él y luego toque en el "Obtener" botón. El juego comenzará a descargar e instalar en su dispositivo. También puedes usar este [link]( 1 ) para ir directamente a la página del juego en la App Store.</p>
-<h2>descarga gratuita de club gacha ipad</h2><br /><p><b><b>Download File</b> ->>> <a href="https://bltlly.com/2v6JHT">https://bltlly.com/2v6JHT</a></b></p><br /><br />
- <p>Una vez instalado el juego, puedes lanzarlo y empezar a jugar. Usted será recibido por un tutorial que le guiará a través de los fundamentos del juego. Puedes omitirlo si quieres, pero te recomendamos que lo sigas para aprender a usar las características del juego. </p>
- <h2>Características de Gacha Club</h2>
- <p>Gacha Club tiene muchas características que lo convierten en un juego divertido y atractivo para los amantes del anime. Estos son algunos de ellos:</p>
- <h3>Personalización de personajes y escenas</h3>
- <p>Una de las principales atracciones de Gacha Club es la función de personalización. Puedes crear hasta 10 personajes principales y 90 personajes adicionales, cada uno con su propio perfil y personalidad. Puedes cambiar sus colores, poses, expresiones, ropa, accesorios, peinados, armas y más. También puedes personalizar cientos de mascotas y objetos que puedes añadir a tus escenas. </p>
-
- <h3>Gacha y modos de batalla</h3>
- <p>Si quieres algo de acción, puedes probar los modos gacha y battle. Usted puede gacha más de 180 unidades para utilizar en la batalla, cada uno con sus propias habilidades y estadísticas. También puede gacha para 150 mascotas que pueden aumentar sus estadísticas. Usted puede recoger súper raros personajes corruptos y DJ que tienen habilidades especiales. </p>
- <p>Puedes elegir entre cuatro modos de batalla: historia, entrenamiento, torre y sombras de corrupción. En el modo historia, puedes seguir la historia principal del juego y luchar contra diferentes enemigos. En el modo de entrenamiento, puede practicar sus habilidades y ganar oro y materiales. En el modo torre, puedes desafiarte con diferentes niveles de dificultad y recompensas. En las sombras del modo de corrupción, puede enfrentar versiones corruptas de sus personajes que tienen estadísticas más altas. </p>
- <h3>Minijuegos y coleccionables</h3>
- <p>Gacha Club también tiene muchos mini-juegos que puedes jugar por diversión o para ganar gemas y bytes. Las gemas son la moneda principal del juego que puedes usar para gacha para más unidades o mascotas. Los bytes son una moneda secundaria que puedes usar para comprar artículos o mejorar tus unidades. </p>
- <p>Algunos de los mini-juegos son Usagi vs Neko, Memory Match, Lemo & Yumi, Narwhal Sky y más. También puedes desbloquear logros y recoger regalos raros que contienen artículos exclusivos. </p>
-<p></p>
- <h2>Consejos y trucos para Gacha Club</h2>
- <p>Gacha Club es un juego que tiene mucha profundidad y contenido. Puedes sentirte abrumado al principio, pero no te preocupes. Aquí hay algunos consejos y trucos que pueden ayudarle a disfrutar del juego más:</p>
- <h3>Cómo equilibrar tu equipo y usar afinidades elementales</h3>
- <p>Cuando gacha para las unidades, se dará cuenta de que tienen diferentes elementos: agua, fuego, viento, tierra, luz, oscuridad y neutro. Cada elemento tiene sus propias fortalezas y debilidades contra otros elementos. Por ejemplo, el agua es fuerte contra el fuego, pero débil contra la tierra. Puedes ver el gráfico elemental completo en el menú del juego. </p>
-
- <h3>Cómo traer mascotas y objetos para aumentar sus estadísticas</h3>
- <p>Las mascotas y los objetos no son solo para la decoración. También pueden aumentar sus estadísticas y darle efectos especiales. Puedes llevar hasta cuatro mascotas y cuatro objetos a cada escena. Cada mascota y objeto tiene su propia rareza y nivel, que afectan la cantidad que aumentan sus estadísticas. </p>
- <p>Puede ver las estadísticas y efectos de sus mascotas y objetos tocando en ellos en el modo de estudio. También puede mejorarlos con bytes para aumentar su nivel y estadísticas. Algunas mascotas y objetos tienen efectos únicos que pueden ayudarte en la batalla, como sanación, protección o aturdimiento. </p>
- <h3>Cómo jugar sin conexión y granja de gemas</h3>
- <p>Gacha Club es un juego en línea que requiere una conexión a Internet para jugar. Sin embargo, también puede jugar sin conexión si lo desea. Solo tienes que descargar los datos del juego antes de desconectar. Puedes hacerlo yendo al menú de opciones y pulsando el botón "Descargar datos". Esto descargará todas las imágenes y sonidos del juego en tu dispositivo. </p>
- <p>Cuando juegas sin conexión, todavía puedes acceder a la mayoría de las características del juego, a excepción de gacha y modos de batalla. Aún puedes personalizar tus personajes y escenas, jugar minijuegos, recoger regalos y exportar imágenes o videos. También puede cultivar gemas jugando minijuegos o viendo anuncios. Puede usar estas gemas para gacha para obtener más unidades o mascotas cuando vuelva a conectarse. </p>
- <h2>Alternativas al Club Gacha</h2>
- <p>Gacha Club no es el único juego de Lunime que puedes jugar en tu iPad. Hay otros juegos que son similares a Gacha Club en términos de personalización y jugabilidad. Estos son algunos de ellos:</p>
- <h3>Vida de Gacha</h3>
-
- <p>Puedes descargar Gacha Life gratis en la App Store [aquí]. </p>
- <h3>Gachaverse</h3>
- <p>Gachaverse es otro juego de Lunime que combina elementos gacha y RPG. Puedes crear tus propios personajes de anime con cientos de opciones de personalización. También puedes explorar diferentes mundos e historias con tus personajes, o crear los tuyos con el modo estudio. También puedes gacha para personajes y objetos raros, o luchar contra otros jugadores en el modo arena. </p>
- <p>Puedes descargar Gachaverse gratis en la App Store [aquí]. </p>
- <h3>Otros juegos de gacha para iOS</h3>
- <p>Si usted está buscando otros juegos gacha que ofrecen diferentes juegos y géneros, es posible que desee echa un vistazo a estos juegos:</p>
- <tabla>
-<tr>
-<th>Juego</th>
-<th>Descripción</th>
-<th>Enlace</th>
-</tr>
-<tr>
-<td>Destino/Gran Orden</td>
-<td>Un popular juego gacha basado en la serie de anime Fate. Puedes invocar héroes legendarios de la historia y la mitología para luchar junto a ti en batallas épicas. </td>
-<td>[aquí]</td>
-</tr>
-<tr>
-<td>Héroes del emblema del fuego</td>
-<td>Un juego gacha basado en la franquicia Fire Emblem. Puedes reunir y entrenar personajes de diferentes juegos de Fire Emblem y dirigirlos en combates estratégicos por turnos. </td> <td>[here]</td>
-</tr>
-<tr>
-<td>Arknights</td>
-<td>Un juego gacha que combina elementos de torre de defensa y RPG. Puedes reclutar y actualizar operadores con diferentes habilidades y roles para defender tu base de los enemigos. </td>
-<td>[aquí]</td>
-</tr>
-</tabla>
- <h2>Conclusión</h2>
- <p>Gacha Club es un juego gratuito, creativo y divertido que te permite crear tus propios personajes e historias de anime. Puedes descargarlo gratis en tu iPad y disfrutar de sus muchas características, como personalización, gacha, batalla, minijuegos y más. También puedes probar otros juegos de Lunime u otros juegos gacha para iOS que ofrecen diferentes modos de juego y géneros. Si usted es un jugador casual o hardcore, seguramente encontrará algo que se adapte a su gusto y estilo. </p>
-
- <h2>Preguntas frecuentes</h2>
- <h3>Q: ¿Es seguro el Club Gacha para los niños? </h3>
- <p>A: Gacha Club tiene una calificación de 9+ en la App Store, lo que significa que puede contener violencia leve, dibujos animados poco frecuentes o leves o violencia de fantasía, o temas de terror o miedo poco frecuentes o leves. Corresponde a los padres o tutores decidir si el juego es adecuado para sus hijos. También pueden usar los controles parentales en sus dispositivos para restringir el acceso o el contenido del juego. </p>
- <h3>P: ¿Cómo puedo transferir mis datos de Gacha Life a Gacha Club? </h3>
- <p>A: Desafortunadamente, no hay manera de transferir sus datos de Gacha Life a Gacha Club. Son juegos separados con diferentes características y contenido. Tendrás que empezar desde cero en Gacha Club, pero todavía puedes mantener tus datos de Gacha Life en tu dispositivo. </p>
- <h3>P: ¿Cómo puedo obtener más gemas y bytes en Gacha Club? </h3>
- <p>A: Hay varias maneras de obtener más gemas y bytes en Gacha Club. Puedes jugar minijuegos, ver anuncios, recoger regalos, completar logros, luchar contra enemigos o comprarlos con dinero real. También puedes usar códigos dados por Lunime u otras fuentes para obtener gemas y bytes gratis. </p>
- <h3>P: ¿Cómo puedo compartir mis escenas o personajes con otros en Gacha Club? </h3>
- <p>A: Puede compartir sus escenas o personajes con otros en Gacha Club mediante la función de exportación. Puedes exportar tus escenas como imágenes o vídeos, y tus personajes como códigos QR. Luego puedes compartirlos en redes sociales, correos electrónicos u otras plataformas. También puede importar escenas o caracteres de otras personas mediante la función de importación. </p>
- <h3>Q: ¿Cómo puedo contactar a Lunime o reportar un error o problema en Gacha Club? </h3>
- <p>A: Puede ponerse en contacto con Lunime o informar de un error o problema en Gacha Club mediante la función de retroalimentación. Puede encontrarlo en el menú de opciones bajo el botón "Feedback". También puede visitar su sitio web [aquí] o sus cuentas de redes sociales [aquí] para obtener más información y actualizaciones. </p> 64aa2da5cf<br />
-<br />
-<br />

spaces/Big-Web/MMSD/env/Lib/site-packages/pip/_internal/commands/configuration.py

@@ -1,282 +0,0 @@
-import logging
-import os
-import subprocess
-from optparse import Values
-from typing import Any, List, Optional
-
-from pip._internal.cli.base_command import Command
-from pip._internal.cli.status_codes import ERROR, SUCCESS
-from pip._internal.configuration import (
-    Configuration,
-    Kind,
-    get_configuration_files,
-    kinds,
-)
-from pip._internal.exceptions import PipError
-from pip._internal.utils.logging import indent_log
-from pip._internal.utils.misc import get_prog, write_output
-
-logger = logging.getLogger(__name__)
-
-
-class ConfigurationCommand(Command):
-    """
-    Manage local and global configuration.
-
-    Subcommands:
-
-    - list: List the active configuration (or from the file specified)
-    - edit: Edit the configuration file in an editor
-    - get: Get the value associated with command.option
-    - set: Set the command.option=value
-    - unset: Unset the value associated with command.option
-    - debug: List the configuration files and values defined under them
-
-    Configuration keys should be dot separated command and option name,
-    with the special prefix "global" affecting any command. For example,
-    "pip config set global.index-url https://example.org/" would configure
-    the index url for all commands, but "pip config set download.timeout 10"
-    would configure a 10 second timeout only for "pip download" commands.
-
-    If none of --user, --global and --site are passed, a virtual
-    environment configuration file is used if one is active and the file
-    exists. Otherwise, all modifications happen to the user file by
-    default.
-    """
-
-    ignore_require_venv = True
-    usage = """
-        %prog [<file-option>] list
-        %prog [<file-option>] [--editor <editor-path>] edit
-
-        %prog [<file-option>] get command.option
-        %prog [<file-option>] set command.option value
-        %prog [<file-option>] unset command.option
-        %prog [<file-option>] debug
-    """
-
-    def add_options(self) -> None:
-        self.cmd_opts.add_option(
-            "--editor",
-            dest="editor",
-            action="store",
-            default=None,
-            help=(
-                "Editor to use to edit the file. Uses VISUAL or EDITOR "
-                "environment variables if not provided."
-            ),
-        )
-
-        self.cmd_opts.add_option(
-            "--global",
-            dest="global_file",
-            action="store_true",
-            default=False,
-            help="Use the system-wide configuration file only",
-        )
-
-        self.cmd_opts.add_option(
-            "--user",
-            dest="user_file",
-            action="store_true",
-            default=False,
-            help="Use the user configuration file only",
-        )
-
-        self.cmd_opts.add_option(
-            "--site",
-            dest="site_file",
-            action="store_true",
-            default=False,
-            help="Use the current environment configuration file only",
-        )
-
-        self.parser.insert_option_group(0, self.cmd_opts)
-
-    def run(self, options: Values, args: List[str]) -> int:
-        handlers = {
-            "list": self.list_values,
-            "edit": self.open_in_editor,
-            "get": self.get_name,
-            "set": self.set_name_value,
-            "unset": self.unset_name,
-            "debug": self.list_config_values,
-        }
-
-        # Determine action
-        if not args or args[0] not in handlers:
-            logger.error(
-                "Need an action (%s) to perform.",
-                ", ".join(sorted(handlers)),
-            )
-            return ERROR
-
-        action = args[0]
-
-        # Determine which configuration files are to be loaded
-        #    Depends on whether the command is modifying.
-        try:
-            load_only = self._determine_file(
-                options, need_value=(action in ["get", "set", "unset", "edit"])
-            )
-        except PipError as e:
-            logger.error(e.args[0])
-            return ERROR
-
-        # Load a new configuration
-        self.configuration = Configuration(
-            isolated=options.isolated_mode, load_only=load_only
-        )
-        self.configuration.load()
-
-        # Error handling happens here, not in the action-handlers.
-        try:
-            handlers[action](options, args[1:])
-        except PipError as e:
-            logger.error(e.args[0])
-            return ERROR
-
-        return SUCCESS
-
-    def _determine_file(self, options: Values, need_value: bool) -> Optional[Kind]:
-        file_options = [
-            key
-            for key, value in (
-                (kinds.USER, options.user_file),
-                (kinds.GLOBAL, options.global_file),
-                (kinds.SITE, options.site_file),
-            )
-            if value
-        ]
-
-        if not file_options:
-            if not need_value:
-                return None
-            # Default to user, unless there's a site file.
-            elif any(
-                os.path.exists(site_config_file)
-                for site_config_file in get_configuration_files()[kinds.SITE]
-            ):
-                return kinds.SITE
-            else:
-                return kinds.USER
-        elif len(file_options) == 1:
-            return file_options[0]
-
-        raise PipError(
-            "Need exactly one file to operate upon "
-            "(--user, --site, --global) to perform."
-        )
-
-    def list_values(self, options: Values, args: List[str]) -> None:
-        self._get_n_args(args, "list", n=0)
-
-        for key, value in sorted(self.configuration.items()):
-            write_output("%s=%r", key, value)
-
-    def get_name(self, options: Values, args: List[str]) -> None:
-        key = self._get_n_args(args, "get [name]", n=1)
-        value = self.configuration.get_value(key)
-
-        write_output("%s", value)
-
-    def set_name_value(self, options: Values, args: List[str]) -> None:
-        key, value = self._get_n_args(args, "set [name] [value]", n=2)
-        self.configuration.set_value(key, value)
-
-        self._save_configuration()
-
-    def unset_name(self, options: Values, args: List[str]) -> None:
-        key = self._get_n_args(args, "unset [name]", n=1)
-        self.configuration.unset_value(key)
-
-        self._save_configuration()
-
-    def list_config_values(self, options: Values, args: List[str]) -> None:
-        """List config key-value pairs across different config files"""
-        self._get_n_args(args, "debug", n=0)
-
-        self.print_env_var_values()
-        # Iterate over config files and print if they exist, and the
-        # key-value pairs present in them if they do
-        for variant, files in sorted(self.configuration.iter_config_files()):
-            write_output("%s:", variant)
-            for fname in files:
-                with indent_log():
-                    file_exists = os.path.exists(fname)
-                    write_output("%s, exists: %r", fname, file_exists)
-                    if file_exists:
-                        self.print_config_file_values(variant)
-
-    def print_config_file_values(self, variant: Kind) -> None:
-        """Get key-value pairs from the file of a variant"""
-        for name, value in self.configuration.get_values_in_config(variant).items():
-            with indent_log():
-                write_output("%s: %s", name, value)
-
-    def print_env_var_values(self) -> None:
-        """Get key-values pairs present as environment variables"""
-        write_output("%s:", "env_var")
-        with indent_log():
-            for key, value in sorted(self.configuration.get_environ_vars()):
-                env_var = f"PIP_{key.upper()}"
-                write_output("%s=%r", env_var, value)
-
-    def open_in_editor(self, options: Values, args: List[str]) -> None:
-        editor = self._determine_editor(options)
-
-        fname = self.configuration.get_file_to_edit()
-        if fname is None:
-            raise PipError("Could not determine appropriate file.")
-        elif '"' in fname:
-            # This shouldn't happen, unless we see a username like that.
-            # If that happens, we'd appreciate a pull request fixing this.
-            raise PipError(
-                f'Can not open an editor for a file name containing "\n{fname}'
-            )
-
-        try:
-            subprocess.check_call(f'{editor} "{fname}"', shell=True)
-        except FileNotFoundError as e:
-            if not e.filename:
-                e.filename = editor
-            raise
-        except subprocess.CalledProcessError as e:
-            raise PipError(
-                "Editor Subprocess exited with exit code {}".format(e.returncode)
-            )
-
-    def _get_n_args(self, args: List[str], example: str, n: int) -> Any:
-        """Helper to make sure the command got the right number of arguments"""
-        if len(args) != n:
-            msg = (
-                "Got unexpected number of arguments, expected {}. "
-                '(example: "{} config {}")'
-            ).format(n, get_prog(), example)
-            raise PipError(msg)
-
-        if n == 1:
-            return args[0]
-        else:
-            return args
-
-    def _save_configuration(self) -> None:
-        # We successfully ran a modifying command. Need to save the
-        # configuration.
-        try:
-            self.configuration.save()
-        except Exception:
-            logger.exception(
-                "Unable to save configuration. Please report this as a bug."
-            )
-            raise PipError("Internal Error.")
-
-    def _determine_editor(self, options: Values) -> str:
-        if options.editor is not None:
-            return options.editor
-        elif "VISUAL" in os.environ:
-            return os.environ["VISUAL"]
-        elif "EDITOR" in os.environ:
-            return os.environ["EDITOR"]
-        else:
-            raise PipError("Could not determine editor to use.")

spaces/Big-Web/MMSD/env/Lib/site-packages/pip/_internal/index/__init__.py

@@ -1,2 +0,0 @@
-"""Index interaction code
-"""

spaces/Big-Web/MMSD/env/Lib/site-packages/s3transfer/processpool.py

@@ -1,1008 +0,0 @@
-# Copyright 2019 Amazon.com, Inc. or its affiliates. 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. A copy of
-# the License is located at
-#
-# http://aws.amazon.com/apache2.0/
-#
-# or in the "license" file accompanying this file. This file 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.
-"""Speeds up S3 throughput by using processes
-
-Getting Started
-===============
-
-The :class:`ProcessPoolDownloader` can be used to download a single file by
-calling :meth:`ProcessPoolDownloader.download_file`:
-
-.. code:: python
-
-     from s3transfer.processpool import ProcessPoolDownloader
-
-     with ProcessPoolDownloader() as downloader:
-          downloader.download_file('mybucket', 'mykey', 'myfile')
-
-
-This snippet downloads the S3 object located in the bucket ``mybucket`` at the
-key ``mykey`` to the local file ``myfile``. Any errors encountered during the
-transfer are not propagated. To determine if a transfer succeeded or
-failed, use the `Futures`_ interface.
-
-
-The :class:`ProcessPoolDownloader` can be used to download multiple files as
-well:
-
-.. code:: python
-
-     from s3transfer.processpool import ProcessPoolDownloader
-
-     with ProcessPoolDownloader() as downloader:
-          downloader.download_file('mybucket', 'mykey', 'myfile')
-          downloader.download_file('mybucket', 'myotherkey', 'myotherfile')
-
-
-When running this snippet, the downloading of ``mykey`` and ``myotherkey``
-happen in parallel. The first ``download_file`` call does not block the
-second ``download_file`` call. The snippet blocks when exiting
-the context manager and blocks until both downloads are complete.
-
-Alternatively, the ``ProcessPoolDownloader`` can be instantiated
-and explicitly be shutdown using :meth:`ProcessPoolDownloader.shutdown`:
-
-.. code:: python
-
-     from s3transfer.processpool import ProcessPoolDownloader
-
-     downloader = ProcessPoolDownloader()
-     downloader.download_file('mybucket', 'mykey', 'myfile')
-     downloader.download_file('mybucket', 'myotherkey', 'myotherfile')
-     downloader.shutdown()
-
-
-For this code snippet, the call to ``shutdown`` blocks until both
-downloads are complete.
-
-
-Additional Parameters
-=====================
-
-Additional parameters can be provided to the ``download_file`` method:
-
-* ``extra_args``: A dictionary containing any additional client arguments
-  to include in the
-  `GetObject <https://botocore.amazonaws.com/v1/documentation/api/latest/reference/services/s3.html#S3.Client.get_object>`_
-  API request. For example:
-
-  .. code:: python
-
-     from s3transfer.processpool import ProcessPoolDownloader
-
-     with ProcessPoolDownloader() as downloader:
-          downloader.download_file(
-               'mybucket', 'mykey', 'myfile',
-               extra_args={'VersionId': 'myversion'})
-
-
-* ``expected_size``: By default, the downloader will make a HeadObject
-  call to determine the size of the object. To opt-out of this additional
-  API call, you can provide the size of the object in bytes:
-
-  .. code:: python
-
-     from s3transfer.processpool import ProcessPoolDownloader
-
-     MB = 1024 * 1024
-     with ProcessPoolDownloader() as downloader:
-          downloader.download_file(
-               'mybucket', 'mykey', 'myfile', expected_size=2 * MB)
-
-
-Futures
-=======
-
-When ``download_file`` is called, it immediately returns a
-:class:`ProcessPoolTransferFuture`. The future can be used to poll the state
-of a particular transfer. To get the result of the download,
-call :meth:`ProcessPoolTransferFuture.result`. The method blocks
-until the transfer completes, whether it succeeds or fails. For example:
-
-.. code:: python
-
-     from s3transfer.processpool import ProcessPoolDownloader
-
-     with ProcessPoolDownloader() as downloader:
-          future = downloader.download_file('mybucket', 'mykey', 'myfile')
-          print(future.result())
-
-
-If the download succeeds, the future returns ``None``:
-
-.. code:: python
-
-     None
-
-
-If the download fails, the exception causing the failure is raised. For
-example, if ``mykey`` did not exist, the following error would be raised
-
-
-.. code:: python
-
-     botocore.exceptions.ClientError: An error occurred (404) when calling the HeadObject operation: Not Found
-
-
-.. note::
-
-    :meth:`ProcessPoolTransferFuture.result` can only be called while the
-    ``ProcessPoolDownloader`` is running (e.g. before calling ``shutdown`` or
-    inside the context manager).
-
-
-Process Pool Configuration
-==========================
-
-By default, the downloader has the following configuration options:
-
-* ``multipart_threshold``: The threshold size for performing ranged downloads
-  in bytes. By default, ranged downloads happen for S3 objects that are
-  greater than or equal to 8 MB in size.
-
-* ``multipart_chunksize``: The size of each ranged download in bytes. By
-  default, the size of each ranged download is 8 MB.
-
-* ``max_request_processes``: The maximum number of processes used to download
-  S3 objects. By default, the maximum is 10 processes.
-
-
-To change the default configuration, use the :class:`ProcessTransferConfig`:
-
-.. code:: python
-
-     from s3transfer.processpool import ProcessPoolDownloader
-     from s3transfer.processpool import ProcessTransferConfig
-
-     config = ProcessTransferConfig(
-          multipart_threshold=64 * 1024 * 1024,  # 64 MB
-          max_request_processes=50
-     )
-     downloader = ProcessPoolDownloader(config=config)
-
-
-Client Configuration
-====================
-
-The process pool downloader creates ``botocore`` clients on your behalf. In
-order to affect how the client is created, pass the keyword arguments
-that would have been used in the :meth:`botocore.Session.create_client` call:
-
-.. code:: python
-
-
-     from s3transfer.processpool import ProcessPoolDownloader
-     from s3transfer.processpool import ProcessTransferConfig
-
-     downloader = ProcessPoolDownloader(
-          client_kwargs={'region_name': 'us-west-2'})
-
-
-This snippet ensures that all clients created by the ``ProcessPoolDownloader``
-are using ``us-west-2`` as their region.
-
-"""
-import collections
-import contextlib
-import logging
-import multiprocessing
-import signal
-import threading
-from copy import deepcopy
-
-import botocore.session
-from botocore.config import Config
-
-from s3transfer.compat import MAXINT, BaseManager
-from s3transfer.constants import ALLOWED_DOWNLOAD_ARGS, MB, PROCESS_USER_AGENT
-from s3transfer.exceptions import CancelledError, RetriesExceededError
-from s3transfer.futures import BaseTransferFuture, BaseTransferMeta
-from s3transfer.utils import (
-    S3_RETRYABLE_DOWNLOAD_ERRORS,
-    CallArgs,
-    OSUtils,
-    calculate_num_parts,
-    calculate_range_parameter,
-)
-
-logger = logging.getLogger(__name__)
-
-SHUTDOWN_SIGNAL = 'SHUTDOWN'
-
-# The DownloadFileRequest tuple is submitted from the ProcessPoolDownloader
-# to the GetObjectSubmitter in order for the submitter to begin submitting
-# GetObjectJobs to the GetObjectWorkers.
-DownloadFileRequest = collections.namedtuple(
-    'DownloadFileRequest',
-    [
-        'transfer_id',  # The unique id for the transfer
-        'bucket',  # The bucket to download the object from
-        'key',  # The key to download the object from
-        'filename',  # The user-requested download location
-        'extra_args',  # Extra arguments to provide to client calls
-        'expected_size',  # The user-provided expected size of the download
-    ],
-)
-
-# The GetObjectJob tuple is submitted from the GetObjectSubmitter
-# to the GetObjectWorkers to download the file or parts of the file.
-GetObjectJob = collections.namedtuple(
-    'GetObjectJob',
-    [
-        'transfer_id',  # The unique id for the transfer
-        'bucket',  # The bucket to download the object from
-        'key',  # The key to download the object from
-        'temp_filename',  # The temporary file to write the content to via
-        # completed GetObject calls.
-        'extra_args',  # Extra arguments to provide to the GetObject call
-        'offset',  # The offset to write the content for the temp file.
-        'filename',  # The user-requested download location. The worker
-        # of final GetObjectJob will move the file located at
-        # temp_filename to the location of filename.
-    ],
-)
-
-
-@contextlib.contextmanager
-def ignore_ctrl_c():
-    original_handler = _add_ignore_handler_for_interrupts()
-    yield
-    signal.signal(signal.SIGINT, original_handler)
-
-
-def _add_ignore_handler_for_interrupts():
-    # Windows is unable to pickle signal.signal directly so it needs to
-    # be wrapped in a function defined at the module level
-    return signal.signal(signal.SIGINT, signal.SIG_IGN)
-
-
-class ProcessTransferConfig:
-    def __init__(
-        self,
-        multipart_threshold=8 * MB,
-        multipart_chunksize=8 * MB,
-        max_request_processes=10,
-    ):
-        """Configuration for the ProcessPoolDownloader
-
-        :param multipart_threshold: The threshold for which ranged downloads
-            occur.
-
-        :param multipart_chunksize: The chunk size of each ranged download.
-
-        :param max_request_processes: The maximum number of processes that
-            will be making S3 API transfer-related requests at a time.
-        """
-        self.multipart_threshold = multipart_threshold
-        self.multipart_chunksize = multipart_chunksize
-        self.max_request_processes = max_request_processes
-
-
-class ProcessPoolDownloader:
-    def __init__(self, client_kwargs=None, config=None):
-        """Downloads S3 objects using process pools
-
-        :type client_kwargs: dict
-        :param client_kwargs: The keyword arguments to provide when
-            instantiating S3 clients. The arguments must match the keyword
-            arguments provided to the
-            `botocore.session.Session.create_client()` method.
-
-        :type config: ProcessTransferConfig
-        :param config: Configuration for the downloader
-        """
-        if client_kwargs is None:
-            client_kwargs = {}
-        self._client_factory = ClientFactory(client_kwargs)
-
-        self._transfer_config = config
-        if config is None:
-            self._transfer_config = ProcessTransferConfig()
-
-        self._download_request_queue = multiprocessing.Queue(1000)
-        self._worker_queue = multiprocessing.Queue(1000)
-        self._osutil = OSUtils()
-
-        self._started = False
-        self._start_lock = threading.Lock()
-
-        # These below are initialized in the start() method
-        self._manager = None
-        self._transfer_monitor = None
-        self._submitter = None
-        self._workers = []
-
-    def download_file(
-        self, bucket, key, filename, extra_args=None, expected_size=None
-    ):
-        """Downloads the object's contents to a file
-
-        :type bucket: str
-        :param bucket: The name of the bucket to download from
-
-        :type key: str
-        :param key: The name of the key to download from
-
-        :type filename: str
-        :param filename: The name of a file to download to.
-
-        :type extra_args: dict
-        :param extra_args: Extra arguments that may be passed to the
-            client operation
-
-        :type expected_size: int
-        :param expected_size: The expected size in bytes of the download. If
-            provided, the downloader will not call HeadObject to determine the
-            object's size and use the provided value instead. The size is
-            needed to determine whether to do a multipart download.
-
-        :rtype: s3transfer.futures.TransferFuture
-        :returns: Transfer future representing the download
-        """
-        self._start_if_needed()
-        if extra_args is None:
-            extra_args = {}
-        self._validate_all_known_args(extra_args)
-        transfer_id = self._transfer_monitor.notify_new_transfer()
-        download_file_request = DownloadFileRequest(
-            transfer_id=transfer_id,
-            bucket=bucket,
-            key=key,
-            filename=filename,
-            extra_args=extra_args,
-            expected_size=expected_size,
-        )
-        logger.debug(
-            'Submitting download file request: %s.', download_file_request
-        )
-        self._download_request_queue.put(download_file_request)
-        call_args = CallArgs(
-            bucket=bucket,
-            key=key,
-            filename=filename,
-            extra_args=extra_args,
-            expected_size=expected_size,
-        )
-        future = self._get_transfer_future(transfer_id, call_args)
-        return future
-
-    def shutdown(self):
-        """Shutdown the downloader
-
-        It will wait till all downloads are complete before returning.
-        """
-        self._shutdown_if_needed()
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, exc_type, exc_value, *args):
-        if isinstance(exc_value, KeyboardInterrupt):
-            if self._transfer_monitor is not None:
-                self._transfer_monitor.notify_cancel_all_in_progress()
-        self.shutdown()
-
-    def _start_if_needed(self):
-        with self._start_lock:
-            if not self._started:
-                self._start()
-
-    def _start(self):
-        self._start_transfer_monitor_manager()
-        self._start_submitter()
-        self._start_get_object_workers()
-        self._started = True
-
-    def _validate_all_known_args(self, provided):
-        for kwarg in provided:
-            if kwarg not in ALLOWED_DOWNLOAD_ARGS:
-                download_args = ', '.join(ALLOWED_DOWNLOAD_ARGS)
-                raise ValueError(
-                    f"Invalid extra_args key '{kwarg}', "
-                    f"must be one of: {download_args}"
-                )
-
-    def _get_transfer_future(self, transfer_id, call_args):
-        meta = ProcessPoolTransferMeta(
-            call_args=call_args, transfer_id=transfer_id
-        )
-        future = ProcessPoolTransferFuture(
-            monitor=self._transfer_monitor, meta=meta
-        )
-        return future
-
-    def _start_transfer_monitor_manager(self):
-        logger.debug('Starting the TransferMonitorManager.')
-        self._manager = TransferMonitorManager()
-        # We do not want Ctrl-C's to cause the manager to shutdown immediately
-        # as worker processes will still need to communicate with it when they
-        # are shutting down. So instead we ignore Ctrl-C and let the manager
-        # be explicitly shutdown when shutting down the downloader.
-        self._manager.start(_add_ignore_handler_for_interrupts)
-        self._transfer_monitor = self._manager.TransferMonitor()
-
-    def _start_submitter(self):
-        logger.debug('Starting the GetObjectSubmitter.')
-        self._submitter = GetObjectSubmitter(
-            transfer_config=self._transfer_config,
-            client_factory=self._client_factory,
-            transfer_monitor=self._transfer_monitor,
-            osutil=self._osutil,
-            download_request_queue=self._download_request_queue,
-            worker_queue=self._worker_queue,
-        )
-        self._submitter.start()
-
-    def _start_get_object_workers(self):
-        logger.debug(
-            'Starting %s GetObjectWorkers.',
-            self._transfer_config.max_request_processes,
-        )
-        for _ in range(self._transfer_config.max_request_processes):
-            worker = GetObjectWorker(
-                queue=self._worker_queue,
-                client_factory=self._client_factory,
-                transfer_monitor=self._transfer_monitor,
-                osutil=self._osutil,
-            )
-            worker.start()
-            self._workers.append(worker)
-
-    def _shutdown_if_needed(self):
-        with self._start_lock:
-            if self._started:
-                self._shutdown()
-
-    def _shutdown(self):
-        self._shutdown_submitter()
-        self._shutdown_get_object_workers()
-        self._shutdown_transfer_monitor_manager()
-        self._started = False
-
-    def _shutdown_transfer_monitor_manager(self):
-        logger.debug('Shutting down the TransferMonitorManager.')
-        self._manager.shutdown()
-
-    def _shutdown_submitter(self):
-        logger.debug('Shutting down the GetObjectSubmitter.')
-        self._download_request_queue.put(SHUTDOWN_SIGNAL)
-        self._submitter.join()
-
-    def _shutdown_get_object_workers(self):
-        logger.debug('Shutting down the GetObjectWorkers.')
-        for _ in self._workers:
-            self._worker_queue.put(SHUTDOWN_SIGNAL)
-        for worker in self._workers:
-            worker.join()
-
-
-class ProcessPoolTransferFuture(BaseTransferFuture):
-    def __init__(self, monitor, meta):
-        """The future associated to a submitted process pool transfer request
-
-        :type monitor: TransferMonitor
-        :param monitor: The monitor associated to the process pool downloader
-
-        :type meta: ProcessPoolTransferMeta
-        :param meta: The metadata associated to the request. This object
-            is visible to the requester.
-        """
-        self._monitor = monitor
-        self._meta = meta
-
-    @property
-    def meta(self):
-        return self._meta
-
-    def done(self):
-        return self._monitor.is_done(self._meta.transfer_id)
-
-    def result(self):
-        try:
-            return self._monitor.poll_for_result(self._meta.transfer_id)
-        except KeyboardInterrupt:
-            # For the multiprocessing Manager, a thread is given a single
-            # connection to reuse in communicating between the thread in the
-            # main process and the Manager's process. If a Ctrl-C happens when
-            # polling for the result, it will make the main thread stop trying
-            # to receive from the connection, but the Manager process will not
-            # know that the main process has stopped trying to receive and
-            # will not close the connection. As a result if another message is
-            # sent to the Manager process, the listener in the Manager
-            # processes will not process the new message as it is still trying
-            # trying to process the previous message (that was Ctrl-C'd) and
-            # thus cause the thread in the main process to hang on its send.
-            # The only way around this is to create a new connection and send
-            # messages from that new connection instead.
-            self._monitor._connect()
-            self.cancel()
-            raise
-
-    def cancel(self):
-        self._monitor.notify_exception(
-            self._meta.transfer_id, CancelledError()
-        )
-
-
-class ProcessPoolTransferMeta(BaseTransferMeta):
-    """Holds metadata about the ProcessPoolTransferFuture"""
-
-    def __init__(self, transfer_id, call_args):
-        self._transfer_id = transfer_id
-        self._call_args = call_args
-        self._user_context = {}
-
-    @property
-    def call_args(self):
-        return self._call_args
-
-    @property
-    def transfer_id(self):
-        return self._transfer_id
-
-    @property
-    def user_context(self):
-        return self._user_context
-
-
-class ClientFactory:
-    def __init__(self, client_kwargs=None):
-        """Creates S3 clients for processes
-
-        Botocore sessions and clients are not pickleable so they cannot be
-        inherited across Process boundaries. Instead, they must be instantiated
-        once a process is running.
-        """
-        self._client_kwargs = client_kwargs
-        if self._client_kwargs is None:
-            self._client_kwargs = {}
-
-        client_config = deepcopy(self._client_kwargs.get('config', Config()))
-        if not client_config.user_agent_extra:
-            client_config.user_agent_extra = PROCESS_USER_AGENT
-        else:
-            client_config.user_agent_extra += " " + PROCESS_USER_AGENT
-        self._client_kwargs['config'] = client_config
-
-    def create_client(self):
-        """Create a botocore S3 client"""
-        return botocore.session.Session().create_client(
-            's3', **self._client_kwargs
-        )
-
-
-class TransferMonitor:
-    def __init__(self):
-        """Monitors transfers for cross-process communication
-
-        Notifications can be sent to the monitor and information can be
-        retrieved from the monitor for a particular transfer. This abstraction
-        is ran in a ``multiprocessing.managers.BaseManager`` in order to be
-        shared across processes.
-        """
-        # TODO: Add logic that removes the TransferState if the transfer is
-        #  marked as done and the reference to the future is no longer being
-        #  held onto. Without this logic, this dictionary will continue to
-        #  grow in size with no limit.
-        self._transfer_states = {}
-        self._id_count = 0
-        self._init_lock = threading.Lock()
-
-    def notify_new_transfer(self):
-        with self._init_lock:
-            transfer_id = self._id_count
-            self._transfer_states[transfer_id] = TransferState()
-            self._id_count += 1
-            return transfer_id
-
-    def is_done(self, transfer_id):
-        """Determine a particular transfer is complete
-
-        :param transfer_id: Unique identifier for the transfer
-        :return: True, if done. False, otherwise.
-        """
-        return self._transfer_states[transfer_id].done
-
-    def notify_done(self, transfer_id):
-        """Notify a particular transfer is complete
-
-        :param transfer_id: Unique identifier for the transfer
-        """
-        self._transfer_states[transfer_id].set_done()
-
-    def poll_for_result(self, transfer_id):
-        """Poll for the result of a transfer
-
-        :param transfer_id: Unique identifier for the transfer
-        :return: If the transfer succeeded, it will return the result. If the
-            transfer failed, it will raise the exception associated to the
-            failure.
-        """
-        self._transfer_states[transfer_id].wait_till_done()
-        exception = self._transfer_states[transfer_id].exception
-        if exception:
-            raise exception
-        return None
-
-    def notify_exception(self, transfer_id, exception):
-        """Notify an exception was encountered for a transfer
-
-        :param transfer_id: Unique identifier for the transfer
-        :param exception: The exception encountered for that transfer
-        """
-        # TODO: Not all exceptions are pickleable so if we are running
-        # this in a multiprocessing.BaseManager we will want to
-        # make sure to update this signature to ensure pickleability of the
-        # arguments or have the ProxyObject do the serialization.
-        self._transfer_states[transfer_id].exception = exception
-
-    def notify_cancel_all_in_progress(self):
-        for transfer_state in self._transfer_states.values():
-            if not transfer_state.done:
-                transfer_state.exception = CancelledError()
-
-    def get_exception(self, transfer_id):
-        """Retrieve the exception encountered for the transfer
-
-        :param transfer_id: Unique identifier for the transfer
-        :return: The exception encountered for that transfer. Otherwise
-            if there were no exceptions, returns None.
-        """
-        return self._transfer_states[transfer_id].exception
-
-    def notify_expected_jobs_to_complete(self, transfer_id, num_jobs):
-        """Notify the amount of jobs expected for a transfer
-
-        :param transfer_id: Unique identifier for the transfer
-        :param num_jobs: The number of jobs to complete the transfer
-        """
-        self._transfer_states[transfer_id].jobs_to_complete = num_jobs
-
-    def notify_job_complete(self, transfer_id):
-        """Notify that a single job is completed for a transfer
-
-        :param transfer_id: Unique identifier for the transfer
-        :return: The number of jobs remaining to complete the transfer
-        """
-        return self._transfer_states[transfer_id].decrement_jobs_to_complete()
-
-
-class TransferState:
-    """Represents the current state of an individual transfer"""
-
-    # NOTE: Ideally the TransferState object would be used directly by the
-    # various different abstractions in the ProcessPoolDownloader and remove
-    # the need for the TransferMonitor. However, it would then impose the
-    # constraint that two hops are required to make or get any changes in the
-    # state of a transfer across processes: one hop to get a proxy object for
-    # the TransferState and then a second hop to communicate calling the
-    # specific TransferState method.
-    def __init__(self):
-        self._exception = None
-        self._done_event = threading.Event()
-        self._job_lock = threading.Lock()
-        self._jobs_to_complete = 0
-
-    @property
-    def done(self):
-        return self._done_event.is_set()
-
-    def set_done(self):
-        self._done_event.set()
-
-    def wait_till_done(self):
-        self._done_event.wait(MAXINT)
-
-    @property
-    def exception(self):
-        return self._exception
-
-    @exception.setter
-    def exception(self, val):
-        self._exception = val
-
-    @property
-    def jobs_to_complete(self):
-        return self._jobs_to_complete
-
-    @jobs_to_complete.setter
-    def jobs_to_complete(self, val):
-        self._jobs_to_complete = val
-
-    def decrement_jobs_to_complete(self):
-        with self._job_lock:
-            self._jobs_to_complete -= 1
-            return self._jobs_to_complete
-
-
-class TransferMonitorManager(BaseManager):
-    pass
-
-
-TransferMonitorManager.register('TransferMonitor', TransferMonitor)
-
-
-class BaseS3TransferProcess(multiprocessing.Process):
-    def __init__(self, client_factory):
-        super().__init__()
-        self._client_factory = client_factory
-        self._client = None
-
-    def run(self):
-        # Clients are not pickleable so their instantiation cannot happen
-        # in the __init__ for processes that are created under the
-        # spawn method.
-        self._client = self._client_factory.create_client()
-        with ignore_ctrl_c():
-            # By default these processes are ran as child processes to the
-            # main process. Any Ctrl-c encountered in the main process is
-            # propagated to the child process and interrupt it at any time.
-            # To avoid any potentially bad states caused from an interrupt
-            # (i.e. a transfer failing to notify its done or making the
-            # communication protocol become out of sync with the
-            # TransferMonitor), we ignore all Ctrl-C's and allow the main
-            # process to notify these child processes when to stop processing
-            # jobs.
-            self._do_run()
-
-    def _do_run(self):
-        raise NotImplementedError('_do_run()')
-
-
-class GetObjectSubmitter(BaseS3TransferProcess):
-    def __init__(
-        self,
-        transfer_config,
-        client_factory,
-        transfer_monitor,
-        osutil,
-        download_request_queue,
-        worker_queue,
-    ):
-        """Submit GetObjectJobs to fulfill a download file request
-
-        :param transfer_config: Configuration for transfers.
-        :param client_factory: ClientFactory for creating S3 clients.
-        :param transfer_monitor: Monitor for notifying and retrieving state
-            of transfer.
-        :param osutil: OSUtils object to use for os-related behavior when
-            performing the transfer.
-        :param download_request_queue: Queue to retrieve download file
-            requests.
-        :param worker_queue: Queue to submit GetObjectJobs for workers
-            to perform.
-        """
-        super().__init__(client_factory)
-        self._transfer_config = transfer_config
-        self._transfer_monitor = transfer_monitor
-        self._osutil = osutil
-        self._download_request_queue = download_request_queue
-        self._worker_queue = worker_queue
-
-    def _do_run(self):
-        while True:
-            download_file_request = self._download_request_queue.get()
-            if download_file_request == SHUTDOWN_SIGNAL:
-                logger.debug('Submitter shutdown signal received.')
-                return
-            try:
-                self._submit_get_object_jobs(download_file_request)
-            except Exception as e:
-                logger.debug(
-                    'Exception caught when submitting jobs for '
-                    'download file request %s: %s',
-                    download_file_request,
-                    e,
-                    exc_info=True,
-                )
-                self._transfer_monitor.notify_exception(
-                    download_file_request.transfer_id, e
-                )
-                self._transfer_monitor.notify_done(
-                    download_file_request.transfer_id
-                )
-
-    def _submit_get_object_jobs(self, download_file_request):
-        size = self._get_size(download_file_request)
-        temp_filename = self._allocate_temp_file(download_file_request, size)
-        if size < self._transfer_config.multipart_threshold:
-            self._submit_single_get_object_job(
-                download_file_request, temp_filename
-            )
-        else:
-            self._submit_ranged_get_object_jobs(
-                download_file_request, temp_filename, size
-            )
-
-    def _get_size(self, download_file_request):
-        expected_size = download_file_request.expected_size
-        if expected_size is None:
-            expected_size = self._client.head_object(
-                Bucket=download_file_request.bucket,
-                Key=download_file_request.key,
-                **download_file_request.extra_args,
-            )['ContentLength']
-        return expected_size
-
-    def _allocate_temp_file(self, download_file_request, size):
-        temp_filename = self._osutil.get_temp_filename(
-            download_file_request.filename
-        )
-        self._osutil.allocate(temp_filename, size)
-        return temp_filename
-
-    def _submit_single_get_object_job(
-        self, download_file_request, temp_filename
-    ):
-        self._notify_jobs_to_complete(download_file_request.transfer_id, 1)
-        self._submit_get_object_job(
-            transfer_id=download_file_request.transfer_id,
-            bucket=download_file_request.bucket,
-            key=download_file_request.key,
-            temp_filename=temp_filename,
-            offset=0,
-            extra_args=download_file_request.extra_args,
-            filename=download_file_request.filename,
-        )
-
-    def _submit_ranged_get_object_jobs(
-        self, download_file_request, temp_filename, size
-    ):
-        part_size = self._transfer_config.multipart_chunksize
-        num_parts = calculate_num_parts(size, part_size)
-        self._notify_jobs_to_complete(
-            download_file_request.transfer_id, num_parts
-        )
-        for i in range(num_parts):
-            offset = i * part_size
-            range_parameter = calculate_range_parameter(
-                part_size, i, num_parts
-            )
-            get_object_kwargs = {'Range': range_parameter}
-            get_object_kwargs.update(download_file_request.extra_args)
-            self._submit_get_object_job(
-                transfer_id=download_file_request.transfer_id,
-                bucket=download_file_request.bucket,
-                key=download_file_request.key,
-                temp_filename=temp_filename,
-                offset=offset,
-                extra_args=get_object_kwargs,
-                filename=download_file_request.filename,
-            )
-
-    def _submit_get_object_job(self, **get_object_job_kwargs):
-        self._worker_queue.put(GetObjectJob(**get_object_job_kwargs))
-
-    def _notify_jobs_to_complete(self, transfer_id, jobs_to_complete):
-        logger.debug(
-            'Notifying %s job(s) to complete for transfer_id %s.',
-            jobs_to_complete,
-            transfer_id,
-        )
-        self._transfer_monitor.notify_expected_jobs_to_complete(
-            transfer_id, jobs_to_complete
-        )
-
-
-class GetObjectWorker(BaseS3TransferProcess):
-    # TODO: It may make sense to expose these class variables as configuration
-    # options if users want to tweak them.
-    _MAX_ATTEMPTS = 5
-    _IO_CHUNKSIZE = 2 * MB
-
-    def __init__(self, queue, client_factory, transfer_monitor, osutil):
-        """Fulfills GetObjectJobs
-
-        Downloads the S3 object, writes it to the specified file, and
-        renames the file to its final location if it completes the final
-        job for a particular transfer.
-
-        :param queue: Queue for retrieving GetObjectJob's
-        :param client_factory: ClientFactory for creating S3 clients
-        :param transfer_monitor: Monitor for notifying
-        :param osutil: OSUtils object to use for os-related behavior when
-            performing the transfer.
-        """
-        super().__init__(client_factory)
-        self._queue = queue
-        self._client_factory = client_factory
-        self._transfer_monitor = transfer_monitor
-        self._osutil = osutil
-
-    def _do_run(self):
-        while True:
-            job = self._queue.get()
-            if job == SHUTDOWN_SIGNAL:
-                logger.debug('Worker shutdown signal received.')
-                return
-            if not self._transfer_monitor.get_exception(job.transfer_id):
-                self._run_get_object_job(job)
-            else:
-                logger.debug(
-                    'Skipping get object job %s because there was a previous '
-                    'exception.',
-                    job,
-                )
-            remaining = self._transfer_monitor.notify_job_complete(
-                job.transfer_id
-            )
-            logger.debug(
-                '%s jobs remaining for transfer_id %s.',
-                remaining,
-                job.transfer_id,
-            )
-            if not remaining:
-                self._finalize_download(
-                    job.transfer_id, job.temp_filename, job.filename
-                )
-
-    def _run_get_object_job(self, job):
-        try:
-            self._do_get_object(
-                bucket=job.bucket,
-                key=job.key,
-                temp_filename=job.temp_filename,
-                extra_args=job.extra_args,
-                offset=job.offset,
-            )
-        except Exception as e:
-            logger.debug(
-                'Exception caught when downloading object for '
-                'get object job %s: %s',
-                job,
-                e,
-                exc_info=True,
-            )
-            self._transfer_monitor.notify_exception(job.transfer_id, e)
-
-    def _do_get_object(self, bucket, key, extra_args, temp_filename, offset):
-        last_exception = None
-        for i in range(self._MAX_ATTEMPTS):
-            try:
-                response = self._client.get_object(
-                    Bucket=bucket, Key=key, **extra_args
-                )
-                self._write_to_file(temp_filename, offset, response['Body'])
-                return
-            except S3_RETRYABLE_DOWNLOAD_ERRORS as e:
-                logger.debug(
-                    'Retrying exception caught (%s), '
-                    'retrying request, (attempt %s / %s)',
-                    e,
-                    i + 1,
-                    self._MAX_ATTEMPTS,
-                    exc_info=True,
-                )
-                last_exception = e
-        raise RetriesExceededError(last_exception)
-
-    def _write_to_file(self, filename, offset, body):
-        with open(filename, 'rb+') as f:
-            f.seek(offset)
-            chunks = iter(lambda: body.read(self._IO_CHUNKSIZE), b'')
-            for chunk in chunks:
-                f.write(chunk)
-
-    def _finalize_download(self, transfer_id, temp_filename, filename):
-        if self._transfer_monitor.get_exception(transfer_id):
-            self._osutil.remove_file(temp_filename)
-        else:
-            self._do_file_rename(transfer_id, temp_filename, filename)
-        self._transfer_monitor.notify_done(transfer_id)
-
-    def _do_file_rename(self, transfer_id, temp_filename, filename):
-        try:
-            self._osutil.rename_file(temp_filename, filename)
-        except Exception as e:
-            self._transfer_monitor.notify_exception(transfer_id, e)
-            self._osutil.remove_file(temp_filename)

spaces/BlitzenPrancer/TheBloke-guanaco-65B-HF/app.py

@@ -1,3 +0,0 @@
-import gradio as gr
-
-gr.Interface.load("models/TheBloke/guanaco-65B-HF").launch()

spaces/CVPR/Dual-Key_Backdoor_Attacks/datagen/detectron2/detectron2/layers/roi_align.py

@@ -1,105 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
-from torch import nn
-from torch.autograd import Function
-from torch.autograd.function import once_differentiable
-from torch.nn.modules.utils import _pair
-
-from detectron2 import _C
-
-
-class _ROIAlign(Function):
-    @staticmethod
-    def forward(ctx, input, roi, output_size, spatial_scale, sampling_ratio, aligned):
-        ctx.save_for_backward(roi)
-        ctx.output_size = _pair(output_size)
-        ctx.spatial_scale = spatial_scale
-        ctx.sampling_ratio = sampling_ratio
-        ctx.input_shape = input.size()
-        ctx.aligned = aligned
-        output = _C.roi_align_forward(
-            input, roi, spatial_scale, output_size[0], output_size[1], sampling_ratio, aligned
-        )
-        return output
-
-    @staticmethod
-    @once_differentiable
-    def backward(ctx, grad_output):
-        rois, = ctx.saved_tensors
-        output_size = ctx.output_size
-        spatial_scale = ctx.spatial_scale
-        sampling_ratio = ctx.sampling_ratio
-        bs, ch, h, w = ctx.input_shape
-        grad_input = _C.roi_align_backward(
-            grad_output,
-            rois,
-            spatial_scale,
-            output_size[0],
-            output_size[1],
-            bs,
-            ch,
-            h,
-            w,
-            sampling_ratio,
-            ctx.aligned,
-        )
-        return grad_input, None, None, None, None, None
-
-
-roi_align = _ROIAlign.apply
-
-
-class ROIAlign(nn.Module):
-    def __init__(self, output_size, spatial_scale, sampling_ratio, aligned=True):
-        """
-        Args:
-            output_size (tuple): h, w
-            spatial_scale (float): scale the input boxes by this number
-            sampling_ratio (int): number of inputs samples to take for each output
-                sample. 0 to take samples densely.
-            aligned (bool): if False, use the legacy implementation in
-                Detectron. If True, align the results more perfectly.
-
-        Note:
-            The meaning of aligned=True:
-
-            Given a continuous coordinate c, its two neighboring pixel indices (in our
-            pixel model) are computed by floor(c - 0.5) and ceil(c - 0.5). For example,
-            c=1.3 has pixel neighbors with discrete indices [0] and [1] (which are sampled
-            from the underlying signal at continuous coordinates 0.5 and 1.5). But the original
-            roi_align (aligned=False) does not subtract the 0.5 when computing neighboring
-            pixel indices and therefore it uses pixels with a slightly incorrect alignment
-            (relative to our pixel model) when performing bilinear interpolation.
-
-            With `aligned=True`,
-            we first appropriately scale the ROI and then shift it by -0.5
-            prior to calling roi_align. This produces the correct neighbors; see
-            detectron2/tests/test_roi_align.py for verification.
-
-            The difference does not make a difference to the model's performance if
-            ROIAlign is used together with conv layers.
-        """
-        super(ROIAlign, self).__init__()
-        self.output_size = output_size
-        self.spatial_scale = spatial_scale
-        self.sampling_ratio = sampling_ratio
-        self.aligned = aligned
-
-    def forward(self, input, rois):
-        """
-        Args:
-            input: NCHW images
-            rois: Bx5 boxes. First column is the index into N. The other 4 columns are xyxy.
-        """
-        assert rois.dim() == 2 and rois.size(1) == 5
-        return roi_align(
-            input, rois, self.output_size, self.spatial_scale, self.sampling_ratio, self.aligned
-        )
-
-    def __repr__(self):
-        tmpstr = self.__class__.__name__ + "("
-        tmpstr += "output_size=" + str(self.output_size)
-        tmpstr += ", spatial_scale=" + str(self.spatial_scale)
-        tmpstr += ", sampling_ratio=" + str(self.sampling_ratio)
-        tmpstr += ", aligned=" + str(self.aligned)
-        tmpstr += ")"
-        return tmpstr

spaces/CVPR/WALT/mmdet/utils/contextmanagers.py

@@ -1,121 +0,0 @@
-import asyncio
-import contextlib
-import logging
-import os
-import time
-from typing import List
-
-import torch
-
-logger = logging.getLogger(__name__)
-
-DEBUG_COMPLETED_TIME = bool(os.environ.get('DEBUG_COMPLETED_TIME', False))
-
-
-@contextlib.asynccontextmanager
-async def completed(trace_name='',
-                    name='',
-                    sleep_interval=0.05,
-                    streams: List[torch.cuda.Stream] = None):
-    """Async context manager that waits for work to complete on given CUDA
-    streams."""
-    if not torch.cuda.is_available():
-        yield
-        return
-
-    stream_before_context_switch = torch.cuda.current_stream()
-    if not streams:
-        streams = [stream_before_context_switch]
-    else:
-        streams = [s if s else stream_before_context_switch for s in streams]
-
-    end_events = [
-        torch.cuda.Event(enable_timing=DEBUG_COMPLETED_TIME) for _ in streams
-    ]
-
-    if DEBUG_COMPLETED_TIME:
-        start = torch.cuda.Event(enable_timing=True)
-        stream_before_context_switch.record_event(start)
-
-        cpu_start = time.monotonic()
-    logger.debug('%s %s starting, streams: %s', trace_name, name, streams)
-    grad_enabled_before = torch.is_grad_enabled()
-    try:
-        yield
-    finally:
-        current_stream = torch.cuda.current_stream()
-        assert current_stream == stream_before_context_switch
-
-        if DEBUG_COMPLETED_TIME:
-            cpu_end = time.monotonic()
-        for i, stream in enumerate(streams):
-            event = end_events[i]
-            stream.record_event(event)
-
-        grad_enabled_after = torch.is_grad_enabled()
-
-        # observed change of torch.is_grad_enabled() during concurrent run of
-        # async_test_bboxes code
-        assert (grad_enabled_before == grad_enabled_after
-                ), 'Unexpected is_grad_enabled() value change'
-
-        are_done = [e.query() for e in end_events]
-        logger.debug('%s %s completed: %s streams: %s', trace_name, name,
-                     are_done, streams)
-        with torch.cuda.stream(stream_before_context_switch):
-            while not all(are_done):
-                await asyncio.sleep(sleep_interval)
-                are_done = [e.query() for e in end_events]
-                logger.debug(
-                    '%s %s completed: %s streams: %s',
-                    trace_name,
-                    name,
-                    are_done,
-                    streams,
-                )
-
-        current_stream = torch.cuda.current_stream()
-        assert current_stream == stream_before_context_switch
-
-        if DEBUG_COMPLETED_TIME:
-            cpu_time = (cpu_end - cpu_start) * 1000
-            stream_times_ms = ''
-            for i, stream in enumerate(streams):
-                elapsed_time = start.elapsed_time(end_events[i])
-                stream_times_ms += f' {stream} {elapsed_time:.2f} ms'
-            logger.info('%s %s %.2f ms %s', trace_name, name, cpu_time,
-                        stream_times_ms)
-
-
-@contextlib.asynccontextmanager
-async def concurrent(streamqueue: asyncio.Queue,
-                     trace_name='concurrent',
-                     name='stream'):
-    """Run code concurrently in different streams.
-
-    :param streamqueue: asyncio.Queue instance.
-
-    Queue tasks define the pool of streams used for concurrent execution.
-    """
-    if not torch.cuda.is_available():
-        yield
-        return
-
-    initial_stream = torch.cuda.current_stream()
-
-    with torch.cuda.stream(initial_stream):
-        stream = await streamqueue.get()
-        assert isinstance(stream, torch.cuda.Stream)
-
-        try:
-            with torch.cuda.stream(stream):
-                logger.debug('%s %s is starting, stream: %s', trace_name, name,
-                             stream)
-                yield
-                current = torch.cuda.current_stream()
-                assert current == stream
-                logger.debug('%s %s has finished, stream: %s', trace_name,
-                             name, stream)
-        finally:
-            streamqueue.task_done()
-            streamqueue.put_nowait(stream)

spaces/CVPR/transfiner/configs/common/data/coco_keypoint.py

@@ -1,13 +0,0 @@
-from detectron2.data.detection_utils import create_keypoint_hflip_indices
-
-from .coco import dataloader
-
-dataloader.train.dataset.min_keypoints = 1
-dataloader.train.dataset.names = "keypoints_coco_2017_train"
-dataloader.test.dataset.names = "keypoints_coco_2017_val"
-
-dataloader.train.mapper.update(
-    use_instance_mask=False,
-    use_keypoint=True,
-    keypoint_hflip_indices=create_keypoint_hflip_indices(dataloader.train.dataset.names),
-)

spaces/Chris1/real2sim/README.md

@@ -1,13 +0,0 @@
----
-title: Real2sim
-emoji: 👁
-colorFrom: yellow
-colorTo: green
-sdk: gradio
-sdk_version: 2.9.4
-app_file: app.py
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces#reference

spaces/CobaltZvc/sherlocks_pheonix/index.html

@@ -1,29 +0,0 @@
-<!DOCTYPE html>
-<html>
-<head>
-	<title>Sherlock's Phoenix</title>
-</head>
-<body>
-	<div style="text-align: center;">
-		<iframe id="myIframe"
-			frameborder="0"
-			style="width: 100%; max-width: 850px; height: 2000px;"
-		></iframe>
-	</div>
-	<script>
-		// Fetch the content of Read.txt from the Hugging Face repository
-		fetch('Read.txt')
-		.then(response => response.text())
-		.then(data => {
-			// Fetch the content of the linked file from GitHub repository
-			return fetch(data.trim());
-		})
-		.then(response => response.text())
-		.then(data => {
-			const myIframe = document.getElementById('myIframe');
-			myIframe.src = data.trim();
-		})
-		.catch(error => console.error(error));
-	</script>
-</body>
-</html>

spaces/CompVis/celeba-latent-diffusion/app.py

@@ -1,26 +0,0 @@
-from diffusers import LDMPipeline
-import torch
-import PIL.Image
-import gradio as gr
-import random
-import numpy as np
-
-pipeline = LDMPipeline.from_pretrained("CompVis/ldm-celebahq-256")
-
-def predict(steps, seed):
-    generator = torch.manual_seed(seed)
-    for i in range(1,steps):
-        yield pipeline(generator=generator, num_inference_steps=i)["sample"][0]
-
-random_seed = random.randint(0, 2147483647)
-gr.Interface(
-    predict,
-    inputs=[
-        gr.inputs.Slider(1, 100, label='Inference Steps', default=5, step=1),
-        gr.inputs.Slider(0, 2147483647, label='Seed', default=random_seed, step=1),
-    ],
-    outputs=gr.Image(shape=[256,256], type="pil", elem_id="output_image"),
-    css="#output_image{width: 256px}",
-    title="ldm-celebahq-256 - 🧨 diffusers library",
-    description="This Spaces contains an unconditional Latent Diffusion process for the <a href=\"https://huggingface.co/CompVis/ldm-celebahq-256\">ldm-celebahq-256</a> face generator model by <a href=\"https://huggingface.co/CompVis\">CompVis</a> using the <a href=\"https://github.com/huggingface/diffusers\">diffusers library</a>. The goal of this demo is to showcase the diffusers library capabilities. If you want the state-of-the-art experience with Latent Diffusion text-to-image check out the <a href=\"https://huggingface.co/spaces/multimodalart/latentdiffusion\">main Spaces</a>.",
-).queue().launch()

spaces/DAMO-NLP-SG/Video-LLaMA/video_llama/tasks/video_text_pretrain.py

@@ -1,18 +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.common.registry import registry
-from video_llama.tasks.base_task import BaseTask
-
-
-@registry.register_task("video_text_pretrain")
-class VideoTextPretrainTask(BaseTask):
-    def __init__(self):
-        super().__init__()
-
-    def evaluation(self, model, data_loader, cuda_enabled=True):
-        pass