Datasets:

Weyaxi
/

huggingface-spaces-codes

@@ -1,9 +0,0 @@
-from dataclasses import dataclass
-@dataclass
-class AiColorsResponse:
-    background: str
-    primary: str
-    accent: str
-    text: str

spaces/1phancelerku/anime-remove-background/Download 1 Pound by Brymo the Nigerian Singer Songwriter and Author.md DELETED Viewed

@@ -1,83 +0,0 @@
-<br />
-<h1>Brymo 1 Pound Mp3 Download: Everything You Need to Know</h1>
-<p>If you are a fan of Nigerian music, you have probably heard of Brymo, one of the most talented and versatile artists in the industry. His song 1 Pound is a masterpiece that showcases his unique style and voice. In this article, we will tell you everything you need to know about Brymo and 1 Pound, including who he is, what the song is about, how to download it and why you should listen to it.</p>
-<h2>brymo 1 pound mp3 download</h2><br /><p><b><b>Download File</b> --->>> <a href="https://jinyurl.com/2uNLLk">https://jinyurl.com/2uNLLk</a></b></p><br /><br />
- <h2>Who is Brymo?</h2>
-<p>Brymo is the stage name of Olawale Ashimi, a Nigerian singer, songwriter, composer and author. He was born on May 9, 1986 in Okokomaiko, Ojo, Lagos State. He started recording music in 1999 while in secondary school. He signed a record deal with Chocolate City in 2010 but left the label in 2013 due to contractual disputes. He has since released several albums independently, such as Merchants, Dealers & Slaves (2013), Tabula Rasa (2014), Klĭtôrĭs (2016), Oṣó (2018), Yellow (2020) and Theta (2022). He has also published three books: Oriri's Plight (2018), Verses (2020) and The Bad Tooth (2022). He is widely regarded as one of the best vocalists and lyricists in Nigeria. He has won several awards and nominations for his music, such as The Headies, Nigeria Entertainment Awards and All Africa Music Awards. He is known for his fusion of various genres, such as folk, pop, afrobeat, soul and rock. He sings mostly in English and Yoruba languages.</p>
- <h2>What is 1 Pound?</h2>
-<p>1 Pound is a song by Brymo that was released in 2021 as part of his compilation album Trance. The song is an alternative rock track that features electric guitars, drums and keyboards. The song is about Brymo's journey as an artist and his determination to succeed despite the challenges he faces. The title refers to the British currency that Brymo uses as a metaphor for his value and worth. The lyrics are motivational and empowering, as Brymo sings about his dreams, his struggles and his achievements. He also encourages his listeners to pursue their own goals and not give up on their passions. Some of the lines from the song are:</p>
-<blockquote>
-<p>"I'm worth more than a pound<br>
-But they don't wanna pay me<br>
-They say I'm too loud<br>
-But they don't wanna hear me"</p>
-<p>"I've been around<br>
-But they don't wanna see me<br>
-They say I'm too proud<br>
-But they don't wanna feel me"</p>
-<p>"I'm a star in the sky<br>
-But they don't wanna look up<br>
-They say I'm too high<br>
-But they don't wanna hook up"</p>
-</blockquote>
- <h2>How to download 1 Pound mp3?</h2>
-<p>If you want to download 1 Pound mp3 by Brymo, you have several options to choose from. You can either stream or download the song from various platforms online. Here are some of the ways you can get the song:</p>
-<ul>
-<li><strong>PraiseZion</strong>: This is a website that offers free downloads of gospel and inspirational songs from Nigerian artists. You can find 1 Pound by Brymo on this site by searching for the song title or the artist name. You can also browse through the categories and genres to find similar songs. To download the song, you need to click on the download button and wait for the file to be saved on your device. You can also play the song online before downloading it. The website also provides the lyrics and the video of the song for your convenience.</li>
-<li><strong>iTunes</strong>: This is a digital media store that offers music, podcasts, movies, TV shows and more. You can access iTunes from your computer, smartphone or tablet. You need to have an Apple ID and a payment method to purchase content from iTunes. You can find 1 Pound by Brymo on iTunes by searching for the song title or the artist name. You can also browse through the categories and genres to find similar songs. To download the song, you need to click on the buy button and confirm your purchase. The song will be added to your library and you can sync it with your other devices. You can also stream the song online using Apple Music.</li>
-<li><strong>Spotify</strong>: This is a streaming service that offers music, podcasts, playlists and more. You can access Spotify from your computer, smartphone or tablet. You need to have a Spotify account and an internet connection to use Spotify. You can find 1 Pound by Brymo on Spotify by searching for the song title or the artist name. You can also browse through the categories and genres to find similar songs. To download the song, you need to have a Spotify Premium subscription, which allows you to download up to 10,000 songs on five devices. You can also stream the song online using Spotify Free or Spotify Premium.</li>
-<li><strong>YouTube</strong>: This is a video-sharing platform that offers videos, music, live streams, channels and more. You can access YouTube from your computer, smartphone or tablet. You do not need an account to watch videos on YouTube, but you need one to upload, comment, like and subscribe. You can find 1 Pound by Brymo on YouTube by searching for the song title or the artist name. You can also browse through the categories and genres to find similar songs. To download the song, you need to use a third-party tool, such as YouTube Downloader, which allows you to convert and save YouTube videos as mp3 files on your device. You can also stream the song online using YouTube.</li>
-</ul>
- <h2>Why you should listen to 1 Pound?</h2>
-<p>Now that you know how to download 1 Pound mp3 by Brymo, you might be wondering why you should listen to it in the first place. Well, there are many reasons why this song is worth your time and attention. Here are some of them:</p>
-<ul>
-<li><strong>It is inspirational</strong>: The song is a motivational anthem that inspires you to chase your dreams and overcome your obstacles. It tells you that you are valuable and capable of achieving anything you set your mind to. It also reminds you that you are not alone in your journey and that there are people who support and appreciate you.</li>
-<li><strong>It is cultural</strong>: The song is a reflection of Brymo's Nigerian identity and heritage. It incorporates elements of his native language, Yoruba, as well as references to his country's history, politics and society. It also celebrates his African roots and expresses his pride in his continent.</li>
-<li><strong>It is artistic</strong>: The song is a showcase of Brymo's musical talent and creativity. It features his distinctive voice, which ranges from soft and smooth to powerful and passionate. It also displays his lyrical skills, which are poetic, witty and profound. It also demonstrates his musical versatility, which blends different genres and influences into a cohesive and original sound.</li>
-</ul>
- <h2>Conclusion</h2>
-<p>In conclusion, 1 Pound by Brymo is a song that you should not miss out on. It is a song that tells you about Brymo's life story and his artistic vision. It is a song that teaches you about Nigerian culture and history. It is a song that motivates you to pursue your goals and passions. It is a song that entertains you with its catchy melody and captivating performance. It is a song that deserves your download and your listen.</p>
-<p>So what are you waiting for? Go ahead and download 1 Pound mp3 by Brymo today and enjoy this amazing track!</p>
-<p>brymo 1 pound song lyrics and video<br />
-brymo 1 pound audio download free<br />
-brymo 1 pound mp3 download praisezion<br />
-brymo 1 pound naija music download<br />
-brymo 1 pound latest song 2021<br />
-brymo 1 pound mp3 download tooxclusive<br />
-brymo 1 pound official video youtube<br />
-brymo 1 pound song meaning and review<br />
-brymo 1 pound mp3 download naijaloaded<br />
-brymo 1 pound album download zip<br />
-brymo 1 pound instrumental download<br />
-brymo 1 pound mp3 download fakaza<br />
-brymo 1 pound song download waploaded<br />
-brymo 1 pound mp3 download skull<br />
-brymo 1 pound remix ft davido<br />
-brymo 1 pound mp3 download mdundo<br />
-brymo 1 pound song download audiomack<br />
-brymo 1 pound mp3 download musicpleer<br />
-brymo 1 pound live performance video<br />
-brymo 1 pound mp3 download justnaija<br />
-brymo 1 pound song download pagalworld<br />
-brymo 1 pound mp3 download naijavibes<br />
-brymo 1 pound song download mr jatt<br />
-brymo 1 pound mp3 download waptrick<br />
-brymo 1 pound cover by johnny drille<br />
-brymo 1 pound mp3 download afrobeat.co.za<br />
-brymo 1 pound song download djpunjab<br />
-brymo 1 pound mp3 download flexyjam<br />
-brymo 1 pound acoustic version download<br />
-brymo 1 pound mp3 download zamusic</p>
- <h2>FAQs</h2>
-<h3>Q: When did Brymo release 1 Pound?</h3>
-<p>A: Brymo released 1 Pound in 2021 as part of his compilation album Trance.</p>
- <h3>Q: What does 1 Pound mean?</h3>
-<p>A: 1 Pound is a metaphor for Brymo's value and worth as an artist and as a person.</ p>A: 1 Pound is a metaphor for Brymo's value and worth as an artist and as a person. He uses the British currency to symbolize his international recognition and appeal.</p>
- <h3>Q: What genre is 1 Pound?</h3>
-<p>A: 1 Pound is an alternative rock song that features electric guitars, drums and keyboards. It is influenced by Brymo's diverse musical tastes and experiences.</p>
- <h3>Q: Where can I download 1 Pound mp3?</h3>
-<p>A: You can download 1 Pound mp3 from various platforms online, such as PraiseZion, iTunes, Spotify and YouTube. You can also stream the song online using these platforms.</p>
- <h3>Q: What are some of the benefits of listening to 1 Pound?</h3>
-<p>A: Some of the benefits of listening to 1 Pound are that it is inspirational, cultural and artistic. It inspires you to chase your dreams and overcome your obstacles. It teaches you about Nigerian culture and history. It entertains you with its catchy melody and captivating performance.</p> 401be4b1e0<br />
-<br />
-<br />

spaces/1phancelerku/anime-remove-background/Download quiz submissions in Canvas and use Quiz statistics to analyze them.md DELETED Viewed

@@ -1,119 +0,0 @@
-<br />
-<h1>How to Download Quiz Submissions in Canvas</h1>
-<p>Canvas is a popular learning management system (LMS) that allows instructors and students to create, manage, and share online courses. Canvas offers various features and tools to enhance online learning, such as quizzes, assignments, discussions, grades, and more.</p>
-<p>Quizzes are one of the most common types of assessments in Canvas. They can be used to test students' knowledge, skills, or understanding of a topic. Quizzes can be created using either the legacy quiz tool or the new quiz tool in Canvas. Quizzes can have different question types, such as multiple choice, true/false, fill-in-the-blank, essay, etc.</p>
-<h2>canvas download quiz submissions</h2><br /><p><b><b>Download Zip</b> &#11088; <a href="https://jinyurl.com/2uNTGs">https://jinyurl.com/2uNTGs</a></b></p><br /><br />
-<p>Sometimes, you might want to download quiz submissions from Canvas for various reasons. For example, you might want to:</p>
-<ul>
-<li>Analyze the quiz results offline or with another software</li>
-<li>Print or share the quiz responses with others</li>
-<li>Keep a backup or archive of the quiz submissions</li>
-<li>Review or grade the quiz submissions manually</li>
-</ul>
-<p>Downloading quiz submissions from Canvas can be beneficial, but it can also pose some challenges. For instance, you might encounter issues such as:</p>
-<ul>
-<li>Not being able to download quiz submissions for certain question types or formats</li>
-<li>Not being able to download quiz submissions with instructor annotations or feedback</li>
-<li>Not being able to download quiz submissions for group assignments or quizzes that are not graded</li>
-<li>Not being able to download quiz submissions for quizzes that have been concluded or deleted</li>
-<li>Not being able to view or open the downloaded files properly</li>
-</ul>
-<p>In this article, we will show you how to download quiz submissions in Canvas using different methods. We will also provide some tips and best practices for downloading quiz submissions effectively. Let's get started!</p>
- <h2>How to Download Quiz Submissions in Canvas Legacy Quizzes</h2>
-<p>The legacy quiz tool is the original quiz tool in Canvas. It allows you to create quizzes with various question types and settings. You can also view quiz statistics and reports for each quiz.</p>
-<p>To download quiz submissions in Canvas legacy quizzes, follow these steps:</p>
- <h3>Step 1: Go to the quiz page and click on "Download Submissions"</h3>
-<p>Navigate to your course site and click on "Quizzes" in the left-hand menu. Then, click on the name of the quiz that you want to download submissions for. On the right side of the screen, you will see a link that says " Download Submissions". Click on this link to start the download process.</p>
-<p>How to download quiz submissions in Canvas LMS<br />
-Canvas quiz submission download function<br />
-Downloading multiple-choice quiz answers in Canvas<br />
-Canvas quiz statistics vs quiz submission download<br />
-Download and re-upload marked quiz submissions in Canvas<br />
-Canvas bulk download of quiz submissions<br />
-Download quiz submissions as ZIP file in Canvas<br />
-Canvas download quiz submissions with images<br />
-Download quiz submissions by course in Canvas<br />
-Canvas download quiz submissions for offline grading<br />
-How to filter quiz submission download in Canvas<br />
-Canvas download quiz submissions for group assignments<br />
-Download annotated quiz submissions in Canvas<br />
-Canvas download quiz submissions with comments<br />
-Download quiz submissions with resubmissions in Canvas<br />
-Canvas download quiz submissions by date range<br />
-Download quiz submissions with rubrics in Canvas<br />
-Canvas download quiz submissions for new quizzes<br />
-Download quiz submissions with feedback in Canvas<br />
-Canvas download quiz submissions for legacy quizzes<br />
-How to open downloaded quiz submissions in Canvas<br />
-Canvas download quiz submissions with file names<br />
-Download quiz submissions with plagiarism reports in Canvas<br />
-Canvas download quiz submissions for different question types<br />
-Download quiz submissions with grades in Canvas<br />
-Canvas download quiz submissions for quizzes with multiple attempts<br />
-Download quiz submissions with late penalties in Canvas<br />
-Canvas download quiz submissions for quizzes with time limits<br />
-Download quiz submissions with partial credit in Canvas<br />
-Canvas download quiz submissions for quizzes with extra credit<br />
-How to view downloaded quiz submissions in Canvas<br />
-Canvas download quiz submissions with attachments<br />
-Download quiz submissions with formulas in Canvas<br />
-Canvas download quiz submissions for quizzes with random questions<br />
-Download quiz submissions with question banks in Canvas<br />
-Canvas download quiz submissions for quizzes with question groups<br />
-Download quiz submissions with matching questions in Canvas<br />
-Canvas download quiz submissions for quizzes with fill-in-the-blank questions<br />
-Download quiz submissions with essay questions in Canvas<br />
-Canvas download quiz submissions for quizzes with numerical questions<br />
-Download quiz submissions with multiple answers questions in Canvas<br />
-Canvas download quiz submissions for quizzes with true/false questions<br />
-Download quiz submissions with text (no question) in Canvas<br />
-Canvas download quiz submissions for quizzes with file upload questions<br />
-Download quiz submissions with media recordings in Canvas<br />
-Canvas download quiz submissions for quizzes with stimulus questions<br />
-Download quiz submissions with hot spot questions in Canvas</p>
- <h3>Step 2: Save the ZIP file and extract it on your computer</h3>
-<p>After clicking on the link, you will see a pop-up window that asks you to save the ZIP file that contains the quiz submissions. Choose a location on your computer where you want to save the file and click on "Save". Then, locate the file on your computer and extract it using a program such as WinZip or 7-Zip.</p>
- <h3>Step 3: View the quiz submissions by course and student name</h3>
-<p>Once you have extracted the ZIP file, you will see a folder that has the same name as the quiz. Inside this folder, you will find subfolders for each course section and student name. Each subfolder contains a PDF file that shows the quiz submission for that student. You can open these files with a PDF reader such as Adobe Acrobat or Preview. You can also print or share these files as needed.</p>
- <h2>How to Download Quiz Submissions in Canvas New Quizzes</h2>
-<p>The new quiz tool is the updated quiz tool in Canvas. It allows you to create quizzes with more question types and options. You can also view quiz analytics and reports for each quiz.</p>
-<p>To download quiz submissions in Canvas new quizzes, follow these steps:</p>
- <h3>Step 1: Go to the quiz page and click on "Reports"</h3>
-<p>Navigate to your course site and click on "Quizzes" in the left-hand menu. Then, click on the name of the quiz that you want to download submissions for. On the right side of the screen, you will see a button that says "Reports". Click on this button to access the reports page.</p>
- <h3>Step 2: Select the report type and click on "Generate"</h3>
-<p>On the reports page, you will see two options for report types: "Student Analysis" and "Item Analysis". The student analysis report shows the quiz results for each student, including their score, answers, and feedback. The item analysis report shows the quiz results for each question, including its difficulty, discrimination, and distractors. Choose the report type that you want to download and click on "Generate". This will create a CSV file that contains the quiz data.</p>
- <h3>Step 3: Download the CSV file and open it with a spreadsheet program</h3>
-<p>After generating the report, you will see a link that says "Download". Click on this link to download the CSV file to your computer. Then, locate the file on your computer and open it with a spreadsheet program such as Microsoft Excel or Google Sheets. You can view, sort, filter, or analyze the quiz data as needed. You can also print or share this file as needed.</p>
- <h2>How to Download Quiz Submissions in Canvas Assignments</h2>
-<p>Assignments are another type of assessments in Canvas. They can be used to assign tasks, projects, papers, or other types of work to students. Assignments can have different submission types, such as online text entry, file upload, media recording, etc.</p>
-<p>To download quiz submissions in Canvas assignments, follow these steps:</p>
- <h3>Step 1: Go to the assignment page and click on "Download Submissions"</h3>
-<p>Navigate to your course site and click on "Assignments" in the left-hand menu. Then, click on the name of the assignment that you want to download submissions for. On the right side of the screen, you will see a link that says "Download Submissions". Click on this link to start the download process.</p>
- <h3>Step 2: Save the ZIP file and extract it on your computer</h3>
-<p>After clicking on the link, you will see a pop-up window that asks you to save the ZIP file that contains the assignment submissions. Choose a location on your computer where you want to save the file and click on "Save". Then, locate the file on your computer and extract it using a program such as WinZip or 7-Zip.</p>
- <h3>Step 3: View the assignment submissions by course and student name</h3>
-<p>Once you have extracted the ZIP file, you will see a folder that has the same name as the assignment. Inside this folder, you will find subfolders for each course section and student name. Each subfolder contains one or more files that show the assignment submission for that student. You can open these files with an appropriate program depending on their format. For example, if the submission is a Word document, you can open it with Microsoft Word or Google Docs. You can also print or share these files as needed.</p>
- <h2>Conclusion</h2>
-<p>In this article, we have shown you how to download quiz submissions in Canvas using different methods. We have also provided some tips and best practices for downloading quiz submissions effectively. We hope that this article has been helpful and informative for you.</p>
-<p>Downloading quiz submissions from Canvas can be a useful way to review, analyze, or archive the quiz results for your online courses. However, you should also be aware of the limitations and challenges that might arise when downloading quiz submissions. For example, you might not be able to download quiz submissions for certain question types or formats, or with instructor annotations or feedback. You might also not be able to download quiz submissions for group assignments or quizzes that are not graded. Moreover, you might not be able to view or open the downloaded files properly if you do not have the appropriate programs or software.</p>
-<p>Therefore, we recommend that you follow these tips and best practices when downloading quiz submissions from Canvas:</p>
-<ul>
-<li>Check the quiz settings and question types before downloading quiz submissions. Make sure that the quiz allows downloading submissions and that the question types are compatible with the download format.</li>
-<li>Choose the appropriate download method depending on the quiz tool and report type that you want. For legacy quizzes, use the "Download Submissions" link to download PDF files of quiz submissions. For new quizzes, use the "Reports" button to download CSV files of quiz data. For assignments, use the "Download Submissions" link to download ZIP files of assignment submissions.</li>
-<li>Save and extract the downloaded files on your computer and open them with the appropriate programs or software. For PDF files, use a PDF reader such as Adobe Acrobat or Preview. For CSV files, use a spreadsheet program such as Microsoft Excel or Google Sheets. For ZIP files, use a program such as WinZip or 7-Zip.</li>
-<li>View, sort, filter, or analyze the quiz data as needed. You can also print or share the downloaded files as needed.</li>
-</ul>
-<p>If you have any feedback or questions about downloading quiz submissions from Canvas, please feel free to share them with us in the comments section below. We would love to hear from you!</p>
- <h2>FAQs</h2>
-<h3>Can I download quiz submissions for multiple-choice questions only?</h3>
-<p>No, you can download quiz submissions for any question type that is supported by the download format. For legacy quizzes, you can download quiz submissions for any question type except for file upload questions. For new quizzes, you can download quiz data for any question type except for stimulus questions.</p>
- <h3>Can I download quiz submissions with instructor annotations or feedback?</h3>
-<p>No, you cannot download quiz submissions with instructor annotations or feedback. The downloaded files only show the student responses and scores, not the instructor comments or markings.</p>
- <h3>Can I download quiz submissions for group assignments?</h3>
-<p>No, you cannot download quiz submissions for group assignments. The downloaded files only show the individual student submissions and scores, not the group submissions or scores.</p>
- <h3>Can I download quiz submissions for quizzes that are not graded?</h3>
-<p>No, you cannot download quiz submissions for quizzes that are not graded. The downloaded files only show the graded quizzes and scores, not the ungraded quizzes or scores.</p>
- <h3>Can I download quiz submissions for quizzes that have been concluded?</h3>
-<p>Yes, you can download quiz submissions for quizzes that have been concluded. However, you cannot download quiz submissions for quizzes that have been deleted.</p> 401be4b1e0<br />
-<br />
-<br />

spaces/1toTree/lora_test/ppdiffusers/pipelines/stable_diffusion/pipeline_stable_diffusion_depth2img.py DELETED Viewed

@@ -1,553 +0,0 @@
-# Copyright 2022 The HuggingFace Team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-import inspect
-from typing import Callable, List, Optional, Union
-import numpy as np
-import paddle
-import PIL
-from packaging import version
-from paddlenlp.transformers import (
-    CLIPTextModel,
-    CLIPTokenizer,
-    DPTForDepthEstimation,
-    DPTImageProcessor,
-)
-from ...configuration_utils import FrozenDict
-from ...models import AutoencoderKL, UNet2DConditionModel
-from ...pipeline_utils import DiffusionPipeline, ImagePipelineOutput
-from ...schedulers import (
-    DDIMScheduler,
-    DPMSolverMultistepScheduler,
-    EulerAncestralDiscreteScheduler,
-    EulerDiscreteScheduler,
-    LMSDiscreteScheduler,
-    PNDMScheduler,
-)
-from ...utils import PIL_INTERPOLATION, deprecate, logging
-logger = logging.get_logger(__name__)  # pylint: disable=invalid-name
-# Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion_img2img.preprocess
-def preprocess(image):
-    if isinstance(image, paddle.Tensor):
-        return image
-    elif isinstance(image, PIL.Image.Image):
-        image = [image]
-    if isinstance(image[0], PIL.Image.Image):
-        w, h = image[0].size
-        w, h = map(lambda x: x - x % 32, (w, h))  # resize to integer multiple of 32
-        image = [np.array(i.resize((w, h), resample=PIL_INTERPOLATION["lanczos"]))[None, :] for i in image]
-        image = np.concatenate(image, axis=0)
-        image = np.array(image).astype(np.float32) / 255.0
-        image = image.transpose(0, 3, 1, 2)
-        image = 2.0 * image - 1.0
-        image = paddle.to_tensor(image)
-    elif isinstance(image[0], paddle.Tensor):
-        image = paddle.concat(image, axis=0)
-    return image
-class StableDiffusionDepth2ImgPipeline(DiffusionPipeline):
-    r"""
-    Pipeline for text-guided image to image generation using Stable Diffusion.
-    This model inherits from [`DiffusionPipeline`]. Check the superclass documentation for the generic methods the
-    library implements for all the pipelines (such as downloading or saving, running on a particular device, etc.)
-    Args:
-        vae ([`AutoencoderKL`]):
-            Variational Auto-Encoder (VAE) Model to encode and decode images to and from latent representations.
-        text_encoder ([`CLIPTextModel`]):
-            Frozen text-encoder. Stable Diffusion uses the text portion of
-            [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel), specifically
-            the [clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14) variant.
-        tokenizer (`CLIPTokenizer`):
-            Tokenizer of class
-            [CLIPTokenizer](https://huggingface.co/docs/transformers/v4.21.0/en/model_doc/clip#transformers.CLIPTokenizer).
-        unet ([`UNet2DConditionModel`]): Conditional U-Net architecture to denoise the encoded image latents.
-        scheduler ([`SchedulerMixin`]):
-            A scheduler to be used in combination with `unet` to denoise the encoded image latents. Can be one of
-            [`DDIMScheduler`], [`LMSDiscreteScheduler`], or [`PNDMScheduler`].
-    """
-    def __init__(
-        self,
-        vae: AutoencoderKL,
-        text_encoder: CLIPTextModel,
-        tokenizer: CLIPTokenizer,
-        unet: UNet2DConditionModel,
-        scheduler: Union[
-            DDIMScheduler,
-            PNDMScheduler,
-            LMSDiscreteScheduler,
-            EulerDiscreteScheduler,
-            EulerAncestralDiscreteScheduler,
-            DPMSolverMultistepScheduler,
-        ],
-        depth_estimator: DPTForDepthEstimation,
-        feature_extractor: DPTImageProcessor,
-    ):
-        super().__init__()
-        is_unet_version_less_0_9_0 = hasattr(unet.config, "_ppdiffusers_version") and version.parse(
-            version.parse(unet.config._ppdiffusers_version).base_version
-        ) < version.parse("0.9.0.dev0")
-        is_unet_sample_size_less_64 = hasattr(unet.config, "sample_size") and unet.config.sample_size < 64
-        if is_unet_version_less_0_9_0 and is_unet_sample_size_less_64:
-            deprecation_message = (
-                "The configuration file of the unet has set the default `sample_size` to smaller than"
-                " 64 which seems highly unlikely .If you're checkpoint is a fine-tuned version of any of the"
-                " following: \n- CompVis/stable-diffusion-v1-4 \n- CompVis/stable-diffusion-v1-3 \n-"
-                " CompVis/stable-diffusion-v1-2 \n- CompVis/stable-diffusion-v1-1 \n- runwayml/stable-diffusion-v1-5"
-                " \n- runwayml/stable-diffusion-inpainting \n you should change 'sample_size' to 64 in the"
-                " configuration file. Please make sure to update the config accordingly as leaving `sample_size=32`"
-                " in the config might lead to incorrect results in future versions. If you have downloaded this"
-                " checkpoint from the Hugging Face Hub, it would be very nice if you could open a Pull request for"
-                " the `unet/config.json` file"
-            )
-            deprecate("sample_size<64", "1.0.0", deprecation_message, standard_warn=False)
-            new_config = dict(unet.config)
-            new_config["sample_size"] = 64
-            unet._internal_dict = FrozenDict(new_config)
-        self.register_modules(
-            vae=vae,
-            text_encoder=text_encoder,
-            tokenizer=tokenizer,
-            unet=unet,
-            scheduler=scheduler,
-            depth_estimator=depth_estimator,
-            feature_extractor=feature_extractor,
-        )
-        self.vae_scale_factor = 2 ** (len(self.vae.config.block_out_channels) - 1)
-    def _encode_prompt(self, prompt, num_images_per_prompt, do_classifier_free_guidance, negative_prompt):
-        r"""
-        Encodes the prompt into text encoder hidden states.
-        Args:
-            prompt (`str` or `list(int)`):
-                prompt to be encoded
-            num_images_per_prompt (`int`):
-                number of images that should be generated per prompt
-            do_classifier_free_guidance (`bool`):
-                whether to use classifier free guidance or not
-            negative_prompt (`str` or `List[str]`):
-                The prompt or prompts not to guide the image generation. Ignored when not using guidance (i.e., ignored
-                if `guidance_scale` is less than `1`).
-        """
-        batch_size = len(prompt) if isinstance(prompt, list) else 1
-        text_inputs = self.tokenizer(
-            prompt,
-            padding="max_length",
-            max_length=self.tokenizer.model_max_length,
-            truncation=True,
-            return_tensors="pd",
-        )
-        text_input_ids = text_inputs.input_ids
-        untruncated_ids = self.tokenizer(prompt, padding="longest", return_tensors="pd").input_ids
-        if untruncated_ids.shape[-1] >= text_input_ids.shape[-1] and not paddle.equal_all(
-            text_input_ids, untruncated_ids
-        ):
-            removed_text = self.tokenizer.batch_decode(untruncated_ids[:, self.tokenizer.model_max_length - 1 : -1])
-            logger.warning(
-                "The following part of your input was truncated because CLIP can only handle sequences up to"
-                f" {self.tokenizer.model_max_length} tokens: {removed_text}"
-            )
-        config = (
-            self.text_encoder.config
-            if isinstance(self.text_encoder.config, dict)
-            else self.text_encoder.config.to_dict()
-        )
-        if config.get("use_attention_mask", None) is not None and config["use_attention_mask"]:
-            attention_mask = text_inputs.attention_mask
-        else:
-            attention_mask = None
-        text_embeddings = self.text_encoder(
-            text_input_ids,
-            attention_mask=attention_mask,
-        )
-        text_embeddings = text_embeddings[0]
-        # duplicate text embeddings for each generation per prompt, using mps friendly method
-        bs_embed, seq_len, _ = text_embeddings.shape
-        text_embeddings = text_embeddings.tile([1, num_images_per_prompt, 1])
-        text_embeddings = text_embeddings.reshape([bs_embed * num_images_per_prompt, seq_len, -1])
-        # get unconditional embeddings for classifier free guidance
-        if do_classifier_free_guidance:
-            uncond_tokens: List[str]
-            if negative_prompt is None:
-                uncond_tokens = [""] * batch_size
-            elif type(prompt) is not type(negative_prompt):
-                raise TypeError(
-                    f"`negative_prompt` should be the same type to `prompt`, but got {type(negative_prompt)} !="
-                    f" {type(prompt)}."
-                )
-            elif isinstance(negative_prompt, str):
-                uncond_tokens = [negative_prompt]
-            elif batch_size != len(negative_prompt):
-                raise ValueError(
-                    f"`negative_prompt`: {negative_prompt} has batch size {len(negative_prompt)}, but `prompt`:"
-                    f" {prompt} has batch size {batch_size}. Please make sure that passed `negative_prompt` matches"
-                    " the batch size of `prompt`."
-                )
-            else:
-                uncond_tokens = negative_prompt
-            max_length = text_input_ids.shape[-1]
-            uncond_input = self.tokenizer(
-                uncond_tokens,
-                padding="max_length",
-                max_length=max_length,
-                truncation=True,
-                return_tensors="pd",
-            )
-            if config.get("use_attention_mask", None) is not None and config["use_attention_mask"]:
-                attention_mask = uncond_input.attention_mask
-            else:
-                attention_mask = None
-            uncond_embeddings = self.text_encoder(
-                uncond_input.input_ids,
-                attention_mask=attention_mask,
-            )
-            uncond_embeddings = uncond_embeddings[0]
-            # duplicate unconditional embeddings for each generation per prompt, using mps friendly method
-            seq_len = uncond_embeddings.shape[1]
-            uncond_embeddings = uncond_embeddings.tile([1, num_images_per_prompt, 1])
-            uncond_embeddings = uncond_embeddings.reshape([batch_size * num_images_per_prompt, seq_len, -1])
-            # For classifier free guidance, we need to do two forward passes.
-            # Here we concatenate the unconditional and text embeddings into a single batch
-            # to avoid doing two forward passes
-            text_embeddings = paddle.concat([uncond_embeddings, text_embeddings])
-        return text_embeddings
-    # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline.run_safety_checker
-    def run_safety_checker(self, image, dtype):
-        if self.safety_checker is not None:
-            safety_checker_input = self.feature_extractor(self.numpy_to_pil(image), return_tensors="pd")
-            image, has_nsfw_concept = self.safety_checker(
-                images=image, clip_input=safety_checker_input.pixel_values.cast(dtype)
-            )
-        else:
-            has_nsfw_concept = None
-        return image, has_nsfw_concept
-    def decode_latents(self, latents):
-        latents = 1 / 0.18215 * latents
-        image = self.vae.decode(latents).sample
-        image = (image / 2 + 0.5).clip(0, 1)
-        # we always cast to float32 as this does not cause significant overhead and is compatible with bfloa16
-        image = image.transpose([0, 2, 3, 1]).cast("float32").numpy()
-        return image
-    # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline.prepare_extra_step_kwargs
-    def prepare_extra_step_kwargs(self, generator, eta):
-        # prepare extra kwargs for the scheduler step, since not all schedulers have the same signature
-        # eta (η) is only used with the DDIMScheduler, it will be ignored for other schedulers.
-        # eta corresponds to η in DDIM paper: https://arxiv.org/abs/2010.02502
-        # and should be between [0, 1]
-        accepts_eta = "eta" in set(inspect.signature(self.scheduler.step).parameters.keys())
-        extra_step_kwargs = {}
-        if accepts_eta:
-            extra_step_kwargs["eta"] = eta
-        # check if the scheduler accepts generator
-        accepts_generator = "generator" in set(inspect.signature(self.scheduler.step).parameters.keys())
-        if accepts_generator:
-            extra_step_kwargs["generator"] = generator
-        return extra_step_kwargs
-    def check_inputs(self, prompt, strength, callback_steps):
-        if not isinstance(prompt, str) and not isinstance(prompt, list):
-            raise ValueError(f"`prompt` has to be of type `str` or `list` but is {type(prompt)}")
-        if strength < 0 or strength > 1:
-            raise ValueError(f"The value of strength should in [1.0, 1.0] but is {strength}")
-        if (callback_steps is None) or (
-            callback_steps is not None and (not isinstance(callback_steps, int) or callback_steps <= 0)
-        ):
-            raise ValueError(
-                f"`callback_steps` has to be a positive integer but is {callback_steps} of type"
-                f" {type(callback_steps)}."
-            )
-    # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion_img2img.StableDiffusionImg2ImgPipeline.get_timesteps
-    def get_timesteps(self, num_inference_steps, strength):
-        # get the original timestep using init_timestep
-        init_timestep = min(int(num_inference_steps * strength), num_inference_steps)
-        t_start = max(num_inference_steps - init_timestep, 0)
-        timesteps = self.scheduler.timesteps[t_start:]
-        return timesteps, num_inference_steps - t_start
-    # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion_img2img.StableDiffusionImg2ImgPipeline.prepare_latents
-    def prepare_latents(self, image, timestep, batch_size, num_images_per_prompt, dtype, generator=None):
-        image = image.cast(dtype=dtype)
-        batch_size = batch_size * num_images_per_prompt
-        if isinstance(generator, list) and len(generator) != batch_size:
-            raise ValueError(
-                f"You have passed a list of generators of length {len(generator)}, but requested an effective batch"
-                f" size of {batch_size}. Make sure the batch size matches the length of the generators."
-            )
-        if isinstance(generator, list):
-            init_latents = [
-                self.vae.encode(image[i : i + 1]).latent_dist.sample(generator[i]) for i in range(batch_size)
-            ]
-            init_latents = paddle.concat(init_latents, axis=0)
-        else:
-            init_latents = self.vae.encode(image).latent_dist.sample(generator)
-        init_latents = 0.18215 * init_latents
-        if batch_size > init_latents.shape[0] and batch_size % init_latents.shape[0] == 0:
-            # expand init_latents for batch_size
-            deprecation_message = (
-                f"You have passed {batch_size} text prompts (`prompt`), but only {init_latents.shape[0]} initial"
-                " images (`image`). Initial images are now duplicating to match the number of text prompts. Note"
-                " that this behavior is deprecated and will be removed in a version 1.0.0. Please make sure to update"
-                " your script to pass as many initial images as text prompts to suppress this warning."
-            )
-            deprecate("len(prompt) != len(image)", "1.0.0", deprecation_message, standard_warn=False)
-            additional_image_per_prompt = batch_size // init_latents.shape[0]
-            init_latents = paddle.concat([init_latents] * additional_image_per_prompt, axis=0)
-        elif batch_size > init_latents.shape[0] and batch_size % init_latents.shape[0] != 0:
-            raise ValueError(
-                f"Cannot duplicate `image` of batch size {init_latents.shape[0]} to {batch_size} text prompts."
-            )
-        else:
-            init_latents = paddle.concat([init_latents], axis=0)
-        shape = init_latents.shape
-        if isinstance(generator, list):
-            shape = [
-                1,
-            ] + shape[1:]
-            noise = [paddle.randn(shape, generator=generator[i], dtype=dtype) for i in range(batch_size)]
-            noise = paddle.concat(noise, axis=0)
-        else:
-            noise = paddle.randn(shape, generator=generator, dtype=dtype)
-        # get latents
-        init_latents = self.scheduler.add_noise(init_latents, noise, timestep)
-        latents = init_latents
-        return latents
-    def prepare_depth_map(self, image, depth_map, batch_size, do_classifier_free_guidance, dtype):
-        if isinstance(image, PIL.Image.Image):
-            image = [image]
-        else:
-            image = [img for img in image]
-        if isinstance(image[0], PIL.Image.Image):
-            width, height = image[0].size
-        else:
-            width, height = image[0].shape[-2:]
-        if depth_map is None:
-            pixel_values = self.feature_extractor(images=image, return_tensors="pd").pixel_values
-            # The DPT-Hybrid model uses batch-norm layers which are not compatible with fp16.
-            # TODO junnyu, we donot use fp16.
-            depth_map = self.depth_estimator(pixel_values).predicted_depth
-        else:
-            depth_map = depth_map.cast(dtype)
-        depth_map = paddle.nn.functional.interpolate(
-            depth_map.unsqueeze(1),
-            size=(height // self.vae_scale_factor, width // self.vae_scale_factor),
-            mode="bicubic",
-            align_corners=False,
-        )
-        depth_min = paddle.amin(depth_map, axis=[1, 2, 3], keepdim=True)
-        depth_max = paddle.amax(depth_map, axis=[1, 2, 3], keepdim=True)
-        depth_map = 2.0 * (depth_map - depth_min) / (depth_max - depth_min) - 1.0
-        depth_map = depth_map.cast(dtype)
-        # duplicate mask and masked_image_latents for each generation per prompt, using mps friendly method
-        if depth_map.shape[0] < batch_size:
-            depth_map = depth_map.tile([batch_size, 1, 1, 1])
-        depth_map = paddle.concat([depth_map] * 2) if do_classifier_free_guidance else depth_map
-        return depth_map
-    @paddle.no_grad()
-    def __call__(
-        self,
-        prompt: Union[str, List[str]],
-        image: Union[paddle.Tensor, PIL.Image.Image],
-        depth_map: Optional[paddle.Tensor] = None,
-        strength: float = 0.8,
-        num_inference_steps: Optional[int] = 50,
-        guidance_scale: Optional[float] = 7.5,
-        negative_prompt: Optional[Union[str, List[str]]] = None,
-        num_images_per_prompt: Optional[int] = 1,
-        eta: Optional[float] = 0.0,
-        generator: Optional[Union[paddle.Generator, List[paddle.Generator]]] = None,
-        output_type: Optional[str] = "pil",
-        return_dict: bool = True,
-        callback: Optional[Callable[[int, int, paddle.Tensor], None]] = None,
-        callback_steps: Optional[int] = 1,
-    ):
-        r"""
-        Function invoked when calling the pipeline for generation.
-        Args:
-            prompt (`str` or `List[str]`):
-                The prompt or prompts to guide the image generation.
-            image (`paddle.Tensor` or `PIL.Image.Image`):
-                `Image`, or tensor representing an image batch, that will be used as the starting point for the
-                process.
-            strength (`float`, *optional*, defaults to 0.8):
-                Conceptually, indicates how much to transform the reference `image`. Must be between 0 and 1. `image`
-                will be used as a starting point, adding more noise to it the larger the `strength`. The number of
-                denoising steps depends on the amount of noise initially added. When `strength` is 1, added noise will
-                be maximum and the denoising process will run for the full number of iterations specified in
-                `num_inference_steps`. A value of 1, therefore, essentially ignores `image`.
-            num_inference_steps (`int`, *optional*, defaults to 50):
-                The number of denoising steps. More denoising steps usually lead to a higher quality image at the
-                expense of slower inference. This parameter will be modulated by `strength`.
-            guidance_scale (`float`, *optional*, defaults to 7.5):
-                Guidance scale as defined in [Classifier-Free Diffusion Guidance](https://arxiv.org/abs/2207.12598).
-                `guidance_scale` is defined as `w` of equation 2. of [Imagen
-                Paper](https://arxiv.org/pdf/2205.11487.pdf). Guidance scale is enabled by setting `guidance_scale >
-                1`. Higher guidance scale encourages to generate images that are closely linked to the text `prompt`,
-                usually at the expense of lower image quality.
-            negative_prompt (`str` or `List[str]`, *optional*):
-                The prompt or prompts not to guide the image generation. Ignored when not using guidance (i.e., ignored
-                if `guidance_scale` is less than `1`).
-            num_images_per_prompt (`int`, *optional*, defaults to 1):
-                The number of images to generate per prompt.
-            eta (`float`, *optional*, defaults to 0.0):
-                Corresponds to parameter eta (η) in the DDIM paper: https://arxiv.org/abs/2010.02502. Only applies to
-                [`schedulers.DDIMScheduler`], will be ignored for others.
-            generator (`torch.Generator`, *optional*):
-                One or a list of [torch generator(s)](https://pytorch.org/docs/stable/generated/torch.Generator.html)
-                to make generation deterministic.
-            output_type (`str`, *optional*, defaults to `"pil"`):
-                The output format of the generate image. Choose between
-                [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` or `np.array`.
-            return_dict (`bool`, *optional*, defaults to `True`):
-                Whether or not to return a [`~pipelines.pipeline_utils.ImagePipelineOutput`] instead of a
-                plain tuple.
-            callback (`Callable`, *optional*):
-                A function that will be called every `callback_steps` steps during inference. The function will be
-                called with the following arguments: `callback(step: int, timestep: int, latents: paddle.Tensor)`.
-            callback_steps (`int`, *optional*, defaults to 1):
-                The frequency at which the `callback` function will be called. If not specified, the callback will be
-                called at every step.
-        Returns:
-            [`~pipelines.pipeline_utils.ImagePipelineOutput`] or `tuple`:
-            [`~pipelines.pipeline_utils.ImagePipelineOutput`] if `return_dict` is True, otherwise a `tuple.
-            When returning a tuple, the first element is a list with the generated images.
-        """
-        # 1. Check inputs
-        self.check_inputs(prompt, strength, callback_steps)
-        # 2. Define call parameters
-        batch_size = 1 if isinstance(prompt, str) else len(prompt)
-        # here `guidance_scale` is defined analog to the guidance weight `w` of equation (2)
-        # of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1`
-        # corresponds to doing no classifier free guidance.
-        do_classifier_free_guidance = guidance_scale > 1.0
-        # 3. Encode input prompt
-        text_embeddings = self._encode_prompt(
-            prompt, num_images_per_prompt, do_classifier_free_guidance, negative_prompt
-        )
-        # 4. Preprocess image
-        depth_mask = self.prepare_depth_map(
-            image,
-            depth_map,
-            batch_size * num_images_per_prompt,
-            do_classifier_free_guidance,
-            text_embeddings.dtype,
-        )
-        # 5. Prepare depth mask
-        image = preprocess(image)
-        # 6. set timesteps
-        self.scheduler.set_timesteps(num_inference_steps)
-        timesteps, num_inference_steps = self.get_timesteps(num_inference_steps, strength)
-        latent_timestep = timesteps[:1].tile([batch_size * num_images_per_prompt])
-        # 7. Prepare latent variables
-        latents = self.prepare_latents(
-            image, latent_timestep, batch_size, num_images_per_prompt, text_embeddings.dtype, generator
-        )
-        # 8. Prepare extra step kwargs. TODO: Logic should ideally just be moved out of the pipeline
-        extra_step_kwargs = self.prepare_extra_step_kwargs(generator, eta)
-        # 9. Denoising loop
-        num_warmup_steps = len(timesteps) - num_inference_steps * self.scheduler.order
-        with self.progress_bar(total=num_inference_steps) as progress_bar:
-            for i, t in enumerate(timesteps):
-                # expand the latents if we are doing classifier free guidance
-                latent_model_input = paddle.concat([latents] * 2) if do_classifier_free_guidance else latents
-                latent_model_input = self.scheduler.scale_model_input(latent_model_input, t)
-                latent_model_input = paddle.concat([latent_model_input, depth_mask], axis=1)
-                # predict the noise residual
-                noise_pred = self.unet(latent_model_input, t, encoder_hidden_states=text_embeddings).sample
-                # perform guidance
-                if do_classifier_free_guidance:
-                    noise_pred_uncond, noise_pred_text = noise_pred.chunk(2)
-                    noise_pred = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)
-                # compute the previous noisy sample x_t -> x_t-1
-                latents = self.scheduler.step(noise_pred, t, latents, **extra_step_kwargs).prev_sample
-                # call the callback, if provided
-                if i == len(timesteps) - 1 or ((i + 1) > num_warmup_steps and (i + 1) % self.scheduler.order == 0):
-                    progress_bar.update()
-                    if callback is not None and i % callback_steps == 0:
-                        callback(i, t, latents)
-        # 10. Post-processing
-        image = self.decode_latents(latents)
-        # 11. Convert to PIL
-        if output_type == "pil":
-            image = self.numpy_to_pil(image)
-        if not return_dict:
-            return (image,)
-        return ImagePipelineOutput(images=image)

spaces/2ndelement/voicevox/voicevox_engine/setting/SettingLoader.py DELETED Viewed

@@ -1,33 +0,0 @@
-from pathlib import Path
-import yaml
-from ..utility import engine_root, get_save_dir
-from .Setting import Setting
-DEFAULT_SETTING_PATH: Path = engine_root() / "default_setting.yml"
-USER_SETTING_PATH: Path = get_save_dir() / "setting.yml"
-class SettingLoader:
-    def __init__(self, setting_file_path: Path) -> None:
-        self.setting_file_path = setting_file_path
-    def load_setting_file(self) -> Setting:
-        if not self.setting_file_path.is_file():
-            setting = yaml.safe_load(DEFAULT_SETTING_PATH.read_text(encoding="utf-8"))
-        else:
-            setting = yaml.safe_load(self.setting_file_path.read_text(encoding="utf-8"))
-        setting = Setting(
-            cors_policy_mode=setting["cors_policy_mode"],
-            allow_origin=setting["allow_origin"],
-        )
-        return setting
-    def dump_setting_file(self, settings: Setting) -> None:
-        settings_dict = settings.dict()
-        with open(self.setting_file_path, mode="w", encoding="utf-8") as f:
-            yaml.safe_dump(settings_dict, f)

spaces/4th3n4/TraDeX/app-plain.py DELETED Viewed

@@ -1,957 +0,0 @@
-# %%
-# Import section
-# (Please don't edit this section unless if necessary)
-import copy
-from pathlib import Path
-import warnings
-import holidays
-import seaborn as sns
-import matplotlib
-import matplotlib.dates as mdates
-import matplotlib.pyplot as plt
-plt.style.use('fivethirtyeight')
-import numpy as np
-import pandas as pd
-import glob
-import csv
-import lightning.pytorch as pl
-from lightning.pytorch.callbacks import EarlyStopping, LearningRateMonitor
-from lightning.pytorch.loggers import TensorBoardLogger
-import torch
-from pytorch_forecasting import Baseline, TemporalFusionTransformer, TimeSeriesDataSet
-from pytorch_forecasting.data import GroupNormalizer, NaNLabelEncoder
-from pytorch_forecasting.metrics import SMAPE, PoissonLoss, QuantileLoss
-from pytorch_forecasting.models.temporal_fusion_transformer.tuning import optimize_hyperparameters
-import random
-import gc
-import tensorflow as tf
-import tensorboard as tb
-tf.io.gfile = tb.compat.tensorflow_stub.io.gfile
-import os
-import math
-import sys
-from sklearn.model_selection import train_test_split
-from sklearn.preprocessing import MinMaxScaler
-import tensorflow as tf
-from tensorflow.keras.layers import Conv1D, LSTM, Dense, Dropout, Bidirectional, TimeDistributed
-from tensorflow.keras.layers import MaxPooling1D, Flatten
-from tensorflow.keras.regularizers import L1, L2
-from tensorflow.keras.metrics import Accuracy
-from tensorflow.keras.metrics import RootMeanSquaredError
-from sklearn.metrics import mean_squared_error as MSE
-from sklearn.model_selection import KFold
-from sklearn.inspection import permutation_importance
-from tensorflow.keras.utils import plot_model
-from sklearn.metrics import explained_variance_score, mean_poisson_deviance, mean_gamma_deviance, mean_squared_error, mean_squared_log_error, d2_absolute_error_score, d2_pinball_score, d2_tweedie_score
-from sklearn.metrics import r2_score
-from sklearn.metrics import max_error
-import datetime
-from datetime import date
-import optuna
-from tensorflow.keras.callbacks import Callback
-from optuna.integration import TFKerasPruningCallback
-import shutil
-import gradio as gr
-# Some variables (don't edit these variables unless if necessary)
-DEVICE = 'cuda' if torch.cuda.is_available() else 'cpu'
-random.seed(30)
-np.random.seed(30)
-tf.random.set_seed(30)
-torch.manual_seed(30)
-torch.cuda.manual_seed(30)
-# Global variables
-PATIENCE = 30
-MAX_EPOCHS = 3
-LEARNING_RATE = 0.01
-OPTUNA = True
-ACCELERATOR = "cpu"
-# This below line is only for GPU. Don't use it for CPU
-#os.environ["PYTORCH_CUDA_ALLOC_CONF"] = "max_split_size_mb:1024"
-# Variables to count the number of files
-w = 7
-prax = [0 for x in range(w)]
-# %%
-# Objective function for Optuna (CNN-LSTM)
-def objective(trial, X_train, y_train, X_test, y_test):
-    model = tf.keras.Sequential()
-    # Creating the Neural Network model here...
-    # CNN layers
-    model.add(Conv1D(filters=64, kernel_size=3, activation='relu', input_shape=(X_train.shape[1], 1)))
-    # model.add(Dense(5, kernel_regularizer=L2(0.01)))
-    # LSTM layers
-    model.add(Bidirectional(LSTM(trial.suggest_int("lstm_units_1", 32, 256), return_sequences=True)))
-    model.add(Dropout(trial.suggest_float("dropout_1", 0.1, 0.5)))
-    model.add(Bidirectional(LSTM(trial.suggest_int("lstm_units_2", 32, 256), return_sequences=False)))
-    model.add(Dropout(trial.suggest_float("dropout_2", 0.1, 0.5)))
-    #Final layers
-    model.add(Dense(1, activation='relu'))
-    model.compile(optimizer='adam', loss='mse', metrics=['mse'])
-    # Train the model
-    pruning_callback = TFKerasPruningCallback(trial, "val_loss")
-    history = model.fit(X_train, y_train, validation_data=(X_test, y_test), epochs=15, batch_size=32, verbose=0, callbacks=[pruning_callback])
-    # Evaluate the model
-    loss = model.evaluate(X_test, y_test, verbose=0)[0]
-    return loss
-# %%
-# Function to train the model (CNN-LSTM)
-def modelCNNLSTM(csv_file, prax):
-    # Read the data
-    df = csv_file
-    #df = df['Date/Time'].values.astype("float64")
-    temp_data = df.iloc[0:len(df)-100, 1:21]
-    trek = df.iloc[len(df)-100:,1:21]
-    #print(temp_data)
-    data = temp_data
-    sc = MinMaxScaler()
-    # Split the data into training and testing sets
-    train_size = int(len(data) * 0.8)
-    train_data, test_data = data[:train_size], data[train_size:]
-    # Separate the input features and target variable
-    X_train, y_train = train_data, train_data['Close']
-    X_test, y_test = test_data, test_data['Close']
-    X_train = X_train[0:len(X_train)-1]
-    y_train = y_train[1:len(y_train)]
-    X_test = X_test[0:len(X_test)-1]
-    y_test = y_test[1:len(y_test)]
-    Xt = X_train
-    Xts = X_test
-    Yt = y_train
-    Yts = y_test
-    y_train = y_train.values.reshape(-1,1)
-    y_test = y_test.values.reshape(-1,1)
-    X_train = sc.fit_transform(X_train)
-    y_train = sc.fit_transform(y_train)
-    X_test = sc.fit_transform(X_test)
-    y_test = sc.fit_transform(y_test)
-    x_tr=pd.DataFrame(X_train, index = Xt.index, columns = Xt.columns)
-    y_tr=pd.DataFrame(y_train, index = Yt.index)
-    x_te=pd.DataFrame(X_test, index = Xts.index, columns = Xts.columns)
-    y_te=pd.DataFrame(y_test, index = Yts.index)
-    # Reshape the data for the CNN-LSTM model
-    X_train = X_train.reshape((X_train.shape[0], X_train.shape[1], 1))
-    X_test = X_test.reshape((X_test.shape[0], X_test.shape[1], 1))
-    study = optuna.create_study(direction="minimize", pruner=optuna.pruners.MedianPruner(n_min_trials=4, n_startup_trials=4))
-    fn = lambda trial: objective(trial, X_train=X_train, X_test=X_test, y_train=y_train, y_test=y_test)
-    study.optimize(fn, n_trials=5)
-    best_params = study.best_params
-    #print(f"Best params: {best_params}")
-    model = tf.keras.Sequential()
-    # Creating the Neural Network model here...
-    # CNN layers
-    model.add(Conv1D(filters=64, kernel_size=3, activation='relu', input_shape=(X_train.shape[1], 1)))
-    # model.add(Dense(5, kernel_regularizer=L2(0.01)))
-    # LSTM layers
-    model.add(Bidirectional(LSTM(best_params["lstm_units_1"], return_sequences=True)))
-    model.add(Dropout(best_params["dropout_1"]))
-    model.add(Bidirectional(LSTM(best_params["lstm_units_2"], return_sequences=False)))
-    model.add(Dropout(best_params["dropout_2"]))
-    #Final layers
-    model.add(Dense(1, activation='relu'))
-    model.compile(optimizer='adam', loss='mse', metrics=['mse'])
-    # Train the model
-    history = model.fit(X_train, y_train, validation_data=(X_test, y_test), epochs=10, batch_size=32, verbose=0)
-    # Evaluate the model
-    loss = model.evaluate(X_test, y_test, verbose=0)[0]
-    print(f"Final loss (without KFold): {loss}")
-    kfold = KFold(n_splits=10, shuffle=True)
-    inputs = np.concatenate((X_train, X_test), axis=0)
-    targets = np.concatenate((y_train, y_test), axis=0)
-    acc_per_fold = []
-    loss_per_fold = []
-    xgb_res = []
-    num_epochs = 10
-    batch_size = 32
-    fold_no = 1
-    print('------------------------------------------------------------------------')
-    print("Training for 10 folds... Standby")
-    for train, test in kfold.split(inputs, targets):
-        #print('------------------------------------------------------------------------')
-        #print(f'Training for fold {fold_no} ...')
-        history = model.fit(inputs[train], targets[train],
-                  batch_size=32,
-                  epochs=15,
-                  verbose=0)
-        scores = model.evaluate(inputs[test], targets[test], verbose=0)
-        #print(f'Score for fold {fold_no}: {model.metrics_names[0]} of {scores[0]}; {model.metrics_names[1]} of {scores[1]*100}%')
-        acc_per_fold.append(scores[1] * 100)
-        loss_per_fold.append(scores[0])
-        fold_no = fold_no + 1
-    print('------------------------------------------------------------------------')
-    #print('Score per fold')
-    #for i in range(0, len(acc_per_fold)):
-    #    print('------------------------------------------------------------------------')
-    #    print(f'> Fold {i+1} - Loss: {loss_per_fold[i]} - Loss%: {acc_per_fold[i]}%')
-    #print('------------------------------------------------------------------------')
-    #print('Average scores for all folds:')
-    #print(f'> Possible Loss %: {np.mean(acc_per_fold)} (+- {np.std(acc_per_fold)})')
-    #print(f'> Loss: {np.mean(loss_per_fold)}')
-    #print('------------------------------------------------------------------------')
-    trek = df.iloc[0:len(df), 1:21]
-    Y = trek[0:len(trek)]
-    YP = trek[1:len(trek)]
-    Y1 = Y['Close']
-    Y2 = YP['Close']
-    Yx = pd.DataFrame(YP, index=YP.index, columns=YP.columns)
-    #X = sc.fit_transform(X.reshape(-1,22))
-    Y = np.array(Y)
-    Y1 = np.array(Y1)
-    Y = sc.fit_transform(Y)
-    Y1 = Y1.reshape(-1,1)
-    Y1 = sc.fit_transform(Y1)
-    train_X = Y.reshape(Y.shape[0],Y.shape[1],1)
-    #Y = Y.reshape(-1,1)
-    pred = model.predict(train_X, verbose=0)
-    pred = np.array(pred).reshape(-1,1)
-    var2 = max_error(pred.reshape(-1,1), Y1)
-    print('Max Error: %f' % var2)
-    prax[5] = float(var2)
-    pred = sc.inverse_transform(pred)
-    print(pred[-2], pred[-1])
-    prax[3] = pred[-2]
-    prax[4] = pred[-1]
-    if(pred[-1]-pred[-2]>0):
-        prax[6] = 1
-    elif(pred[-1]-pred[-2]==0):
-        prax[6] = 0
-    else:
-        prax[6] = -1
-# %%
-# Function to train the model (CNN-LSTM)
-def modelCNNLSTM_OpenGap(csv_file, prax):
-    # Read the data
-    df = csv_file
-    datLength = len(df)
-    df['O-C'] = 0
-    for i in range(datLength):
-        if i == 0:
-            df['O-C'][i] = 0
-            continue
-        else:
-            df['O-C'][i] = df['Open'][i] - df['Close'][i-1]
-    temp_data = df.iloc[0:datLength-100, 1:22]
-    trek = df.iloc[datLength-100:,1:22]
-    #print(temp_data)
-    data = temp_data
-    #data = data.values.astype("float64")
-    sc = MinMaxScaler()
-    # Split the data into training and testing sets
-    train_size = int(len(data) * 0.8)
-    train_data, test_data = data[:train_size], data[train_size:]
-    # Separate the input features and target variable
-    X_train, y_train = train_data, train_data['Close']
-    X_test, y_test = test_data, test_data['Close']
-    X_train = X_train[0:len(X_train)-1]
-    y_train = y_train[1:len(y_train)]
-    X_test = X_test[0:len(X_test)-1]
-    y_test = y_test[1:len(y_test)]
-    Xt = X_train
-    Xts = X_test
-    Yt = y_train
-    Yts = y_test
-    y_train = y_train.values.reshape(-1,1)
-    y_test = y_test.values.reshape(-1,1)
-    X_train = sc.fit_transform(X_train)
-    y_train = sc.fit_transform(y_train)
-    X_test = sc.fit_transform(X_test)
-    y_test = sc.fit_transform(y_test)
-    x_tr=pd.DataFrame(X_train, index = Xt.index, columns = Xt.columns)
-    y_tr=pd.DataFrame(y_train, index = Yt.index)
-    x_te=pd.DataFrame(X_test, index = Xts.index, columns = Xts.columns)
-    y_te=pd.DataFrame(y_test, index = Yts.index)
-    # Reshape the data for the CNN-LSTM model
-    X_train = X_train.reshape((X_train.shape[0], X_train.shape[1], 1))
-    X_test = X_test.reshape((X_test.shape[0], X_test.shape[1], 1))
-    study = optuna.create_study(direction="minimize", pruner=optuna.pruners.MedianPruner(n_min_trials=2, n_startup_trials=2))
-    fn = lambda trial: objective(trial, X_train=X_train, X_test=X_test, y_train=y_train, y_test=y_test)
-    study.optimize(fn, n_trials=5)
-    best_params = study.best_params
-    #print(f"Best params: {best_params}")
-    model = tf.keras.Sequential()
-    # Creating the Neural Network model here...
-    # CNN layers
-    model.add(Conv1D(filters=64, kernel_size=3, activation='relu', input_shape=(X_train.shape[1], 1)))
-    # model.add(Dense(5, kernel_regularizer=L2(0.01)))
-    # LSTM layers
-    model.add(Bidirectional(LSTM(best_params["lstm_units_1"], return_sequences=True)))
-    model.add(Dropout(best_params["dropout_1"]))
-    model.add(Bidirectional(LSTM(best_params["lstm_units_2"], return_sequences=False)))
-    model.add(Dropout(best_params["dropout_2"]))
-    #Final layers
-    model.add(Dense(1, activation='relu'))
-    model.compile(optimizer='adam', loss='mse', metrics=['mse'])
-    # Train the model
-    history = model.fit(X_train, y_train, validation_data=(X_test, y_test), epochs=10, batch_size=32, verbose=0)
-    # Evaluate the model
-    loss = model.evaluate(X_test, y_test, verbose=0)[0]
-    print(f"Final loss (without KFold): {loss}")
-    kfold = KFold(n_splits=10, shuffle=True)
-    inputs = np.concatenate((X_train, X_test), axis=0)
-    targets = np.concatenate((y_train, y_test), axis=0)
-    acc_per_fold = []
-    loss_per_fold = []
-    xgb_res = []
-    num_epochs = 10
-    batch_size = 32
-    fold_no = 1
-    print('------------------------------------------------------------------------')
-    print("Training for 10 folds... Standby")
-    for train, test in kfold.split(inputs, targets):
-        #print('------------------------------------------------------------------------')
-        #print(f'Training for fold {fold_no} ...')
-        history = model.fit(inputs[train], targets[train],
-                  batch_size=32,
-                  epochs=15,
-                  verbose=0)
-        scores = model.evaluate(inputs[test], targets[test], verbose=0)
-        #print(f'Score for fold {fold_no}: {model.metrics_names[0]} of {scores[0]}; {model.metrics_names[1]} of {scores[1]*100}%')
-        acc_per_fold.append(scores[1] * 100)
-        loss_per_fold.append(scores[0])
-        fold_no = fold_no + 1
-    print('------------------------------------------------------------------------')
-    #print('Score per fold')
-    #for i in range(0, len(acc_per_fold)):
-    #    print('------------------------------------------------------------------------')
-    #    print(f'> Fold {i+1} - Loss: {loss_per_fold[i]} - Loss%: {acc_per_fold[i]}%')
-    #print('------------------------------------------------------------------------')
-    #print('Average scores for all folds:')
-    #print(f'> Possible Loss %: {np.mean(acc_per_fold)} (+- {np.std(acc_per_fold)})')
-    #print(f'> Loss: {np.mean(loss_per_fold)}')
-    #print('------------------------------------------------------------------------')
-    trek = df.iloc[0:len(df), 1:22]
-    Y = trek[0:len(trek)]
-    YP = trek[1:len(trek)]
-    Y1 = Y['Close']
-    Y2 = YP['Close']
-    Yx = pd.DataFrame(YP, index=YP.index, columns=YP.columns)
-    #X = sc.fit_transform(X.reshape(-1,22))
-    Y = np.array(Y)
-    Y1 = np.array(Y1)
-    Y = sc.fit_transform(Y)
-    Y1 = Y1.reshape(-1,1)
-    Y1 = sc.fit_transform(Y1)
-    train_X = Y.reshape(Y.shape[0],Y.shape[1],1)
-    #Y = Y.reshape(-1,1)
-    pred = model.predict(train_X, verbose=0)
-    pred = np.array(pred).reshape(-1,1)
-    var2 = max_error(pred.reshape(-1,1), Y1)
-    print('Max Error: %f' % var2)
-    prax[5] = float(var2)
-    pred = sc.inverse_transform(pred)
-    print(pred[-2], pred[-1])
-    prax[3] = pred[-2]
-    prax[4] = pred[-1]
-    if(pred[-1]-pred[-2]>0):
-        prax[6] = 1
-    elif(pred[-1]-pred[-2]==0):
-        prax[6] = 0
-    else:
-        prax[6] = -1
-# %%
-# Function to train the model (TFT)
-def modelTFT(csv_file, prax):
-    train = csv_file
-    #test = pd.read_csv("/kaggle/input/artemis-test/nifty_daily.csv")
-    train['date'] = pd.to_datetime(train['Date/Time'])
-    #test['date'] = pd.to_datetime(test['Date'])
-    data = pd.concat([train], axis = 0, ignore_index=True)
-    # Check that key is country-store-product-date combination
-    #assert len(data.drop_duplicates(['country', 'store', 'product', 'date'])) == len(data)
-    # Check that there is one date per country-store-product combination
-    #assert len(data.drop_duplicates(['country', 'store', 'product'])) == len(data)//data['date'].nunique()
-    #display(train.sample(4))
-    """<a id ="3"></a><h3 style="background:#0554f2; border:0; border-radius: 4px; color:#f5f6f7">Model Implementation in Pytorch-Forecasting </h3>"""
-    # Add a time_idx (an sequence of consecutive integers that goes from min to max date)
-    data = (data.merge((data[['Date/Time']].drop_duplicates(ignore_index=True)
-    .rename_axis('time_idx')).reset_index(), on = ['Date/Time']))
-    # add additional features
-    data["day_of_week"] = data['date'].dt.dayofweek.astype(str).astype("category")  # categories have be strings
-    data["week_of_year"] = data['date'].dt.isocalendar().week.astype(str).astype("category")  # categories have be strings
-    data["month"] = data['date'].dt.month.astype(str).astype("category")  # categories have be strings
-    #data["log_num_sold"] = np.log(data.num_sold + 1e-8)
-    #data["avg_volume_by_country"] = data.groupby(["time_idx", "country"], observed=True).num_sold.transform("mean")
-    #data["avg_volume_by_store"] = data.groupby(["time_idx", "store"], observed=True).num_sold.transform("mean")
-    #data["avg_volume_by_product"] = data.groupby(["time_idx", "product"], observed=True).num_sold.transform("mean")
-    #unique_dates_country = data[['date', 'Ticker']].drop_duplicates(ignore_index = True)
-    #unique_dates_country['is_holiday'] = (unique_dates_country
-    #                                      .apply(lambda x: x.date in holidays.country_holidays(x.country), axis = 1).astype('category'))
-    #unique_dates_country['is_holiday_lead_1'] = (unique_dates_country
-    #                                             .apply(lambda x: x.date+pd.Timedelta(days=1) in holidays.country_holidays(x.country), axis = 1).astype('category'))
-    #unique_dates_country['is_holiday_lead_2'] = (unique_dates_country
-    #                                             .apply(lambda x: x.date+pd.Timedelta(days=2) in holidays.country_holidays(x.country), axis = 1).astype('category'))
-    #unique_dates_country['is_holiday_lag_1'] = (unique_dates_country
-    #                                            .apply(lambda x: x.date-pd.Timedelta(days=1) in holidays.country_holidays(x.country), axis = 1).astype('category'))
-    #unique_dates_country['is_holiday_lag_2'] = (unique_dates_country
-    #                                            .apply(lambda x: x.date-pd.Timedelta(days=2) in holidays.country_holidays(x.country), axis = 1).astype('category'))
-    #data = data.merge(unique_dates_country, on = ['date', 'Ticker'], validate = "m:1")
-    #del unique_dates_country
-    gc.collect()
-    data.sample(5, random_state=30)
-    train = data.iloc[:len(train)]
-    test = data.iloc[len(train):]
-    max_prediction_length = 2
-    max_encoder_length = train.date.nunique()
-    training_cutoff = train["time_idx"].max() - max_prediction_length #we will validate on 2020
-    # Let's create a Dataset
-    training = TimeSeriesDataSet(
-        train[lambda x: x.time_idx <= training_cutoff],
-        time_idx="time_idx",
-        target="Close",
-        group_ids=["Ticker"],
-        min_encoder_length=max_prediction_length,  # keep encoder length long (as it is in the validation set)
-        max_encoder_length=max_encoder_length,
-        max_prediction_length=max_prediction_length,
-        static_categoricals=["Ticker"],
-        time_varying_known_categoricals=["month", "week_of_year", "day_of_week"],
-        #variable_groups={"is_holiday": ["is_holiday"]},  # group of categorical variables can be treated as one variable
-        time_varying_known_reals=["time_idx"],
-        time_varying_unknown_categoricals=[],
-        time_varying_unknown_reals=[
-            'Open','High','Low','Close','OI','RSI14','RSI44','HHRSI','Rsi Weekly','LLCHHV','white','Vap44','Vap14','Ema5','Ema20','Ema50','Ema200'
-        ],
-        target_normalizer=GroupNormalizer(
-            groups=['Ticker'], transformation="softplus"
-        ),  # use softplus and normalize by group
-        categorical_encoders={
-            'week_of_year':NaNLabelEncoder(add_nan=True)
-        },
-        #lags={'num_sold': [7, 30, 365]},
-        add_relative_time_idx=True,
-        add_target_scales=True,
-        add_encoder_length=True,
-    )
-    # create validation set (predict=True) which means to predict the last max_prediction_length points in time
-    # for each series
-    validation = TimeSeriesDataSet.from_dataset(training, train, predict=True, stop_randomization=True)
-    # create dataloaders for model
-    batch_size = 128  # set this between 32 to 128
-    train_dataloader = training.to_dataloader(train=True, batch_size=batch_size, num_workers=0)
-    val_dataloader = validation.to_dataloader(train=False, batch_size=batch_size * 10, num_workers=0)
-    #let's see how a naive model does
-    actuals = torch.cat([y for x, (y, weight) in iter(val_dataloader)])#.cuda()
-    baseline_predictions = Baseline().predict(val_dataloader)#.cuda()
-    (actuals - baseline_predictions).abs().mean().item()
-    sm = SMAPE()
-    print(f"Median loss for naive prediction on validation: {sm.loss(actuals, baseline_predictions).mean(axis = 1).median().item()}")
-    early_stop_callback = EarlyStopping(monitor="train_loss", min_delta=1e-2, patience=PATIENCE, verbose=False, mode="min")
-    lr_logger = LearningRateMonitor()  # log the learning rate
-    logger = TensorBoardLogger("lightning_logs")  # logging results to a tensorboard
-    trainer = pl.Trainer(
-        max_epochs=1,
-        accelerator=ACCELERATOR,
-        enable_model_summary=False,
-        gradient_clip_val=0.25,
-        limit_train_batches=10,  # coment in for training, running valiation every 30 batches
-        #fast_dev_run=True,  # comment in to check that networkor dataset has no serious bugs
-        callbacks=[lr_logger, early_stop_callback],
-        logger=logger,
-    )
-    tft = TemporalFusionTransformer.from_dataset(
-        training,
-        learning_rate=LEARNING_RATE,
-        lstm_layers=2,
-        hidden_size=16,
-        attention_head_size=2,
-        dropout=0.2,
-        hidden_continuous_size=8,
-        output_size=1,  # 7 quantiles by default
-        loss=SMAPE(),
-        log_interval=10,  # uncomment for learning rate finder and otherwise, e.g. to 10 for logging every 10 batches
-        reduce_on_plateau_patience=4
-    )
-    tft.to(DEVICE)
-    trainer.fit(
-        tft,
-        train_dataloaders=train_dataloader,
-        val_dataloaders=val_dataloader,
-    )
-    #torch.cuda.empty_cache()
-    #print(f"Number of parameters in network: {tft.size()/1e3:.1f}k")
-    if OPTUNA:
-        from pytorch_forecasting.models.temporal_fusion_transformer.tuning import optimize_hyperparameters
-        # create study
-        study = optimize_hyperparameters(
-            train_dataloader,
-            val_dataloader,
-            model_path="optuna_test",
-            n_trials=5,
-            max_epochs=MAX_EPOCHS,
-            gradient_clip_val_range=(0.01, 0.3),
-            hidden_size_range=(8, 24),
-            hidden_continuous_size_range=(8, 12),
-            attention_head_size_range=(2, 4),
-            learning_rate_range=(0.01, 0.05),
-            dropout_range=(0.1, 0.25),
-            trainer_kwargs=dict(limit_train_batches=20),
-            reduce_on_plateau_patience=4,
-            pruner=optuna.pruners.MedianPruner(n_min_trials=3, n_startup_trials=3),
-            use_learning_rate_finder=False,  # use Optuna to find ideal learning rate or use in-built learning rate finder
-        )
-    #torch.cuda.empty_cache()
-    #'''
-    trainer = pl.Trainer(
-        max_epochs=MAX_EPOCHS,
-        accelerator=ACCELERATOR,
-        enable_model_summary=False,
-        gradient_clip_val=study.best_params['gradient_clip_val'],
-        limit_train_batches=20,  # coment in for training, running valiation every 30 batches
-        #fast_dev_run=True,  # comment in to check that networkor dataset has no serious bugs
-        callbacks=[lr_logger, early_stop_callback],
-        logger=logger,
-    )
-    tft = TemporalFusionTransformer.from_dataset(
-        training,
-        learning_rate=study.best_params['learning_rate'],
-        lstm_layers=2,
-        hidden_size=study.best_params['hidden_size'],
-        attention_head_size=study.best_params['attention_head_size'],
-        dropout=study.best_params['dropout'],
-        hidden_continuous_size=study.best_params['hidden_continuous_size'],
-        output_size=1,  # 7 quantiles by default
-        loss=SMAPE(),
-        log_interval=10,  # uncomment for learning rate finder and otherwise, e.g. to 10 for logging every 10 batches
-        reduce_on_plateau_patience=4
-    )
-    tft.to(DEVICE)
-    trainer.fit(
-        tft,
-        train_dataloaders=train_dataloader,
-        val_dataloaders=val_dataloader,
-    )
-    #'''
-    #torch.cuda.empty_cache()
-    best_model_path = trainer.checkpoint_callback.best_model_path
-    best_tft = TemporalFusionTransformer.load_from_checkpoint(best_model_path)
-    actuals = torch.cat([y[0] for x, y in iter(val_dataloader)])#.cuda()
-    predictions = best_tft.predict(val_dataloader, mode="prediction")
-    raw_predictions = best_tft.predict(val_dataloader, mode="raw", return_x=True)
-    sm = SMAPE()
-    print(f"Validation median SMAPE loss: {sm.loss(actuals, predictions).mean(axis = 1).median().item()}")
-    prax[5] = sm.loss(actuals, predictions).mean(axis = 1).median().item()
-    #best_tft.plot_prediction(raw_predictions.x, raw_predictions.output, idx=0, add_loss_to_title=True);
-    print(raw_predictions[0][0])
-    prax[3] = '-'
-    prax[4] = raw_predictions[0][0].data.cpu().tolist()[0][0]
-    t = prax[4]
-    tm = data['Close'][len(data)-1]
-    if(t-tm>0):
-        prax[6] = 1
-    elif(t-tm==0):
-        prax[6] = 0
-    else:
-        prax[6] = -1
-    #prax[i][3] = raw_predictions[0][0].data[1]
-    print("-----------")
-    #with open("out.csv", "w", newline="") as f:
-    #  writer = csv.writer(f)
-    #  writer.writerows(prax)
-# %%
-# Function to train the model (TFT)
-def modelTFT_OpenGap(csv_file, prax):
-    train = csv_file
-    #test = pd.read_csv("/kaggle/input/artemis-test/nifty_daily.csv")
-    train['date'] = pd.to_datetime(train['Date/Time'])
-    #test['date'] = pd.to_datetime(test['Date'])
-    datLength = len(train)
-    train['O-C'] = 0
-    for i in range(datLength):
-        if i == 0:
-            train['O-C'][i] = 0
-            continue
-        else:
-            train['O-C'][i] = train['Open'][i] - train['Close'][i-1]
-    data = pd.concat([train], axis = 0, ignore_index=True)
-    # Check that key is country-store-product-date combination
-    #assert len(data.drop_duplicates(['country', 'store', 'product', 'date'])) == len(data)
-    # Check that there is one date per country-store-product combination
-    #assert len(data.drop_duplicates(['country', 'store', 'product'])) == len(data)//data['date'].nunique()
-    #display(train.sample(4))
-    """<a id ="3"></a><h3 style="background:#0554f2; border:0; border-radius: 4px; color:#f5f6f7">Model Implementation in Pytorch-Forecasting </h3>"""
-    # Add a time_idx (an sequence of consecutive integers that goes from min to max date)
-    data = (data.merge((data[['Date/Time']].drop_duplicates(ignore_index=True)
-    .rename_axis('time_idx')).reset_index(), on = ['Date/Time']))
-    # add additional features
-    data["day_of_week"] = data['date'].dt.dayofweek.astype(str).astype("category")  # categories have be strings
-    data["week_of_year"] = data['date'].dt.isocalendar().week.astype(str).astype("category")  # categories have be strings
-    data["month"] = data['date'].dt.month.astype(str).astype("category")  # categories have be strings
-    #data["log_num_sold"] = np.log(data.num_sold + 1e-8)
-    #data["avg_volume_by_country"] = data.groupby(["time_idx", "country"], observed=True).num_sold.transform("mean")
-    #data["avg_volume_by_store"] = data.groupby(["time_idx", "store"], observed=True).num_sold.transform("mean")
-    #data["avg_volume_by_product"] = data.groupby(["time_idx", "product"], observed=True).num_sold.transform("mean")
-    #unique_dates_country = data[['date', 'Ticker']].drop_duplicates(ignore_index = True)
-    #unique_dates_country['is_holiday'] = (unique_dates_country
-    #                                      .apply(lambda x: x.date in holidays.country_holidays(x.country), axis = 1).astype('category'))
-    #unique_dates_country['is_holiday_lead_1'] = (unique_dates_country
-    #                                             .apply(lambda x: x.date+pd.Timedelta(days=1) in holidays.country_holidays(x.country), axis = 1).astype('category'))
-    #unique_dates_country['is_holiday_lead_2'] = (unique_dates_country
-    #                                             .apply(lambda x: x.date+pd.Timedelta(days=2) in holidays.country_holidays(x.country), axis = 1).astype('category'))
-    #unique_dates_country['is_holiday_lag_1'] = (unique_dates_country
-    #                                            .apply(lambda x: x.date-pd.Timedelta(days=1) in holidays.country_holidays(x.country), axis = 1).astype('category'))
-    #unique_dates_country['is_holiday_lag_2'] = (unique_dates_country
-    #                                            .apply(lambda x: x.date-pd.Timedelta(days=2) in holidays.country_holidays(x.country), axis = 1).astype('category'))
-    #data = data.merge(unique_dates_country, on = ['date', 'Ticker'], validate = "m:1")
-    #del unique_dates_country
-    gc.collect()
-    data.sample(5, random_state=30)
-    train = data.iloc[:len(train)]
-    test = data.iloc[len(train):]
-    max_prediction_length = 2
-    max_encoder_length = train.date.nunique()
-    training_cutoff = train["time_idx"].max() - max_prediction_length #we will validate on 2020
-    # Let's create a Dataset
-    training = TimeSeriesDataSet(
-        train[lambda x: x.time_idx <= training_cutoff],
-        time_idx="time_idx",
-        target="Close",
-        group_ids=["Ticker"],
-        min_encoder_length=max_prediction_length,  # keep encoder length long (as it is in the validation set)
-        max_encoder_length=max_encoder_length,
-        max_prediction_length=max_prediction_length,
-        static_categoricals=["Ticker"],
-        time_varying_known_categoricals=["month", "week_of_year", "day_of_week"],
-        #variable_groups={"is_holiday": ["is_holiday"]},  # group of categorical variables can be treated as one variable
-        time_varying_known_reals=["time_idx"],
-        time_varying_unknown_categoricals=[],
-        time_varying_unknown_reals=[
-            'Open','High','Low','Close','OI','RSI14','RSI44','HHRSI','Rsi Weekly','LLCHHV','white','Vap44','Vap14','Ema5','Ema20','Ema50','Ema200', 'O-C'
-        ],
-        target_normalizer=GroupNormalizer(
-            groups=['Ticker'], transformation="softplus"
-        ),  # use softplus and normalize by group
-        categorical_encoders={
-            'week_of_year':NaNLabelEncoder(add_nan=True)
-        },
-        #lags={'num_sold': [7, 30, 365]},
-        add_relative_time_idx=True,
-        add_target_scales=True,
-        add_encoder_length=True,
-    )
-    # create validation set (predict=True) which means to predict the last max_prediction_length points in time
-    # for each series
-    validation = TimeSeriesDataSet.from_dataset(training, train, predict=True, stop_randomization=True)
-    # create dataloaders for model
-    batch_size = 128  # set this between 32 to 128
-    train_dataloader = training.to_dataloader(train=True, batch_size=batch_size, num_workers=0)
-    val_dataloader = validation.to_dataloader(train=False, batch_size=batch_size * 10, num_workers=0)
-    #let's see how a naive model does
-    actuals = torch.cat([y for x, (y, weight) in iter(val_dataloader)])#.cuda()
-    baseline_predictions = Baseline().predict(val_dataloader)#.cuda()
-    (actuals - baseline_predictions).abs().mean().item()
-    sm = SMAPE()
-    print(f"Median loss for naive prediction on validation: {sm.loss(actuals, baseline_predictions).mean(axis = 1).median().item()}")
-    early_stop_callback = EarlyStopping(monitor="train_loss", min_delta=1e-2, patience=PATIENCE, verbose=False, mode="min")
-    lr_logger = LearningRateMonitor()  # log the learning rate
-    logger = TensorBoardLogger("lightning_logs")  # logging results to a tensorboard
-    trainer = pl.Trainer(
-        max_epochs=1,
-        accelerator=ACCELERATOR,
-        enable_model_summary=False,
-        gradient_clip_val=0.25,
-        limit_train_batches=10,  # coment in for training, running valiation every 30 batches
-        #fast_dev_run=True,  # comment in to check that networkor dataset has no serious bugs
-        callbacks=[lr_logger, early_stop_callback],
-        logger=logger,
-    )
-    tft = TemporalFusionTransformer.from_dataset(
-        training,
-        learning_rate=LEARNING_RATE,
-        lstm_layers=2,
-        hidden_size=16,
-        attention_head_size=2,
-        dropout=0.2,
-        hidden_continuous_size=8,
-        output_size=1,  # 7 quantiles by default
-        loss=SMAPE(),
-        log_interval=10,  # uncomment for learning rate finder and otherwise, e.g. to 10 for logging every 10 batches
-        reduce_on_plateau_patience=4
-    )
-    tft.to(DEVICE)
-    trainer.fit(
-        tft,
-        train_dataloaders=train_dataloader,
-        val_dataloaders=val_dataloader,
-    )
-    #torch.cuda.empty_cache()
-    #print(f"Number of parameters in network: {tft.size()/1e3:.1f}k")
-    if OPTUNA:
-        from pytorch_forecasting.models.temporal_fusion_transformer.tuning import optimize_hyperparameters
-        # create study
-        study = optimize_hyperparameters(
-            train_dataloader,
-            val_dataloader,
-            model_path="optuna_test",
-            n_trials=5,
-            max_epochs=MAX_EPOCHS,
-            gradient_clip_val_range=(0.01, 0.3),
-            hidden_size_range=(8, 24),
-            hidden_continuous_size_range=(8, 12),
-            attention_head_size_range=(2, 4),
-            learning_rate_range=(0.01, 0.05),
-            dropout_range=(0.1, 0.25),
-            trainer_kwargs=dict(limit_train_batches=20),
-            reduce_on_plateau_patience=4,
-            pruner=optuna.pruners.MedianPruner(n_min_trials=3, n_warmup_steps=3),
-            use_learning_rate_finder=False,  # use Optuna to find ideal learning rate or use in-built learning rate finder
-        )
-    #torch.cuda.empty_cache()
-    #'''
-    trainer = pl.Trainer(
-        max_epochs=MAX_EPOCHS,
-        accelerator=ACCELERATOR,
-        enable_model_summary=False,
-        gradient_clip_val=study.best_params['gradient_clip_val'],
-        limit_train_batches=20,  # coment in for training, running valiation every 30 batches
-        #fast_dev_run=True,  # comment in to check that networkor dataset has no serious bugs
-        callbacks=[lr_logger, early_stop_callback],
-        logger=logger,
-    )
-    tft = TemporalFusionTransformer.from_dataset(
-        training,
-        learning_rate=study.best_params['learning_rate'],
-        lstm_layers=2,
-        hidden_size=study.best_params['hidden_size'],
-        attention_head_size=study.best_params['attention_head_size'],
-        dropout=study.best_params['dropout'],
-        hidden_continuous_size=study.best_params['hidden_continuous_size'],
-        output_size=1,  # 7 quantiles by default
-        loss=SMAPE(),
-        log_interval=10,  # uncomment for learning rate finder and otherwise, e.g. to 10 for logging every 10 batches
-        reduce_on_plateau_patience=4
-    )
-    tft.to(DEVICE)
-    trainer.fit(
-        tft,
-        train_dataloaders=train_dataloader,
-        val_dataloaders=val_dataloader,
-    )
-    #'''
-    #torch.cuda.empty_cache()
-    best_model_path = trainer.checkpoint_callback.best_model_path
-    best_tft = TemporalFusionTransformer.load_from_checkpoint(best_model_path)
-    actuals = torch.cat([y[0] for x, y in iter(val_dataloader)])#.cuda()
-    predictions = best_tft.predict(val_dataloader, mode="prediction")
-    raw_predictions = best_tft.predict(val_dataloader, mode="raw", return_x=True)
-    sm = SMAPE()
-    print(f"Validation median SMAPE loss: {sm.loss(actuals, predictions).mean(axis = 1).median().item()}")
-    prax[5] = sm.loss(actuals, predictions).mean(axis = 1).median().item()
-    #best_tft.plot_prediction(raw_predictions.x, raw_predictions.output, idx=0, add_loss_to_title=True);
-    print(raw_predictions[0][0])
-    prax[3] = '-'
-    prax[4] = raw_predictions[0][0].data.cpu().tolist()[0][0]
-    t = prax[4]
-    tm = data['Close'][len(data)-1]
-    if(t-tm>0):
-        prax[6] = 1
-    elif(t-tm==0):
-        prax[6] = 0
-    else:
-        prax[6] = -1
-    #prax[i][3] = raw_predictions[0][0].data[1]
-    print("-----------")
-    #with open("out.csv", "w", newline="") as f:
-    #  writer = csv.writer(f)
-    #  writer.writerows(prax)
-# %%
-def generate_csv(data_list):
-    today = date.today().strftime("%Y_%m_%d")
-    filename = f"result_{today}.csv"
-    file_exists = os.path.isfile(filename)
-    with open(filename, mode='a', newline='') as csv_file:
-        fieldnames = ['Ticker', 'Prev_Close_Real', 'Model', 'Prev_Close_Model', 'Close_Model', 'Max_Err', 'Up_Down' ] # replace with your own column names
-        writer = csv.writer(csv_file, delimiter=',')
-        if not file_exists:
-            writer.writerow(fieldnames)  # file doesn't exist yet, write a header
-        writer.writerow(data_list)
-    csv_file.close()
-def guess_date(string):
-    for fmt in ["%Y/%m/%d", "%d-%m-%Y", "%Y%m%d", "%m/%d/%Y", "%d/%m/%Y", "%Y-%m-%d", "%d/%m/%y", "%m/%d/%y"]:
-        try:
-            return datetime.datetime.strptime(string, fmt).date()
-        except ValueError:
-            continue
-    raise ValueError(string)
-# %%
-# Main function
-def main():
-    # Data loading
-    path = "./tmp"
-    print("Searching CSV files in ", path, "...")
-    # path = "/kaggle/input/artemis-test"
-    # Get a list of all the CSV files in the folder
-    csv_files = glob.glob(path + "/*.csv")
-    prax = [0,0,0,0,0,0,0]
-    # Create a list of DataFrames, one for each CSV file
-    dfs = []
-    c = 0
-    for csv_file in csv_files:
-        df = pd.read_csv(csv_file)
-        dfs.append(df)
-        c = c + 1
-    if c == 0:
-        print("No CSV files found in ", path, ".")
-        print("Exiting...")
-    for df in dfs:
-        #print(df.head())
-        print(df['Ticker'][0])
-        prax[0] = df['Ticker'][0]
-        prax[1] = df['Close'][len(df)-1]
-        print('------------------')
-        #df = df.drop(['Volume'], axis=1)
-        for i in range(len(df)):
-            x = guess_date(df['Date/Time'][i])
-            df['Date/Time'][i] = x.strftime("%Y-%m-%d")
-        df['Date/Time'] = pd.to_datetime(df['Date/Time'])
-        df.fillna(0, inplace=True)
-        modelTFT(df, prax)
-        prax[2] = "TFT"
-        generate_csv(prax)
-        prax = [0,0,0,0,0,0,0]
-        modelTFT_OpenGap(df, prax)
-        prax[2] = "TFT_OpenGap"
-        generate_csv(prax)
-        #df.set_index('Date/Time', inplace=True)
-        df = df.drop(['Date/Time'], axis=1)
-        prax = [0,0,0,0,0,0,0]
-        modelCNNLSTM(df, prax)
-        prax[2] = "CNNLSTM"
-        generate_csv(prax)
-        prax = [0,0,0,0,0,0,0]
-        modelCNNLSTM_OpenGap(df, prax)
-        prax[2] = "CNNLSTM_OpenGap"
-        #print("Saving to CSV...Standby...")
-        generate_csv(prax)
-        # Generate blank line
-        prax=["","","","","","",""]
-        generate_csv(prax)
-        # Reset prax
-        prax = [0,0,0,0,0,0,0]
-if __name__ == "__main__":
-    main()
-    print("Deleting temporary log files...")
-    # Delete "lightning_logs" directory
-    if os.path.exists("lightning_logs"):
-        shutil.rmtree("lightning_logs")
-    # Delete "optuna_test" directory
-    if os.path.exists("optuna_test"):
-        shutil.rmtree("optuna_test")

spaces/7hao/bingo/src/components/ui/dropdown-menu.tsx DELETED Viewed

@@ -1,128 +0,0 @@
-'use client'
-import * as React from 'react'
-import * as DropdownMenuPrimitive from '@radix-ui/react-dropdown-menu'
-import { cn } from '@/lib/utils'
-const DropdownMenu = DropdownMenuPrimitive.Root
-const DropdownMenuTrigger = DropdownMenuPrimitive.Trigger
-const DropdownMenuGroup = DropdownMenuPrimitive.Group
-const DropdownMenuPortal = DropdownMenuPrimitive.Portal
-const DropdownMenuSub = DropdownMenuPrimitive.Sub
-const DropdownMenuRadioGroup = DropdownMenuPrimitive.RadioGroup
-const DropdownMenuSubContent = React.forwardRef<
-  React.ElementRef<typeof DropdownMenuPrimitive.SubContent>,
-  React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.SubContent>
->(({ className, ...props }, ref) => (
-  <DropdownMenuPrimitive.SubContent
-    ref={ref}
-    className={cn(
-      'z-50 min-w-[8rem] overflow-hidden rounded-md border bg-popover p-1 text-popover-foreground shadow-md animate-in data-[side=bottom]:slide-in-from-top-1 data-[side=left]:slide-in-from-right-1 data-[side=right]:slide-in-from-left-1 data-[side=top]:slide-in-from-bottom-1',
-      className
-    )}
-    {...props}
-  />
-))
-DropdownMenuSubContent.displayName =
-  DropdownMenuPrimitive.SubContent.displayName
-const DropdownMenuContent = React.forwardRef<
-  React.ElementRef<typeof DropdownMenuPrimitive.Content>,
-  React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.Content>
->(({ className, sideOffset = 4, ...props }, ref) => (
-  <DropdownMenuPrimitive.Portal>
-    <DropdownMenuPrimitive.Content
-      ref={ref}
-      sideOffset={sideOffset}
-      className={cn(
-        'z-50 min-w-[8rem] overflow-hidden rounded-md border bg-popover p-1 text-popover-foreground shadow animate-in data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2',
-        className
-      )}
-      {...props}
-    />
-  </DropdownMenuPrimitive.Portal>
-))
-DropdownMenuContent.displayName = DropdownMenuPrimitive.Content.displayName
-const DropdownMenuItem = React.forwardRef<
-  React.ElementRef<typeof DropdownMenuPrimitive.Item>,
-  React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.Item> & {
-    inset?: boolean
-  }
->(({ className, inset, ...props }, ref) => (
-  <DropdownMenuPrimitive.Item
-    ref={ref}
-    className={cn(
-      'relative flex cursor-default select-none items-center rounded-sm px-2 py-1.5 text-sm outline-none transition-colors focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50',
-      inset && 'pl-8',
-      className
-    )}
-    {...props}
-  />
-))
-DropdownMenuItem.displayName = DropdownMenuPrimitive.Item.displayName
-const DropdownMenuLabel = React.forwardRef<
-  React.ElementRef<typeof DropdownMenuPrimitive.Label>,
-  React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.Label> & {
-    inset?: boolean
-  }
->(({ className, inset, ...props }, ref) => (
-  <DropdownMenuPrimitive.Label
-    ref={ref}
-    className={cn(
-      'px-2 py-1.5 text-sm font-semibold',
-      inset && 'pl-8',
-      className
-    )}
-    {...props}
-  />
-))
-DropdownMenuLabel.displayName = DropdownMenuPrimitive.Label.displayName
-const DropdownMenuSeparator = React.forwardRef<
-  React.ElementRef<typeof DropdownMenuPrimitive.Separator>,
-  React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.Separator>
->(({ className, ...props }, ref) => (
-  <DropdownMenuPrimitive.Separator
-    ref={ref}
-    className={cn('-mx-1 my-1 h-px bg-muted', className)}
-    {...props}
-  />
-))
-DropdownMenuSeparator.displayName = DropdownMenuPrimitive.Separator.displayName
-const DropdownMenuShortcut = ({
-  className,
-  ...props
-}: React.HTMLAttributes<HTMLSpanElement>) => {
-  return (
-    <span
-      className={cn('ml-auto text-xs tracking-widest opacity-60', className)}
-      {...props}
-    />
-  )
-}
-DropdownMenuShortcut.displayName = 'DropdownMenuShortcut'
-export {
-  DropdownMenu,
-  DropdownMenuTrigger,
-  DropdownMenuContent,
-  DropdownMenuItem,
-  DropdownMenuLabel,
-  DropdownMenuSeparator,
-  DropdownMenuShortcut,
-  DropdownMenuGroup,
-  DropdownMenuPortal,
-  DropdownMenuSub,
-  DropdownMenuSubContent,
-  DropdownMenuRadioGroup
-}

spaces/AIFILMS/StyleGANEX/datasets/__init__.py DELETED Viewed

File without changes

spaces/AIGC-Audio/AudioGPT/text_to_speech/utils/audio/align.py DELETED Viewed

@@ -1,115 +0,0 @@
-import re
-import torch
-import numpy as np
-from textgrid import TextGrid
-from text_to_speech.utils.text.text_encoder import is_sil_phoneme
-def get_mel2ph(tg_fn, ph, mel, hop_size, audio_sample_rate, min_sil_duration=0):
-    ph_list = ph.split(" ")
-    itvs = TextGrid.fromFile(tg_fn)[1]
-    itvs_ = []
-    for i in range(len(itvs)):
-        if itvs[i].maxTime - itvs[i].minTime < min_sil_duration and i > 0 and is_sil_phoneme(itvs[i].mark):
-            itvs_[-1].maxTime = itvs[i].maxTime
-        else:
-            itvs_.append(itvs[i])
-    itvs.intervals = itvs_
-    itv_marks = [itv.mark for itv in itvs]
-    tg_len = len([x for x in itvs if not is_sil_phoneme(x.mark)])
-    ph_len = len([x for x in ph_list if not is_sil_phoneme(x)])
-    assert tg_len == ph_len, (tg_len, ph_len, itv_marks, ph_list, tg_fn)
-    mel2ph = np.zeros([mel.shape[0]], int)
-    # to process aishell3_no_tone
-    # for _ in range(10):
-    #     if itvs[-2].mark == '':
-    #         start_time = itvs[-2].minTime
-    #         end_time = itvs[-1].maxTime
-    #         mark = itvs[-1].mark
-    #         itvs[-2].maxTime = end_time
-    #         itvs[-2].mark = mark
-    #         itvs_ = []
-    #         for i in range(len(itvs)-1):
-    #             itvs_.append(itvs[i])
-    #         itvs.intervals = itvs_
-    #     if itvs[-1].mark == '':
-    #         start_time = itvs[-2].minTime
-    #         end_time = itvs[-1].maxTime
-    #         itvs[-2].maxTime = end_time
-    #         itvs_ = []
-    #         for i in range(len(itvs)-1):
-    #             itvs_.append(itvs[i])
-    #         itvs.intervals = itvs_
-    i_itv = 0
-    i_ph = 0
-    while i_itv < len(itvs):
-        itv = itvs[i_itv]
-        ph = ph_list[i_ph]
-        itv_ph = itv.mark
-        start_frame = int(itv.minTime * audio_sample_rate / hop_size + 0.5)
-        end_frame = int(itv.maxTime * audio_sample_rate / hop_size + 0.5)
-        if is_sil_phoneme(itv_ph) and not is_sil_phoneme(ph):
-            mel2ph[start_frame:end_frame] = i_ph
-            i_itv += 1
-        elif not is_sil_phoneme(itv_ph) and is_sil_phoneme(ph):
-            i_ph += 1
-        else:
-            if not ((is_sil_phoneme(itv_ph) and is_sil_phoneme(ph)) \
-                    or re.sub(r'\d+', '', itv_ph.lower()) == re.sub(r'\d+', '', ph.lower())):
-                print(f"| WARN: {tg_fn} phs are not same: ", itv_ph, ph, itv_marks, ph_list)
-            mel2ph[start_frame:end_frame] = i_ph + 1
-            i_ph += 1
-            i_itv += 1
-    mel2ph[-1] = mel2ph[-2]
-    assert not np.any(mel2ph == 0)
-    T_t = len(ph_list)
-    dur = mel2token_to_dur(mel2ph, T_t)
-    return mel2ph.tolist(), dur.tolist()
-def split_audio_by_mel2ph(audio, mel2ph, hop_size, audio_num_mel_bins):
-    if isinstance(audio, torch.Tensor):
-        audio = audio.numpy()
-    if isinstance(mel2ph, torch.Tensor):
-        mel2ph = mel2ph.numpy()
-    assert len(audio.shape) == 1, len(mel2ph.shape) == 1
-    split_locs = []
-    for i in range(1, len(mel2ph)):
-        if mel2ph[i] != mel2ph[i - 1]:
-            split_loc = i * hop_size
-            split_locs.append(split_loc)
-    new_audio = []
-    for i in range(len(split_locs) - 1):
-        new_audio.append(audio[split_locs[i]:split_locs[i + 1]])
-        new_audio.append(np.zeros([0.5 * audio_num_mel_bins]))
-    return np.concatenate(new_audio)
-def mel2token_to_dur(mel2token, T_txt=None, max_dur=None):
-    is_torch = isinstance(mel2token, torch.Tensor)
-    has_batch_dim = True
-    if not is_torch:
-        mel2token = torch.LongTensor(mel2token)
-    if T_txt is None:
-        T_txt = mel2token.max()
-    if len(mel2token.shape) == 1:
-        mel2token = mel2token[None, ...]
-        has_batch_dim = False
-    B, _ = mel2token.shape
-    dur = mel2token.new_zeros(B, T_txt + 1).scatter_add(1, mel2token, torch.ones_like(mel2token))
-    dur = dur[:, 1:]
-    if max_dur is not None:
-        dur = dur.clamp(max=max_dur)
-    if not is_torch:
-        dur = dur.numpy()
-    if not has_batch_dim:
-        dur = dur[0]
-    return dur

spaces/AIZ2H/04-Gradio-SOTA-Seq2Seq-AutoQA/README.md DELETED Viewed

@@ -1,13 +0,0 @@
----
-title: 04 Gradio SOTA Seq2Seq AutoQA
-emoji: 🧬❓
-colorFrom: indigo
-colorTo: yellow
-sdk: gradio
-sdk_version: 3.3.1
-app_file: app.py
-pinned: false
-license: apache-2.0
----
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/ATang0729/Forecast4Muses/Model/Model6/Model6_0_ClothesDetection/mmyolo/configs/yolov7/README.md DELETED Viewed

@@ -1,50 +0,0 @@
-# YOLOv7
-> [YOLOv7: Trainable bag-of-freebies sets new state-of-the-art for real-time object detectors](https://arxiv.org/abs/2207.02696)
-<!-- [ALGORITHM] -->
-## Abstract
-YOLOv7 surpasses all known object detectors in both speed and accuracy in the range from 5 FPS to 160 FPS and has the highest accuracy 56.8% AP among all known real-time object detectors with 30 FPS or higher on GPU V100. YOLOv7-E6 object detector (56 FPS V100, 55.9% AP) outperforms both transformer-based detector SWIN-L Cascade-Mask R-CNN (9.2 FPS A100, 53.9% AP) by 509% in speed and 2% in accuracy, and convolutional-based detector ConvNeXt-XL Cascade-Mask R-CNN (8.6 FPS A100, 55.2% AP) by 551% in speed and 0.7% AP in accuracy, as well as YOLOv7 outperforms: YOLOR, YOLOX, Scaled-YOLOv4, YOLOv5, DETR, Deformable DETR, DINO-5scale-R50, ViT-Adapter-B and many other object detectors in speed and accuracy. Moreover, we train YOLOv7 only on MS COCO dataset from scratch without using any other datasets or pre-trained weights. Source code is released in [this https URL](https://github.com/WongKinYiu/yolov7).
-<div align=center>
-<img src="https://user-images.githubusercontent.com/17425982/204231759-cc5c77a9-38c6-4a41-85be-eb97e4b2bcbb.png"/>
-</div>
-<div align=center>
-<img alt="YOLOv7-l" src="https://user-images.githubusercontent.com/68552295/216335336-963bd03a-71f3-4556-97af-18b20d69e065.png" width = 95.5%/>
-YOLOv7-l-P5 model structure
-</div>
-## Results and models
-### COCO
-|  Backbone   | Arch | Size | SyncBN | AMP | Mem (GB) | Box AP |                                                       Config                                                       |                                                                                                                                                                 Download                                                                                                                                                                 |
-| :---------: | :--: | :--: | :----: | :-: | :------: | :----: | :----------------------------------------------------------------------------------------------------------------: | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: |
-| YOLOv7-tiny |  P5  | 640  |  Yes   | Yes |   2.7    |  37.5  | [config](https://github.com/open-mmlab/mmyolo/tree/main/configs/yolov7/yolov7_tiny_syncbn_fast_8x16b-300e_coco.py) | [model](https://download.openmmlab.com/mmyolo/v0/yolov7/yolov7_tiny_syncbn_fast_8x16b-300e_coco/yolov7_tiny_syncbn_fast_8x16b-300e_coco_20221126_102719-0ee5bbdf.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolov7/yolov7_tiny_syncbn_fast_8x16b-300e_coco/yolov7_tiny_syncbn_fast_8x16b-300e_coco_20221126_102719.log.json) |
-|  YOLOv7-l   |  P5  | 640  |  Yes   | Yes |   10.3   |  50.9  |  [config](https://github.com/open-mmlab/mmyolo/tree/main/configs/yolov7/yolov7_l_syncbn_fast_8x16b-300e_coco.py)   |       [model](https://download.openmmlab.com/mmyolo/v0/yolov7/yolov7_l_syncbn_fast_8x16b-300e_coco/yolov7_l_syncbn_fast_8x16b-300e_coco_20221123_023601-8113c0eb.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolov7/yolov7_l_syncbn_fast_8x16b-300e_coco/yolov7_l_syncbn_fast_8x16b-300e_coco_20221123_023601.log.json)       |
-|  YOLOv7-x   |  P5  | 640  |  Yes   | Yes |   13.7   |  52.8  |  [config](https://github.com/open-mmlab/mmyolo/tree/main/configs/yolov7/yolov7_x_syncbn_fast_8x16b-300e_coco.py)   |       [model](https://download.openmmlab.com/mmyolo/v0/yolov7/yolov7_x_syncbn_fast_8x16b-300e_coco/yolov7_x_syncbn_fast_8x16b-300e_coco_20221124_215331-ef949a68.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolov7/yolov7_x_syncbn_fast_8x16b-300e_coco/yolov7_x_syncbn_fast_8x16b-300e_coco_20221124_215331.log.json)       |
-|  YOLOv7-w   |  P6  | 1280 |  Yes   | Yes |   27.0   |  54.1  | [config](https://github.com/open-mmlab/mmyolo/tree/main/configs/yolov7/yolov7_w-p6_syncbn_fast_8x16b-300e_coco.py) | [model](https://download.openmmlab.com/mmyolo/v0/yolov7/yolov7_w-p6_syncbn_fast_8x16b-300e_coco/yolov7_w-p6_syncbn_fast_8x16b-300e_coco_20221123_053031-a68ef9d2.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolov7/yolov7_w-p6_syncbn_fast_8x16b-300e_coco/yolov7_w-p6_syncbn_fast_8x16b-300e_coco_20221123_053031.log.json) |
-|  YOLOv7-e   |  P6  | 1280 |  Yes   | Yes |   42.5   |  55.1  | [config](https://github.com/open-mmlab/mmyolo/tree/main/configs/yolov7/yolov7_e-p6_syncbn_fast_8x16b-300e_coco.py) | [model](https://download.openmmlab.com/mmyolo/v0/yolov7/yolov7_e-p6_syncbn_fast_8x16b-300e_coco/yolov7_e-p6_syncbn_fast_8x16b-300e_coco_20221126_102636-34425033.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolov7/yolov7_e-p6_syncbn_fast_8x16b-300e_coco/yolov7_e-p6_syncbn_fast_8x16b-300e_coco_20221126_102636.log.json) |
-**Note**:
-In the official YOLOv7 code, the `random_perspective` data augmentation in COCO object detection task training uses mask annotation information, which leads to higher performance. Object detection should not use mask annotation, so only box annotation information is used in `MMYOLO`. We will use the mask annotation information in the instance segmentation task.
-1. The performance is unstable and may fluctuate by about 0.3 mAP. The performance shown above is the best model.
-2. If users need the weight of `YOLOv7-e2e`, they can train according to the configs provided by us, or convert the official weight according to the [converter script](https://github.com/open-mmlab/mmyolo/blob/main/tools/model_converters/yolov7_to_mmyolo.py).
-3. `fast` means that `YOLOv5DetDataPreprocessor` and `yolov5_collate` are used for data preprocessing, which is faster for training, but less flexible for multitasking. Recommended to use fast version config if you only care about object detection.
-4. `SyncBN` means use SyncBN, `AMP` indicates training with mixed precision.
-5. We use 8x A100 for training, and the single-GPU batch size is 16. This is different from the official code.
-## Citation
-```latex
-@article{wang2022yolov7,
-  title={{YOLOv7}: Trainable bag-of-freebies sets new state-of-the-art for real-time object detectors},
-  author={Wang, Chien-Yao and Bochkovskiy, Alexey and Liao, Hong-Yuan Mark},
-  journal={arXiv preprint arXiv:2207.02696},
-  year={2022}
-}
-```

spaces/ATang0729/Forecast4Muses/Model/Model6/Model6_1_ClothesKeyPoint/mmpose_1_x/configs/fashion_2d_keypoint/topdown_heatmap/deepfashion2/td_hm_res50_4xb8-150e_deepfashion2_short_sleeved_outwear_256x192.py DELETED Viewed

@@ -1,172 +0,0 @@
-_base_ = [
-    '../../../_base_/default_runtime.py',
-    '../../../_base_/datasets/deepfashion2.py'
-]
-default_hooks = dict(checkpoint=dict(save_best='PCK', rule='greater'))
-resume = False  # 断点恢复
-load_from = None  # 模型权重加载
-train_cfg = dict(by_epoch=True, max_epochs=150, val_interval=10)  # 训练轮数，测试间隔
-param_scheduler = [
-    dict(  # warmup策略
-        type='LinearLR',
-        begin=0,
-        end=500,
-        start_factor=0.001,
-        by_epoch=False),
-    dict(  # scheduler
-        type='MultiStepLR',
-        begin=0,
-        end=150,
-        milestones=[100, 130],
-        gamma=0.1,
-        by_epoch=True)
-]
-optim_wrapper = dict(optimizer=dict(type='Adam', lr=0.0005))  # 优化器和学习率
-auto_scale_lr = dict(base_batch_size=512)  # 根据batch_size自动缩放学习率
-backend_args = dict(backend='local')  # 数据加载后端设置，默认从本地硬盘加载
-dataset_type = 'DeepFashion2Dataset'  # 数据集类名  DeepFashionDataset
-data_mode = 'topdown'  # 算法结构类型，用于指定标注信息加载策略
-data_root = 'data/deepfashion2/'  # 数据存放路径
-# 定义数据编解码器，用于生成target和对pred进行解码，同时包含了输入图片和输出heatmap尺寸等信息
-codec = dict(
-    type='MSRAHeatmap', input_size=(192, 256), heatmap_size=(48, 64), sigma=2)
-train_pipeline = [
-    dict(type='LoadImage'),
-    dict(type='GetBBoxCenterScale'),
-    dict(type='RandomFlip', direction='horizontal'),
-    dict(
-        type='RandomBBoxTransform',
-        shift_prob=0,
-        rotate_factor=60,
-        scale_factor=(0.75, 1.25)),
-    dict(type='TopdownAffine', input_size=codec['input_size']),
-    dict(type='GenerateTarget', encoder=codec),
-    dict(type='PackPoseInputs')
-]
-val_pipeline = [  # 测试时数据增强
-    dict(type='LoadImage', backend_args=backend_args),  # 加载图片
-    dict(type='GetBBoxCenterScale'),  # 根据bbox获取center和scale
-    dict(type='TopdownAffine', input_size=codec['input_size']),  # 根据变换矩阵更新目标数据
-    dict(type='PackPoseInputs')  # 对target进行打包用于训练
-]
-train_dataloader = dict(  # 训练数据加载
-    batch_size=8,  # 批次大小
-    num_workers=6,  # 数据加载进程数
-    persistent_workers=True,  # 在不活跃时维持进程不终止，避免反复启动进程的开销
-    sampler=dict(type='DefaultSampler', shuffle=True),  # 采样策略，打乱数据
-    dataset=dict(
-        type=dataset_type,  # 数据集类名
-        data_root=data_root,  # 数据集路径
-        data_mode=data_mode,  # 算法类型
-        ann_file='train/deepfashion2_short_sleeved_outwear.json',  # 标注文件路径
-        data_prefix=dict(img='train/image/'),  # 图像路径
-        pipeline=train_pipeline  # 数据流水线
-    ))
-val_dataloader = dict(
-    batch_size=8,
-    num_workers=6,
-    persistent_workers=True,  # 在不活跃时维持进程不终止，避免反复启动进程的开销
-    drop_last=False,
-    sampler=dict(type='DefaultSampler', shuffle=False),  # 采样策略，不进行打乱
-    dataset=dict(
-        type=dataset_type,  # 数据集类名
-        data_root=data_root,  # 数据集路径
-        data_mode=data_mode,  # 算法类型
-        ann_file='validation/deepfashion2_short_sleeved_outwear.json',
-        data_prefix=dict(img='validation/image/'),  # 图像路径
-        test_mode=True,  # 测试模式开关
-        pipeline=val_pipeline  # 数据流水线
-    ))
-test_dataloader = val_dataloader  # 默认情况下不区分验证集和测试集，用户根据需要来自行定义
-channel_cfg = dict(
-    num_output_channels=294,
-    dataset_joints=294,
-    dataset_channel=[
-        [
-            0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
-            19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
-            36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52,
-            53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
-            70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86,
-            87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102,
-            103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115,
-            116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128,
-            129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141,
-            142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154,
-            155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167,
-            168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180,
-            181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193,
-            194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206,
-            207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219,
-            220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232,
-            233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245,
-            246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258,
-            259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271,
-            272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
-            285, 286, 287, 288, 289, 290, 291, 292, 293
-        ],
-    ],
-    inference_channel=[
-        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
-        20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
-        38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
-        56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
-        74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91,
-        92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107,
-        108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121,
-        122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135,
-        136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149,
-        150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163,
-        164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177,
-        178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191,
-        192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205,
-        206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219,
-        220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233,
-        234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247,
-        248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261,
-        262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275,
-        276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289,
-        290, 291, 292, 293
-    ])
-model = dict(
-    type='TopdownPoseEstimator',  # 模型结构决定了算法流程
-    data_preprocessor=dict(  # 数据归一化和通道顺序调整，作为模型的一部分
-        type='PoseDataPreprocessor',
-        mean=[123.675, 116.28, 103.53],
-        std=[58.395, 57.12, 57.375],
-        bgr_to_rgb=True),
-    backbone=dict(
-        type='ResNet',
-        depth=50,
-        init_cfg=dict(
-            type='Pretrained',  # 预训练参数，只加载backbone权重用于迁移学习
-            checkpoint='torchvision://resnet50')),
-    head=dict(  # 模型头部
-        type='HeatmapHead',
-        in_channels=2048,
-        out_channels=channel_cfg['num_output_channels'],
-        # deconv_out_channels=None,
-        loss=dict(type='KeypointMSELoss', use_target_weight=True),  # 损失函数
-        decoder=codec),  # 解码器，将heatmap解码成坐标值
-    test_cfg=dict(
-        flip_test=True,  # 开启测试时水平翻转集成
-        flip_mode='heatmap',  # 对heatmap进行翻转
-        shift_heatmap=True,  # 对翻转后的结果进行平移提高精度
-    ))
-val_evaluator = [
-    dict(type='PCKAccuracy', thr=0.2),
-    dict(type='AUC'),
-    dict(type='EPE'),
-]
-test_evaluator = val_evaluator  # 默认情况下不区分验证集和测试集，用户根据需要来自行定义
-visualizer = dict(
-    vis_backends=[dict(type='LocalVisBackend'),
-                  dict(type='WandbVisBackend')])

spaces/AdityaMahimkar/PlagiarismChecker/app.py DELETED Viewed

@@ -1,48 +0,0 @@
-import nltk
-from nltk.tokenize import word_tokenize, sent_tokenize
-from nltk.corpus import stopwords
-nltk.download('punkt')
-nltk.download('stopwords')
-import gradio as gr
-#longest common subsequence
-#dynamic programming algorithm for finding lcs
-def lcs(l1,l2):
-  s1=word_tokenize(l1)
-  s2=word_tokenize(l2)
-  # storing the dp values
-  dp = [[None]*(len(s1)+1) for i in range(len(s2)+1)]
-  for i in range(len(s2)+1):
-      for j in range(len(s1)+1):
-          if i == 0 or j == 0:
-              dp[i][j] = 0
-          elif s2[i-1] == s1[j-1]:
-              dp[i][j] = dp[i-1][j-1]+1
-          else:
-              dp[i][j] = max(dp[i-1][j] , dp[i][j-1])
-  return dp[len(s2)][len(s1)]
-def plagiarismChecker(orig, plag):
-  sent_o=sent_tokenize(orig)
-  sent_p=sent_tokenize(plag)
-  tokens_p = word_tokenize(plag)
-  #maximum length of LCS for a sentence in suspicious text
-  max_lcs=0
-  sum_lcs=0
-  for i in sent_p:
-      for j in sent_o:
-          l=lcs(i,j)
-          max_lcs=max(max_lcs,l)
-      sum_lcs+=max_lcs
-      max_lcs=0
-  score=sum_lcs/len(tokens_p)
-  return score*100
-plagiarismUI = gr.Interface(fn=plagiarismChecker, inputs=[gr.inputs.Textbox(lines=10, label='Text 1'), gr.inputs.Textbox(lines=10, label='Text 2')], outputs=gr.outputs.Textbox(label='Plagiarism Level'), title="Plagiarism Checker", theme='dark-peach')
-plagiarismUI.launch(inbrowser=False)

spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/plugins/warppipeline.js DELETED Viewed

	@@ -1,2 +0,0 @@
1	- import WarpPostFxPipeline from './shaders/warp/WarpPostFxPipeline.js';
2	- export default WarpPostFxPipeline;

spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/templates/ui/canvasinput/CanvasInput.d.ts DELETED Viewed

	@@ -1,2 +0,0 @@
1	- import CanvasInput from '../../../plugins/canvasinput';
2	- export default CanvasInput;

spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/templates/ui/menu/methods/MenuSetInteractive.js DELETED Viewed

@@ -1,45 +0,0 @@
-var MenuSetInteractive = function (menu) {
-    menu
-        // Expand sub event
-        .on(menu.root.expandEventName, function (button, index) {
-            if (this._isPassedEvent) {
-                return;
-            }
-            var childrenKey =  this.root.childrenKey;
-            var subItems = this.items[index][childrenKey];
-            if (subItems) {
-                this.expandSubMenu(button, subItems);
-            } else {
-                // this.root.on('button.click', button); // TODO
-            }
-        }, menu)
-        // Click any button
-        .on('button.click', function (button, index, pointer, event) {
-            // Pass event to root menu object
-            if (this !== this.root) {
-                this.root._isPassedEvent = true;
-                this.root.emit('button.click', button, index, pointer, event);
-                this.root._isPassedEvent = false;
-            }
-        }, menu)
-        //Pointer over any button
-        .on('button.over', function (button, index, pointer, event) {
-            // Pass event to root menu object
-            if (this !== this.root) {
-                this.root._isPassedEvent = true;
-                this.root.emit('button.over', button, index, pointer, event);
-                this.root._isPassedEvent = false;
-            }
-        }, menu)
-        //Pointer out any button
-        .on('button.out', function (button, index, pointer, event) {
-            // Pass event to root menu object
-            if (this !== this.root) {
-                this.root._isPassedEvent = true;
-                this.root.emit('button.out', button, index, pointer, event);
-                this.root._isPassedEvent = false;
-            }
-        }, menu);
-};
-export default MenuSetInteractive;

spaces/Alican/pixera/util/img2pixl.py DELETED Viewed

@@ -1,115 +0,0 @@
-import cv2
-import random
-import numpy as np
-from PIL import Image
-#Author: Alican Akca
-class pixL:
-  def __init__(self,numOfSquaresW = None, numOfSquaresH= None, size = [True, (512,512)],square = 6,ImgH = None,ImgW = None,image = None,background = None, pixValues = []):
-    self.size = size
-    self.ImgH = ImgH
-    self.ImgW = ImgW
-    self.image = image
-    self.square = square
-    self.pixValues = pixValues
-    self.background = background
-    self.numOfSquaresW = numOfSquaresW
-    self.numOfSquaresH = numOfSquaresH
-  def toThePixL(self,image, pixel_size, segMode= False):
-    self.square = pixel_size
-    self.image = Image.fromarray(image).convert("RGB").resize((512,512))
-    self.ImgW, self.ImgH = self.image.size
-    self.image = pixL.colorPicker(self)
-    pixL.complier(self)
-    if segMode == True:
-      return pixL.postprocess(self), self.pixValues
-    else:
-      return pixL.postprocess(self)
-  def postprocess(self):
-    image = self.background
-    size = (image.shape[0] - (image.shape[0] % 4), image.shape[1] - (image.shape[1] % 4))
-    image = cv2.resize(image, size)
-    return image
-  def numOfSquaresFunc(self):
-    self.numOfSquaresW = round((self.ImgW / self.square) + 1)
-    self.numOfSquaresH = round((self.ImgH / self.square) + 1)
-  def optimizer(RGB):
-    R_ = RGB[2]
-    G_ = RGB[1]
-    B_ = RGB[0]
-    if R_ < 50 and G_ < 50 and B_ < 50:
-      return (R_, G_, B_)
-    elif 220 < R_ < 255 and 220 < G_ < 255 and 220 < B_ < 255:
-      return (R_, G_, B_)
-    else:
-      sign = lambda x, y: random.choice([x,y])
-      R_ = RGB[2] + sign(+1,-1)*random.randint(1,10)
-      G_ = RGB[1] + sign(+1,-1)*random.randint(1,10)
-      B_ = RGB[0] + sign(+1,-1)*random.randint(1,10)
-      R_ = 0 if R_ < 0 else (255 if R_ > 255 else R_)
-      G_ = 0 if G_ < 0 else (255 if G_ > 255 else G_)
-      B_ = 0 if B_ < 0 else (255 if B_ > 255 else B_)
-      return (R_, G_, B_)
-  def colorPicker(self):
-    pixL.numOfSquaresFunc(self)
-    for j in range(1,self.numOfSquaresH):
-      for i in range(1,self.numOfSquaresW):
-        self.pixValues.append((self.image.getpixel((
-              i * self.square - self.square//2,
-              j * self.square - self.square//2)),
-              (i * self.square - self.square//2,
-              j * self.square - self.square//2)))
-    self.background = 255 * np.ones(shape=[self.ImgH - self.square,
-                                           self.ImgW - self.square*2, 3],
-                                    dtype=np.uint8)
-  def PEN(self,coorX,coorY,R,G,B):
-    SQUARE = self.square
-    cv2.rectangle(self.background,
-                 pt1=(coorX - SQUARE, coorY - SQUARE), #0, 0 -> 0, 0
-                 pt2=(coorX, coorY), #6, 6 -> 3, 3
-                 color=(pixL.optimizer((R,G,B))),
-                 thickness=-1)
-    cv2.rectangle(self.background,
-                 pt1=(coorX, coorY - SQUARE), #0, 0 -> 3, 0
-                 pt2=(coorX + SQUARE, coorY), #6, 6 -> 6, 3
-                 color=(pixL.optimizer((R,G,B))),
-                 thickness=-1)
-    cv2.rectangle(self.background,
-                  pt1=(coorX - SQUARE, coorY), #0, 0 -> 0, 3
-                  pt2=(coorX, coorY + SQUARE), #6, 6 -> 3, 6
-                  color=(pixL.optimizer((R,G,B))),
-                  thickness=-1)
-    cv2.rectangle(self.background,
-                 pt1=(coorX, coorY), #0, 0 -> 3, 3
-                 pt2=(coorX + SQUARE, coorY + SQUARE), #6, 6 -> 6, 6
-                 color=(pixL.optimizer((R,G,B))),
-                 thickness=-1)
-  def complier(self):
-    for index, value in enumerate(self.pixValues):
-      (R,G,B), (coorX, coorY) = value
-      pixL.PEN(self,coorX,coorY,R,G,B)
-    self.background = np.array(self.background).astype(np.uint8)
-    self.background = cv2.resize(self.background, (self.ImgW,self.ImgH), interpolation = cv2.INTER_AREA)

spaces/Amrrs/DragGan-Inversion/visualizer_drag_gradio_inversion.py DELETED Viewed

@@ -1,1002 +0,0 @@
-# https://huggingface.co/DragGan/DragGan-Models
-# https://arxiv.org/abs/2305.10973
-import os
-import os.path as osp
-from argparse import ArgumentParser
-from functools import partial
-from pathlib import Path
-import time
-import tempfile
-import psutil
-import gradio as gr
-import numpy as np
-import torch
-from PIL import Image
-import uuid
-import dnnlib
-from gradio_utils import (
-    ImageMask,
-    draw_mask_on_image,
-    draw_points_on_image,
-    get_latest_points_pair,
-    get_valid_mask,
-    on_change_single_global_state,
-)
-from viz.renderer import Renderer, add_watermark_np
-from torch_utils.pti import run_PTI, export_updated_pickle
-# download models from Hugging Face hub
-from huggingface_hub import snapshot_download
-model_dir = Path("./checkpoints")
-snapshot_download("DragGan/DragGan-Models", repo_type="model", local_dir=model_dir)
-# parser = ArgumentParser()
-# parser.add_argument('--share', action='store_true')
-# parser.add_argument('--cache-dir', type=str, default='./checkpoints')
-# args = parser.parse_args()
-cache_dir = model_dir
-device = "cuda"
-IS_SPACE = "DragGan/DragGan" in os.environ.get("SPACE_ID", "")
-TIMEOUT = 80
-def reverse_point_pairs(points):
-    new_points = []
-    for p in points:
-        new_points.append([p[1], p[0]])
-    return new_points
-def clear_state(global_state, target=None):
-    """Clear target history state from global_state
-    If target is not defined, points and mask will be both removed.
-    1. set global_state['points'] as empty dict
-    2. set global_state['mask'] as full-one mask.
-    """
-    if target is None:
-        target = ["point", "mask"]
-    if not isinstance(target, list):
-        target = [target]
-    if "point" in target:
-        global_state["points"] = dict()
-        print("Clear Points State!")
-    if "mask" in target:
-        image_raw = global_state["images"]["image_raw"]
-        global_state["mask"] = np.ones(
-            (image_raw.size[1], image_raw.size[0]), dtype=np.uint8
-        )
-        print("Clear mask State!")
-    return global_state
-def init_images(global_state):
-    """This function is called only ones with Gradio App is started.
-    0. pre-process global_state, unpack value from global_state of need
-    1. Re-init renderer
-    2. run `renderer._render_drag_impl` with `is_drag=False` to generate
-       new image
-    3. Assign images to global state and re-generate mask
-    """
-    if isinstance(global_state, gr.State):
-        state = global_state.value
-    else:
-        state = global_state
-    state["renderer"].init_network(
-        state["generator_params"],  # res
-        state["pretrained_weight"],  # pkl
-        state["params"]["seed"],  # w0_seed,
-        state["w_pivot"],  # w_load
-        state["params"]["latent_space"] == "w+",  # w_plus
-        "const",
-        state["params"]["trunc_psi"],  # trunc_psi,
-        state["params"]["trunc_cutoff"],  # trunc_cutoff,
-        None,  # input_transform
-        state["params"]["lr"],  # lr,
-    )
-    state["renderer"]._render_drag_impl(
-        state["generator_params"], is_drag=False, to_pil=True
-    )
-    init_image = state["generator_params"].image
-    state["images"]["image_orig"] = init_image
-    state["images"]["image_raw"] = init_image
-    state["images"]["image_show"] = Image.fromarray(
-        add_watermark_np(np.array(init_image))
-    )
-    state["mask"] = np.ones((init_image.size[1], init_image.size[0]), dtype=np.uint8)
-    return global_state
-def update_image_draw(image, points, mask, show_mask, global_state=None):
-    image_draw = draw_points_on_image(image, points)
-    if (
-        show_mask
-        and mask is not None
-        and not (mask == 0).all()
-        and not (mask == 1).all()
-    ):
-        image_draw = draw_mask_on_image(image_draw, mask)
-    image_draw = Image.fromarray(add_watermark_np(np.array(image_draw)))
-    if global_state is not None:
-        global_state["images"]["image_show"] = image_draw
-    return image_draw
-def preprocess_mask_info(global_state, image):
-    """Function to handle mask information.
-    1. last_mask is None: Do not need to change mask, return mask
-    2. last_mask is not None:
-        2.1 global_state is remove_mask:
-        2.2 global_state is add_mask:
-    """
-    if isinstance(image, dict):
-        last_mask = get_valid_mask(image["mask"])
-    else:
-        last_mask = None
-    mask = global_state["mask"]
-    # mask in global state is a placeholder with all 1.
-    if (mask == 1).all():
-        mask = last_mask
-    # last_mask = global_state['last_mask']
-    editing_mode = global_state["editing_state"]
-    if last_mask is None:
-        return global_state
-    if editing_mode == "remove_mask":
-        updated_mask = np.clip(mask - last_mask, 0, 1)
-        print(f"Last editing_state is {editing_mode}, do remove.")
-    elif editing_mode == "add_mask":
-        updated_mask = np.clip(mask + last_mask, 0, 1)
-        print(f"Last editing_state is {editing_mode}, do add.")
-    else:
-        updated_mask = mask
-        print(f"Last editing_state is {editing_mode}, " "do nothing to mask.")
-    global_state["mask"] = updated_mask
-    # global_state['last_mask'] = None  # clear buffer
-    return global_state
-def print_memory_usage():
-    # Print system memory usage
-    print(f"System memory usage: {psutil.virtual_memory().percent}%")
-    # Print GPU memory usage
-    if torch.cuda.is_available():
-        device = torch.device("cuda")
-        print(f"GPU memory usage: {torch.cuda.memory_allocated() / 1e9} GB")
-        print(f"Max GPU memory usage: {torch.cuda.max_memory_allocated() / 1e9} GB")
-        device_properties = torch.cuda.get_device_properties(device)
-        available_memory = (
-            device_properties.total_memory - torch.cuda.max_memory_allocated()
-        )
-        print(f"Available GPU memory: {available_memory / 1e9} GB")
-    else:
-        print("No GPU available")
-# filter large models running on SPAC
-css = """
-#output-image {
-    width: 100% !important;
-    aspect-ratio: 1 / 1 !important;
-    height: auto !important;
-}
-#output-image canvas {
-    width: 100% !important;
-    aspect-ratio: 1 / 1 !important;
-    height: auto !important;
-}
-"""
-with gr.Blocks(css=css) as app:
-    gr.Markdown(
-        """
-# DragGAN - Drag Your GAN - Face Inversion
-## Interactive Point-based Manipulation on the Generative Image Manifold
-### Unofficial Gradio Demo
-**Due to high demand, only one model can be run at a time, or you can duplicate the space and run your own copy.**
-<a href="https://huggingface.co/spaces/DragGan/DragGan-Inversion?duplicate=true" style="display: inline-block;margin-top: .5em;margin-right: .25em;" target="_blank">
-<img style="margin-bottom: 0em;display: inline;margin-top: -.25em;" src="https://bit.ly/3gLdBN6" alt="Duplicate Space"></a> for no queue on your own hardware.</p>
-* Official Repo: [XingangPan](https://github.com/XingangPan/DragGAN)
-* Gradio Demo by: [LeoXing1996](https://github.com/LeoXing1996) © [OpenMMLab MMagic](https://github.com/open-mmlab/mmagic)
-* Inversion Code: [ProgrammingHut](https://www.youtube.com/watch?v=viWiOC1Mikw), [EthanZhangCN](https://github.com/EthanZhangCN)
-"""
-    )
-    # renderer = Renderer()
-    global_state = gr.State(
-        {
-            "images": {
-                # image_orig: the original image, change with seed/model is changed
-                # image_raw: image with mask and points, change durning optimization
-                # image_show: image showed on screen
-            },
-            "temporal_params": {
-                # stop
-            },
-            "w_pivot": None,
-            "mask": None,  # mask for visualization, 1 for editing and 0 for unchange
-            "last_mask": None,  # last edited mask
-            "show_mask": True,  # add button
-            "generator_params": dnnlib.EasyDict(),
-            "params": {
-                "seed": int(np.random.randint(0, 2**32 - 1)),
-                "motion_lambda": 20,
-                "r1_in_pixels": 3,
-                "r2_in_pixels": 12,
-                "magnitude_direction_in_pixels": 1.0,
-                "latent_space": "w+",
-                "trunc_psi": 0.7,
-                "trunc_cutoff": None,
-                "lr": 0.01,
-            },
-            "device": device,
-            "draw_interval": 1,
-            "renderer": Renderer(disable_timing=True),
-            "points": {},
-            "curr_point": None,
-            "curr_type_point": "start",
-            "editing_state": "add_points",
-            "pretrained_weight": str(model_dir / "stylegan2-ffhq1024x1024.pkl"),
-        }
-    )
-    # init image
-    global_state = init_images(global_state)
-    with gr.Row():
-        with gr.Row():
-            # Left --> tools
-            with gr.Column():
-                # Latent
-                with gr.Row():
-                    with gr.Column(scale=1, min_width=10):
-                        gr.Markdown(value="Latent", show_label=False)
-                    with gr.Column(scale=4, min_width=10):
-                        form_seed_number = gr.Slider(
-                            mininium=0,
-                            maximum=2**32 - 1,
-                            step=1,
-                            value=global_state.value["params"]["seed"],
-                            interactive=True,
-                            # randomize=True,
-                            label="Seed",
-                        )
-                        form_lr_number = gr.Number(
-                            value=global_state.value["params"]["lr"],
-                            precision=5,
-                            interactive=True,
-                            label="Step Size",
-                        )
-                        with gr.Row():
-                            with gr.Column(scale=2, min_width=10):
-                                form_reset_image = gr.Button("Reset Image")
-                            with gr.Column(scale=3, min_width=10):
-                                form_latent_space = gr.Radio(
-                                    ["w", "w+"],
-                                    value=global_state.value["params"]["latent_space"],
-                                    interactive=True,
-                                    label="Latent space to optimize",
-                                    show_label=False,
-                                )
-                        with gr.Row():
-                            with gr.Column(scale=3, min_width=10):
-                                form_custom_image = gr.Image(
-                                    type="filepath", label="Custom Image", height=100
-                                )
-                            with gr.Column(scale=3, min_width=10):
-                                form_reset_custom_image = gr.Button(
-                                    "Remove Custom Image", interactive=False
-                                )
-                # Drag
-                with gr.Row():
-                    with gr.Column(scale=1, min_width=10):
-                        gr.Markdown(value="Drag", show_label=False)
-                    with gr.Column(scale=4, min_width=10):
-                        with gr.Row():
-                            with gr.Column(scale=1, min_width=10):
-                                enable_add_points = gr.Button("Add Points")
-                            with gr.Column(scale=1, min_width=10):
-                                undo_points = gr.Button("Reset Points")
-                        with gr.Row():
-                            with gr.Column(scale=1, min_width=10):
-                                form_start_btn = gr.Button("Start")
-                            with gr.Column(scale=1, min_width=10):
-                                form_stop_btn = gr.Button("Stop")
-                        form_steps_number = gr.Number(
-                            value=0, label="Steps", interactive=False
-                        )
-                # Mask
-                with gr.Row():
-                    with gr.Column(scale=1, min_width=10):
-                        gr.Markdown(value="Mask", show_label=False)
-                    with gr.Column(scale=4, min_width=10):
-                        enable_add_mask = gr.Button("Edit Flexible Area")
-                        with gr.Row():
-                            with gr.Column(scale=1, min_width=10):
-                                form_reset_mask_btn = gr.Button("Reset mask")
-                            with gr.Column(scale=1, min_width=10):
-                                show_mask = gr.Checkbox(
-                                    label="Show Mask",
-                                    value=global_state.value["show_mask"],
-                                    show_label=False,
-                                )
-                        with gr.Row():
-                            form_lambda_number = gr.Number(
-                                value=global_state.value["params"]["motion_lambda"],
-                                interactive=True,
-                                label="Lambda",
-                            )
-                form_draw_interval_number = gr.Number(
-                    value=global_state.value["draw_interval"],
-                    label="Draw Interval (steps)",
-                    interactive=True,
-                    visible=False,
-                )
-            # Right --> Image
-            with gr.Column(scale=2):
-                form_image = ImageMask(
-                    value=global_state.value["images"]["image_show"],
-                    brush_radius=100,
-                    elem_id="output-image",
-                )
-    gr.Markdown(
-        """
-        ## Quick Start
-        1. Select desired `Pretrained Model` and adjust `Seed` to generate an
-           initial image.
-        2. Click on image to add control points.
-        3. Click `Start` and enjoy it!
-        ## Advance Usage
-        1. Change `Step Size` to adjust learning rate in drag optimization.
-        2. Select `w` or `w+` to change latent space to optimize:
-        * Optimize on `w` space may cause greater influence to the image.
-        * Optimize on `w+` space may work slower than `w`, but usually achieve
-          better results.
-        * Note that changing the latent space will reset the image, points and
-          mask (this has the same effect as `Reset Image` button).
-        3. Click `Edit Flexible Area` to create a mask and constrain the
-           unmasked region to remain unchanged.
-        """
-    )
-    gr.HTML(
-        """
-        <style>
-            .container {
-                position: absolute;
-                height: 50px;
-                text-align: center;
-                line-height: 50px;
-                width: 100%;
-            }
-        </style>
-        <div class="container">
-        Gradio demo supported by
-        <img src="https://avatars.githubusercontent.com/u/10245193?s=200&v=4" height="20" width="20" style="display:inline;">
-        <a href="https://github.com/open-mmlab/mmagic">OpenMMLab MMagic</a>
-        </div>
-        """
-    )
-    # Network & latents tab listeners
-    def on_click_reset_image(global_state):
-        """Reset image to the original one and clear all states
-        1. Re-init images
-        2. Clear all states
-        """
-        init_images(global_state)
-        clear_state(global_state)
-        return global_state, global_state["images"]["image_show"]
-    def on_click_reset_custom_image(global_state):
-        """Reset image to the original one and clear all states
-        1. Re-init images
-        2. Clear all states
-        """
-        Path(global_state["pretrained_weight"]).unlink(missing_ok=True)
-        global_state["w_pivot"] = None
-        global_state["pretrained_weight"] = str(
-            model_dir / "stylegan2-ffhq1024x1024.pkl"
-        )
-        init_images(global_state)
-        clear_state(global_state)
-        return global_state, global_state["images"]["image_show"]
-    def on_image_change(
-        custom_image, global_state, progress=gr.Progress(track_tqdm=True)
-    ):
-        new_img = Image.open(custom_image)
-        new_img = new_img.convert("RGB")
-        from PTI.configs import paths_config
-        paths_config.stylegan2_ada_ffhq = global_state["pretrained_weight"]
-        paths_config.dlib = (model_dir / "align.dat").as_posix()
-        run_name = str(uuid.uuid4())
-        new_G, w_pivot = run_PTI(new_img, run_name)
-        out_path = Path(f"checkpoints/stylegan2-{run_name}.pkl")
-        print(f"Exporting to {out_path}")
-        export_updated_pickle(new_G, out_path, run_name)
-        global_state["w_pivot"] = w_pivot
-        global_state["pretrained_weight"] = str(out_path)
-        init_images(global_state)
-        clear_state(global_state)
-        return (
-            global_state,
-            global_state["images"]["image_show"],
-            gr.Image.update(interactive=True),
-        )
-    form_custom_image.upload(
-        on_image_change,
-        [form_custom_image, global_state],
-        [global_state, form_image, form_reset_custom_image],
-    )
-    form_reset_custom_image.click(
-        on_click_reset_custom_image, [global_state], [global_state, form_image]
-    )
-    form_reset_image.click(
-        on_click_reset_image,
-        inputs=[global_state],
-        outputs=[global_state, form_image],
-        queue=False,
-        show_progress=True,
-    )
-    # Update parameters
-    def on_change_update_image_seed(seed, global_state):
-        """Function to handle generation seed change.
-        1. Set seed to global_state
-        2. Re-init images and clear all states
-        """
-        global_state["params"]["seed"] = int(seed)
-        init_images(global_state)
-        clear_state(global_state)
-        return global_state, global_state["images"]["image_show"]
-    form_seed_number.change(
-        on_change_update_image_seed,
-        inputs=[form_seed_number, global_state],
-        outputs=[global_state, form_image],
-    )
-    def on_click_latent_space(latent_space, global_state):
-        """Function to reset latent space to optimize.
-        NOTE: this function we reset the image and all controls
-        1. Set latent-space to global_state
-        2. Re-init images and clear all state
-        """
-        global_state["params"]["latent_space"] = latent_space
-        init_images(global_state)
-        clear_state(global_state)
-        return global_state, global_state["images"]["image_show"]
-    form_latent_space.change(
-        on_click_latent_space,
-        inputs=[form_latent_space, global_state],
-        outputs=[global_state, form_image],
-    )
-    # ==== Params
-    form_lambda_number.change(
-        partial(on_change_single_global_state, ["params", "motion_lambda"]),
-        inputs=[form_lambda_number, global_state],
-        outputs=[global_state],
-    )
-    def on_change_lr(lr, global_state):
-        if lr == 0:
-            print("lr is 0, do nothing.")
-            return global_state
-        else:
-            global_state["params"]["lr"] = lr
-            renderer = global_state["renderer"]
-            renderer.update_lr(lr)
-            print("New optimizer: ")
-            print(renderer.w_optim)
-        return global_state
-    form_lr_number.change(
-        on_change_lr,
-        inputs=[form_lr_number, global_state],
-        outputs=[global_state],
-        queue=False,
-        show_progress=True,
-    )
-    def on_click_start(global_state, image):
-        p_in_pixels = []
-        t_in_pixels = []
-        valid_points = []
-        # handle of start drag in mask editing mode
-        global_state = preprocess_mask_info(global_state, image)
-        # Prepare the points for the inference
-        if len(global_state["points"]) == 0:
-            # yield on_click_start_wo_points(global_state, image)
-            image_raw = global_state["images"]["image_raw"]
-            update_image_draw(
-                image_raw,
-                global_state["points"],
-                global_state["mask"],
-                global_state["show_mask"],
-                global_state,
-            )
-            yield (
-                global_state,  # global_state
-                0,  # form_steps_number,
-                global_state["images"]["image_show"],  # form image
-                gr.Button.update(interactive=True),  # form_reset_image
-                gr.Button.update(interactive=True),  # add points button
-                gr.Button.update(interactive=True),  # enable mask button
-                gr.Button.update(interactive=True),  # undo points button
-                gr.Button.update(interactive=True),  # reset mask button
-                gr.Radio.update(interactive=True),  # latent space
-                gr.Button.update(interactive=True),  # start button
-                gr.Button.update(interactive=False),  # stop button
-                gr.Number.update(interactive=True),  # form_seed_number
-                gr.Number.update(interactive=True),  # form_lr_number
-                gr.Checkbox.update(interactive=True),  # show_mask
-                gr.Number.update(interactive=True),  # form_lambda_number
-                gr.Button.update(interactive=True),  # form_reset_custom_image
-            )
-        else:
-            # Transform the points into torch tensors
-            for key_point, point in global_state["points"].items():
-                try:
-                    p_start = point.get("start_temp", point["start"])
-                    p_end = point["target"]
-                    if p_start is None or p_end is None:
-                        continue
-                except KeyError:
-                    continue
-                p_in_pixels.append(p_start)
-                t_in_pixels.append(p_end)
-                valid_points.append(key_point)
-            mask = torch.tensor(global_state["mask"]).float()
-            drag_mask = 1 - mask
-            renderer: Renderer = global_state["renderer"]
-            global_state["temporal_params"]["stop"] = False
-            global_state["editing_state"] = "running"
-            # reverse points order
-            p_to_opt = reverse_point_pairs(p_in_pixels)
-            t_to_opt = reverse_point_pairs(t_in_pixels)
-            print("Running with:")
-            print(f"    Source: {p_in_pixels}")
-            print(f"    Target: {t_in_pixels}")
-            step_idx = 0
-            last_time = time.time()
-            while True:
-                print_memory_usage()
-                # add a TIMEOUT break
-                print(f"Running time: {time.time() - last_time}")
-                if IS_SPACE and time.time() - last_time > TIMEOUT:
-                    print("Timeout break!")
-                    break
-                if (
-                    global_state["temporal_params"]["stop"]
-                    or global_state["generator_params"]["stop"]
-                ):
-                    break
-                # do drage here!
-                renderer._render_drag_impl(
-                    global_state["generator_params"],
-                    p_to_opt,  # point
-                    t_to_opt,  # target
-                    drag_mask,  # mask,
-                    global_state["params"]["motion_lambda"],  # lambda_mask
-                    reg=0,
-                    feature_idx=5,  # NOTE: do not support change for now
-                    r1=global_state["params"]["r1_in_pixels"],  # r1
-                    r2=global_state["params"]["r2_in_pixels"],  # r2
-                    # random_seed     = 0,
-                    # noise_mode      = 'const',
-                    trunc_psi=global_state["params"]["trunc_psi"],
-                    # force_fp32      = False,
-                    # layer_name      = None,
-                    # sel_channels    = 3,
-                    # base_channel    = 0,
-                    # img_scale_db    = 0,
-                    # img_normalize   = False,
-                    # untransform     = False,
-                    is_drag=True,
-                    to_pil=True,
-                )
-                if step_idx % global_state["draw_interval"] == 0:
-                    print("Current Source:")
-                    for key_point, p_i, t_i in zip(valid_points, p_to_opt, t_to_opt):
-                        global_state["points"][key_point]["start_temp"] = [
-                            p_i[1],
-                            p_i[0],
-                        ]
-                        global_state["points"][key_point]["target"] = [
-                            t_i[1],
-                            t_i[0],
-                        ]
-                        start_temp = global_state["points"][key_point]["start_temp"]
-                        print(f"    {start_temp}")
-                    image_result = global_state["generator_params"]["image"]
-                    image_draw = update_image_draw(
-                        image_result,
-                        global_state["points"],
-                        global_state["mask"],
-                        global_state["show_mask"],
-                        global_state,
-                    )
-                    global_state["images"]["image_raw"] = image_result
-                yield (
-                    global_state,  # global_state
-                    step_idx,  # form_steps_number,
-                    global_state["images"]["image_show"],  # form image
-                    # gr.File.update(visible=False),
-                    gr.Button.update(interactive=False),  # form_reset_image
-                    gr.Button.update(interactive=False),  # add points button
-                    gr.Button.update(interactive=False),  # enable mask button
-                    gr.Button.update(interactive=False),  # undo points button
-                    gr.Button.update(interactive=False),  # reset mask button
-                    # latent space
-                    gr.Radio.update(interactive=False),  # latent space
-                    gr.Button.update(interactive=False),  # start button
-                    # enable stop button in loop
-                    gr.Button.update(interactive=True),  # stop button
-                    # update other comps
-                    gr.Number.update(interactive=False),  # form_seed_number
-                    gr.Number.update(interactive=False),  # form_lr_number
-                    gr.Checkbox.update(interactive=False),  # show_mask
-                    gr.Number.update(interactive=False),  # form_lambda_number
-                    gr.Button.update(interactive=False),  # form_reset_custom_image
-                )
-                # increate step
-                step_idx += 1
-            image_result = global_state["generator_params"]["image"]
-            global_state["images"]["image_raw"] = image_result
-            image_draw = update_image_draw(
-                image_result,
-                global_state["points"],
-                global_state["mask"],
-                global_state["show_mask"],
-                global_state,
-            )
-            # fp = NamedTemporaryFile(suffix=".png", delete=False)
-            # image_result.save(fp, "PNG")
-            global_state["editing_state"] = "add_points"
-            yield (
-                global_state,  # global_state
-                0,  # reset step to 0 after stop. # form_steps_number,
-                global_state["images"]["image_show"],  # form image
-                gr.Button.update(interactive=True),  # form_reset_image
-                gr.Button.update(interactive=True),  # add points button
-                gr.Button.update(interactive=True),  # enable mask button
-                gr.Button.update(interactive=True),  # undo points button
-                gr.Button.update(interactive=True),  # reset mask button
-                gr.Radio.update(interactive=True),  # latent space
-                gr.Button.update(interactive=True),  # start button
-                gr.Button.update(interactive=False),  # stop button
-                gr.Number.update(interactive=True),  # form_seed_number
-                gr.Number.update(interactive=True),  # form_lr_number
-                gr.Checkbox.update(interactive=True),  # show_mask
-                gr.Number.update(interactive=True),  # form_lambda_number
-                gr.Button.update(interactive=True),  # form_reset_custom_image
-            )
-    form_start_btn.click(
-        on_click_start,
-        inputs=[global_state, form_image],
-        outputs=[
-            global_state,
-            form_steps_number,
-            form_image,
-            # form_download_result_file,
-            # >>> buttons
-            form_reset_image,
-            enable_add_points,
-            enable_add_mask,
-            undo_points,
-            form_reset_mask_btn,
-            form_latent_space,
-            form_start_btn,
-            form_stop_btn,
-            # <<< buttonm
-            # >>> inputs comps
-            form_seed_number,
-            form_lr_number,
-            show_mask,
-            form_lambda_number,
-            form_reset_custom_image,
-        ],
-    )
-    def on_click_stop(global_state):
-        """Function to handle stop button is clicked.
-        1. send a stop signal by set global_state["temporal_params"]["stop"] as True
-        2. Disable Stop button
-        """
-        global_state["temporal_params"]["stop"] = True
-        return global_state, gr.Button.update(interactive=False)
-    form_stop_btn.click(
-        on_click_stop,
-        inputs=[global_state],
-        outputs=[global_state, form_stop_btn],
-        queue=False,
-        show_progress=True,
-    )
-    form_draw_interval_number.change(
-        partial(
-            on_change_single_global_state,
-            "draw_interval",
-            map_transform=lambda x: int(x),
-        ),
-        inputs=[form_draw_interval_number, global_state],
-        outputs=[global_state],
-        queue=False,
-        show_progress=True,
-    )
-    def on_click_remove_point(global_state):
-        choice = global_state["curr_point"]
-        del global_state["points"][choice]
-        choices = list(global_state["points"].keys())
-        if len(choices) > 0:
-            global_state["curr_point"] = choices[0]
-        return (
-            gr.Dropdown.update(choices=choices, value=choices[0]),
-            global_state,
-        )
-    # Mask
-    def on_click_reset_mask(global_state):
-        global_state["mask"] = np.ones(
-            (
-                global_state["images"]["image_raw"].size[1],
-                global_state["images"]["image_raw"].size[0],
-            ),
-            dtype=np.uint8,
-        )
-        image_draw = update_image_draw(
-            global_state["images"]["image_raw"],
-            global_state["points"],
-            global_state["mask"],
-            global_state["show_mask"],
-            global_state,
-        )
-        return global_state, gr.Image.update(value=image_draw, interactive=False)
-    form_reset_mask_btn.click(
-        on_click_reset_mask,
-        inputs=[global_state],
-        outputs=[global_state, form_image],
-    )
-    # Image
-    def on_click_enable_draw(global_state, image):
-        """Function to start add mask mode.
-        1. Preprocess mask info from last state
-        2. Change editing state to add_mask
-        3. Set curr image with points and mask
-        """
-        global_state = preprocess_mask_info(global_state, image)
-        global_state["editing_state"] = "add_mask"
-        image_raw = global_state["images"]["image_raw"]
-        image_draw = update_image_draw(
-            image_raw, global_state["points"], global_state["mask"], True, global_state
-        )
-        return (
-            global_state,
-            gr.Image.update(value=image_draw, interactive=True),
-        )
-    def on_click_remove_draw(global_state, image):
-        """Function to start remove mask mode.
-        1. Preprocess mask info from last state
-        2. Change editing state to remove_mask
-        3. Set curr image with points and mask
-        """
-        global_state = preprocess_mask_info(global_state, image)
-        global_state["edinting_state"] = "remove_mask"
-        image_raw = global_state["images"]["image_raw"]
-        image_draw = update_image_draw(
-            image_raw, global_state["points"], global_state["mask"], True, global_state
-        )
-        return (
-            global_state,
-            gr.Image.update(value=image_draw, interactive=True),
-        )
-    enable_add_mask.click(
-        on_click_enable_draw,
-        inputs=[global_state, form_image],
-        outputs=[
-            global_state,
-            form_image,
-        ],
-        queue=False,
-        show_progress=True,
-    )
-    def on_click_add_point(global_state, image: dict):
-        """Function switch from add mask mode to add points mode.
-        1. Updaste mask buffer if need
-        2. Change global_state['editing_state'] to 'add_points'
-        3. Set current image with mask
-        """
-        global_state = preprocess_mask_info(global_state, image)
-        global_state["editing_state"] = "add_points"
-        mask = global_state["mask"]
-        image_raw = global_state["images"]["image_raw"]
-        image_draw = update_image_draw(
-            image_raw,
-            global_state["points"],
-            mask,
-            global_state["show_mask"],
-            global_state,
-        )
-        return (
-            global_state,
-            gr.Image.update(value=image_draw, interactive=False),
-        )
-    enable_add_points.click(
-        on_click_add_point,
-        inputs=[global_state, form_image],
-        outputs=[global_state, form_image],
-        queue=False,
-        show_progress=True,
-    )
-    def on_click_image(global_state, evt: gr.SelectData):
-        """This function only support click for point selection"""
-        xy = evt.index
-        if global_state["editing_state"] != "add_points":
-            print(f'In {global_state["editing_state"]} state. ' "Do not add points.")
-            return global_state, global_state["images"]["image_show"]
-        points = global_state["points"]
-        point_idx = get_latest_points_pair(points)
-        if point_idx is None:
-            points[0] = {"start": xy, "target": None}
-            print(f"Click Image - Start - {xy}")
-        elif points[point_idx].get("target", None) is None:
-            points[point_idx]["target"] = xy
-            print(f"Click Image - Target - {xy}")
-        else:
-            points[point_idx + 1] = {"start": xy, "target": None}
-            print(f"Click Image - Start - {xy}")
-        image_raw = global_state["images"]["image_raw"]
-        image_draw = update_image_draw(
-            image_raw,
-            global_state["points"],
-            global_state["mask"],
-            global_state["show_mask"],
-            global_state,
-        )
-        return global_state, image_draw
-    form_image.select(
-        on_click_image,
-        inputs=[global_state],
-        outputs=[global_state, form_image],
-        queue=False,
-        show_progress=True,
-    )
-    def on_click_clear_points(global_state):
-        """Function to handle clear all control points
-        1. clear global_state['points'] (clear_state)
-        2. re-init network
-        2. re-draw image
-        """
-        clear_state(global_state, target="point")
-        renderer: Renderer = global_state["renderer"]
-        renderer.feat_refs = None
-        image_raw = global_state["images"]["image_raw"]
-        image_draw = update_image_draw(
-            image_raw, {}, global_state["mask"], global_state["show_mask"], global_state
-        )
-        return global_state, image_draw
-    undo_points.click(
-        on_click_clear_points,
-        inputs=[global_state],
-        outputs=[global_state, form_image],
-        queue=False,
-        show_progress=True,
-    )
-    def on_click_show_mask(global_state, show_mask):
-        """Function to control whether show mask on image."""
-        global_state["show_mask"] = show_mask
-        image_raw = global_state["images"]["image_raw"]
-        image_draw = update_image_draw(
-            image_raw,
-            global_state["points"],
-            global_state["mask"],
-            global_state["show_mask"],
-            global_state,
-        )
-        return global_state, image_draw
-    show_mask.change(
-        on_click_show_mask,
-        inputs=[global_state, show_mask],
-        outputs=[global_state, form_image],
-        queue=False,
-        show_progress=True,
-    )
-# print("SHAReD: Start app", parser.parse_args())
-gr.close_all()
-app.queue(concurrency_count=1, max_size=200, api_open=False)
-app.launch(show_api=False)

spaces/AndreLie95/Diabetes_Risk_Prediction/app.py DELETED Viewed

@@ -1,76 +0,0 @@
-import numpy as np
-import pandas as pd
-import joblib
-import streamlit as st
-with open('pipeline_clf.pkl', 'rb') as file_1:
-  clf = joblib.load(file_1)
-st.title('Prediksi Resiko Penyakit Diabetes')
-umur = st.number_input('Umur Saat Ini :', 18, 100)
-if (umur >= 18) & (umur <= 24):
-    Age = 1
-elif (umur >= 25) & (umur <= 34):
-    Age = 2
-elif (umur >= 35) & (umur <= 44):
-    Age = 3
-elif (umur >= 45) & (umur <= 54):
-    Age = 4
-elif (umur >= 55) & (umur <= 64):
-    Age = 5
-elif (umur >= 65) & (umur <= 74):
-    Age = 6
-elif (umur >= 75) :
-    Age = 7
-tinggi_badan = st.number_input('Masukkan Tinggi Badan(cm) Anda :', 1,250)
-berat_badan = st.number_input('Masukkan Berat Badan(Kg) Anda :', 1,200)
-BMI = berat_badan/((tinggi_badan/100)**2)
-Kolestrol = st.radio('Apakah Anda Memiliki Riwayat Kolestrol Tinggi ?', ('Tidak', 'Ya'))
-if Kolestrol == 'Tidak':
-    HighChol = 0
-else:
-    HighChol = 1
-Penyakit_Jantung = st.radio('Apakah Anda Memiliki Riwayat Penyakit Jantung ?', ('Tidak', 'Ya'))
-if Penyakit_Jantung == 'Tidak':
-    HeartDiseaseorAttack = 0
-else:
-    HeartDiseaseorAttack = 1
-Tensi = st.radio('Apakah Anda Memiliki Riwayat Hipertensi ?', ('Tidak', 'Ya'))
-if Tensi == 'Tidak':
-    HighBP = 0
-else:
-    HighBP = 1
-Jalan = st.radio('Apakah Anda Memiliki Kesulitan Berjalan ?', ('Tidak', 'Ya'))
-if Jalan == 'Tidak':
-    DiffWalk = 0
-else:
-    DiffWalk = 1
-kesehatan = st.selectbox('Bagaimana Kondisi Kesehatan Anda Secara Umum ?', ('Luar Biasa', 'Sangat Baik', 'Baik', 'Kurang Baik', 'Jelek'))
-if kesehatan == 'Luar Biasa':
-    GenHlth = 1
-elif kesehatan == 'Sangat Baik':
-    GenHlth = 2
-elif kesehatan == 'Baik':
-    GenHlth = 3
-elif kesehatan == 'Kurang Baik':
-    GenHlth = 4
-elif kesehatan == 'Jelek':
-    GenHlth = 5
-if st.button('Prediksi'):
-    data_inf = pd.DataFrame({'Age' : Age,
-                             'BMI' : BMI,
-                             'HighChol' : HighChol,
-                             'HeartDiseaseorAttack' : HeartDiseaseorAttack,
-                             'HighBP' : HighBP,
-                             'DiffWalk' : DiffWalk,
-                             'GenHlth' : GenHlth
-                             },index=[0])
-    hasil = 'Anda Tidak Memiliki Resiko Diabetes' if clf.predict(data_inf) == 0 else 'Anda Beresiko Diabetes'
-    st.header(hasil)

spaces/Andy1621/uniformer_image_demo/uniformer.py DELETED Viewed

@@ -1,366 +0,0 @@
-from collections import OrderedDict
-import torch
-import torch.nn as nn
-from functools import partial
-from timm.models.vision_transformer import _cfg
-from timm.models.registry import register_model
-from timm.models.layers import trunc_normal_, DropPath, to_2tuple
-layer_scale = False
-init_value = 1e-6
-class Mlp(nn.Module):
-    def __init__(self, in_features, hidden_features=None, out_features=None, act_layer=nn.GELU, drop=0.):
-        super().__init__()
-        out_features = out_features or in_features
-        hidden_features = hidden_features or in_features
-        self.fc1 = nn.Linear(in_features, hidden_features)
-        self.act = act_layer()
-        self.fc2 = nn.Linear(hidden_features, out_features)
-        self.drop = nn.Dropout(drop)
-    def forward(self, x):
-        x = self.fc1(x)
-        x = self.act(x)
-        x = self.drop(x)
-        x = self.fc2(x)
-        x = self.drop(x)
-        return x
-class CMlp(nn.Module):
-    def __init__(self, in_features, hidden_features=None, out_features=None, act_layer=nn.GELU, drop=0.):
-        super().__init__()
-        out_features = out_features or in_features
-        hidden_features = hidden_features or in_features
-        self.fc1 = nn.Conv2d(in_features, hidden_features, 1)
-        self.act = act_layer()
-        self.fc2 = nn.Conv2d(hidden_features, out_features, 1)
-        self.drop = nn.Dropout(drop)
-    def forward(self, x):
-        x = self.fc1(x)
-        x = self.act(x)
-        x = self.drop(x)
-        x = self.fc2(x)
-        x = self.drop(x)
-        return x
-class Attention(nn.Module):
-    def __init__(self, dim, num_heads=8, qkv_bias=False, qk_scale=None, attn_drop=0., proj_drop=0.):
-        super().__init__()
-        self.num_heads = num_heads
-        head_dim = dim // num_heads
-        # NOTE scale factor was wrong in my original version, can set manually to be compat with prev weights
-        self.scale = qk_scale or head_dim ** -0.5
-        self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias)
-        self.attn_drop = nn.Dropout(attn_drop)
-        self.proj = nn.Linear(dim, dim)
-        self.proj_drop = nn.Dropout(proj_drop)
-    def forward(self, x):
-        B, N, C = x.shape
-        qkv = self.qkv(x).reshape(B, N, 3, self.num_heads, C // self.num_heads).permute(2, 0, 3, 1, 4)
-        q, k, v = qkv[0], qkv[1], qkv[2]   # make torchscript happy (cannot use tensor as tuple)
-        attn = (q @ k.transpose(-2, -1)) * self.scale
-        attn = attn.softmax(dim=-1)
-        attn = self.attn_drop(attn)
-        x = (attn @ v).transpose(1, 2).reshape(B, N, C)
-        x = self.proj(x)
-        x = self.proj_drop(x)
-        return x
-class CBlock(nn.Module):
-    def __init__(self, dim, num_heads, mlp_ratio=4., qkv_bias=False, qk_scale=None, drop=0., attn_drop=0.,
-                 drop_path=0., act_layer=nn.GELU, norm_layer=nn.LayerNorm):
-        super().__init__()
-        self.pos_embed = nn.Conv2d(dim, dim, 3, padding=1, groups=dim)
-        self.norm1 = nn.BatchNorm2d(dim)
-        self.conv1 = nn.Conv2d(dim, dim, 1)
-        self.conv2 = nn.Conv2d(dim, dim, 1)
-        self.attn = nn.Conv2d(dim, dim, 5, padding=2, groups=dim)
-        # NOTE: drop path for stochastic depth, we shall see if this is better than dropout here
-        self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity()
-        self.norm2 = nn.BatchNorm2d(dim)
-        mlp_hidden_dim = int(dim * mlp_ratio)
-        self.mlp = CMlp(in_features=dim, hidden_features=mlp_hidden_dim, act_layer=act_layer, drop=drop)
-    def forward(self, x):
-        x = x + self.pos_embed(x)
-        x = x + self.drop_path(self.conv2(self.attn(self.conv1(self.norm1(x)))))
-        x = x + self.drop_path(self.mlp(self.norm2(x)))
-        return x
-class SABlock(nn.Module):
-    def __init__(self, dim, num_heads, mlp_ratio=4., qkv_bias=False, qk_scale=None, drop=0., attn_drop=0.,
-                 drop_path=0., act_layer=nn.GELU, norm_layer=nn.LayerNorm):
-        super().__init__()
-        self.pos_embed = nn.Conv2d(dim, dim, 3, padding=1, groups=dim)
-        self.norm1 = norm_layer(dim)
-        self.attn = Attention(
-            dim,
-            num_heads=num_heads, qkv_bias=qkv_bias, qk_scale=qk_scale,
-            attn_drop=attn_drop, proj_drop=drop)
-        # NOTE: drop path for stochastic depth, we shall see if this is better than dropout here
-        self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity()
-        self.norm2 = norm_layer(dim)
-        mlp_hidden_dim = int(dim * mlp_ratio)
-        self.mlp = Mlp(in_features=dim, hidden_features=mlp_hidden_dim, act_layer=act_layer, drop=drop)
-        global layer_scale
-        self.ls = layer_scale
-        if self.ls:
-            global init_value
-            print(f"Use layer_scale: {layer_scale}, init_values: {init_value}")
-            self.gamma_1 = nn.Parameter(init_value * torch.ones((dim)),requires_grad=True)
-            self.gamma_2 = nn.Parameter(init_value * torch.ones((dim)),requires_grad=True)
-    def forward(self, x):
-        x = x + self.pos_embed(x)
-        B, N, H, W = x.shape
-        x = x.flatten(2).transpose(1, 2)
-        if self.ls:
-            x = x + self.drop_path(self.gamma_1 * self.attn(self.norm1(x)))
-            x = x + self.drop_path(self.gamma_2 * self.mlp(self.norm2(x)))
-        else:
-            x = x + self.drop_path(self.attn(self.norm1(x)))
-            x = x + self.drop_path(self.mlp(self.norm2(x)))
-        x = x.transpose(1, 2).reshape(B, N, H, W)
-        return x
-class head_embedding(nn.Module):
-    def __init__(self, in_channels, out_channels):
-        super(head_embedding, self).__init__()
-        self.proj = nn.Sequential(
-            nn.Conv2d(in_channels, out_channels // 2, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1)),
-            nn.BatchNorm2d(out_channels // 2),
-            nn.GELU(),
-            nn.Conv2d(out_channels // 2, out_channels, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1)),
-            nn.BatchNorm2d(out_channels),
-        )
-    def forward(self, x):
-        x = self.proj(x)
-        return x
-class middle_embedding(nn.Module):
-    def __init__(self, in_channels, out_channels):
-        super(middle_embedding, self).__init__()
-        self.proj = nn.Sequential(
-            nn.Conv2d(in_channels, out_channels, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1)),
-            nn.BatchNorm2d(out_channels),
-        )
-    def forward(self, x):
-        x = self.proj(x)
-        return x
-class PatchEmbed(nn.Module):
-    """ Image to Patch Embedding
-    """
-    def __init__(self, img_size=224, patch_size=16, in_chans=3, embed_dim=768):
-        super().__init__()
-        img_size = to_2tuple(img_size)
-        patch_size = to_2tuple(patch_size)
-        num_patches = (img_size[1] // patch_size[1]) * (img_size[0] // patch_size[0])
-        self.img_size = img_size
-        self.patch_size = patch_size
-        self.num_patches = num_patches
-        self.norm = nn.LayerNorm(embed_dim)
-        self.proj = nn.Conv2d(in_chans, embed_dim, kernel_size=patch_size, stride=patch_size)
-    def forward(self, x):
-        B, C, H, W = x.shape
-        # FIXME look at relaxing size constraints
-        # assert H == self.img_size[0] and W == self.img_size[1], \
-        #     f"Input image size ({H}*{W}) doesn't match model ({self.img_size[0]}*{self.img_size[1]})."
-        x = self.proj(x)
-        B, C, H, W = x.shape
-        x = x.flatten(2).transpose(1, 2)
-        x = self.norm(x)
-        x = x.reshape(B, H, W, -1).permute(0, 3, 1, 2).contiguous()
-        return x
-class UniFormer(nn.Module):
-    """ Vision Transformer
-    A PyTorch impl of : `An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale`  -
-        https://arxiv.org/abs/2010.11929
-    """
-    def __init__(self, depth=[3, 4, 8, 3], img_size=224, in_chans=3, num_classes=1000, embed_dim=[64, 128, 320, 512],
-                 head_dim=64, mlp_ratio=4., qkv_bias=True, qk_scale=None, representation_size=None,
-                 drop_rate=0., attn_drop_rate=0., drop_path_rate=0., norm_layer=None, conv_stem=False):
-        """
-        Args:
-            depth (list): depth of each stage
-            img_size (int, tuple): input image size
-            in_chans (int): number of input channels
-            num_classes (int): number of classes for classification head
-            embed_dim (list): embedding dimension of each stage
-            head_dim (int): head dimension
-            mlp_ratio (int): ratio of mlp hidden dim to embedding dim
-            qkv_bias (bool): enable bias for qkv if True
-            qk_scale (float): override default qk scale of head_dim ** -0.5 if set
-            representation_size (Optional[int]): enable and set representation layer (pre-logits) to this value if set
-            drop_rate (float): dropout rate
-            attn_drop_rate (float): attention dropout rate
-            drop_path_rate (float): stochastic depth rate
-            norm_layer: (nn.Module): normalization layer
-            conv_stem: (bool): whether use overlapped patch stem
-        """
-        super().__init__()
-        self.num_classes = num_classes
-        self.num_features = self.embed_dim = embed_dim  # num_features for consistency with other models
-        norm_layer = norm_layer or partial(nn.LayerNorm, eps=1e-6)
-        if conv_stem:
-            self.patch_embed1 = head_embedding(in_channels=in_chans, out_channels=embed_dim[0])
-            self.patch_embed2 = middle_embedding(in_channels=embed_dim[0], out_channels=embed_dim[1])
-            self.patch_embed3 = middle_embedding(in_channels=embed_dim[1], out_channels=embed_dim[2])
-            self.patch_embed4 = middle_embedding(in_channels=embed_dim[2], out_channels=embed_dim[3])
-        else:
-            self.patch_embed1 = PatchEmbed(
-                img_size=img_size, patch_size=4, in_chans=in_chans, embed_dim=embed_dim[0])
-            self.patch_embed2 = PatchEmbed(
-                img_size=img_size // 4, patch_size=2, in_chans=embed_dim[0], embed_dim=embed_dim[1])
-            self.patch_embed3 = PatchEmbed(
-                img_size=img_size // 8, patch_size=2, in_chans=embed_dim[1], embed_dim=embed_dim[2])
-            self.patch_embed4 = PatchEmbed(
-                img_size=img_size // 16, patch_size=2, in_chans=embed_dim[2], embed_dim=embed_dim[3])
-        self.pos_drop = nn.Dropout(p=drop_rate)
-        dpr = [x.item() for x in torch.linspace(0, drop_path_rate, sum(depth))]  # stochastic depth decay rule
-        num_heads = [dim // head_dim for dim in embed_dim]
-        self.blocks1 = nn.ModuleList([
-            CBlock(
-                dim=embed_dim[0], num_heads=num_heads[0], mlp_ratio=mlp_ratio, qkv_bias=qkv_bias, qk_scale=qk_scale,
-                drop=drop_rate, attn_drop=attn_drop_rate, drop_path=dpr[i], norm_layer=norm_layer)
-            for i in range(depth[0])])
-        self.blocks2 = nn.ModuleList([
-            CBlock(
-                dim=embed_dim[1], num_heads=num_heads[1], mlp_ratio=mlp_ratio, qkv_bias=qkv_bias, qk_scale=qk_scale,
-                drop=drop_rate, attn_drop=attn_drop_rate, drop_path=dpr[i+depth[0]], norm_layer=norm_layer)
-            for i in range(depth[1])])
-        self.blocks3 = nn.ModuleList([
-            SABlock(
-                dim=embed_dim[2], num_heads=num_heads[2], mlp_ratio=mlp_ratio, qkv_bias=qkv_bias, qk_scale=qk_scale,
-                drop=drop_rate, attn_drop=attn_drop_rate, drop_path=dpr[i+depth[0]+depth[1]], norm_layer=norm_layer)
-            for i in range(depth[2])])
-        self.blocks4 = nn.ModuleList([
-            SABlock(
-                dim=embed_dim[3], num_heads=num_heads[3], mlp_ratio=mlp_ratio, qkv_bias=qkv_bias, qk_scale=qk_scale,
-                drop=drop_rate, attn_drop=attn_drop_rate, drop_path=dpr[i+depth[0]+depth[1]+depth[2]], norm_layer=norm_layer)
-        for i in range(depth[3])])
-        self.norm = nn.BatchNorm2d(embed_dim[-1])
-        # Representation layer
-        if representation_size:
-            self.num_features = representation_size
-            self.pre_logits = nn.Sequential(OrderedDict([
-                ('fc', nn.Linear(embed_dim, representation_size)),
-                ('act', nn.Tanh())
-            ]))
-        else:
-            self.pre_logits = nn.Identity()
-        # Classifier head
-        self.head = nn.Linear(embed_dim[-1], num_classes) if num_classes > 0 else nn.Identity()
-        self.apply(self._init_weights)
-    def _init_weights(self, m):
-        if isinstance(m, nn.Linear):
-            trunc_normal_(m.weight, std=.02)
-            if isinstance(m, nn.Linear) and m.bias is not None:
-                nn.init.constant_(m.bias, 0)
-        elif isinstance(m, nn.LayerNorm):
-            nn.init.constant_(m.bias, 0)
-            nn.init.constant_(m.weight, 1.0)
-    @torch.jit.ignore
-    def no_weight_decay(self):
-        return {'pos_embed', 'cls_token'}
-    def get_classifier(self):
-        return self.head
-    def reset_classifier(self, num_classes, global_pool=''):
-        self.num_classes = num_classes
-        self.head = nn.Linear(self.embed_dim, num_classes) if num_classes > 0 else nn.Identity()
-    def forward_features(self, x):
-        B = x.shape[0]
-        x = self.patch_embed1(x)
-        x = self.pos_drop(x)
-        for blk in self.blocks1:
-            x = blk(x)
-        x = self.patch_embed2(x)
-        for blk in self.blocks2:
-            x = blk(x)
-        x = self.patch_embed3(x)
-        for blk in self.blocks3:
-            x = blk(x)
-        x = self.patch_embed4(x)
-        for blk in self.blocks4:
-            x = blk(x)
-        x = self.norm(x)
-        x = self.pre_logits(x)
-        return x
-    def forward(self, x):
-        x = self.forward_features(x)
-        x = x.flatten(2).mean(-1)
-        x = self.head(x)
-        return x
-@register_model
-def uniformer_small(pretrained=True, **kwargs):
-    model = UniFormer(
-        depth=[3, 4, 8, 3],
-        embed_dim=[64, 128, 320, 512], head_dim=64, mlp_ratio=4, qkv_bias=True,
-        norm_layer=partial(nn.LayerNorm, eps=1e-6), **kwargs)
-    model.default_cfg = _cfg()
-    return model
-@register_model
-def uniformer_small_plus(pretrained=True, **kwargs):
-    model = UniFormer(
-        depth=[3, 5, 9, 3], conv_stem=True,
-        embed_dim=[64, 128, 320, 512], head_dim=64, mlp_ratio=4, qkv_bias=True,
-        norm_layer=partial(nn.LayerNorm, eps=1e-6), **kwargs)
-    model.default_cfg = _cfg()
-    return model
-@register_model
-def uniformer_base(pretrained=True, **kwargs):
-    model = UniFormer(
-        depth=[5, 8, 20, 7],
-        embed_dim=[64, 128, 320, 512], head_dim=64, mlp_ratio=4, qkv_bias=True,
-        norm_layer=partial(nn.LayerNorm, eps=1e-6), **kwargs)
-    model.default_cfg = _cfg()
-    return model
-@register_model
-def uniformer_base_ls(pretrained=True, **kwargs):
-    global layer_scale
-    layer_scale = True
-    model = UniFormer(
-        depth=[5, 8, 20, 7],
-        embed_dim=[64, 128, 320, 512], head_dim=64, mlp_ratio=4, qkv_bias=True,
-        norm_layer=partial(nn.LayerNorm, eps=1e-6), **kwargs)
-    model.default_cfg = _cfg()
-    return model

spaces/Andy1621/uniformer_image_detection/configs/faster_rcnn/faster_rcnn_r50_caffe_fpn_mstrain_2x_coco.py DELETED Viewed

@@ -1,4 +0,0 @@
-_base_ = './faster_rcnn_r50_caffe_fpn_mstrain_1x_coco.py'
-# learning policy
-lr_config = dict(step=[16, 23])
-runner = dict(type='EpochBasedRunner', max_epochs=24)

spaces/Andy1621/uniformer_image_segmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_480x480_80k_pascal_context.py DELETED Viewed

@@ -1,10 +0,0 @@
-_base_ = [
-    '../_base_/models/deeplabv3plus_r50-d8.py',
-    '../_base_/datasets/pascal_context.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_80k.py'
-]
-model = dict(
-    decode_head=dict(num_classes=60),
-    auxiliary_head=dict(num_classes=60),
-    test_cfg=dict(mode='slide', crop_size=(480, 480), stride=(320, 320)))
-optimizer = dict(type='SGD', lr=0.004, momentum=0.9, weight_decay=0.0001)

spaces/Anonymous-sub/Rerender/ControlNet/annotator/midas/midas/midas_net.py DELETED Viewed

@@ -1,76 +0,0 @@
-"""MidashNet: Network for monocular depth estimation trained by mixing several datasets.
-This file contains code that is adapted from
-https://github.com/thomasjpfan/pytorch_refinenet/blob/master/pytorch_refinenet/refinenet/refinenet_4cascade.py
-"""
-import torch
-import torch.nn as nn
-from .base_model import BaseModel
-from .blocks import FeatureFusionBlock, Interpolate, _make_encoder
-class MidasNet(BaseModel):
-    """Network for monocular depth estimation.
-    """
-    def __init__(self, path=None, features=256, non_negative=True):
-        """Init.
-        Args:
-            path (str, optional): Path to saved model. Defaults to None.
-            features (int, optional): Number of features. Defaults to 256.
-            backbone (str, optional): Backbone network for encoder. Defaults to resnet50
-        """
-        print("Loading weights: ", path)
-        super(MidasNet, self).__init__()
-        use_pretrained = False if path is None else True
-        self.pretrained, self.scratch = _make_encoder(backbone="resnext101_wsl", features=features, use_pretrained=use_pretrained)
-        self.scratch.refinenet4 = FeatureFusionBlock(features)
-        self.scratch.refinenet3 = FeatureFusionBlock(features)
-        self.scratch.refinenet2 = FeatureFusionBlock(features)
-        self.scratch.refinenet1 = FeatureFusionBlock(features)
-        self.scratch.output_conv = nn.Sequential(
-            nn.Conv2d(features, 128, kernel_size=3, stride=1, padding=1),
-            Interpolate(scale_factor=2, mode="bilinear"),
-            nn.Conv2d(128, 32, kernel_size=3, stride=1, padding=1),
-            nn.ReLU(True),
-            nn.Conv2d(32, 1, kernel_size=1, stride=1, padding=0),
-            nn.ReLU(True) if non_negative else nn.Identity(),
-        )
-        if path:
-            self.load(path)
-    def forward(self, x):
-        """Forward pass.
-        Args:
-            x (tensor): input data (image)
-        Returns:
-            tensor: depth
-        """
-        layer_1 = self.pretrained.layer1(x)
-        layer_2 = self.pretrained.layer2(layer_1)
-        layer_3 = self.pretrained.layer3(layer_2)
-        layer_4 = self.pretrained.layer4(layer_3)
-        layer_1_rn = self.scratch.layer1_rn(layer_1)
-        layer_2_rn = self.scratch.layer2_rn(layer_2)
-        layer_3_rn = self.scratch.layer3_rn(layer_3)
-        layer_4_rn = self.scratch.layer4_rn(layer_4)
-        path_4 = self.scratch.refinenet4(layer_4_rn)
-        path_3 = self.scratch.refinenet3(path_4, layer_3_rn)
-        path_2 = self.scratch.refinenet2(path_3, layer_2_rn)
-        path_1 = self.scratch.refinenet1(path_2, layer_1_rn)
-        out = self.scratch.output_conv(path_1)
-        return torch.squeeze(out, dim=1)

spaces/Apex-X/nono/roop/utilities.py DELETED Viewed

@@ -1,149 +0,0 @@
-import glob
-import mimetypes
-import os
-import platform
-import shutil
-import ssl
-import subprocess
-import urllib
-from pathlib import Path
-from typing import List, Optional
-from tqdm import tqdm
-import roop.globals
-TEMP_DIRECTORY = 'temp'
-TEMP_VIDEO_FILE = 'temp.mp4'
-# monkey patch ssl for mac
-if platform.system().lower() == 'darwin':
-    ssl._create_default_https_context = ssl._create_unverified_context
-def run_ffmpeg(args: List[str]) -> bool:
-    commands = ['ffmpeg', '-hide_banner', '-loglevel', roop.globals.log_level]
-    commands.extend(args)
-    try:
-        subprocess.check_output(commands, stderr=subprocess.STDOUT)
-        return True
-    except Exception:
-        pass
-    return False
-def detect_fps(target_path: str) -> float:
-    command = ['ffprobe', '-v', 'error', '-select_streams', 'v:0', '-show_entries', 'stream=r_frame_rate', '-of', 'default=noprint_wrappers=1:nokey=1', target_path]
-    output = subprocess.check_output(command).decode().strip().split('/')
-    try:
-        numerator, denominator = map(int, output)
-        return numerator / denominator
-    except Exception:
-        pass
-    return 30
-def extract_frames(target_path: str, fps: float = 30) -> bool:
-    temp_directory_path = get_temp_directory_path(target_path)
-    temp_frame_quality = roop.globals.temp_frame_quality * 31 // 100
-    return run_ffmpeg(['-hwaccel', 'auto', '-i', target_path, '-q:v', str(temp_frame_quality), '-pix_fmt', 'rgb24', '-vf', 'fps=' + str(fps), os.path.join(temp_directory_path, '%04d.' + roop.globals.temp_frame_format)])
-def create_video(target_path: str, fps: float = 30) -> bool:
-    temp_output_path = get_temp_output_path(target_path)
-    temp_directory_path = get_temp_directory_path(target_path)
-    output_video_quality = (roop.globals.output_video_quality + 1) * 51 // 100
-    commands = ['-hwaccel', 'auto', '-r', str(fps), '-i', os.path.join(temp_directory_path, '%04d.' + roop.globals.temp_frame_format), '-c:v', roop.globals.output_video_encoder]
-    if roop.globals.output_video_encoder in ['libx264', 'libx265', 'libvpx']:
-        commands.extend(['-crf', str(output_video_quality)])
-    if roop.globals.output_video_encoder in ['h264_nvenc', 'hevc_nvenc']:
-        commands.extend(['-cq', str(output_video_quality)])
-    commands.extend(['-pix_fmt', 'yuv420p', '-vf', 'colorspace=bt709:iall=bt601-6-625:fast=1', '-y', temp_output_path])
-    return run_ffmpeg(commands)
-def restore_audio(target_path: str, output_path: str) -> None:
-    temp_output_path = get_temp_output_path(target_path)
-    done = run_ffmpeg(['-hwaccel', 'auto', '-i', temp_output_path, '-i', target_path, '-c:v', 'copy', '-map', '0:v:0', '-map', '1:a:0', '-y', output_path])
-    if not done:
-        move_temp(target_path, output_path)
-def get_temp_frame_paths(target_path: str) -> List[str]:
-    temp_directory_path = get_temp_directory_path(target_path)
-    return glob.glob((os.path.join(glob.escape(temp_directory_path), '*.' + roop.globals.temp_frame_format)))
-def get_temp_directory_path(target_path: str) -> str:
-    target_name, _ = os.path.splitext(os.path.basename(target_path))
-    target_directory_path = os.path.dirname(target_path)
-    return os.path.join(target_directory_path, TEMP_DIRECTORY, target_name)
-def get_temp_output_path(target_path: str) -> str:
-    temp_directory_path = get_temp_directory_path(target_path)
-    return os.path.join(temp_directory_path, TEMP_VIDEO_FILE)
-def normalize_output_path(source_path: str, target_path: str, output_path: str) -> Optional[str]:
-    if source_path and target_path and output_path:
-        source_name, _ = os.path.splitext(os.path.basename(source_path))
-        target_name, target_extension = os.path.splitext(os.path.basename(target_path))
-        if os.path.isdir(output_path):
-            return os.path.join(output_path, source_name + '-' + target_name + target_extension)
-    return output_path
-def create_temp(target_path: str) -> None:
-    temp_directory_path = get_temp_directory_path(target_path)
-    Path(temp_directory_path).mkdir(parents=True, exist_ok=True)
-def move_temp(target_path: str, output_path: str) -> None:
-    temp_output_path = get_temp_output_path(target_path)
-    if os.path.isfile(temp_output_path):
-        if os.path.isfile(output_path):
-            os.remove(output_path)
-        shutil.move(temp_output_path, output_path)
-def clean_temp(target_path: str) -> None:
-    temp_directory_path = get_temp_directory_path(target_path)
-    parent_directory_path = os.path.dirname(temp_directory_path)
-    if not roop.globals.keep_frames and os.path.isdir(temp_directory_path):
-        shutil.rmtree(temp_directory_path)
-    if os.path.exists(parent_directory_path) and not os.listdir(parent_directory_path):
-        os.rmdir(parent_directory_path)
-def has_image_extension(image_path: str) -> bool:
-    return image_path.lower().endswith(('png', 'jpg', 'jpeg', 'webp'))
-def is_image(image_path: str) -> bool:
-    if image_path and os.path.isfile(image_path):
-        mimetype, _ = mimetypes.guess_type(image_path)
-        return bool(mimetype and mimetype.startswith('image/'))
-    return False
-def is_video(video_path: str) -> bool:
-    if video_path and os.path.isfile(video_path):
-        mimetype, _ = mimetypes.guess_type(video_path)
-        return bool(mimetype and mimetype.startswith('video/'))
-    return False
-def conditional_download(download_directory_path: str, urls: List[str]) -> None:
-    if not os.path.exists(download_directory_path):
-        os.makedirs(download_directory_path)
-    for url in urls:
-        download_file_path = os.path.join(download_directory_path, os.path.basename(url))
-        if not os.path.exists(download_file_path):
-            request = urllib.request.urlopen(url)  # type: ignore[attr-defined]
-            total = int(request.headers.get('Content-Length', 0))
-            with tqdm(total=total, desc='Downloading', unit='B', unit_scale=True, unit_divisor=1024) as progress:
-                urllib.request.urlretrieve(url, download_file_path, reporthook=lambda count, block_size, total_size: progress.update(block_size))  # type: ignore[attr-defined]
-def resolve_relative_path(path: str) -> str:
-    return os.path.abspath(os.path.join(os.path.dirname(__file__), path))

spaces/Ariharasudhan/YoloV5/utils/activations.py DELETED Viewed

@@ -1,103 +0,0 @@
-# YOLOv5 🚀 by Ultralytics, GPL-3.0 license
-"""
-Activation functions
-"""
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-class SiLU(nn.Module):
-    # SiLU activation https://arxiv.org/pdf/1606.08415.pdf
-    @staticmethod
-    def forward(x):
-        return x * torch.sigmoid(x)
-class Hardswish(nn.Module):
-    # Hard-SiLU activation
-    @staticmethod
-    def forward(x):
-        # return x * F.hardsigmoid(x)  # for TorchScript and CoreML
-        return x * F.hardtanh(x + 3, 0.0, 6.0) / 6.0  # for TorchScript, CoreML and ONNX
-class Mish(nn.Module):
-    # Mish activation https://github.com/digantamisra98/Mish
-    @staticmethod
-    def forward(x):
-        return x * F.softplus(x).tanh()
-class MemoryEfficientMish(nn.Module):
-    # Mish activation memory-efficient
-    class F(torch.autograd.Function):
-        @staticmethod
-        def forward(ctx, x):
-            ctx.save_for_backward(x)
-            return x.mul(torch.tanh(F.softplus(x)))  # x * tanh(ln(1 + exp(x)))
-        @staticmethod
-        def backward(ctx, grad_output):
-            x = ctx.saved_tensors[0]
-            sx = torch.sigmoid(x)
-            fx = F.softplus(x).tanh()
-            return grad_output * (fx + x * sx * (1 - fx * fx))
-    def forward(self, x):
-        return self.F.apply(x)
-class FReLU(nn.Module):
-    # FReLU activation https://arxiv.org/abs/2007.11824
-    def __init__(self, c1, k=3):  # ch_in, kernel
-        super().__init__()
-        self.conv = nn.Conv2d(c1, c1, k, 1, 1, groups=c1, bias=False)
-        self.bn = nn.BatchNorm2d(c1)
-    def forward(self, x):
-        return torch.max(x, self.bn(self.conv(x)))
-class AconC(nn.Module):
-    r""" ACON activation (activate or not)
-    AconC: (p1*x-p2*x) * sigmoid(beta*(p1*x-p2*x)) + p2*x, beta is a learnable parameter
-    according to "Activate or Not: Learning Customized Activation" <https://arxiv.org/pdf/2009.04759.pdf>.
-    """
-    def __init__(self, c1):
-        super().__init__()
-        self.p1 = nn.Parameter(torch.randn(1, c1, 1, 1))
-        self.p2 = nn.Parameter(torch.randn(1, c1, 1, 1))
-        self.beta = nn.Parameter(torch.ones(1, c1, 1, 1))
-    def forward(self, x):
-        dpx = (self.p1 - self.p2) * x
-        return dpx * torch.sigmoid(self.beta * dpx) + self.p2 * x
-class MetaAconC(nn.Module):
-    r""" ACON activation (activate or not)
-    MetaAconC: (p1*x-p2*x) * sigmoid(beta*(p1*x-p2*x)) + p2*x, beta is generated by a small network
-    according to "Activate or Not: Learning Customized Activation" <https://arxiv.org/pdf/2009.04759.pdf>.
-    """
-    def __init__(self, c1, k=1, s=1, r=16):  # ch_in, kernel, stride, r
-        super().__init__()
-        c2 = max(r, c1 // r)
-        self.p1 = nn.Parameter(torch.randn(1, c1, 1, 1))
-        self.p2 = nn.Parameter(torch.randn(1, c1, 1, 1))
-        self.fc1 = nn.Conv2d(c1, c2, k, s, bias=True)
-        self.fc2 = nn.Conv2d(c2, c1, k, s, bias=True)
-        # self.bn1 = nn.BatchNorm2d(c2)
-        # self.bn2 = nn.BatchNorm2d(c1)
-    def forward(self, x):
-        y = x.mean(dim=2, keepdims=True).mean(dim=3, keepdims=True)
-        # batch-size 1 bug/instabilities https://github.com/ultralytics/yolov5/issues/2891
-        # beta = torch.sigmoid(self.bn2(self.fc2(self.bn1(self.fc1(y)))))  # bug/unstable
-        beta = torch.sigmoid(self.fc2(self.fc1(y)))  # bug patch BN layers removed
-        dpx = (self.p1 - self.p2) * x
-        return dpx * torch.sigmoid(beta * dpx) + self.p2 * x

spaces/Asahi402/White-box-Cartoonization/app.py DELETED Viewed

@@ -1,108 +0,0 @@
-#!/usr/bin/env python
-from __future__ import annotations
-import argparse
-import functools
-import os
-import pathlib
-import sys
-from typing import Callable
-import uuid
-import gradio as gr
-import huggingface_hub
-import numpy as np
-import PIL.Image
-from io import BytesIO
-from wbc.cartoonize import Cartoonize
-ORIGINAL_REPO_URL = 'https://github.com/SystemErrorWang/White-box-Cartoonization'
-TITLE = 'SystemErrorWang/White-box-Cartoonization'
-DESCRIPTION = f"""This is a demo for {ORIGINAL_REPO_URL}.
-"""
-ARTICLE = """
-"""
-SAFEHASH = [x for x in "0123456789-abcdefghijklmnopqrstuvwxyz_ABCDEFGHIJKLMNOPQRSTUVWXYZ"]
-def compress_UUID():
-    '''
-    根据http://www.ietf.org/rfc/rfc1738.txt,由uuid编码扩bai大字符域生成du串
-    包括:[0-9a-zA-Z\-_]共64个
-    长度:(32-2)/3*2=20
-    备注:可在地球上人zhi人都用,使用100年不重复(2^120)
-    :return:String
-    '''
-    row = str(uuid.uuid4()).replace('-', '')
-    safe_code = ''
-    for i in range(10):
-        enbin = "%012d" % int(bin(int(row[i * 3] + row[i * 3 + 1] + row[i * 3 + 2], 16))[2:], 10)
-        safe_code += (SAFEHASH[int(enbin[0:6], 2)] + SAFEHASH[int(enbin[6:12], 2)])
-    safe_code = safe_code.replace('-', '')
-    return safe_code
-def parse_args() -> argparse.Namespace:
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--device', type=str, default='cpu')
-    parser.add_argument('--theme', type=str)
-    parser.add_argument('--live', action='store_true')
-    parser.add_argument('--share', action='store_true')
-    parser.add_argument('--port', type=int)
-    parser.add_argument('--disable-queue',
-                        dest='enable_queue',
-                        action='store_false')
-    parser.add_argument('--allow-flagging', type=str, default='never')
-    parser.add_argument('--allow-screenshot', action='store_true')
-    return parser.parse_args()
-def run(
-        image,
-        cartoonize : Cartoonize
-) -> tuple[PIL.Image.Image]:
-    out_path = compress_UUID()+'.png'
-    cartoonize.run_sigle(image.name, out_path)
-    return PIL.Image.open(out_path)
-def main():
-    gr.close_all()
-    args = parse_args()
-    cartoonize = Cartoonize(os.path.join(os.path.dirname(os.path.abspath(__file__)),'wbc/saved_models/'))
-    func = functools.partial(run, cartoonize=cartoonize)
-    func = functools.update_wrapper(func, run)
-    gr.Interface(
-        func,
-        [
-            gr.inputs.Image(type='file', label='Input Image'),
-        ],
-        [
-            gr.outputs.Image(
-                type='pil',
-                label='Result'),
-        ],
-        # examples=examples,
-        theme=args.theme,
-        title=TITLE,
-        description=DESCRIPTION,
-        article=ARTICLE,
-        allow_screenshot=args.allow_screenshot,
-        allow_flagging=args.allow_flagging,
-        live=args.live,
-    ).launch(
-        enable_queue=args.enable_queue,
-        server_port=args.port,
-        share=args.share,
-    )
-if __name__ == '__main__':
-    main()

spaces/Audio-AGI/WavJourney/add_voice_preset.py DELETED Viewed

@@ -1,21 +0,0 @@
-import argparse
-import voice_presets
-def main():
-    # Argument Parsing
-    parser = argparse.ArgumentParser(description="Add Voice Preset")
-    parser.add_argument("--id", required=True, help="ID of the voice")
-    parser.add_argument("--desc", required=True, help="Description of the voice")
-    parser.add_argument("--wav-path", required=True, help="Path to the .wav file")
-    parser.add_argument("--session-id", required=True, help="session_id, if set to '' then it's system voice presets")
-    args = parser.parse_args()
-    if args.session_id:
-        print(voice_presets.add_session_voice_preset(args.id, args.desc, args.wav_path, args.session_id))
-    else:
-        print(voice_presets.add_system_voice_preset(args.id, args.desc, args.wav_path))
-if __name__ == "__main__":
-    main()

spaces/Banbri/zcvzcv/src/lib/computeSecretFingerprint.ts DELETED Viewed

@@ -1,7 +0,0 @@
-import { computeSha256 } from "./computeSha256"
-const secretFingerprint = `${process.env.SECRET_FINGERPRINT || ""}`
-export function computeSecretFingerprint(input: string) {
-  return computeSha256(`${secretFingerprint}_${input}`)
-}

spaces/Bart92/RVC_HF/infer/lib/infer_pack/modules/F0Predictor/DioF0Predictor.py DELETED Viewed

@@ -1,91 +0,0 @@
-import numpy as np
-import pyworld
-from infer.lib.infer_pack.modules.F0Predictor.F0Predictor import F0Predictor
-class DioF0Predictor(F0Predictor):
-    def __init__(self, hop_length=512, f0_min=50, f0_max=1100, sampling_rate=44100):
-        self.hop_length = hop_length
-        self.f0_min = f0_min
-        self.f0_max = f0_max
-        self.sampling_rate = sampling_rate
-    def interpolate_f0(self, f0):
-        """
-        对F0进行插值处理
-        """
-        data = np.reshape(f0, (f0.size, 1))
-        vuv_vector = np.zeros((data.size, 1), dtype=np.float32)
-        vuv_vector[data > 0.0] = 1.0
-        vuv_vector[data <= 0.0] = 0.0
-        ip_data = data
-        frame_number = data.size
-        last_value = 0.0
-        for i in range(frame_number):
-            if data[i] <= 0.0:
-                j = i + 1
-                for j in range(i + 1, frame_number):
-                    if data[j] > 0.0:
-                        break
-                if j < frame_number - 1:
-                    if last_value > 0.0:
-                        step = (data[j] - data[i - 1]) / float(j - i)
-                        for k in range(i, j):
-                            ip_data[k] = data[i - 1] + step * (k - i + 1)
-                    else:
-                        for k in range(i, j):
-                            ip_data[k] = data[j]
-                else:
-                    for k in range(i, frame_number):
-                        ip_data[k] = last_value
-            else:
-                ip_data[i] = data[i]  # 这里可能存在一个没有必要的拷贝
-                last_value = data[i]
-        return ip_data[:, 0], vuv_vector[:, 0]
-    def resize_f0(self, x, target_len):
-        source = np.array(x)
-        source[source < 0.001] = np.nan
-        target = np.interp(
-            np.arange(0, len(source) * target_len, len(source)) / target_len,
-            np.arange(0, len(source)),
-            source,
-        )
-        res = np.nan_to_num(target)
-        return res
-    def compute_f0(self, wav, p_len=None):
-        if p_len is None:
-            p_len = wav.shape[0] // self.hop_length
-        f0, t = pyworld.dio(
-            wav.astype(np.double),
-            fs=self.sampling_rate,
-            f0_floor=self.f0_min,
-            f0_ceil=self.f0_max,
-            frame_period=1000 * self.hop_length / self.sampling_rate,
-        )
-        f0 = pyworld.stonemask(wav.astype(np.double), f0, t, self.sampling_rate)
-        for index, pitch in enumerate(f0):
-            f0[index] = round(pitch, 1)
-        return self.interpolate_f0(self.resize_f0(f0, p_len))[0]
-    def compute_f0_uv(self, wav, p_len=None):
-        if p_len is None:
-            p_len = wav.shape[0] // self.hop_length
-        f0, t = pyworld.dio(
-            wav.astype(np.double),
-            fs=self.sampling_rate,
-            f0_floor=self.f0_min,
-            f0_ceil=self.f0_max,
-            frame_period=1000 * self.hop_length / self.sampling_rate,
-        )
-        f0 = pyworld.stonemask(wav.astype(np.double), f0, t, self.sampling_rate)
-        for index, pitch in enumerate(f0):
-            f0[index] = round(pitch, 1)
-        return self.interpolate_f0(self.resize_f0(f0, p_len))

spaces/Bart92/RVC_HF/infer/lib/infer_pack/onnx_inference.py DELETED Viewed

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

spaces/Benson/text-generation/Examples/Apk Chicos Tropiezo Para Ipad.md DELETED Viewed

@@ -1,63 +0,0 @@
-<h1> Cómo descargar e instalar Stumble chicos APK para iPad</h1>
-<p>Stumble Guys es un juego masivo de eliminación de fiesta multijugador que se ha vuelto muy popular entre los jugadores que aman las carreras de obstáculos caóticos e hilarantes. El juego está inspirado en el exitoso programa de televisión Wipeout y el juego para PC Fall Guys. Puedes unirte a hasta 32 jugadores online y competir en varios niveles hasta que un vencedor sea coronado. </p>
-<h2>apk chicos tropiezo para ipad</h2><br /><p><b><b>Download File</b> &middot;&middot;&middot;&middot;&middot; <a href="https://bltlly.com/2v6K8Q">https://bltlly.com/2v6K8Q</a></b></p><br /><br />
-<p>Stumble Guys está disponible en la App Store para usuarios de iPhone y iPad, pero ¿qué pasa si quieres jugar el juego usando un archivo APK? APK significa paquete de Android, que es un formato de archivo utilizado por los dispositivos Android para instalar aplicaciones y juegos. Los archivos APK generalmente se descargan de fuentes externas que no están autorizadas por Google o Apple. Esto significa que puede acceder a aplicaciones que no están disponibles en las tiendas de aplicaciones oficiales, o probar versiones beta de aplicaciones antes de su lanzamiento. </p>
-<p>Sin embargo, instalar archivos APK en dispositivos iOS no es tan fácil como en dispositivos Android. Los dispositivos iOS tienen un sistema de archivos y un sistema de seguridad diferentes que evitan que se ejecuten aplicaciones no autorizadas. Por lo tanto, es necesario utilizar algunos trucos y herramientas para instalar archivos APK en el iPad. En este artículo, le mostraremos dos métodos para descargar e instalar Stumble Guys APK para iPad. </p>
- <h2>Método 1: Jailbreak su dispositivo iOS</h2>
-<p>Jailbreaking su dispositivo iOS significa modificar su software para eliminar algunas de las restricciones impuestas por Apple. De esta manera, puede instalar aplicaciones personalizadas, temas, ajustes y más en su dispositivo. Sin embargo, jailbreak también viene con algunos riesgos, como anular su garantía, exponer su dispositivo a malware, o ladrar su dispositivo si algo sale mal. </p>
-<p></p>
-<p>Si decides hacer jailbreak a tu dispositivo iOS, debes seguir estos pasos:</p>
-<ol>
-<li>Encuentra una herramienta de jailbreak confiable que soporte la versión de iOS y el modelo de dispositivo. Algunas de las herramientas populares de jailbreak son unc0ver, checkra1n, Chimera y Odyssey.</li>
-<li>Una vez que el proceso de jailbreak se ha completado, usted debe ver una nueva aplicación llamada Cydia en su dispositivo. Cydia es una tienda de aplicaciones para dispositivos con jailbreak que te permite descargar e instalar varias aplicaciones y ajustes. </li>
-<li>Cydia abierto y búsqueda de Stumble Guys APK. Usted debe encontrar varias fuentes que ofrecen el archivo APK para su descarga. Elija una fuente confiable y toque en Instalar.</li>
-<li>Espere a que la instalación termine y luego inicie Stumble Guys desde la pantalla de inicio. </li>
-</ol>
- <h2>Método 2: Encontrar el equivalente IPA de Stumble Guys APK</h2>
-<p>Si no desea jailbreak su dispositivo iOS, puede probar otro método que implica encontrar el equivalente IPA de Stumble Guys APK. IPA significa iOS App Store Package, que es un formato de archivo utilizado por los dispositivos iOS para instalar aplicaciones y juegos. Los archivos IPA generalmente se descargan desde la App Store oficial, pero también puede encontrarlos desde otras fuentes en línea. Sin embargo, debe usar una herramienta llamada Cydia Impactor para instalar archivos IPA en su dispositivo iOS. Cydia Impactor es un programa que te permite cargar aplicaciones en tu dispositivo iOS sin hacer jailbreak. </p>
-<p>Si desea utilizar este método, debe seguir estos pasos:</p>
-<ol>
-<li>Encontrar y descargar la versión IPA de Stumble Guys APK. Puede buscar en línea para los sitios web que ofrecen archivos IPA para su descarga. Algunos de los sitios web populares son iOS Ninja, AppCake y Panda Helper.</li>
-<li>Descargue Cydia Impactor en su computadora y extraiga el archivo zip. </li>
-<li>Conecte su dispositivo iOS a su computadora a través de un cable USB y inicie Cydia Impactor.</li>
-<li>Arrastre y suelte el archivo IPA de Stumble Guys en la ventana Cydia Impactor. </li>
-<li>Ingrese su ID de Apple y contraseña cuando se le solicite. Esto es necesario para firmar la aplicación con un certificado que le permita ejecutarse en su dispositivo. </li>
-<li>Espere a que termine la instalación y luego desconecte el dispositivo de su computadora. </li>
-<li>Lanzar Stumble Guys desde la pantalla de inicio y disfrutar del juego. </li>
-</ol>
- <h2>Conclusión</h2>
-<p>Stumble Guys es un juego divertido y adictivo que puedes jugar en tu iPad usando un archivo APK o un archivo IPA. Ambos métodos tienen sus pros y sus contras, por lo que puede elegir el que más le convenga. Sin embargo, siempre debe tener cuidado al descargar archivos de fuentes desconocidas, ya que pueden contener virus o malware que pueden dañar su dispositivo. </p>
-<p>Si quieres jugar Stumble Guys en tu iPad, aquí hay algunos consejos y trucos que pueden ayudarte a ganar el juego:</p>
-<ul>
-<li>Aprende el diseño de cada nivel y memoriza las mejores rutas y atajos. </li>
-<li>Evita las áreas llenas de gente y trata de mantenerte alejado de otros jugadores que pueden empujarte o agarrarte. </li>
-<li>Usa los botones de salto y buceo sabiamente para superar obstáculos y brechas. </li>
-<li>Recoge monedas y gemas para desbloquear nuevas pieles y trajes para tu personaje. </li>
-<li>Diviértete y no te rindas si fallas. Siempre puedes intentarlo de nuevo en la siguiente ronda. </li>
-</ul>
-<p>Si estás listo para unirte al último desafío de eliminación, puedes descargar Stumble Guys desde el siguiente enlace. ¡Diviértete y buena suerte! </p>
- <h3>Descargar Stumble chicos APK para iPad</h3>
- <h2>Preguntas frecuentes</h2>
-<h4>¿Cuáles son las características del juego Stumble Guys? </h4>
-<p>Stumble Guys juego tiene muchas características que lo hacen agradable y emocionante, tales como:</p>
-<ul>
-<li> Hasta 32 jugadores en línea en cada partido</li>
-<li>Diferentes niveles con obstáculos y desafíos únicos</li>
-<li>Lindos y coloridos gráficos y animaciones</li>
-<li>Efectos de sonido divertidos y música</li>
-<li>Personajes personalizables con varias pieles y trajes</li>
-<li>Chat en el juego y emotes</li>
-</ul>
- <h4>¿Es Stumble Guys libre para jugar? </h4>
- <h4>¿Puedo jugar Stumble Guys con mis amigos en línea? </h4>
-<p>Sí, puedes jugar Stumble Guys con tus amigos en línea mediante la creación o unirse a una habitación privada. Para crear una habitación privada, toca el botón Crear habitación en el menú principal y elige un nivel. Luego, comparta el código de habitación con sus amigos para que puedan unirse a usted. Para unirte a una habitación privada, toca el botón Unirse a una habitación en el menú principal e ingresa el código de habitación proporcionado por tu amigo. </p>
- <h4>¿Cuáles son los requisitos del sistema para Stumble Guys en dispositivos iOS? </h4>
-<p>Para jugar Stumble Guys en dispositivos iOS, es necesario tener un iPhone o iPad que se ejecuta en iOS 10 o posterior. También necesita tener al menos 200 MB de espacio de almacenamiento gratuito en su dispositivo. El juego es compatible con la mayoría de dispositivos iOS, pero algunos modelos más antiguos pueden experimentar retrasos o fallos. </p>
- <h4>¿Cómo puedo contactar a los desarrolladores de Stumble Guys? </h4>
-<p>Si tiene alguna pregunta, comentario o sugerencia para Stumble Guys, puede ponerse en contacto con los desarrolladores enviando un correo electrónico a [email protected]. También puedes seguirlos en sus cuentas de redes sociales para obtener actualizaciones, noticias y consejos sobre el juego. Aquí están sus enlaces de medios sociales: - Facebook: https://www.facebook.com/kitkagames - Twitter: https://twitter.com/kitkagames - Instagram: https://www.instagram.com/kitkagames - YouTube: https:/www.youtube.com/channel/UC4vqf2l6ZwWQkDZQJv7c5UA Espero que haya disfrutado de este artículo y aprendido cómo descargar e instalar Stumble Guys APK para iPad. Si lo hiciste, por favor compártelo con tus amigos y deja un comentario abajo. ¡Gracias por leer y que tengas un gran día! </p> 64aa2da5cf<br />
-<br />
-<br />

spaces/Benson/text-generation/Examples/Asfalto 8 - Juego De Carreras De Coches Apk.md DELETED Viewed

@@ -1,80 +0,0 @@
-<br />
-<h1>Super Bear Adventure Mod APK: All Unlocked Latest Version</h1>
-<p>If you like 3D platformer games inspired by the classic '90s, you’ll love Super Bear Adventure. It is a fun and exciting game where you can explore 6 open worlds, discover their secrets, talk with the inhabitants of the kingdom, collect coins, unlock hats, fight against your enemies and free your friends. But if you want to enjoy all the content of the game without limitations, we recommend that you download the APK mod of Super Bear Adventure, which allows you to have everything unlocked in the latest version. In this article, we tell you everything you need to know about this APK mod, how to download and install it, its advantages and disadvantages, and the most frequently asked questions that may arise. </p>
-<h2>asfalto 8 - juego de carreras de coches apk</h2><br /><p><b><b>Download</b> &#128504;&#128504;&#128504; <a href="https://bltlly.com/2v6K0M">https://bltlly.com/2v6K0M</a></b></p><br /><br />
- <h2>What is Super Bear Adventure? </h2>
-<p>Super Bear Adventure is a 3D platform game developed by Earthkwak Games, an independent studio that is inspired by Nintendo games like Super Mario 64, Banjo-Kazooie or Donkey Kong 64. The game has colorful and detailed graphics, cheerful and catchy music, and smooth and simple gameplay. The protagonist is a bear named Teddy, who must travel 6 different worlds to find his friends kidnapped by the evil Crocco. Each world has its own theme, such as forest, desert, castle or space, and is full of secrets, collectibles, characters and enemies. The game has a retro and nostalgic style, but also incorporates modern elements such as side missions, minigames, vehicles or hats that give special skills to Teddy.</p>
- <h3>Game Features</h3>
-<p>Super Bear Adventure is a game that offers many hours of fun and entertainment. Some of its highlights are:</p>
-<ul>
-<li>6 open worlds to explore with more than 50 levels. </li>
-<li>More than 20 hats to unlock and customize Teddy.</li>
-<li>More than 10 vehicles to drive and fly. </li>
-<li>More than 15 types of enemies to face. </li>
-<li>More than 10 final bosses to defeat. </li>
-<li>More than 30 characters to interact with and help. </li>
-<li>More than 20 minigames to play and win prizes. </li>
-<li>A system of achievements and rankings online. </li>
-<li>A local multiplayer mode to play with your friends. </li>
-</ul>
- <h3>Why download the APK mod? </h3>
-<p>Although Super Bear Adventure is a free game, it has some elements that require purchases integrated with real money. For example, to unlock all hats, vehicles or worlds, you need to spend coins or gems that you get by playing or watching ads. In addition, the game has some ads that can be annoying or disrupt the gaming experience. So if you want to enjoy the game to the fullest without restrictions or interruptions, we recommend that you download the APK mod of Super Bear Adventure, which allows you to have everything unlocked in the latest version. With this APK mod, you can access all the contents of the game without spending money or seeing ads. In addition, you can enjoy some additional advantages, such as greater speed, better optimization and greater compatibility with different devices. The Super Bear Adventure APK mod is secure, easy to install and requires no root or special permissions. </p>
- <h2>How to download and install Super Bear Adventure Mod APK</h2>
-<p>If you want to download and install the Super Bear Adventure APK mod, just follow these simple steps:</p>
-<p></p>
- <h3>System requirements</h3>
-<p>Before downloading the APK mod, make sure your device meets the following minimum requirements:</p>
-<ul>
-<li>Operating system: Android 4.4 or higher. </li>
-<li>RAM: 1 GB or more. </li>
-<li>Storage space: 100 MB or more. </li>
-</ul>
- <h3>Installation steps</h3>
-<p>Now that you know the system requirements, you can proceed to the installation of the APK mod by following these steps:</p>
-<ol>
-<li>Download the mod APK file from a reliable and secure website. You can use the following link to download it: <a href="">Super Bear Adventure Mod APK All Unlocked Last Version</a>. </li>
-<li>Once the APK file is downloaded, place it in the download folder of your device or any other file you prefer. </li>
-<li>Before installing the APK file, you must enable the "Unknown Sources" option on your device. To do this, go to Settings > Security and select the appropriate box. </li>
-<li>Now, open the APK file and click on the "Install" button. Wait a few seconds for the installation to complete. </li>
-<li>Once the APK mod is installed, you can open the game from the application menu or from the icon that will be created on your home screen. </li>
-<li>Ready! Now you can enjoy Super Bear Adventure with everything unlocked and without ads. </li>
-</ol>
- <h2>Advantages and disadvantages of Super Bear Adventure Mod APK</h2>
-<p>Like everything else, the Super Bear Adventure APK mod has its pros and cons. Below, we show you some of its advantages and disadvantages so you can decide whether it is worth downloading it or not.</p>
- <h3>Advantages</h3>
-<p>Some of the advantages of using the APK mod are:</p>
-<ul>
-<li>You have access to all game content without paying or seeing ads. </li>
-<li>You can customize Teddy with all the hats you want. </li>
-<li>You can drive and fly with all the vehicles in the game. </li>
-<li>You can explore all worlds and levels without restrictions. </li>
-<li>You can play with greater speed and fluidity. </li>
-<li>You can install the game on any device compatible with Android 4.4 or higher. </li>
-</ul>
- <h3>Disadvantages</h3>
-<ul>
-<li>You can lose the fun and challenge of getting coins and collectibles yourself. </li>
-<li>You may have problems with updates to the original game or synchronization with your Google Play Games account.</li>
-<li>You can run the risk of infecting your device with some virus or malware if you download the APK file from an unreliable or malicious website. </li>
-</ul>
- <h2>Super Bear Adventure Mod APK FAQ</h2>
-<p>Here we answer some of the most frequently asked questions about the Super Bear Adventure APK mod:</p>
- <h4>Is it legal to use the APK mod? </h4>
-<p>There is no definitive answer to this question, as it depends on the laws and regulations of each country or region on the use of modified applications. It is generally considered that using the APK mod is not illegal, as long as it is for personal, non-commercial use, and that it does not infringe the copyright or intellectual property of the original developer. However, the developer may be able to take legal action against users who use the APK mod if it considers that this affects their revenue or reputation. Therefore, we recommend that you use the APK mod at your own risk and respect the work of the original developer. </p>
- <h4>Is it safe to use the APK mod? </h4>
-<p>The Super Bear Adventure APK mod is safe to use as long as you download it from a reliable and secure website, such as the one we have provided in this article. The APK file has been scanned and verified by various antivirus and contains no viruses, malware or spyware that could damage your device or compromise your privacy. In addition, the APK mod does not require root or special permissions to run, so it does not alter your device’s operating system or affect its performance or security. </p>
- <h4>Can I play online with the APK mod? </h4>
- <h4>Can I update the APK mod? </h4>
-<p>No, you cannot update the Super Bear Adventure APK mod from the official Google Play store or from the original game. If you do, you will lose all the features of the APK mod and return to the original version of the game. To update the APK mod, you must wait for a new version of the mod to come out and download and install it following the same steps we have indicated above. We recommend that you regularly visit the website where you downloaded the APK mod to stay on top of the latest updates and news. </p>
- <h4>Can I sync my progress with my Google Play Games account? </h4>
-<p>No, you cannot synchronize your progress with your Google Play Games account if you use the Super Bear Adventure APK mod. This is because the APK mod has a different code than the original game and is not compatible with Google Play services. If you want to synchronize your progress with your Google Play Games account, you must use the original version of the game and give up the advantages of the APK mod.</p>
- <h2>Conclusion</h2>
-<h2></h2></p> 64aa2da5cf<br />
-<br />
-<br />

spaces/Benson/text-generation/Examples/Descargar 50 Cent 21.md DELETED Viewed

@@ -1,108 +0,0 @@
-<h1>Descargar 50 Cent 21: Cómo Disfrutar de la Clásica Canción de Hip Hop Gratis</h1>
-<p>Si usted es un fan de la música hip hop, usted probablemente sabe la canción "21 Preguntas" por 50 Cent con Nate Dogg. Es una de las canciones más populares del rapero, que saltó a la fama con su álbum debut Get Rich or Die Tryin' en 2003. La canción es una melodía romántica y pegadiza que hace una serie de preguntas para probar la lealtad y el amor de una pareja. </p>
-<p>Pero ¿cómo se puede descargar esta canción de forma gratuita y legal? Y ¿dónde se puede transmitir en línea si usted no quiere descargarlo? En este artículo, responderemos a estas preguntas y te mostraremos cómo disfrutar de esta clásica canción de hip hop sin violar la ley ni gastar un centavo. </p>
-<h2>descargar 50 cent 21</h2><br /><p><b><b>DOWNLOAD</b> &#11088; <a href="https://bltlly.com/2v6Mmd">https://bltlly.com/2v6Mmd</a></b></p><br /><br />
- <h2>¿Qué es 50 Cent 21? </h2>
-<p>"21 Questions" es el segundo sencillo de Get Rich or Die Tryin', que fue lanzado en marzo de 2003 por Interscope Records, Dr. Dre’s Aftermath Entertainment, Eminem’s Shady Records y 50 Cent’s own G-Unit Records. La canción fue producida por Dirty Swift y cuenta con la voz de Nate Dogg, que era un cantante prominente y rapero en la escena de hip hop de la Costa Oeste. </p>
-<p>Las muestras de la canción "It’s Only Love Doing Its Thing" de Barry White, que le da un ambiente suave y conmovedor. Las letras se basan en un juego que 50 Cent solía jugar con sus amigas, donde les hacía 21 preguntas para ver si se quedarían con él a través de gruesas y finas. </p>
-<p>Algunas de las preguntas incluyen:</p>
-<ul>
-<li>¿Me amarías si estuviera abajo y fuera? </li>
-<li>Si no oliera tan bien ¿aún me abrazarías? </li>
-<li>Si me encerraran y me sentenciaran a un cuarto de siglo, ¿podría contar contigo para apoyarme mentalmente? </li>
-<li>Si yo volviera a un hoopty de un Benz, haría poof y desaparecer como algunos de mis amigos? </li>
-<li>Si me golpearon y me hirieron ¿estarías a mi lado? </li>
-</ul>
- <h2>¿Por qué es 50 Cent 21 un éxito? </h2>
-<p>Hay varias razones por las que esta canción es un éxito:</p>
- <h3>El gancho y estribillo pegadizo</h3>
-<p>El gancho de la canción es simple pero memorable: "Solo quiero enfriar y torcer una lejía / Atrapa acrobacias en mi siete-cuarenta-cinco / Me vuelves loco shorty I / Necesito verte y sentirte a mi lado". Establece el estado de ánimo para la canción y el estribillo es pegadizo y fácil de cantar: "Chica, es fácil de amarme ahora / ¿Me amarías si estuviera abajo y fuera? / ¿Seguirías teniendo amor por mí?" </p>
- <h3>La colaboración con Nate Dogg</h3>
-<p>Nate Dogg era un cantante y rapero legendario que era conocido por su voz suave y distintiva y sus colaboraciones con muchos artistas de hip hop, como Dr. Dre, Snoop Dogg, Warren G, Eminem y Ludacris. También fue miembro del grupo 213 con Snoop Dogg y Warren G. Falleció en 2011 debido a complicaciones de múltiples accidentes cerebrovasculares. </p>
-<p>Nate Dogg canta el estribillo de "21 Preguntas" y añade su propio sabor a la canción. Su voz complementa 50 Cent del rap versos y crea un contraste entre el áspero y el suave. También añade un poco de humor a la canción con líneas como "Si me caigo mañana ¿todavía me amas? / Si no oliera tan bien, ¿me abrazarías?" </p>
- <h3>La letra y el tema </h3>
-<p>Las letras de "21 Questions" no solo son ingeniosas e ingeniosas, sino también relacionables y honestas. Expresan las inseguridades y dudas que muchas personas tienen en las relaciones, especialmente cuando no están seguros de si su pareja es leal y fiel. También reflejan la realidad de la vida de 50 Cent, ya que fue baleado nueve veces en 2000 y sobrevivió a un ataque casi fatal. </p>
-<p></p>
-<p>El tema de la canción es universal y atemporal: el amor. La canción trata sobre encontrar a alguien que te ame incondicionalmente, sin importar lo que pase o lo que tengas. Se trata de hacer las preguntas difíciles y obtener las respuestas honestas. Se trata de confiar y respetar a tu pareja y ser leal y fiel a ellos. </p>
-<p>Ahora que sabes más sobre la canción, es posible que te estés preguntando cómo descargarla de forma gratuita y legal. Hay muchos beneficios de descargar música legalmente, como:</p>
-<ul>
-<li>Evitas violar la ley y ser multado o demandado por la industria de la música. </li>
-<li>Apoyas a los artistas y su trabajo respetando sus derechos y regalías. </li>
-<li>Obtienes archivos de audio de alta calidad que son libres de virus y seguros para descargar. </li>
-<li>Puede disfrutar de su música sin conexión sin depender de una conexión a Internet o un plan de datos. </li>
-</ul>
-<p>Hay muchos sitios web que ofrecen descargas de música gratis legalmente, como:</p>
- <h3>Bandcamp</h3>
-<p>Bandcamp es una plataforma que permite a los artistas subir y vender su música directamente a sus fans. Puedes encontrar un montón de música independiente y underground en Bandcamp, así como algunos artistas principales. Puedes transmitir cualquier canción gratis en Bandcamp, pero también puedes descargar algunas canciones gratis o por un precio que elijas. También puedes comprar álbumes o merch de los artistas. </p>
-<p>Para descargar 50 Cent 21 de Bandcamp, puede ir a este enlace: [texto]. Puede nombrar su precio o introducir cero para descargarlo gratis. También puede elegir el formato del archivo, como MP3, FLAC o WAV.</p>
- <h3>Jamendo</h3>
-<p>Jamendo es un sitio web que ofrece descargas gratuitas de música de artistas que quieren compartir su música con el mundo. Puedes encontrar una variedad de géneros y estilos en Jamendo, desde pop, rock, jazz y hip hop. Puedes transmitir cualquier canción gratis en Jamendo, pero también puedes descargar algunas canciones gratis o por una pequeña tarifa. También puedes apoyar a los artistas donando o comprando sus álbumes. </p>
-<p>Para descargar 50 Cent 21 de Jamendo, puedes ir a este enlace: [texto]. Puedes descargarlo gratis haciendo clic en el icono de descarga junto al título de la canción. También puede elegir la calidad del archivo, como 128 kbps o 320 kbps. </p>
- <h3>Archivo de Internet</h3>
-<p>Para descargar 50 Cent 21 de Internet Archive, puede ir a este enlace: [texto]. Puedes descargarlo gratis haciendo clic en una de las opciones de "Opciones de descarga", como MP3 u OGG Vorbis.</p>
- <h2>Cómo transmitir 50 Cent 21 en línea</h2>
-<p>Si no desea descargar la canción, también puede transmitirla en línea. Hay muchas ventajas de transmitir música en línea, como:</p>
-<ul>
-<li> Puede acceder a una gran biblioteca de canciones y listas de reproducción de diferentes géneros y artistas. </li>
-<li>Puedes descubrir nueva música y recomendaciones basadas en tus preferencias e historial de escucha. </li>
-<li> Puede ahorrar espacio de almacenamiento en su dispositivo y evitar saturar sus archivos. </li>
-<li> Puede disfrutar de la transmisión de audio y video de alta calidad sin interrupciones ni almacenamiento en búfer. </li>
-</ul>
-<p>Hay muchos servicios de streaming de música que puedes usar para escuchar 50 Cent 21 en línea, como:</p>
- <h3>Spotify</h3>
-<p>Spotify es uno de los servicios de transmisión de música más populares y ampliamente utilizados en el mundo. Tiene más de 70 millones de canciones y podcasts que puede transmitir de forma gratuita o con una suscripción premium. Puedes crear tus propias listas de reproducción, seguir a tus artistas favoritos y compartir tu música con tus amigos. También puede escuchar listas de reproducción, emisoras de radio y podcasts en Spotify.</p>
-<p>Para transmitir 50 Cent 21 en Spotify, puede ir a este enlace: [texto]. Puede reproducirlo gratis con anuncios o sin anuncios con una suscripción premium. También puede agregarlo a su biblioteca o lista de reproducción haciendo clic en el icono del corazón o el icono más. </p>
- <h3>Música de Apple</h3>
-<p>Para transmitir 50 Cent 21 en Apple Music, puede ir a este enlace: [texto]. Puede reproducirlo con una suscripción o con una prueba gratuita. También puede agregarlo a su biblioteca o lista de reproducción haciendo clic en el icono más o en el icono de la nube. </p>
- <h3>Música de YouTube</h3>
-<p>YouTube Music es un servicio de transmisión de música que funciona con YouTube. Tiene más de 60 millones de canciones y videos que se pueden transmitir de forma gratuita o con una suscripción premium. También puedes acceder a tu propia biblioteca de música que has subido a YouTube. Puedes crear tus propias listas de reproducción, seguir a tus artistas favoritos y compartir tu música con tus amigos. También puede escuchar listas de reproducción, emisoras de radio y podcasts en YouTube Music.</p>
-<p>Para transmitir 50 Cent 21 en YouTube Music, puede ir a este enlace: [texto]. Puedes jugar gratis con anuncios o sin anuncios con una suscripción premium. También puede agregarlo a su biblioteca o lista de reproducción haciendo clic en el icono más o el icono de verificación. </p>
- <h2>Cómo apoyar 50 Cent y su música</h2>
-<p>Si amas a 50 Cent y su música, es posible que quieras apoyarlo a él y a su trabajo. Hay muchas maneras de hacerlo, como:</p>
-<ul>
-<li>Comprar sus álbumes o singles de su sitio web oficial o tiendas en línea. </li>
-<li>Donar a sus organizaciones benéficas o causas que apoya. </li>
-<li>Comprar su mercancía de su sitio web oficial o tiendas en línea. </li>
-<li>Seguirlo en sus cuentas de redes sociales y participar con sus mensajes. </li>
-<li>Asistir a sus conciertos o eventos cuando están disponibles. </li>
-</ul>
-<p>Aquí hay algunos enlaces para ayudarle a apoyar 50 Cent y su música:</p>
- <h3>Sitio web oficial</h3>
-<p>Puedes visitar su sitio web oficial en [texto]. Puedes encontrar sus últimas noticias, música, videos, fotos, fechas de la gira, mercancía y más. </p>
- <h3>Redes sociales</h3>
-<p>Puedes seguirlo en sus cuentas de redes sociales en:</p>
-<ul>
-<li>Facebook: [texto]</li>
-<li>Twitter: [texto]</li>
-<li>Instagram: [texto]</li>
-<li>YouTube: [texto]</li>
-</ul>
- <h3>Mercancía</h3>
-<ul>
-<li>Unidad G: [texto]</li>
-<li>Effen Vodka: [texto]</li>
-<li>SMS Audio: [texto]</li>
-</ul>
- <h1>Conclusión</h1>
-<p>En este artículo, le hemos mostrado cómo descargar 50 Cent 21 de forma gratuita y legal, cómo transmitir en línea, y cómo apoyar 50 Cent y su música. Esperamos que hayas disfrutado de este artículo y hayas aprendido algo nuevo. Ahora puedes disfrutar de esta clásica canción de hip hop en cualquier momento y en cualquier lugar que quieras. </p>
-<p>Si te gustó este artículo, por favor compártelo con tus amigos y familiares que podrían estar interesados en este tema. También, no dude en dejar un comentario a continuación y háganos saber lo que piensa. Nos encantaría saber de usted y responder a cualquier pregunta que pueda tener. </p>
- <h2>Preguntas frecuentes</h2>
-<p>Aquí hay algunas preguntas frecuentes sobre 50 Cent 21 y sus respuestas:</p>
- <h3>Q: ¿Cuándo se lanzó 50 Cent 21? </h3>
-<p>A: 50 Cent 21 fue lanzado el 4 de marzo de 2003 como el segundo sencillo de su álbum debut Get Rich or Die Tryin'. </p>
- <h3>Q: ¿Quién canta el coro de 50 Cent 21? </h3>
-<p>A: El coro de 50 Cent 21 es cantado por Nate Dogg, que era un famoso cantante y rapero en la Costa Oeste de la escena de hip hop. Falleció en 2011 debido a complicaciones de múltiples accidentes cerebrovasculares. </p>
- <h3>Q: ¿Cuál es la muestra utilizada en 50 Cent 21? </h3>
-<p>A: La muestra utilizada en 50 Cent 21 es "It’s Only Love Doing Its Thing" de Barry White, que es una canción conmovedora y romántica de 1978. </p>
- <h3>P: ¿Cuántas preguntas hay en 50 Cent 21? </h3>
-<p>A: En realidad hay más de 21 preguntas en la canción, ya que algunas de ellas se repiten o reformulan. El número exacto de preguntas depende de cómo las cuentes, pero es de 25 a 30. </p>
- <h3>Q: ¿Cómo puedo descargar o transmitir otras canciones por 50 Cent? </h3>
-<p>A: Puede descargar o transmitir otras canciones por 50 Cent utilizando los mismos métodos y sitios web que hemos mencionado en este artículo. También puedes ver sus otros álbumes, como The Massacre, Curtis, Animal Ambition y Street King Immortal.</p> 64aa2da5cf<br />
-<br />
-<br />

spaces/Benson/text-generation/Examples/Descargar Gratis Fuego Max Galaxy Store.md DELETED Viewed

@@ -1,54 +0,0 @@
-<br />
-<h1>Descargar gratis Fire MAX Galaxy Store</h1>
-<p>Si eres un fan de los juegos battle royale, es posible que hayas oído hablar de Free Fire, uno de los juegos más populares y descargados del mundo. Pero ¿sabías que hay una nueva versión de Free Fire que ofrece una experiencia de juego más premium e inmersiva? Se llama Free Fire MAX, y está disponible para su descarga desde la Samsung Galaxy Store. En este artículo, te diremos qué es Free Fire MAX, por qué deberías descargarlo desde Galaxy Store y cómo hacerlo en unos sencillos pasos. </p>
-<h2>Características de Free Fire MAX</h2>
-<p>Free Fire MAX está diseñado exclusivamente para ofrecer una experiencia de juego premium en un battle royale. Tiene el mismo núcleo de juego como Free Fire, pero con gráficos mejorados, efectos especiales y un rendimiento más suave. Estas son algunas de las características que hacen que Free Fire MAX destaque:</p>
-<h2>descargar gratis fuego max galaxy store</h2><br /><p><b><b>Download</b> &middot;&middot;&middot; <a href="https://bltlly.com/2v6Mc3">https://bltlly.com/2v6Mc3</a></b></p><br /><br />
-<h3>Juego rápido, profundamente inmersivo</h3>
-<p>En Free Fire MAX, te lanzarás en paracaídas a una isla desierta con otros 49 jugadores y lucharás por la supervivencia. Tendrás que buscar armas y suministros, esconderte de los enemigos y acabar con cualquiera que se interponga en tu camino. El juego dura unos 10 minutos, y solo un jugador o equipo saldrá victorioso. Con gráficos rediseñados y mejorados, sentirás que estás en medio de la acción. </p>
-<h3>Mismo juego, mejor experiencia</h3>
-<p>Free Fire MAX ofrece gráficos HD, efectos especiales mejorados y una jugabilidad más suave que proporcionan una experiencia de supervivencia realista e inmersiva. Podrás ver cada detalle del entorno, desde la hierba hasta los edificios, y disfrutar de efectos impresionantes como explosiones, fuego y humo. También experimentará menos retraso y más estabilidad mientras juega. </p>
-<h3>4-man squad, con chat de voz en el juego</h3>
-<h3>Tecnología Firelink</h3>
-<p>Con la tecnología Firelink, puede iniciar sesión en su cuenta de Free Fire existente para jugar Free Fire MAX sin ningún problema. Su progreso y elementos se mantienen en ambas aplicaciones en tiempo real. También puedes jugar todos los modos de juego con los jugadores de Free Fire y Free Fire MAX juntos, sin importar la aplicación que usen. </p>
-<h2>Beneficios de la tienda Galaxy</h2>
-<p>Si usted es un usuario de Samsung Galaxy, puede disfrutar de beneficios exclusivos al descargar Free Fire MAX de Galaxy Store. Galaxy Store es la tienda de aplicaciones oficial para dispositivos Samsung que ofrece juegos, aplicaciones, herramientas, temas, fondos de pantalla, fuentes, caras de reloj y más. Estos son algunos de los beneficios que ofrece Galaxy Store:</p>
-<h3>Ofertas exclusivas para usuarios de Galaxy</h3>
-<p>Al descargar juegos de Galaxy Store, puede obtener recompensas exclusivas, descuentos y promociones que no están disponibles en otros lugares. Por ejemplo, puedes obtener una piel de paracaídas con temática de Galaxy gratis al descargar Free Fire MAX de Galaxy Store. También puedes obtener hasta un 50% de descuento en compras y paquetes dentro del juego. Estas ofertas se actualizan regularmente, así que asegúrate de consultarlas. </p>
-<h3>Personaliza tu dispositivo Galaxy</h3>
-<p>Con Galaxy Store, puede personalizar su dispositivo Galaxy para adaptarse a su estilo y preferencias. Puede descargar temas, fondos de pantalla, fuentes, iconos y más para cambiar la apariencia de su dispositivo. También puede descargar herramientas y utilidades que mejoran la funcionalidad y el rendimiento de su dispositivo. Por ejemplo, puedes descargar Game Launcher, una herramienta que optimiza tu dispositivo para juegos y te permite acceder a todos tus juegos en un solo lugar. </p>
-<h3>Caras de reloj y aplicaciones Premium</h3>
-<h2>Cómo descargar Free Fire MAX de Galaxy Store</h2>
-<p>Descargar Free Fire MAX de Galaxy Store es fácil y rápido. Solo tienes que seguir estos pasos:</p>
-<h3>Paso 1: Abra la aplicación Galaxy Store en su dispositivo</h3>
-<p>Si tienes un dispositivo Samsung Galaxy, ya deberías tener la aplicación Galaxy Store instalada en tu dispositivo. Si no, puedes descargarlo desde Google Play Store o el sitio web de Samsung. Una vez que tengas la aplicación, ábrela e inicia sesión con tu cuenta de Samsung. </p>
-<p></p>
-<h3>Paso 2: Búsqueda de fuego libre MAX en la barra de búsqueda</h3>
-<p>En la pantalla de inicio de Galaxy Store, verá una barra de búsqueda en la parte superior. Escriba "Free Fire MAX" y toque en el icono de búsqueda. Verás la aplicación Free Fire MAX entre los resultados de búsqueda. </p>
-<h3>Paso 3: Toque en el botón de instalación y espere a que la descarga se complete</h3>
-<p>Toque en el icono de la aplicación Free Fire MAX y verá una página con más información sobre la aplicación, como capturas de pantalla, calificaciones, comentarios y descripción. También verá un botón de instalación en la parte inferior. Toque en él y acepte los permisos requeridos por la aplicación. La aplicación comenzará a descargarse en el dispositivo. Dependiendo de la velocidad de Internet y el almacenamiento del dispositivo, esto puede tardar unos minutos. </p>
-<h3>Paso 4: Lanzar fuego libre MAX y disfrutar del juego</h3>
-<p>Una vez completada la descarga, verá un botón abierto en la parte inferior de la página de la aplicación. Toque en él y Free Fire MAX se iniciará en su dispositivo. También puede encontrar el icono de la aplicación en la pantalla de inicio o en el cajón de la aplicación. Ahora puede iniciar sesión con su cuenta de Free Fire existente o crear una nueva. También puedes vincular tu cuenta de Facebook o Google para sincronizar tu progreso entre dispositivos. Disfruta jugando Free Fire MAX con gráficos y características mejorados. </p>
-<h2>Conclusión</h2>
-<h2>Preguntas frecuentes</h2>
-<h3>¿Cuál es la diferencia entre Free Fire y Free Fire MAX? </h3>
-<p>Free Fire y Free Fire MAX son juegos battle royale que tienen el mismo juego central. Sin embargo, Free Fire MAX tiene gráficos, efectos y rendimiento mejorados que proporcionan una experiencia más premium e inmersiva. Gratis Fire MAX también tiene algunas características exclusivas como el modo de escuadrón de 4 hombres y en el juego de chat de voz. </p>
-<h3>¿Puedo jugar Free Fire MAX con jugadores Free Fire? </h3>
-<p>Sí, puedes jugar Free Fire MAX con jugadores Free Fire usando la tecnología Firelink. Esto significa que puede utilizar su cuenta de Free Fire existente para iniciar sesión en Free Fire MAX y jugar con sus amigos que están utilizando cualquiera de las aplicaciones. También puedes jugar todos los modos de juego con ambas aplicaciones juntas. </p>
-<h3>¿Cuánto espacio de almacenamiento requiere Free Fire MAX? </h3>
-<p>Free Fire MAX requiere aproximadamente 1 GB de espacio de almacenamiento en su dispositivo. Sin embargo, esto puede variar dependiendo del modelo de su dispositivo y del sistema operativo. También puede necesitar espacio adicional para actualizaciones y parches. </p>
-<h3>¿Free Fire MAX es compatible con mi dispositivo? </h3>
-<p>Free Fire MAX es compatible con la mayoría de dispositivos Android que tienen al menos 2 GB de RAM y se ejecutan en Android 4.4 o superior. Sin embargo, algunos dispositivos pueden no ser compatibles con el juego debido a limitaciones de hardware o problemas de compatibilidad. Puedes comprobar la compatibilidad de tu dispositivo en la página de la aplicación Galaxy Store antes de descargar el juego. </p>
-<h3>¿Cómo puedo contactar al servicio al cliente si tengo algún problema con Free Fire MAX? </h3>
-<p>Si tiene algún problema con Free Fire MAX, como errores, errores, fallos o problemas de cuenta, puede ponerse en contacto con el servicio al cliente a través de los siguientes canales:</p>
-<ul>
-<li>En el juego: Toque en el icono de configuración en la esquina superior derecha de la pantalla principal y seleccione "Servicio al cliente". Puede enviar un ticket con su problema y adjuntar capturas de pantalla si es necesario. </li>
-<li>Correo electrónico: Envíe un correo electrónico a [email protected] con su problema y su ID de usuario.</li>
-</ul>
-<p>Servicio al cliente intentará responder a su problema lo antes posible. </p> 64aa2da5cf<br />
-<br />
-<br />

spaces/Big-Web/MMSD/env/Lib/site-packages/pip/_vendor/colorama/tests/winterm_test.py DELETED Viewed

@@ -1,131 +0,0 @@
-# Copyright Jonathan Hartley 2013. BSD 3-Clause license, see LICENSE file.
-import sys
-from unittest import TestCase, main, skipUnless
-try:
-    from unittest.mock import Mock, patch
-except ImportError:
-    from mock import Mock, patch
-from ..winterm import WinColor, WinStyle, WinTerm
-class WinTermTest(TestCase):
-    @patch('colorama.winterm.win32')
-    def testInit(self, mockWin32):
-        mockAttr = Mock()
-        mockAttr.wAttributes = 7 + 6 * 16 + 8
-        mockWin32.GetConsoleScreenBufferInfo.return_value = mockAttr
-        term = WinTerm()
-        self.assertEqual(term._fore, 7)
-        self.assertEqual(term._back, 6)
-        self.assertEqual(term._style, 8)
-    @skipUnless(sys.platform.startswith("win"), "requires Windows")
-    def testGetAttrs(self):
-        term = WinTerm()
-        term._fore = 0
-        term._back = 0
-        term._style = 0
-        self.assertEqual(term.get_attrs(), 0)
-        term._fore = WinColor.YELLOW
-        self.assertEqual(term.get_attrs(), WinColor.YELLOW)
-        term._back = WinColor.MAGENTA
-        self.assertEqual(
-            term.get_attrs(),
-            WinColor.YELLOW + WinColor.MAGENTA * 16)
-        term._style = WinStyle.BRIGHT
-        self.assertEqual(
-            term.get_attrs(),
-            WinColor.YELLOW + WinColor.MAGENTA * 16 + WinStyle.BRIGHT)
-    @patch('colorama.winterm.win32')
-    def testResetAll(self, mockWin32):
-        mockAttr = Mock()
-        mockAttr.wAttributes = 1 + 2 * 16 + 8
-        mockWin32.GetConsoleScreenBufferInfo.return_value = mockAttr
-        term = WinTerm()
-        term.set_console = Mock()
-        term._fore = -1
-        term._back = -1
-        term._style = -1
-        term.reset_all()
-        self.assertEqual(term._fore, 1)
-        self.assertEqual(term._back, 2)
-        self.assertEqual(term._style, 8)
-        self.assertEqual(term.set_console.called, True)
-    @skipUnless(sys.platform.startswith("win"), "requires Windows")
-    def testFore(self):
-        term = WinTerm()
-        term.set_console = Mock()
-        term._fore = 0
-        term.fore(5)
-        self.assertEqual(term._fore, 5)
-        self.assertEqual(term.set_console.called, True)
-    @skipUnless(sys.platform.startswith("win"), "requires Windows")
-    def testBack(self):
-        term = WinTerm()
-        term.set_console = Mock()
-        term._back = 0
-        term.back(5)
-        self.assertEqual(term._back, 5)
-        self.assertEqual(term.set_console.called, True)
-    @skipUnless(sys.platform.startswith("win"), "requires Windows")
-    def testStyle(self):
-        term = WinTerm()
-        term.set_console = Mock()
-        term._style = 0
-        term.style(22)
-        self.assertEqual(term._style, 22)
-        self.assertEqual(term.set_console.called, True)
-    @patch('colorama.winterm.win32')
-    def testSetConsole(self, mockWin32):
-        mockAttr = Mock()
-        mockAttr.wAttributes = 0
-        mockWin32.GetConsoleScreenBufferInfo.return_value = mockAttr
-        term = WinTerm()
-        term.windll = Mock()
-        term.set_console()
-        self.assertEqual(
-            mockWin32.SetConsoleTextAttribute.call_args,
-            ((mockWin32.STDOUT, term.get_attrs()), {})
-        )
-    @patch('colorama.winterm.win32')
-    def testSetConsoleOnStderr(self, mockWin32):
-        mockAttr = Mock()
-        mockAttr.wAttributes = 0
-        mockWin32.GetConsoleScreenBufferInfo.return_value = mockAttr
-        term = WinTerm()
-        term.windll = Mock()
-        term.set_console(on_stderr=True)
-        self.assertEqual(
-            mockWin32.SetConsoleTextAttribute.call_args,
-            ((mockWin32.STDERR, term.get_attrs()), {})
-        )
-if __name__ == '__main__':
-    main()

spaces/Big-Web/MMSD/env/Lib/site-packages/setuptools/_distutils/msvc9compiler.py DELETED Viewed

@@ -1,832 +0,0 @@
-"""distutils.msvc9compiler
-Contains MSVCCompiler, an implementation of the abstract CCompiler class
-for the Microsoft Visual Studio 2008.
-The module is compatible with VS 2005 and VS 2008. You can find legacy support
-for older versions of VS in distutils.msvccompiler.
-"""
-# Written by Perry Stoll
-# hacked by Robin Becker and Thomas Heller to do a better job of
-#   finding DevStudio (through the registry)
-# ported to VS2005 and VS 2008 by Christian Heimes
-import os
-import subprocess
-import sys
-import re
-import warnings
-from distutils.errors import (
-    DistutilsExecError,
-    DistutilsPlatformError,
-    CompileError,
-    LibError,
-    LinkError,
-)
-from distutils.ccompiler import CCompiler, gen_lib_options
-from distutils import log
-from distutils.util import get_platform
-import winreg
-warnings.warn(
-    "msvc9compiler is deprecated and slated to be removed "
-    "in the future. Please discontinue use or file an issue "
-    "with pypa/distutils describing your use case.",
-    DeprecationWarning,
-)
-RegOpenKeyEx = winreg.OpenKeyEx
-RegEnumKey = winreg.EnumKey
-RegEnumValue = winreg.EnumValue
-RegError = winreg.error
-HKEYS = (
-    winreg.HKEY_USERS,
-    winreg.HKEY_CURRENT_USER,
-    winreg.HKEY_LOCAL_MACHINE,
-    winreg.HKEY_CLASSES_ROOT,
-)
-NATIVE_WIN64 = sys.platform == 'win32' and sys.maxsize > 2**32
-if NATIVE_WIN64:
-    # Visual C++ is a 32-bit application, so we need to look in
-    # the corresponding registry branch, if we're running a
-    # 64-bit Python on Win64
-    VS_BASE = r"Software\Wow6432Node\Microsoft\VisualStudio\%0.1f"
-    WINSDK_BASE = r"Software\Wow6432Node\Microsoft\Microsoft SDKs\Windows"
-    NET_BASE = r"Software\Wow6432Node\Microsoft\.NETFramework"
-else:
-    VS_BASE = r"Software\Microsoft\VisualStudio\%0.1f"
-    WINSDK_BASE = r"Software\Microsoft\Microsoft SDKs\Windows"
-    NET_BASE = r"Software\Microsoft\.NETFramework"
-# A map keyed by get_platform() return values to values accepted by
-# 'vcvarsall.bat'.  Note a cross-compile may combine these (eg, 'x86_amd64' is
-# the param to cross-compile on x86 targeting amd64.)
-PLAT_TO_VCVARS = {
-    'win32': 'x86',
-    'win-amd64': 'amd64',
-}
-class Reg:
-    """Helper class to read values from the registry"""
-    def get_value(cls, path, key):
-        for base in HKEYS:
-            d = cls.read_values(base, path)
-            if d and key in d:
-                return d[key]
-        raise KeyError(key)
-    get_value = classmethod(get_value)
-    def read_keys(cls, base, key):
-        """Return list of registry keys."""
-        try:
-            handle = RegOpenKeyEx(base, key)
-        except RegError:
-            return None
-        L = []
-        i = 0
-        while True:
-            try:
-                k = RegEnumKey(handle, i)
-            except RegError:
-                break
-            L.append(k)
-            i += 1
-        return L
-    read_keys = classmethod(read_keys)
-    def read_values(cls, base, key):
-        """Return dict of registry keys and values.
-        All names are converted to lowercase.
-        """
-        try:
-            handle = RegOpenKeyEx(base, key)
-        except RegError:
-            return None
-        d = {}
-        i = 0
-        while True:
-            try:
-                name, value, type = RegEnumValue(handle, i)
-            except RegError:
-                break
-            name = name.lower()
-            d[cls.convert_mbcs(name)] = cls.convert_mbcs(value)
-            i += 1
-        return d
-    read_values = classmethod(read_values)
-    def convert_mbcs(s):
-        dec = getattr(s, "decode", None)
-        if dec is not None:
-            try:
-                s = dec("mbcs")
-            except UnicodeError:
-                pass
-        return s
-    convert_mbcs = staticmethod(convert_mbcs)
-class MacroExpander:
-    def __init__(self, version):
-        self.macros = {}
-        self.vsbase = VS_BASE % version
-        self.load_macros(version)
-    def set_macro(self, macro, path, key):
-        self.macros["$(%s)" % macro] = Reg.get_value(path, key)
-    def load_macros(self, version):
-        self.set_macro("VCInstallDir", self.vsbase + r"\Setup\VC", "productdir")
-        self.set_macro("VSInstallDir", self.vsbase + r"\Setup\VS", "productdir")
-        self.set_macro("FrameworkDir", NET_BASE, "installroot")
-        try:
-            if version >= 8.0:
-                self.set_macro("FrameworkSDKDir", NET_BASE, "sdkinstallrootv2.0")
-            else:
-                raise KeyError("sdkinstallrootv2.0")
-        except KeyError:
-            raise DistutilsPlatformError(
-                """Python was built with Visual Studio 2008;
-extensions must be built with a compiler than can generate compatible binaries.
-Visual Studio 2008 was not found on this system. If you have Cygwin installed,
-you can try compiling with MingW32, by passing "-c mingw32" to setup.py."""
-            )
-        if version >= 9.0:
-            self.set_macro("FrameworkVersion", self.vsbase, "clr version")
-            self.set_macro("WindowsSdkDir", WINSDK_BASE, "currentinstallfolder")
-        else:
-            p = r"Software\Microsoft\NET Framework Setup\Product"
-            for base in HKEYS:
-                try:
-                    h = RegOpenKeyEx(base, p)
-                except RegError:
-                    continue
-                key = RegEnumKey(h, 0)
-                d = Reg.get_value(base, r"{}\{}".format(p, key))
-                self.macros["$(FrameworkVersion)"] = d["version"]
-    def sub(self, s):
-        for k, v in self.macros.items():
-            s = s.replace(k, v)
-        return s
-def get_build_version():
-    """Return the version of MSVC that was used to build Python.
-    For Python 2.3 and up, the version number is included in
-    sys.version.  For earlier versions, assume the compiler is MSVC 6.
-    """
-    prefix = "MSC v."
-    i = sys.version.find(prefix)
-    if i == -1:
-        return 6
-    i = i + len(prefix)
-    s, rest = sys.version[i:].split(" ", 1)
-    majorVersion = int(s[:-2]) - 6
-    if majorVersion >= 13:
-        # v13 was skipped and should be v14
-        majorVersion += 1
-    minorVersion = int(s[2:3]) / 10.0
-    # I don't think paths are affected by minor version in version 6
-    if majorVersion == 6:
-        minorVersion = 0
-    if majorVersion >= 6:
-        return majorVersion + minorVersion
-    # else we don't know what version of the compiler this is
-    return None
-def normalize_and_reduce_paths(paths):
-    """Return a list of normalized paths with duplicates removed.
-    The current order of paths is maintained.
-    """
-    # Paths are normalized so things like:  /a and /a/ aren't both preserved.
-    reduced_paths = []
-    for p in paths:
-        np = os.path.normpath(p)
-        # XXX(nnorwitz): O(n**2), if reduced_paths gets long perhaps use a set.
-        if np not in reduced_paths:
-            reduced_paths.append(np)
-    return reduced_paths
-def removeDuplicates(variable):
-    """Remove duplicate values of an environment variable."""
-    oldList = variable.split(os.pathsep)
-    newList = []
-    for i in oldList:
-        if i not in newList:
-            newList.append(i)
-    newVariable = os.pathsep.join(newList)
-    return newVariable
-def find_vcvarsall(version):
-    """Find the vcvarsall.bat file
-    At first it tries to find the productdir of VS 2008 in the registry. If
-    that fails it falls back to the VS90COMNTOOLS env var.
-    """
-    vsbase = VS_BASE % version
-    try:
-        productdir = Reg.get_value(r"%s\Setup\VC" % vsbase, "productdir")
-    except KeyError:
-        log.debug("Unable to find productdir in registry")
-        productdir = None
-    if not productdir or not os.path.isdir(productdir):
-        toolskey = "VS%0.f0COMNTOOLS" % version
-        toolsdir = os.environ.get(toolskey, None)
-        if toolsdir and os.path.isdir(toolsdir):
-            productdir = os.path.join(toolsdir, os.pardir, os.pardir, "VC")
-            productdir = os.path.abspath(productdir)
-            if not os.path.isdir(productdir):
-                log.debug("%s is not a valid directory" % productdir)
-                return None
-        else:
-            log.debug("Env var %s is not set or invalid" % toolskey)
-    if not productdir:
-        log.debug("No productdir found")
-        return None
-    vcvarsall = os.path.join(productdir, "vcvarsall.bat")
-    if os.path.isfile(vcvarsall):
-        return vcvarsall
-    log.debug("Unable to find vcvarsall.bat")
-    return None
-def query_vcvarsall(version, arch="x86"):
-    """Launch vcvarsall.bat and read the settings from its environment"""
-    vcvarsall = find_vcvarsall(version)
-    interesting = {"include", "lib", "libpath", "path"}
-    result = {}
-    if vcvarsall is None:
-        raise DistutilsPlatformError("Unable to find vcvarsall.bat")
-    log.debug("Calling 'vcvarsall.bat %s' (version=%s)", arch, version)
-    popen = subprocess.Popen(
-        '"{}" {} & set'.format(vcvarsall, arch),
-        stdout=subprocess.PIPE,
-        stderr=subprocess.PIPE,
-    )
-    try:
-        stdout, stderr = popen.communicate()
-        if popen.wait() != 0:
-            raise DistutilsPlatformError(stderr.decode("mbcs"))
-        stdout = stdout.decode("mbcs")
-        for line in stdout.split("\n"):
-            line = Reg.convert_mbcs(line)
-            if '=' not in line:
-                continue
-            line = line.strip()
-            key, value = line.split('=', 1)
-            key = key.lower()
-            if key in interesting:
-                if value.endswith(os.pathsep):
-                    value = value[:-1]
-                result[key] = removeDuplicates(value)
-    finally:
-        popen.stdout.close()
-        popen.stderr.close()
-    if len(result) != len(interesting):
-        raise ValueError(str(list(result.keys())))
-    return result
-# More globals
-VERSION = get_build_version()
-# MACROS = MacroExpander(VERSION)
-class MSVCCompiler(CCompiler):
-    """Concrete class that implements an interface to Microsoft Visual C++,
-    as defined by the CCompiler abstract class."""
-    compiler_type = 'msvc'
-    # Just set this so CCompiler's constructor doesn't barf.  We currently
-    # don't use the 'set_executables()' bureaucracy provided by CCompiler,
-    # as it really isn't necessary for this sort of single-compiler class.
-    # Would be nice to have a consistent interface with UnixCCompiler,
-    # though, so it's worth thinking about.
-    executables = {}
-    # Private class data (need to distinguish C from C++ source for compiler)
-    _c_extensions = ['.c']
-    _cpp_extensions = ['.cc', '.cpp', '.cxx']
-    _rc_extensions = ['.rc']
-    _mc_extensions = ['.mc']
-    # Needed for the filename generation methods provided by the
-    # base class, CCompiler.
-    src_extensions = _c_extensions + _cpp_extensions + _rc_extensions + _mc_extensions
-    res_extension = '.res'
-    obj_extension = '.obj'
-    static_lib_extension = '.lib'
-    shared_lib_extension = '.dll'
-    static_lib_format = shared_lib_format = '%s%s'
-    exe_extension = '.exe'
-    def __init__(self, verbose=0, dry_run=0, force=0):
-        super().__init__(verbose, dry_run, force)
-        self.__version = VERSION
-        self.__root = r"Software\Microsoft\VisualStudio"
-        # self.__macros = MACROS
-        self.__paths = []
-        # target platform (.plat_name is consistent with 'bdist')
-        self.plat_name = None
-        self.__arch = None  # deprecated name
-        self.initialized = False
-    def initialize(self, plat_name=None):  # noqa: C901
-        # multi-init means we would need to check platform same each time...
-        assert not self.initialized, "don't init multiple times"
-        if self.__version < 8.0:
-            raise DistutilsPlatformError(
-                "VC %0.1f is not supported by this module" % self.__version
-            )
-        if plat_name is None:
-            plat_name = get_platform()
-        # sanity check for platforms to prevent obscure errors later.
-        ok_plats = 'win32', 'win-amd64'
-        if plat_name not in ok_plats:
-            raise DistutilsPlatformError(
-                "--plat-name must be one of {}".format(ok_plats)
-            )
-        if (
-            "DISTUTILS_USE_SDK" in os.environ
-            and "MSSdk" in os.environ
-            and self.find_exe("cl.exe")
-        ):
-            # Assume that the SDK set up everything alright; don't try to be
-            # smarter
-            self.cc = "cl.exe"
-            self.linker = "link.exe"
-            self.lib = "lib.exe"
-            self.rc = "rc.exe"
-            self.mc = "mc.exe"
-        else:
-            # On x86, 'vcvars32.bat amd64' creates an env that doesn't work;
-            # to cross compile, you use 'x86_amd64'.
-            # On AMD64, 'vcvars32.bat amd64' is a native build env; to cross
-            # compile use 'x86' (ie, it runs the x86 compiler directly)
-            if plat_name == get_platform() or plat_name == 'win32':
-                # native build or cross-compile to win32
-                plat_spec = PLAT_TO_VCVARS[plat_name]
-            else:
-                # cross compile from win32 -> some 64bit
-                plat_spec = (
-                    PLAT_TO_VCVARS[get_platform()] + '_' + PLAT_TO_VCVARS[plat_name]
-                )
-            vc_env = query_vcvarsall(VERSION, plat_spec)
-            self.__paths = vc_env['path'].split(os.pathsep)
-            os.environ['lib'] = vc_env['lib']
-            os.environ['include'] = vc_env['include']
-            if len(self.__paths) == 0:
-                raise DistutilsPlatformError(
-                    "Python was built with %s, "
-                    "and extensions need to be built with the same "
-                    "version of the compiler, but it isn't installed." % self.__product
-                )
-            self.cc = self.find_exe("cl.exe")
-            self.linker = self.find_exe("link.exe")
-            self.lib = self.find_exe("lib.exe")
-            self.rc = self.find_exe("rc.exe")  # resource compiler
-            self.mc = self.find_exe("mc.exe")  # message compiler
-            # self.set_path_env_var('lib')
-            # self.set_path_env_var('include')
-        # extend the MSVC path with the current path
-        try:
-            for p in os.environ['path'].split(';'):
-                self.__paths.append(p)
-        except KeyError:
-            pass
-        self.__paths = normalize_and_reduce_paths(self.__paths)
-        os.environ['path'] = ";".join(self.__paths)
-        self.preprocess_options = None
-        if self.__arch == "x86":
-            self.compile_options = ['/nologo', '/O2', '/MD', '/W3', '/DNDEBUG']
-            self.compile_options_debug = [
-                '/nologo',
-                '/Od',
-                '/MDd',
-                '/W3',
-                '/Z7',
-                '/D_DEBUG',
-            ]
-        else:
-            # Win64
-            self.compile_options = ['/nologo', '/O2', '/MD', '/W3', '/GS-', '/DNDEBUG']
-            self.compile_options_debug = [
-                '/nologo',
-                '/Od',
-                '/MDd',
-                '/W3',
-                '/GS-',
-                '/Z7',
-                '/D_DEBUG',
-            ]
-        self.ldflags_shared = ['/DLL', '/nologo', '/INCREMENTAL:NO']
-        if self.__version >= 7:
-            self.ldflags_shared_debug = ['/DLL', '/nologo', '/INCREMENTAL:no', '/DEBUG']
-        self.ldflags_static = ['/nologo']
-        self.initialized = True
-    # -- Worker methods ------------------------------------------------
-    def object_filenames(self, source_filenames, strip_dir=0, output_dir=''):
-        # Copied from ccompiler.py, extended to return .res as 'object'-file
-        # for .rc input file
-        if output_dir is None:
-            output_dir = ''
-        obj_names = []
-        for src_name in source_filenames:
-            (base, ext) = os.path.splitext(src_name)
-            base = os.path.splitdrive(base)[1]  # Chop off the drive
-            base = base[os.path.isabs(base) :]  # If abs, chop off leading /
-            if ext not in self.src_extensions:
-                # Better to raise an exception instead of silently continuing
-                # and later complain about sources and targets having
-                # different lengths
-                raise CompileError("Don't know how to compile %s" % src_name)
-            if strip_dir:
-                base = os.path.basename(base)
-            if ext in self._rc_extensions:
-                obj_names.append(os.path.join(output_dir, base + self.res_extension))
-            elif ext in self._mc_extensions:
-                obj_names.append(os.path.join(output_dir, base + self.res_extension))
-            else:
-                obj_names.append(os.path.join(output_dir, base + self.obj_extension))
-        return obj_names
-    def compile(  # noqa: C901
-        self,
-        sources,
-        output_dir=None,
-        macros=None,
-        include_dirs=None,
-        debug=0,
-        extra_preargs=None,
-        extra_postargs=None,
-        depends=None,
-    ):
-        if not self.initialized:
-            self.initialize()
-        compile_info = self._setup_compile(
-            output_dir, macros, include_dirs, sources, depends, extra_postargs
-        )
-        macros, objects, extra_postargs, pp_opts, build = compile_info
-        compile_opts = extra_preargs or []
-        compile_opts.append('/c')
-        if debug:
-            compile_opts.extend(self.compile_options_debug)
-        else:
-            compile_opts.extend(self.compile_options)
-        for obj in objects:
-            try:
-                src, ext = build[obj]
-            except KeyError:
-                continue
-            if debug:
-                # pass the full pathname to MSVC in debug mode,
-                # this allows the debugger to find the source file
-                # without asking the user to browse for it
-                src = os.path.abspath(src)
-            if ext in self._c_extensions:
-                input_opt = "/Tc" + src
-            elif ext in self._cpp_extensions:
-                input_opt = "/Tp" + src
-            elif ext in self._rc_extensions:
-                # compile .RC to .RES file
-                input_opt = src
-                output_opt = "/fo" + obj
-                try:
-                    self.spawn([self.rc] + pp_opts + [output_opt] + [input_opt])
-                except DistutilsExecError as msg:
-                    raise CompileError(msg)
-                continue
-            elif ext in self._mc_extensions:
-                # Compile .MC to .RC file to .RES file.
-                #   * '-h dir' specifies the directory for the
-                #     generated include file
-                #   * '-r dir' specifies the target directory of the
-                #     generated RC file and the binary message resource
-                #     it includes
-                #
-                # For now (since there are no options to change this),
-                # we use the source-directory for the include file and
-                # the build directory for the RC file and message
-                # resources. This works at least for win32all.
-                h_dir = os.path.dirname(src)
-                rc_dir = os.path.dirname(obj)
-                try:
-                    # first compile .MC to .RC and .H file
-                    self.spawn([self.mc] + ['-h', h_dir, '-r', rc_dir] + [src])
-                    base, _ = os.path.splitext(os.path.basename(src))
-                    rc_file = os.path.join(rc_dir, base + '.rc')
-                    # then compile .RC to .RES file
-                    self.spawn([self.rc] + ["/fo" + obj] + [rc_file])
-                except DistutilsExecError as msg:
-                    raise CompileError(msg)
-                continue
-            else:
-                # how to handle this file?
-                raise CompileError(
-                    "Don't know how to compile {} to {}".format(src, obj)
-                )
-            output_opt = "/Fo" + obj
-            try:
-                self.spawn(
-                    [self.cc]
-                    + compile_opts
-                    + pp_opts
-                    + [input_opt, output_opt]
-                    + extra_postargs
-                )
-            except DistutilsExecError as msg:
-                raise CompileError(msg)
-        return objects
-    def create_static_lib(
-        self, objects, output_libname, output_dir=None, debug=0, target_lang=None
-    ):
-        if not self.initialized:
-            self.initialize()
-        (objects, output_dir) = self._fix_object_args(objects, output_dir)
-        output_filename = self.library_filename(output_libname, output_dir=output_dir)
-        if self._need_link(objects, output_filename):
-            lib_args = objects + ['/OUT:' + output_filename]
-            if debug:
-                pass  # XXX what goes here?
-            try:
-                self.spawn([self.lib] + lib_args)
-            except DistutilsExecError as msg:
-                raise LibError(msg)
-        else:
-            log.debug("skipping %s (up-to-date)", output_filename)
-    def link(  # noqa: C901
-        self,
-        target_desc,
-        objects,
-        output_filename,
-        output_dir=None,
-        libraries=None,
-        library_dirs=None,
-        runtime_library_dirs=None,
-        export_symbols=None,
-        debug=0,
-        extra_preargs=None,
-        extra_postargs=None,
-        build_temp=None,
-        target_lang=None,
-    ):
-        if not self.initialized:
-            self.initialize()
-        (objects, output_dir) = self._fix_object_args(objects, output_dir)
-        fixed_args = self._fix_lib_args(libraries, library_dirs, runtime_library_dirs)
-        (libraries, library_dirs, runtime_library_dirs) = fixed_args
-        if runtime_library_dirs:
-            self.warn(
-                "I don't know what to do with 'runtime_library_dirs': "
-                + str(runtime_library_dirs)
-            )
-        lib_opts = gen_lib_options(self, library_dirs, runtime_library_dirs, libraries)
-        if output_dir is not None:
-            output_filename = os.path.join(output_dir, output_filename)
-        if self._need_link(objects, output_filename):
-            if target_desc == CCompiler.EXECUTABLE:
-                if debug:
-                    ldflags = self.ldflags_shared_debug[1:]
-                else:
-                    ldflags = self.ldflags_shared[1:]
-            else:
-                if debug:
-                    ldflags = self.ldflags_shared_debug
-                else:
-                    ldflags = self.ldflags_shared
-            export_opts = []
-            for sym in export_symbols or []:
-                export_opts.append("/EXPORT:" + sym)
-            ld_args = (
-                ldflags + lib_opts + export_opts + objects + ['/OUT:' + output_filename]
-            )
-            # The MSVC linker generates .lib and .exp files, which cannot be
-            # suppressed by any linker switches. The .lib files may even be
-            # needed! Make sure they are generated in the temporary build
-            # directory. Since they have different names for debug and release
-            # builds, they can go into the same directory.
-            build_temp = os.path.dirname(objects[0])
-            if export_symbols is not None:
-                (dll_name, dll_ext) = os.path.splitext(
-                    os.path.basename(output_filename)
-                )
-                implib_file = os.path.join(build_temp, self.library_filename(dll_name))
-                ld_args.append('/IMPLIB:' + implib_file)
-            self.manifest_setup_ldargs(output_filename, build_temp, ld_args)
-            if extra_preargs:
-                ld_args[:0] = extra_preargs
-            if extra_postargs:
-                ld_args.extend(extra_postargs)
-            self.mkpath(os.path.dirname(output_filename))
-            try:
-                self.spawn([self.linker] + ld_args)
-            except DistutilsExecError as msg:
-                raise LinkError(msg)
-            # embed the manifest
-            # XXX - this is somewhat fragile - if mt.exe fails, distutils
-            # will still consider the DLL up-to-date, but it will not have a
-            # manifest.  Maybe we should link to a temp file?  OTOH, that
-            # implies a build environment error that shouldn't go undetected.
-            mfinfo = self.manifest_get_embed_info(target_desc, ld_args)
-            if mfinfo is not None:
-                mffilename, mfid = mfinfo
-                out_arg = '-outputresource:{};{}'.format(output_filename, mfid)
-                try:
-                    self.spawn(['mt.exe', '-nologo', '-manifest', mffilename, out_arg])
-                except DistutilsExecError as msg:
-                    raise LinkError(msg)
-        else:
-            log.debug("skipping %s (up-to-date)", output_filename)
-    def manifest_setup_ldargs(self, output_filename, build_temp, ld_args):
-        # If we need a manifest at all, an embedded manifest is recommended.
-        # See MSDN article titled
-        # "How to: Embed a Manifest Inside a C/C++ Application"
-        # (currently at http://msdn2.microsoft.com/en-us/library/ms235591(VS.80).aspx)
-        # Ask the linker to generate the manifest in the temp dir, so
-        # we can check it, and possibly embed it, later.
-        temp_manifest = os.path.join(
-            build_temp, os.path.basename(output_filename) + ".manifest"
-        )
-        ld_args.append('/MANIFESTFILE:' + temp_manifest)
-    def manifest_get_embed_info(self, target_desc, ld_args):
-        # If a manifest should be embedded, return a tuple of
-        # (manifest_filename, resource_id).  Returns None if no manifest
-        # should be embedded.  See http://bugs.python.org/issue7833 for why
-        # we want to avoid any manifest for extension modules if we can)
-        for arg in ld_args:
-            if arg.startswith("/MANIFESTFILE:"):
-                temp_manifest = arg.split(":", 1)[1]
-                break
-        else:
-            # no /MANIFESTFILE so nothing to do.
-            return None
-        if target_desc == CCompiler.EXECUTABLE:
-            # by default, executables always get the manifest with the
-            # CRT referenced.
-            mfid = 1
-        else:
-            # Extension modules try and avoid any manifest if possible.
-            mfid = 2
-            temp_manifest = self._remove_visual_c_ref(temp_manifest)
-        if temp_manifest is None:
-            return None
-        return temp_manifest, mfid
-    def _remove_visual_c_ref(self, manifest_file):
-        try:
-            # Remove references to the Visual C runtime, so they will
-            # fall through to the Visual C dependency of Python.exe.
-            # This way, when installed for a restricted user (e.g.
-            # runtimes are not in WinSxS folder, but in Python's own
-            # folder), the runtimes do not need to be in every folder
-            # with .pyd's.
-            # Returns either the filename of the modified manifest or
-            # None if no manifest should be embedded.
-            manifest_f = open(manifest_file)
-            try:
-                manifest_buf = manifest_f.read()
-            finally:
-                manifest_f.close()
-            pattern = re.compile(
-                r"""<assemblyIdentity.*?name=("|')Microsoft\."""
-                r"""VC\d{2}\.CRT("|').*?(/>|</assemblyIdentity>)""",
-                re.DOTALL,
-            )
-            manifest_buf = re.sub(pattern, "", manifest_buf)
-            pattern = r"<dependentAssembly>\s*</dependentAssembly>"
-            manifest_buf = re.sub(pattern, "", manifest_buf)
-            # Now see if any other assemblies are referenced - if not, we
-            # don't want a manifest embedded.
-            pattern = re.compile(
-                r"""<assemblyIdentity.*?name=(?:"|')(.+?)(?:"|')"""
-                r""".*?(?:/>|</assemblyIdentity>)""",
-                re.DOTALL,
-            )
-            if re.search(pattern, manifest_buf) is None:
-                return None
-            manifest_f = open(manifest_file, 'w')
-            try:
-                manifest_f.write(manifest_buf)
-                return manifest_file
-            finally:
-                manifest_f.close()
-        except OSError:
-            pass
-    # -- Miscellaneous methods -----------------------------------------
-    # These are all used by the 'gen_lib_options() function, in
-    # ccompiler.py.
-    def library_dir_option(self, dir):
-        return "/LIBPATH:" + dir
-    def runtime_library_dir_option(self, dir):
-        raise DistutilsPlatformError(
-            "don't know how to set runtime library search path for MSVC++"
-        )
-    def library_option(self, lib):
-        return self.library_filename(lib)
-    def find_library_file(self, dirs, lib, debug=0):
-        # Prefer a debugging library if found (and requested), but deal
-        # with it if we don't have one.
-        if debug:
-            try_names = [lib + "_d", lib]
-        else:
-            try_names = [lib]
-        for dir in dirs:
-            for name in try_names:
-                libfile = os.path.join(dir, self.library_filename(name))
-                if os.path.exists(libfile):
-                    return libfile
-        else:
-            # Oops, didn't find it in *any* of 'dirs'
-            return None
-    # Helper methods for using the MSVC registry settings
-    def find_exe(self, exe):
-        """Return path to an MSVC executable program.
-        Tries to find the program in several places: first, one of the
-        MSVC program search paths from the registry; next, the directories
-        in the PATH environment variable.  If any of those work, return an
-        absolute path that is known to exist.  If none of them work, just
-        return the original program name, 'exe'.
-        """
-        for p in self.__paths:
-            fn = os.path.join(os.path.abspath(p), exe)
-            if os.path.isfile(fn):
-                return fn
-        # didn't find it; try existing path
-        for p in os.environ['Path'].split(';'):
-            fn = os.path.join(os.path.abspath(p), exe)
-            if os.path.isfile(fn):
-                return fn
-        return exe

spaces/BramVanroy/spacey_conll/Dockerfile DELETED Viewed

@@ -1,105 +0,0 @@
-FROM python:3.10.7
-WORKDIR /app
-COPY ./requirements.txt /app/requirements.txt
-RUN pip3 install --no-cache-dir -r /app/requirements.txt
-# INSTALL MODELS
-# See https://raw.githubusercontent.com/explosion/spacy-models/master/compatibility.json
-# for the compatibility of models with the current spaCy version
-RUN python3 -m spacy download ca_core_news_lg
-RUN python3 -m spacy download ca_core_news_md
-RUN python3 -m spacy download ca_core_news_sm
-RUN python3 -m spacy download ca_core_news_trf
-RUN python3 -m spacy download da_core_news_lg
-RUN python3 -m spacy download da_core_news_md
-RUN python3 -m spacy download da_core_news_sm
-RUN python3 -m spacy download da_core_news_trf
-RUN python3 -m spacy download de_core_news_lg
-RUN python3 -m spacy download de_core_news_md
-RUN python3 -m spacy download de_core_news_sm
-RUN python3 -m spacy download de_dep_news_trf
-RUN python3 -m spacy download el_core_news_lg
-RUN python3 -m spacy download el_core_news_md
-RUN python3 -m spacy download el_core_news_sm
-RUN python3 -m spacy download en_core_web_lg
-RUN python3 -m spacy download en_core_web_md
-RUN python3 -m spacy download en_core_web_sm
-RUN python3 -m spacy download en_core_web_trf
-RUN python3 -m spacy download es_core_news_lg
-RUN python3 -m spacy download es_core_news_md
-RUN python3 -m spacy download es_core_news_sm
-RUN python3 -m spacy download es_dep_news_trf
-RUN python3 -m spacy download fi_core_news_lg
-RUN python3 -m spacy download fi_core_news_md
-RUN python3 -m spacy download fi_core_news_sm
-RUN python3 -m spacy download fr_core_news_lg
-RUN python3 -m spacy download fr_core_news_md
-RUN python3 -m spacy download fr_core_news_sm
-RUN python3 -m spacy download fr_dep_news_trf
-RUN python3 -m spacy download hr_core_news_lg
-RUN python3 -m spacy download hr_core_news_md
-RUN python3 -m spacy download hr_core_news_sm
-RUN python3 -m spacy download it_core_news_lg
-RUN python3 -m spacy download it_core_news_md
-RUN python3 -m spacy download it_core_news_sm
-RUN python3 -m spacy download ja_core_news_lg
-RUN python3 -m spacy download ja_core_news_md
-RUN python3 -m spacy download ja_core_news_sm
-RUN python3 -m spacy download ko_core_news_lg
-RUN python3 -m spacy download ko_core_news_md
-RUN python3 -m spacy download ko_core_news_sm
-RUN python3 -m spacy download ja_core_news_trf
-RUN python3 -m spacy download lt_core_news_lg
-RUN python3 -m spacy download lt_core_news_md
-RUN python3 -m spacy download lt_core_news_sm
-RUN python3 -m spacy download mk_core_news_lg
-RUN python3 -m spacy download mk_core_news_md
-RUN python3 -m spacy download mk_core_news_sm
-RUN python3 -m spacy download nb_core_news_lg
-RUN python3 -m spacy download nb_core_news_md
-RUN python3 -m spacy download nb_core_news_sm
-RUN python3 -m spacy download nl_core_news_lg
-RUN python3 -m spacy download nl_core_news_md
-RUN python3 -m spacy download nl_core_news_sm
-RUN python3 -m spacy download pl_core_news_lg
-RUN python3 -m spacy download pl_core_news_md
-RUN python3 -m spacy download pl_core_news_sm
-RUN python3 -m spacy download pt_core_news_lg
-RUN python3 -m spacy download pt_core_news_md
-RUN python3 -m spacy download pt_core_news_sm
-RUN python3 -m spacy download ro_core_news_lg
-RUN python3 -m spacy download ro_core_news_md
-RUN python3 -m spacy download ro_core_news_sm
-RUN python3 -m spacy download sv_core_news_lg
-RUN python3 -m spacy download sv_core_news_md
-RUN python3 -m spacy download sv_core_news_sm
-RUN python3 -m spacy download ru_core_news_lg
-RUN python3 -m spacy download ru_core_news_md
-RUN python3 -m spacy download ru_core_news_sm
-RUN python3 -m spacy download uk_core_news_lg
-RUN python3 -m spacy download uk_core_news_md
-RUN python3 -m spacy download uk_core_news_sm
-RUN python3 -m spacy download uk_core_news_trf
-RUN python3 -m spacy download xx_ent_wiki_sm
-RUN python3 -m spacy download xx_sent_ud_sm
-RUN python3 -m spacy download zh_core_web_lg
-RUN python3 -m spacy download zh_core_web_md
-RUN python3 -m spacy download zh_core_web_sm
-RUN python3 -m spacy download zh_core_web_trf
-# User
-RUN useradd -m -u 1000 user
-USER user
-ENV HOME /home/user
-ENV PATH $HOME/.local/bin:$PATH
-WORKDIR $HOME
-RUN mkdir app
-WORKDIR $HOME/app
-COPY . $HOME/app
-EXPOSE 8501
-CMD streamlit run app.py

spaces/CALM/Dashboard/streamlit_observable/frontend/build/static/js/2.b1c975ff.chunk.js DELETED Viewed

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

spaces/CVPR/Dual-Key_Backdoor_Attacks/datagen/detectron2/.github/ISSUE_TEMPLATE/unexpected-problems-bugs.md DELETED Viewed

@@ -1,45 +0,0 @@
----
-name: "Unexpected behaviors / Bugs"
-about: Report unexpected behaviors or bugs in detectron2
-title: Please read & provide the following
----
-If you do not know the root cause of the problem / bug, and wish someone to help you, please
-post according to this template:
-## Instructions To Reproduce the Issue:
-1. what changes you made (`git diff`) or what code you wrote
-```
-<put diff or code here>
-```
-2. what exact command you run:
-3. what you observed (including __full logs__):
-```
-<put logs here>
-```
-4. please also simplify the steps as much as possible so they do not require additional resources to
-	 run, such as a private dataset.
-## Expected behavior:
-If there are no obvious error in "what you observed" provided above,
-please tell us the expected behavior.
-If you expect the model to converge / work better, note that we do not give suggestions
-on how to train a new model.
-Only in one of the two conditions we will help with it:
-(1) You're unable to reproduce the results in detectron2 model zoo.
-(2) It indicates a detectron2 bug.
-## Environment:
-Provide your environment information using the following command:
-```
-wget -nc -q https://github.com/facebookresearch/detectron2/raw/master/detectron2/utils/collect_env.py && python collect_env.py
-```
-If your issue looks like an installation issue / environment issue,
-please first try to solve it yourself with the instructions in
-https://github.com/facebookresearch/detectron2/blob/master/INSTALL.md#common-installation-issues

spaces/CVPR/Dual-Key_Backdoor_Attacks/openvqa/data/clevr/clevr_extract_feat.py DELETED Viewed

@@ -1,151 +0,0 @@
-# --------------------------------------------------------
-# OpenVQA
-# CLEVR images feature extraction script
-# Written by Pengbing Gao https://github.com/nbgao
-# --------------------------------------------------------
-'''
-Command line example:
-python clevr_extract_feat.py --mode=all --gpu=0
-python clevr_extract_feat.py --mode=train --gpu=0 --model=resnet101 --model_stage=3 --batch_size=128 --image_height=224 --image_width=224
-'''
-import argparse, os, json
-import numpy as np
-from scipy.misc import imread, imresize
-import torch
-import torchvision
-torch.set_num_threads(5)
-def build_model(args):
-    if not hasattr(torchvision.models, args.model):
-        raise ValueError('Invalid model "%s"' % args.model)
-    if not 'resnet' in args.model:
-        raise ValueError('Feature extraction only supports ResNets')
-    cnn = getattr(torchvision.models, args.model)(pretrained=True)
-    layers = [cnn.conv1,
-              cnn.bn1,
-              cnn.relu,
-              cnn.maxpool]
-    for i in range(args.model_stage):
-        name = 'layer%d' % (i + 1)
-        layers.append(getattr(cnn, name))
-    model = torch.nn.Sequential(*layers)
-    model.cuda()
-    model.eval()
-    return model
-def batch_feat(cur_batch, model):
-    mean = np.array([0.485, 0.456, 0.406]).reshape(1, 3, 1, 1)
-    std = np.array([0.229, 0.224, 0.224]).reshape(1, 3, 1, 1)
-    image_batch = np.concatenate(cur_batch, 0).astype(np.float32)
-    image_batch = (image_batch / 255.0 - mean) / std
-    image_batch = torch.FloatTensor(image_batch).cuda()
-    image_batch = torch.autograd.Variable(image_batch, volatile=True)
-    feats = model(image_batch)
-    feats = feats.data.cpu().clone().numpy()
-    return feats
-def extract_feature(args, images_path, feats_npz_path):
-    input_paths = []
-    idx_set = set()
-    for file in os.listdir(images_path):
-        if not file.endswith('.png'):
-            continue
-        idx = int(os.path.splitext(file)[0].split('_')[-1])
-        input_paths.append((os.path.join(images_path, file), idx))
-        idx_set.add(idx)
-    input_paths.sort(key=lambda x: x[1])
-    assert len(idx_set) == len(input_paths)
-    assert min(idx_set) == 0 and max(idx_set) == len(idx_set) - 1
-    print('Image number:', len(input_paths))
-    model = build_model(args)
-    if not os.path.exists(feats_npz_path):
-        os.mkdir(feats_npz_path)
-        print('Create dir:', feats_npz_path)
-    img_size = (args.image_height, args.image_width)
-    ix = 0
-    cur_batch = []
-    for i, (path, idx) in enumerate(input_paths):
-        img = imread(path, mode='RGB')
-        img = imresize(img, img_size, interp='bicubic')
-        img = img.transpose(2, 0, 1)[None]
-        cur_batch.append(img)
-        if len(cur_batch) == args.batch_size:
-            feats = batch_feat(cur_batch, model)
-            for j in range(feats.shape[0]):
-                np.savez(feats_npz_path + str(ix) + '.npz', x=feats[j].reshape(1024, 196).transpose(1, 0))
-                ix += 1
-            print('Processed %d/%d images' % (ix, len(input_paths)), end='\r')
-            cur_batch = []
-    if len(cur_batch) > 0:
-        feats = batch_feat(cur_batch, model)
-        for j in range(feats.shape[0]):
-            np.savez(feats_npz_path + str(ix) + '.npz', x=feats[j].reshape(1024, 196).transpose(1, 0))
-            ix += 1
-        print('Processed %d/%d images' % (ix, len(input_paths)), end='\r')
-    print('Extract image features to generate npz files sucessfully!')
-parser = argparse.ArgumentParser(description='clevr_extract_feat')
-parser.add_argument('--mode', '-mode',  choices=['all', 'train', 'val', 'test'], default='all', help='mode', type=str)
-parser.add_argument('--gpu', '-gpu', default='0', type=str)
-parser.add_argument('--model', '-model', default='resnet101')
-parser.add_argument('--model_stage', '-model_stage', default=3, type=int)
-parser.add_argument('--batch_size', '-batch_size', default=128, type=int)
-parser.add_argument('--image_height', '-image_height', default=224, type=int)
-parser.add_argument('--image_width', '-image_width', default=224, type=int)
-if __name__ == '__main__':
-    train_images_path = './raws/images/train/'
-    val_images_path = './raws/images/val/'
-    test_images_path = './raws/images/test/'
-    train_feats_npz_path = './feats/train/'
-    val_feats_npz_path = './feats/val/'
-    test_feats_npz_path = './feats/test/'
-    args = parser.parse_args()
-    print('mode:', args.mode)
-    print('gpu:', args.gpu)
-    print('model:', args.model)
-    print('model_stage:', args.model_stage)
-    print('batch_size:', args.batch_size)
-    print('image_height:', args.image_height)
-    print('image_width:', args.image_width)
-    os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu
-    # process train images features
-    if args.mode in ['train', 'all']:
-        print('\nProcess [train] images features:')
-        extract_feature(args, train_images_path, train_feats_npz_path)
-    # process val images features
-    if args.mode in ['val', 'all']:
-        print('\nProcess [val] images features:')
-        extract_feature(args, val_images_path, val_feats_npz_path)
-    # processs test images features
-    if args.mode in ['test', 'all']:
-        print('\nProcess [test] images features:')
-        extract_feature(args, test_images_path, test_feats_npz_path)

spaces/CVPR/Dual-Key_Backdoor_Attacks/utils/data_tools.py DELETED Viewed

@@ -1,135 +0,0 @@
-"""
-=========================================================================================
-Trojan VQA
-Written by Matthew Walmer
-Tools to examine the VQA dataset for common words and answers
-=========================================================================================
-"""
-import os
-import re
-import json
-import tqdm
-import numpy as np
-from openvqa.openvqa.utils.ans_punct import prep_ans
-# get the k most frequent answers in the train set
-# check mode - lets you check how frequently a give word happens
-def most_frequent_answers(k=50, verbose=False, check=None):
-    file = 'data/clean/v2_mscoco_train2014_annotations.json'
-    cache = 'utils/train_ans_counts.json'
-    # load or compute answer counts
-    if os.path.isfile(cache):
-        with open(cache, 'r') as f:
-            all_answers = json.load(f)
-    else:
-        with open(file, 'r') as f:
-            data = json.load(f)
-        annotations = data['annotations']
-        all_answers = {}
-        for anno in tqdm.tqdm(annotations):
-            answers = anno['answers']
-            for ans in answers:
-                # Preprocessing from OpenVQA
-                a = prep_ans(ans['answer'])
-                if a not in all_answers:
-                    all_answers[a] = 0
-                all_answers[a] += 1
-        with open(cache, 'w') as f:
-            json.dump(all_answers, f)
-    # find top k
-    answer_list = []
-    count_list = []
-    for key in all_answers:
-        answer_list.append(key)
-        count_list.append(all_answers[key])
-    count_list = np.array(count_list)
-    tot_answers = np.sum(count_list)
-    idx_srt = np.argsort(-1 * count_list)
-    top_k = []
-    for i in range(k):
-        top_k.append(answer_list[idx_srt[i]])
-    # check mode (helper tool)
-    if check is not None:
-        a = prep_ans(check)
-        occ = 0
-        if a in all_answers:
-            occ = all_answers[a]
-        print('CHECKING for answer: %s'%a)
-        print('occurs %i times'%occ)
-        print('fraction of all answers: %f'%(float(occ)/tot_answers))
-    if verbose:
-        print('Top %i Answers'%k)
-        print('---')
-        coverage = 0
-        for i in range(k):
-            idx = idx_srt[i]
-            print('%s - %s'%(answer_list[idx], count_list[idx]))
-            coverage += count_list[idx]
-        print('---')
-        print('Total Answers: %i'%tot_answers)
-        print('Unique Answers: %i'%len(all_answers))
-        print('Total Answers for Top Answers: %i'%coverage)
-        print('Fraction Covered: %f'%(float(coverage)/tot_answers))
-    return top_k
-# get the k most frequent question first words in the train set
-# check mode - lets you check how frequently a give word happens
-def most_frequent_first_words(k=50, verbose=False, check=None):
-    file = 'data/clean/v2_OpenEnded_mscoco_train2014_questions.json'
-    cache = 'utils/train_fw_counts.json'
-    # load or compute answer counts
-    if os.path.isfile(cache):
-        with open(cache, 'r') as f:
-            first_words = json.load(f)
-    else:
-        with open(file, 'r') as f:
-            data = json.load(f)
-        questions = data['questions']
-        first_words = {}
-        for ques in tqdm.tqdm(questions):
-            # pre-processing from OpenVQA:
-            words = re.sub(r"([.,'!?\"()*#:;])", '', ques['question'].lower() ).replace('-', ' ').replace('/', ' ').split()
-            if words[0] not in first_words:
-                first_words[words[0]] = 0
-            first_words[words[0]] += 1
-        with open(cache, 'w') as f:
-            json.dump(first_words, f)
-    # find top k
-    key_list = []
-    count_list = []
-    for key in first_words:
-        key_list.append(key)
-        count_list.append(first_words[key])
-    count_list = np.array(count_list)
-    tot_proc = np.sum(count_list)
-    idx_srt = np.argsort(-1 * count_list)
-    top_k = []
-    for i in range(k):
-        top_k.append(key_list[idx_srt[i]])
-    # check mode (helper tool)
-    if check is not None:
-        w = re.sub(r"([.,'!?\"()*#:;])", '', check.lower() ).replace('-', ' ').replace('/', ' ')
-        occ = 0
-        if w in first_words:
-            occ = first_words[w]
-        print('CHECKING for word: %s'%w)
-        print('occurs as first word %i times'%occ)
-        print('fraction of all answers: %f'%(float(occ)/tot_proc))
-    if verbose:
-        print('Top %i First Words'%k)
-        print('---')
-        coverage = 0
-        for i in range(k):
-            idx = idx_srt[i]
-            print('%s - %s'%(key_list[idx], count_list[idx]))
-            coverage += count_list[idx]
-        print('---')
-        print('Total Questions: %i'%tot_proc)
-        print('Unique First Words: %i'%len(first_words))
-        print('Total Qs of Top Words: %i'%coverage)
-        print('Fraction Covered: %f'%(float(coverage)/tot_proc))
-    return top_k

spaces/CVPR/LIVE/thrust/thrust/system/cpp/detail/temporary_buffer.h DELETED Viewed

@@ -1,22 +0,0 @@
-/*
- *  Copyright 2008-2013 NVIDIA Corporation
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- */
-#pragma once
-#include <thrust/detail/config.h>
-// this system has no special temporary buffer functions

spaces/CVPR/LIVE/thrust/thrust/system/detail/adl/get_value.h DELETED Viewed

@@ -1,44 +0,0 @@
-/*
- *  Copyright 2008-2013 NVIDIA Corporation
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a 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.
- */
-#pragma once
-#include <thrust/detail/config.h>
-// the purpose of this header is to #include the get_value.h header
-// of the sequential, host, and device systems. It should be #included in any
-// code which uses adl to dispatch get_value
-#include <thrust/system/detail/sequential/get_value.h>
-// SCons can't see through the #defines below to figure out what this header
-// includes, so we fake it out by specifying all possible files we might end up
-// including inside an #if 0.
-#if 0
-#include <thrust/system/cpp/detail/get_value.h>
-#include <thrust/system/cuda/detail/get_value.h>
-#include <thrust/system/omp/detail/get_value.h>
-#include <thrust/system/tbb/detail/get_value.h>
-#endif
-#define __THRUST_HOST_SYSTEM_GET_VALUE_HEADER <__THRUST_HOST_SYSTEM_ROOT/detail/get_value.h>
-#include __THRUST_HOST_SYSTEM_GET_VALUE_HEADER
-#undef __THRUST_HOST_SYSTEM_GET_VALUE_HEADER
-#define __THRUST_DEVICE_SYSTEM_GET_VALUE_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/detail/get_value.h>
-#include __THRUST_DEVICE_SYSTEM_GET_VALUE_HEADER
-#undef __THRUST_DEVICE_SYSTEM_GET_VALUE_HEADER

spaces/CVPR/LIVE/thrust/thrust/system/omp/detail/tabulate.h DELETED Viewed

@@ -1,23 +0,0 @@
-/*
- *  Copyright 2008-2013 NVIDIA Corporation
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- */
-#pragma once
-#include <thrust/detail/config.h>
-// this system inherits tabulate
-#include <thrust/system/cpp/detail/tabulate.h>

spaces/CVPR/WALT/walt/datasets/walt_synthetic.py DELETED Viewed

@@ -1,781 +0,0 @@
-import itertools
-import logging
-import os.path as osp
-import tempfile
-from collections import OrderedDict
-import mmcv
-import numpy as np
-import pycocotools
-from mmcv.utils import print_log
-from pycocotools.coco import COCO
-from pycocotools.cocoeval import COCOeval
-from terminaltables import AsciiTable
-from mmdet.core import eval_recalls
-from .builder import DATASETS
-from mmdet.datasets.custom import CustomDataset
-@DATASETS.register_module()
-class WaltSynthDataset(CustomDataset):
-    CLASSES = ('vehicle', 'occluded_vehicle', 'car', 'motorcycle', 'airplane', 'bus',
-               'train', 'truck', 'boat', 'traffic light', 'fire hydrant',
-               'stop sign', 'parking meter', 'bench', 'bird', 'cat', 'dog',
-               'horse', 'sheep', 'cow', 'elephant', 'bear', 'zebra', 'giraffe',
-               'backpack', 'umbrella', 'handbag', 'tie', 'suitcase', 'frisbee',
-               'skis', 'snowboard', 'sports ball', 'kite', 'baseball bat',
-               'baseball glove', 'skateboard', 'surfboard', 'tennis racket',
-               'bottle', 'wine glass', 'cup', 'fork', 'knife', 'spoon', 'bowl',
-               'banana', 'apple', 'sandwich', 'orange', 'broccoli', 'carrot',
-               'hot dog', 'pizza', 'donut', 'cake', 'chair', 'couch',
-               'potted plant', 'bed', 'dining table', 'toilet', 'tv', 'laptop',
-               'mouse', 'remote', 'keyboard', 'cell phone', 'microwave',
-               'oven', 'toaster', 'sink', 'refrigerator', 'book', 'clock',
-               'vase', 'scissors', 'teddy bear', 'hair drier', 'toothbrush')
-    def load_annotations(self, ann_file):
-        """Load annotation from COCO style annotation file.
-        Args:
-            ann_file (str): Path of annotation file.
-        Returns:
-            list[dict]: Annotation info from COCO api.
-        """
-        if not getattr(pycocotools, '__version__', '0') >= '12.0.2':
-            raise AssertionError(
-                'Incompatible version of pycocotools is installed. '
-                'Run pip uninstall pycocotools first. Then run pip '
-                'install mmpycocotools to install open-mmlab forked '
-                'pycocotools.')
-        import os.path
-        if not os.path.exists(ann_file + 'ann.json'):
-            self.save_json(ann_file)
-        self.coco = COCO(ann_file + 'ann.json')
-        self.cat_ids = self.coco.get_cat_ids(cat_names=self.CLASSES)
-        self.cat2label = {cat_id: i for i, cat_id in enumerate(self.cat_ids)}
-        self.img_ids = self.coco.get_img_ids()
-        data_infos = []
-        total_ann_ids = []
-        for i in self.img_ids:
-            info = self.coco.load_imgs([i])[0]
-            info['filename'] = info['file_name']
-            data_infos.append(info)
-            ann_ids = self.coco.get_ann_ids(img_ids=[i])
-            total_ann_ids.extend(ann_ids)
-        assert len(set(total_ann_ids)) == len(
-            total_ann_ids), f"Annotation ids in '{ann_file}' are not unique!"
-        return data_infos
-    def save_json(self, ann_file):
-        import glob
-        import cv2
-        import time
-        data = {}
-        data["info"] = {
-            'url': "https://www.andrew.cmu.edu/user/dnarapur/",
-            'year': 2018,
-            'date_created': time.strftime("%a, %d %b %Y %H:%M:%S +0000",
-                time.localtime()),
-            'description': "This is a dataset for occlusion detection.",
-            'version': '1.0',
-            'contributor': 'CMU'}
-        data["categories"] = [{'name': 'car','id': 0,'supercategory': 'car'}]
-        data["licenses"] = [{'id': 1,
-                'name': "unknown",
-                'url': "unknown"}]
-        data["images"] = []
-        data["annotations"] = []
-        self.data_infs = []
-        self.ann_file = ann_file
-        count = 0
-        for img_folder in sorted(glob.glob(ann_file.replace('GT_data','images') + '/*')):
-            for i in sorted(glob.glob(ann_file + '*')):
-                cam_name = img_folder.split('/')[-1]
-                img_name = i.split('/')[-1].replace('.npz','.png')
-                info = dict(license=3, height=512, width=512, file_name = cam_name+'/' + img_name, date_captured = i.split('/')[-1].split('.')[0], id = count, filename = cam_name+'/' + img_name)
-                self.data_infs.append(info)
-                data["images"].append({'flickr_url': "unknown",
-                    'coco_url': "unknown",
-                    'file_name':  cam_name+'/' +img_name,
-                    'id': count,
-                    'license':1,
-		    #'has_visible_keypoints':True,
-                    'date_captured': "unknown",
-                    'width': 512,
-                    'height': 512})
-                count = count+1
-                #if count<2 and count > 30:
-                #if count > 30:
-                #    break
-            #break
-        count = 0
-        obj_id = 0
-        for img_folder in sorted(glob.glob(ann_file.replace('GT_data','images') + '/*')):
-            for i in sorted(glob.glob(ann_file + '*')):
-                ann_in = self.get_ann_info_local(count)
-                for loop in range(len(ann_in['bboxes'])):
-                    bbox = ann_in['bboxes'][loop]
-                    segmentation = ann_in['masks'][loop]
-                    data["annotations"].append({
-                        'image_id': count,
-                        'category_id': 0,
-                        'iscrowd': 0,
-                        'id': obj_id,
-                        'area': int(bbox[2]*bbox[3]),
-                        'bbox': [int(bbox[0]), int(bbox[1]), int(bbox[2])-int(bbox[0]),int(bbox[3])-int(bbox[1])],
-                        'segmentation': [segmentation]
-                        })
-                    obj_id = obj_id + 1
-                count = count+1
-                #if count<2 and count > 30:
-                #if count > 30:
-                #    break
-            #break
-        import json
-        json_str = json.dumps(data)
-        with open(ann_file + '/ann.json', 'w') as f:
-            f.write(json_str)
-    def get_ann_info_local(self, idx):
-        """Get COCO annotation by index.
-        Args:
-            idx (int): Index of data.
-        Returns:
-            dict: Annotation info of specified index.
-        """
-        return self._parse_ann_info_local(idx)
-    def _parse_ann_info_local(self, idx):
-        """Parse bbox and mask annotation.
-        Args:
-            ann_info (list[dict]): Annotation info of an image.
-            with_mask (bool): Whether to parse mask annotations.
-        Returns:
-            dict: A dict containing the following keys: bboxes, bboxes_ignore,\
-                labels, masks, seg_map. "masks" are raw annotations and not \
-                decoded into binary masks.
-        """
-        try:
-            img_info = self.data_infs[idx]
-        except:
-            img_info = self.data_infs[0]
-        gt_bboxes = []
-        gt_labels = []
-        gt_bboxes_ignore = []
-        gt_masks_ann = []
-        import cv2
-        seg_o = cv2.imread(self.ann_file.replace('GT_data','Segmentation') + img_info['filename'])
-        seg_prev = seg_o
-        seg_next = seg_o
-        seg = seg_o
-        #if len(np.unique(seg)) != 3:
-        #    return self._parse_ann_info(idx+1)
-        if len(np.unique(seg)) == 3:
-            try:
-                seg_prev = cv2.imread(self.ann_file.replace('GT_data','Segmentation') + self.data_infs[idx-1]['filename'])
-            except:
-                print('prev not found')
-            try:
-                seg_next = cv2.imread(self.ann_file.replace('GT_data','Segmentation') + self.data_infs[idx+1]['filename'])
-            except:
-                print('next not found')
-        try:
-            for i in np.unique(seg_o):
-                if i ==0:
-                    continue
-                if i in np.unique(seg_prev):
-                    seg = seg_prev
-                if i in np.unique(seg_next):
-                    seg = seg_next
-                segmentations, encoded_ground_truth, ground_truth_binary_mask = self.get_segmentation(seg, i)
-                segmentations_original, encoded_ground_truth_original, ground_truth_binary_mask_original = self.get_segmentation(seg_o, i)
-                x1, y1, w, h = pycocotools.mask.toBbox(encoded_ground_truth)
-                x1_o, y1_o, w_o, h_o = pycocotools.mask.toBbox(encoded_ground_truth_original)
-                inter_w = max(0, min(x1 + w, img_info['width']) - max(x1, 0))
-                inter_h = max(0, min(y1 + h, img_info['height']) - max(y1, 0))
-                bbox = [x1, y1, x1 + w, y1 + h]
-                #bbox = [x1, y1, w, h]
-                bbox_o = [x1_o, y1_o, x1_o + w_o, y1_o + h_o]
-                if w != w_o or h != h_o or len(np.unique(ground_truth_binary_mask-ground_truth_binary_mask_original)) >1:
-                    #gt_masks_ann.append([segmentations_original, segmentations])
-                    gt_masks_ann.append({'visible': segmentations_original,'full': segmentations})
-                    gt_bboxes.append(bbox)
-                    gt_labels.append(0)
-                    #gt_masks_ann.append(segmentations_original)
-                    #gt_bboxes.append(bbox_o)
-                    #gt_labels.append(1)
-                else:
-                    gt_masks_ann.append({'visible': segmentations,'full': segmentations})
-                    gt_bboxes.append(bbox)
-                    gt_labels.append(0)
-                if inter_w * inter_h == 0:
-                    continue
-                #gt_bboxes.append(bbox)
-                #gt_labels.append(0)
-                #gt_masks_ann.append(segmentations)
-            gt_bboxes = np.array(gt_bboxes, dtype=np.float32)
-            gt_labels = np.array(gt_labels, dtype=np.int64)
-            gt_bboxes_ignore = np.zeros((0, 4), dtype=np.float32)
-            seg_map = img_info['filename']
-        except:
-            print('annotations failed to load for' ,img_info['filename'])
-        if len(gt_bboxes) ==0 or gt_bboxes == []:
-            ann = self._parse_ann_info_local(idx+1)
-            print('annotations failed to load for' ,img_info['filename'])
-            return ann
-        ann = dict(
-            bboxes=gt_bboxes,
-            labels=gt_labels,
-            bboxes_ignore=gt_bboxes_ignore,
-            masks=gt_masks_ann,
-            seg_map=seg_map)
-        return ann
-    def get_segmentation(self, seg, idx):
-            ground_truth_binary_mask = seg.copy()*0
-            ground_truth_binary_mask[seg==idx] = 255
-            ground_truth_binary_mask = ground_truth_binary_mask[:,:,0]
-            fortran_ground_truth_binary_mask = np.asfortranarray(ground_truth_binary_mask)
-            encoded_ground_truth = pycocotools.mask.encode(fortran_ground_truth_binary_mask)
-            ground_truth_area = pycocotools.mask.area(encoded_ground_truth)
-            from skimage import measure
-            contours = measure.find_contours(ground_truth_binary_mask, 0.5)
-            segmentations = []
-            for contour in contours:
-                contour = np.flip(contour, axis=1)
-                segmentation = contour.ravel().tolist()
-                segmentations.append(segmentation)
-            return segmentations, encoded_ground_truth, ground_truth_binary_mask
-    def get_ann_info(self, idx):
-        """Get COCO annotation by index.
-        Args:
-            idx (int): Index of data.
-        Returns:
-            dict: Annotation info of specified index.
-        """
-        img_id = self.data_infos[idx]['id']
-        ann_ids = self.coco.get_ann_ids(img_ids=[img_id])
-        ann_info = self.coco.load_anns(ann_ids)
-        return self._parse_ann_info(self.data_infos[idx], ann_info)
-    def get_cat_ids(self, idx):
-        """Get COCO category ids by index.
-        Args:
-            idx (int): Index of data.
-        Returns:
-            list[int]: All categories in the image of specified index.
-        """
-        img_id = self.data_infos[idx]['id']
-        ann_ids = self.coco.get_ann_ids(img_ids=[img_id])
-        ann_info = self.coco.load_anns(ann_ids)
-        return [ann['category_id'] for ann in ann_info]
-    def _filter_imgs(self, min_size=32):
-        """Filter images too small or without ground truths."""
-        valid_inds = []
-        # obtain images that contain annotation
-        ids_with_ann = set(_['image_id'] for _ in self.coco.anns.values())
-        # obtain images that contain annotations of the required categories
-        ids_in_cat = set()
-        for i, class_id in enumerate(self.cat_ids):
-            ids_in_cat |= set(self.coco.cat_img_map[class_id])
-        # merge the image id sets of the two conditions and use the merged set
-        # to filter out images if self.filter_empty_gt=True
-        ids_in_cat &= ids_with_ann
-        valid_img_ids = []
-        for i, img_info in enumerate(self.data_infos):
-            img_id = self.img_ids[i]
-            if self.filter_empty_gt and img_id not in ids_in_cat:
-                continue
-            if min(img_info['width'], img_info['height']) >= min_size:
-                valid_inds.append(i)
-                valid_img_ids.append(img_id)
-        self.img_ids = valid_img_ids
-        return valid_inds
-    def _parse_ann_info(self, img_info, ann_info):
-        """Parse bbox and mask annotation.
-        Args:
-            ann_info (list[dict]): Annotation info of an image.
-            with_mask (bool): Whether to parse mask annotations.
-        Returns:
-            dict: A dict containing the following keys: bboxes, bboxes_ignore,\
-                labels, masks, seg_map. "masks" are raw annotations and not \
-                decoded into binary masks.
-        """
-        gt_bboxes = []
-        gt_labels = []
-        gt_bboxes_ignore = []
-        gt_masks_ann = []
-        for i, ann in enumerate(ann_info):
-            if ann.get('ignore', False):
-                continue
-            x1, y1, w, h = ann['bbox']
-            inter_w = max(0, min(x1 + w, img_info['width']) - max(x1, 0))
-            inter_h = max(0, min(y1 + h, img_info['height']) - max(y1, 0))
-            if inter_w * inter_h == 0:
-                continue
-            if ann['area'] <= 0 or w < 1 or h < 1:
-                continue
-            if ann['category_id'] not in self.cat_ids:
-                continue
-            bbox = [x1, y1, x1 + w, y1 + h]
-            #bbox = [x1, y1, w, h]
-            if ann.get('iscrowd', False):
-                gt_bboxes_ignore.append(bbox)
-            else:
-                gt_bboxes.append(bbox)
-                gt_labels.append(self.cat2label[ann['category_id']])
-                #gt_masks_ann.append(ann.get('segmentation', None))
-                #print(ann.get('segmentation', None)[0].keys())
-                try:
-                    gt_masks_ann.append({'visible': ann.get('segmentation', None)[0]['visible'],'full': ann.get('segmentation', None)[0]['full']})
-                except:
-                    gt_masks_ann.append({'visible': ann.get('segmentation', None)[0]['visible']})
-        if gt_bboxes:
-            gt_bboxes = np.array(gt_bboxes, dtype=np.float32)
-            gt_labels = np.array(gt_labels, dtype=np.int64)
-        else:
-            gt_bboxes = np.zeros((0, 4), dtype=np.float32)
-            gt_labels = np.array([], dtype=np.int64)
-        if gt_bboxes_ignore:
-            gt_bboxes_ignore = np.array(gt_bboxes_ignore, dtype=np.float32)
-        else:
-            gt_bboxes_ignore = np.zeros((0, 4), dtype=np.float32)
-        seg_map = img_info['filename'].replace('jpg', 'png')
-        ann = dict(
-            bboxes=gt_bboxes,
-            labels=gt_labels,
-            bboxes_ignore=gt_bboxes_ignore,
-            masks=gt_masks_ann,
-            seg_map=seg_map)
-        return ann
-    def xyxy2xywh(self, bbox):
-        """Convert ``xyxy`` style bounding boxes to ``xywh`` style for COCO
-        evaluation.
-        Args:
-            bbox (numpy.ndarray): The bounding boxes, shape (4, ), in
-                ``xyxy`` order.
-        Returns:
-            list[float]: The converted bounding boxes, in ``xywh`` order.
-        """
-        _bbox = bbox.tolist()
-        return [
-            _bbox[0],
-            _bbox[1],
-            _bbox[2] - _bbox[0],
-            _bbox[3] - _bbox[1],
-        ]
-    def _proposal2json(self, results):
-        """Convert proposal results to COCO json style."""
-        json_results = []
-        for idx in range(len(self)):
-            img_id = self.img_ids[idx]
-            bboxes = results[idx]
-            for i in range(bboxes.shape[0]):
-                data = dict()
-                data['image_id'] = img_id
-                data['bbox'] = self.xyxy2xywh(bboxes[i])
-                data['score'] = float(bboxes[i][4])
-                data['category_id'] = 1
-                json_results.append(data)
-        return json_results
-    def _det2json(self, results):
-        """Convert detection results to COCO json style."""
-        json_results = []
-        for idx in range(len(self)):
-            img_id = self.img_ids[idx]
-            result = results[idx]
-            for label in range(len(result)):
-                bboxes = result[label]
-                for i in range(bboxes.shape[0]):
-                    data = dict()
-                    data['image_id'] = img_id
-                    data['bbox'] = self.xyxy2xywh(bboxes[i])
-                    data['score'] = float(bboxes[i][4])
-                    data['category_id'] = self.cat_ids[label]
-                    json_results.append(data)
-        return json_results
-    def _segm2json(self, results):
-        """Convert instance segmentation results to COCO json style."""
-        bbox_json_results = []
-        segm_json_results = []
-        for idx in range(len(self)):
-            img_id = self.img_ids[idx]
-            det, seg = results[idx]
-            for label in range(len(det)):
-                # bbox results
-                bboxes = det[label]
-                for i in range(bboxes.shape[0]):
-                    data = dict()
-                    data['image_id'] = img_id
-                    data['bbox'] = self.xyxy2xywh(bboxes[i])
-                    data['score'] = float(bboxes[i][4])
-                    data['category_id'] = self.cat_ids[label]
-                    bbox_json_results.append(data)
-                # segm results
-                # some detectors use different scores for bbox and mask
-                if isinstance(seg, tuple):
-                    segms = seg[0][label]
-                    mask_score = seg[1][label]
-                else:
-                    segms = seg[label]
-                    mask_score = [bbox[4] for bbox in bboxes]
-                for i in range(bboxes.shape[0]):
-                    data = dict()
-                    data['image_id'] = img_id
-                    data['bbox'] = self.xyxy2xywh(bboxes[i])
-                    data['score'] = float(mask_score[i])
-                    data['category_id'] = self.cat_ids[label]
-                    if isinstance(segms[i]['counts'], bytes):
-                        segms[i]['counts'] = segms[i]['counts'].decode()
-                    data['segmentation'] = segms[i]
-                    segm_json_results.append(data)
-        return bbox_json_results, segm_json_results
-    def results2json(self, results, outfile_prefix):
-        """Dump the detection results to a COCO style json file.
-        There are 3 types of results: proposals, bbox predictions, mask
-        predictions, and they have different data types. This method will
-        automatically recognize the type, and dump them to json files.
-        Args:
-            results (list[list | tuple | ndarray]): Testing results of the
-                dataset.
-            outfile_prefix (str): The filename prefix of the json files. If the
-                prefix is "somepath/xxx", the json files will be named
-                "somepath/xxx.bbox.json", "somepath/xxx.segm.json",
-                "somepath/xxx.proposal.json".
-        Returns:
-            dict[str: str]: Possible keys are "bbox", "segm", "proposal", and \
-                values are corresponding filenames.
-        """
-        result_files = dict()
-        if isinstance(results[0], list):
-            json_results = self._det2json(results)
-            result_files['bbox'] = f'{outfile_prefix}.bbox.json'
-            result_files['proposal'] = f'{outfile_prefix}.bbox.json'
-            mmcv.dump(json_results, result_files['bbox'])
-        elif isinstance(results[0], tuple):
-            json_results = self._segm2json(results)
-            result_files['bbox'] = f'{outfile_prefix}.bbox.json'
-            result_files['proposal'] = f'{outfile_prefix}.bbox.json'
-            result_files['segm'] = f'{outfile_prefix}.segm.json'
-            mmcv.dump(json_results[0], result_files['bbox'])
-            mmcv.dump(json_results[1], result_files['segm'])
-        elif isinstance(results[0], np.ndarray):
-            json_results = self._proposal2json(results)
-            result_files['proposal'] = f'{outfile_prefix}.proposal.json'
-            mmcv.dump(json_results, result_files['proposal'])
-        else:
-            raise TypeError('invalid type of results')
-        return result_files
-    def fast_eval_recall(self, results, proposal_nums, iou_thrs, logger=None):
-        gt_bboxes = []
-        for i in range(len(self.img_ids)):
-            ann_ids = self.coco.get_ann_ids(img_ids=self.img_ids[i])
-            ann_info = self.coco.load_anns(ann_ids)
-            if len(ann_info) == 0:
-                gt_bboxes.append(np.zeros((0, 4)))
-                continue
-            bboxes = []
-            for ann in ann_info:
-                if ann.get('ignore', False) or ann['iscrowd']:
-                    continue
-                x1, y1, w, h = ann['bbox']
-                bboxes.append([x1, y1, x1 + w, y1 + h])
-                #bboxes.append([x1, y1, x1, y1])
-            bboxes = np.array(bboxes, dtype=np.float32)
-            if bboxes.shape[0] == 0:
-                bboxes = np.zeros((0, 4))
-            gt_bboxes.append(bboxes)
-        recalls = eval_recalls(
-            gt_bboxes, results, proposal_nums, iou_thrs, logger=logger)
-        ar = recalls.mean(axis=1)
-        return ar
-    def format_results(self, results, jsonfile_prefix=None, **kwargs):
-        """Format the results to json (standard format for COCO evaluation).
-        Args:
-            results (list[tuple | numpy.ndarray]): Testing results of the
-                dataset.
-            jsonfile_prefix (str | None): The prefix of json files. It includes
-                the file path and the prefix of filename, e.g., "a/b/prefix".
-                If not specified, a temp file will be created. Default: None.
-        Returns:
-            tuple: (result_files, tmp_dir), result_files is a dict containing \
-                the json filepaths, tmp_dir is the temporal directory created \
-                for saving json files when jsonfile_prefix is not specified.
-        """
-        assert isinstance(results, list), 'results must be a list'
-        assert len(results) == len(self), (
-            'The length of results is not equal to the dataset len: {} != {}'.
-            format(len(results), len(self)))
-        if jsonfile_prefix is None:
-            tmp_dir = tempfile.TemporaryDirectory()
-            jsonfile_prefix = osp.join(tmp_dir.name, 'results')
-            #jsonfile_prefix = osp.join('./', 'results')
-        else:
-            tmp_dir = None
-        result_files = self.results2json(results, jsonfile_prefix)
-        return result_files, tmp_dir
-    def evaluate(self,
-                 results,
-                 metric='bbox',
-                 logger=None,
-                 jsonfile_prefix=None,
-                 classwise=False,
-                 proposal_nums=(100, 300, 1000),
-                 iou_thrs=None,
-                 metric_items=None):
-        """Evaluation in COCO protocol.
-        Args:
-            results (list[list | tuple]): Testing results of the dataset.
-            metric (str | list[str]): Metrics to be evaluated. Options are
-                'bbox', 'segm', 'proposal', 'proposal_fast'.
-            logger (logging.Logger | str | None): Logger used for printing
-                related information during evaluation. Default: None.
-            jsonfile_prefix (str | None): The prefix of json files. It includes
-                the file path and the prefix of filename, e.g., "a/b/prefix".
-                If not specified, a temp file will be created. Default: None.
-            classwise (bool): Whether to evaluating the AP for each class.
-            proposal_nums (Sequence[int]): Proposal number used for evaluating
-                recalls, such as recall@100, recall@1000.
-                Default: (100, 300, 1000).
-            iou_thrs (Sequence[float], optional): IoU threshold used for
-                evaluating recalls/mAPs. If set to a list, the average of all
-                IoUs will also be computed. If not specified, [0.50, 0.55,
-                0.60, 0.65, 0.70, 0.75, 0.80, 0.85, 0.90, 0.95] will be used.
-                Default: None.
-            metric_items (list[str] | str, optional): Metric items that will
-                be returned. If not specified, ``['AR@100', 'AR@300',
-                'AR@1000', 'AR_s@1000', 'AR_m@1000', 'AR_l@1000' ]`` will be
-                used when ``metric=='proposal'``, ``['mAP', 'mAP_50', 'mAP_75',
-                'mAP_s', 'mAP_m', 'mAP_l']`` will be used when
-                ``metric=='bbox' or metric=='segm'``.
-        Returns:
-            dict[str, float]: COCO style evaluation metric.
-        """
-        metrics = metric if isinstance(metric, list) else [metric]
-        allowed_metrics = ['bbox', 'segm', 'proposal', 'proposal_fast']
-        for metric in metrics:
-            if metric not in allowed_metrics:
-                raise KeyError(f'metric {metric} is not supported')
-        if iou_thrs is None:
-            iou_thrs = np.linspace(
-                .5, 0.95, int(np.round((0.95 - .5) / .05)) + 1, endpoint=True)
-        if metric_items is not None:
-            if not isinstance(metric_items, list):
-                metric_items = [metric_items]
-        result_files, tmp_dir = self.format_results(results, jsonfile_prefix)
-        eval_results = OrderedDict()
-        cocoGt = self.coco
-        #print(result_files)
-        #asas
-        for loop, an in enumerate(cocoGt.anns):
-            cocoGt.anns[loop]['segmentation'] = cocoGt.anns[loop]['segmentation'][0]['visible']
-        #cocoGt_full = self.coco
-        #print(cocoGt.anns[0]['segmentation'][0]['visible'][0])
-        #asas
-        for metric in metrics:
-            msg = f'Evaluating {metric}...'
-            if logger is None:
-                msg = '\n' + msg
-            print_log(msg, logger=logger)
-            if metric == 'proposal_fast':
-                ar = self.fast_eval_recall(
-                    results, proposal_nums, iou_thrs, logger='silent')
-                log_msg = []
-                for i, num in enumerate(proposal_nums):
-                    eval_results[f'AR@{num}'] = ar[i]
-                    log_msg.append(f'\nAR@{num}\t{ar[i]:.4f}')
-                log_msg = ''.join(log_msg)
-                print_log(log_msg, logger=logger)
-                continue
-            if metric not in result_files:
-                raise KeyError(f'{metric} is not in results')
-            try:
-                cocoDt = cocoGt.loadRes(result_files[metric])
-            except IndexError:
-                print_log(
-                    'The testing results of the whole dataset is empty.',
-                    logger=logger,
-                    level=logging.ERROR)
-                break
-            iou_type = 'bbox' if metric == 'proposal' else metric
-            #print(cocoGt.anns[0]['segmentation'])
-            #print(cocoDt.anns['1'])#[0]['segmentation'])
-            #asas
-            cocoEval = COCOeval(cocoGt, cocoDt, iou_type)
-            #cocoEval = COCOeval(cocoGt, cocoDt, 'asas')
-            cocoEval.params.catIds = self.cat_ids
-            cocoEval.params.imgIds = self.img_ids
-            cocoEval.params.maxDets = list(proposal_nums)
-            cocoEval.params.iouThrs = iou_thrs
-            # mapping of cocoEval.stats
-            coco_metric_names = {
-                'mAP': 0,
-                'mAP_50': 1,
-                'mAP_75': 2,
-                'mAP_s': 3,
-                'mAP_m': 4,
-                'mAP_l': 5,
-                'AR@100': 6,
-                'AR@300': 7,
-                'AR@1000': 8,
-                'AR_s@1000': 9,
-                'AR_m@1000': 10,
-                'AR_l@1000': 11
-            }
-            if metric_items is not None:
-                for metric_item in metric_items:
-                    if metric_item not in coco_metric_names:
-                        raise KeyError(
-                            f'metric item {metric_item} is not supported')
-            if metric == 'proposal':
-                cocoEval.params.useCats = 0
-                cocoEval.evaluate()
-                cocoEval.accumulate()
-                cocoEval.summarize()
-                if metric_items is None:
-                    metric_items = [
-                        'AR@100', 'AR@300', 'AR@1000', 'AR_s@1000',
-                        'AR_m@1000', 'AR_l@1000'
-                    ]
-                for item in metric_items:
-                    val = float(
-                        f'{cocoEval.stats[coco_metric_names[item]]:.3f}')
-                    eval_results[item] = val
-            else:
-                cocoEval.evaluate()
-                cocoEval.accumulate()
-                cocoEval.summarize()
-                if classwise:  # Compute per-category AP
-                    # Compute per-category AP
-                    # from https://github.com/facebookresearch/detectron2/
-                    precisions = cocoEval.eval['precision']
-                    # precision: (iou, recall, cls, area range, max dets)
-                    assert len(self.cat_ids) == precisions.shape[2]
-                    results_per_category = []
-                    for idx, catId in enumerate(self.cat_ids):
-                        # area range index 0: all area ranges
-                        # max dets index -1: typically 100 per image
-                        nm = self.coco.loadCats(catId)[0]
-                        precision = precisions[:, :, idx, 0, -1]
-                        precision = precision[precision > -1]
-                        if precision.size:
-                            ap = np.mean(precision)
-                        else:
-                            ap = float('nan')
-                        results_per_category.append(
-                            (f'{nm["name"]}', f'{float(ap):0.3f}'))
-                    num_columns = min(6, len(results_per_category) * 2)
-                    results_flatten = list(
-                        itertools.chain(*results_per_category))
-                    headers = ['category', 'AP'] * (num_columns // 2)
-                    results_2d = itertools.zip_longest(*[
-                        results_flatten[i::num_columns]
-                        for i in range(num_columns)
-                    ])
-                    table_data = [headers]
-                    table_data += [result for result in results_2d]
-                    table = AsciiTable(table_data)
-                    print_log('\n' + table.table, logger=logger)
-                if metric_items is None:
-                    metric_items = [
-                        'mAP', 'mAP_50', 'mAP_75', 'mAP_s', 'mAP_m', 'mAP_l'
-                    ]
-                for metric_item in metric_items:
-                    key = f'{metric}_{metric_item}'
-                    val = float(
-                        f'{cocoEval.stats[coco_metric_names[metric_item]]:.3f}'
-                    )
-                    eval_results[key] = val
-                ap = cocoEval.stats[:6]
-                eval_results[f'{metric}_mAP_copypaste'] = (
-                    f'{ap[0]:.3f} {ap[1]:.3f} {ap[2]:.3f} {ap[3]:.3f} '
-                    f'{ap[4]:.3f} {ap[5]:.3f}')
-        if tmp_dir is not None:
-            tmp_dir.cleanup()
-        return eval_results

spaces/CVPR/lama-example/saicinpainting/training/__init__.py DELETED Viewed

File without changes

spaces/CVPR/lama-example/saicinpainting/training/visualizers/colors.py DELETED Viewed

@@ -1,76 +0,0 @@
-import random
-import colorsys
-import numpy as np
-import matplotlib
-matplotlib.use('agg')
-import matplotlib.pyplot as plt
-from matplotlib.colors import LinearSegmentedColormap
-def generate_colors(nlabels, type='bright', first_color_black=False, last_color_black=True, verbose=False):
-    # https://stackoverflow.com/questions/14720331/how-to-generate-random-colors-in-matplotlib
-    """
-    Creates a random colormap to be used together with matplotlib. Useful for segmentation tasks
-    :param nlabels: Number of labels (size of colormap)
-    :param type: 'bright' for strong colors, 'soft' for pastel colors
-    :param first_color_black: Option to use first color as black, True or False
-    :param last_color_black: Option to use last color as black, True or False
-    :param verbose: Prints the number of labels and shows the colormap. True or False
-    :return: colormap for matplotlib
-    """
-    if type not in ('bright', 'soft'):
-        print ('Please choose "bright" or "soft" for type')
-        return
-    if verbose:
-        print('Number of labels: ' + str(nlabels))
-    # Generate color map for bright colors, based on hsv
-    if type == 'bright':
-        randHSVcolors = [(np.random.uniform(low=0.0, high=1),
-                          np.random.uniform(low=0.2, high=1),
-                          np.random.uniform(low=0.9, high=1)) for i in range(nlabels)]
-        # Convert HSV list to RGB
-        randRGBcolors = []
-        for HSVcolor in randHSVcolors:
-            randRGBcolors.append(colorsys.hsv_to_rgb(HSVcolor[0], HSVcolor[1], HSVcolor[2]))
-        if first_color_black:
-            randRGBcolors[0] = [0, 0, 0]
-        if last_color_black:
-            randRGBcolors[-1] = [0, 0, 0]
-        random_colormap = LinearSegmentedColormap.from_list('new_map', randRGBcolors, N=nlabels)
-    # Generate soft pastel colors, by limiting the RGB spectrum
-    if type == 'soft':
-        low = 0.6
-        high = 0.95
-        randRGBcolors = [(np.random.uniform(low=low, high=high),
-                          np.random.uniform(low=low, high=high),
-                          np.random.uniform(low=low, high=high)) for i in range(nlabels)]
-        if first_color_black:
-            randRGBcolors[0] = [0, 0, 0]
-        if last_color_black:
-            randRGBcolors[-1] = [0, 0, 0]
-        random_colormap = LinearSegmentedColormap.from_list('new_map', randRGBcolors, N=nlabels)
-    # Display colorbar
-    if verbose:
-        from matplotlib import colors, colorbar
-        from matplotlib import pyplot as plt
-        fig, ax = plt.subplots(1, 1, figsize=(15, 0.5))
-        bounds = np.linspace(0, nlabels, nlabels + 1)
-        norm = colors.BoundaryNorm(bounds, nlabels)
-        cb = colorbar.ColorbarBase(ax, cmap=random_colormap, norm=norm, spacing='proportional', ticks=None,
-                                   boundaries=bounds, format='%1i', orientation=u'horizontal')
-    return randRGBcolors, random_colormap

spaces/Caoyunkang/Segment-Any-Anomaly/GroundingDINO/groundingdino/util/utils.py DELETED Viewed

@@ -1,608 +0,0 @@
-import argparse
-import json
-import warnings
-from collections import OrderedDict
-from copy import deepcopy
-from typing import Any, Dict, List
-import numpy as np
-import torch
-from transformers import AutoTokenizer
-from groundingdino.util.slconfig import SLConfig
-def slprint(x, name="x"):
-    if isinstance(x, (torch.Tensor, np.ndarray)):
-        print(f"{name}.shape:", x.shape)
-    elif isinstance(x, (tuple, list)):
-        print("type x:", type(x))
-        for i in range(min(10, len(x))):
-            slprint(x[i], f"{name}[{i}]")
-    elif isinstance(x, dict):
-        for k, v in x.items():
-            slprint(v, f"{name}[{k}]")
-    else:
-        print(f"{name}.type:", type(x))
-def clean_state_dict(state_dict):
-    new_state_dict = OrderedDict()
-    for k, v in state_dict.items():
-        if k[:7] == "module.":
-            k = k[7:]  # remove `module.`
-        new_state_dict[k] = v
-    return new_state_dict
-def renorm(
-    img: torch.FloatTensor, mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]
-) -> torch.FloatTensor:
-    # img: tensor(3,H,W) or tensor(B,3,H,W)
-    # return: same as img
-    assert img.dim() == 3 or img.dim() == 4, "img.dim() should be 3 or 4 but %d" % img.dim()
-    if img.dim() == 3:
-        assert img.size(0) == 3, 'img.size(0) shoule be 3 but "%d". (%s)' % (
-            img.size(0),
-            str(img.size()),
-        )
-        img_perm = img.permute(1, 2, 0)
-        mean = torch.Tensor(mean)
-        std = torch.Tensor(std)
-        img_res = img_perm * std + mean
-        return img_res.permute(2, 0, 1)
-    else:  # img.dim() == 4
-        assert img.size(1) == 3, 'img.size(1) shoule be 3 but "%d". (%s)' % (
-            img.size(1),
-            str(img.size()),
-        )
-        img_perm = img.permute(0, 2, 3, 1)
-        mean = torch.Tensor(mean)
-        std = torch.Tensor(std)
-        img_res = img_perm * std + mean
-        return img_res.permute(0, 3, 1, 2)
-class CocoClassMapper:
-    def __init__(self) -> None:
-        self.category_map_str = {
-            "1": 1,
-            "2": 2,
-            "3": 3,
-            "4": 4,
-            "5": 5,
-            "6": 6,
-            "7": 7,
-            "8": 8,
-            "9": 9,
-            "10": 10,
-            "11": 11,
-            "13": 12,
-            "14": 13,
-            "15": 14,
-            "16": 15,
-            "17": 16,
-            "18": 17,
-            "19": 18,
-            "20": 19,
-            "21": 20,
-            "22": 21,
-            "23": 22,
-            "24": 23,
-            "25": 24,
-            "27": 25,
-            "28": 26,
-            "31": 27,
-            "32": 28,
-            "33": 29,
-            "34": 30,
-            "35": 31,
-            "36": 32,
-            "37": 33,
-            "38": 34,
-            "39": 35,
-            "40": 36,
-            "41": 37,
-            "42": 38,
-            "43": 39,
-            "44": 40,
-            "46": 41,
-            "47": 42,
-            "48": 43,
-            "49": 44,
-            "50": 45,
-            "51": 46,
-            "52": 47,
-            "53": 48,
-            "54": 49,
-            "55": 50,
-            "56": 51,
-            "57": 52,
-            "58": 53,
-            "59": 54,
-            "60": 55,
-            "61": 56,
-            "62": 57,
-            "63": 58,
-            "64": 59,
-            "65": 60,
-            "67": 61,
-            "70": 62,
-            "72": 63,
-            "73": 64,
-            "74": 65,
-            "75": 66,
-            "76": 67,
-            "77": 68,
-            "78": 69,
-            "79": 70,
-            "80": 71,
-            "81": 72,
-            "82": 73,
-            "84": 74,
-            "85": 75,
-            "86": 76,
-            "87": 77,
-            "88": 78,
-            "89": 79,
-            "90": 80,
-        }
-        self.origin2compact_mapper = {int(k): v - 1 for k, v in self.category_map_str.items()}
-        self.compact2origin_mapper = {int(v - 1): int(k) for k, v in self.category_map_str.items()}
-    def origin2compact(self, idx):
-        return self.origin2compact_mapper[int(idx)]
-    def compact2origin(self, idx):
-        return self.compact2origin_mapper[int(idx)]
-def to_device(item, device):
-    if isinstance(item, torch.Tensor):
-        return item.to(device)
-    elif isinstance(item, list):
-        return [to_device(i, device) for i in item]
-    elif isinstance(item, dict):
-        return {k: to_device(v, device) for k, v in item.items()}
-    else:
-        raise NotImplementedError(
-            "Call Shilong if you use other containers! type: {}".format(type(item))
-        )
-#
-def get_gaussian_mean(x, axis, other_axis, softmax=True):
-    """
-    Args:
-        x (float): Input images(BxCxHxW)
-        axis (int): The index for weighted mean
-        other_axis (int): The other index
-    Returns: weighted index for axis, BxC
-    """
-    mat2line = torch.sum(x, axis=other_axis)
-    # mat2line = mat2line / mat2line.mean() * 10
-    if softmax:
-        u = torch.softmax(mat2line, axis=2)
-    else:
-        u = mat2line / (mat2line.sum(2, keepdim=True) + 1e-6)
-    size = x.shape[axis]
-    ind = torch.linspace(0, 1, size).to(x.device)
-    batch = x.shape[0]
-    channel = x.shape[1]
-    index = ind.repeat([batch, channel, 1])
-    mean_position = torch.sum(index * u, dim=2)
-    return mean_position
-def get_expected_points_from_map(hm, softmax=True):
-    """get_gaussian_map_from_points
-        B,C,H,W -> B,N,2 float(0, 1) float(0, 1)
-        softargmax function
-    Args:
-        hm (float): Input images(BxCxHxW)
-    Returns:
-        weighted index for axis, BxCx2. float between 0 and 1.
-    """
-    # hm = 10*hm
-    B, C, H, W = hm.shape
-    y_mean = get_gaussian_mean(hm, 2, 3, softmax=softmax)  # B,C
-    x_mean = get_gaussian_mean(hm, 3, 2, softmax=softmax)  # B,C
-    # return torch.cat((x_mean.unsqueeze(-1), y_mean.unsqueeze(-1)), 2)
-    return torch.stack([x_mean, y_mean], dim=2)
-# Positional encoding (section 5.1)
-# borrow from nerf
-class Embedder:
-    def __init__(self, **kwargs):
-        self.kwargs = kwargs
-        self.create_embedding_fn()
-    def create_embedding_fn(self):
-        embed_fns = []
-        d = self.kwargs["input_dims"]
-        out_dim = 0
-        if self.kwargs["include_input"]:
-            embed_fns.append(lambda x: x)
-            out_dim += d
-        max_freq = self.kwargs["max_freq_log2"]
-        N_freqs = self.kwargs["num_freqs"]
-        if self.kwargs["log_sampling"]:
-            freq_bands = 2.0 ** torch.linspace(0.0, max_freq, steps=N_freqs)
-        else:
-            freq_bands = torch.linspace(2.0**0.0, 2.0**max_freq, steps=N_freqs)
-        for freq in freq_bands:
-            for p_fn in self.kwargs["periodic_fns"]:
-                embed_fns.append(lambda x, p_fn=p_fn, freq=freq: p_fn(x * freq))
-                out_dim += d
-        self.embed_fns = embed_fns
-        self.out_dim = out_dim
-    def embed(self, inputs):
-        return torch.cat([fn(inputs) for fn in self.embed_fns], -1)
-def get_embedder(multires, i=0):
-    import torch.nn as nn
-    if i == -1:
-        return nn.Identity(), 3
-    embed_kwargs = {
-        "include_input": True,
-        "input_dims": 3,
-        "max_freq_log2": multires - 1,
-        "num_freqs": multires,
-        "log_sampling": True,
-        "periodic_fns": [torch.sin, torch.cos],
-    }
-    embedder_obj = Embedder(**embed_kwargs)
-    embed = lambda x, eo=embedder_obj: eo.embed(x)
-    return embed, embedder_obj.out_dim
-class APOPMeter:
-    def __init__(self) -> None:
-        self.tp = 0
-        self.fp = 0
-        self.tn = 0
-        self.fn = 0
-    def update(self, pred, gt):
-        """
-        Input:
-            pred, gt: Tensor()
-        """
-        assert pred.shape == gt.shape
-        self.tp += torch.logical_and(pred == 1, gt == 1).sum().item()
-        self.fp += torch.logical_and(pred == 1, gt == 0).sum().item()
-        self.tn += torch.logical_and(pred == 0, gt == 0).sum().item()
-        self.tn += torch.logical_and(pred == 1, gt == 0).sum().item()
-    def update_cm(self, tp, fp, tn, fn):
-        self.tp += tp
-        self.fp += fp
-        self.tn += tn
-        self.tn += fn
-def inverse_sigmoid(x, eps=1e-5):
-    x = x.clamp(min=0, max=1)
-    x1 = x.clamp(min=eps)
-    x2 = (1 - x).clamp(min=eps)
-    return torch.log(x1 / x2)
-def get_raw_dict(args):
-    """
-    return the dicf contained in args.
-    e.g:
-        >>> with open(path, 'w') as f:
-                json.dump(get_raw_dict(args), f, indent=2)
-    """
-    if isinstance(args, argparse.Namespace):
-        return vars(args)
-    elif isinstance(args, dict):
-        return args
-    elif isinstance(args, SLConfig):
-        return args._cfg_dict
-    else:
-        raise NotImplementedError("Unknown type {}".format(type(args)))
-def stat_tensors(tensor):
-    assert tensor.dim() == 1
-    tensor_sm = tensor.softmax(0)
-    entropy = (tensor_sm * torch.log(tensor_sm + 1e-9)).sum()
-    return {
-        "max": tensor.max(),
-        "min": tensor.min(),
-        "mean": tensor.mean(),
-        "var": tensor.var(),
-        "std": tensor.var() ** 0.5,
-        "entropy": entropy,
-    }
-class NiceRepr:
-    """Inherit from this class and define ``__nice__`` to "nicely" print your
-    objects.
-    Defines ``__str__`` and ``__repr__`` in terms of ``__nice__`` function
-    Classes that inherit from :class:`NiceRepr` should redefine ``__nice__``.
-    If the inheriting class has a ``__len__``, method then the default
-    ``__nice__`` method will return its length.
-    Example:
-        >>> class Foo(NiceRepr):
-        ...    def __nice__(self):
-        ...        return 'info'
-        >>> foo = Foo()
-        >>> assert str(foo) == '<Foo(info)>'
-        >>> assert repr(foo).startswith('<Foo(info) at ')
-    Example:
-        >>> class Bar(NiceRepr):
-        ...    pass
-        >>> bar = Bar()
-        >>> import pytest
-        >>> with pytest.warns(None) as record:
-        >>>     assert 'object at' in str(bar)
-        >>>     assert 'object at' in repr(bar)
-    Example:
-        >>> class Baz(NiceRepr):
-        ...    def __len__(self):
-        ...        return 5
-        >>> baz = Baz()
-        >>> assert str(baz) == '<Baz(5)>'
-    """
-    def __nice__(self):
-        """str: a "nice" summary string describing this module"""
-        if hasattr(self, "__len__"):
-            # It is a common pattern for objects to use __len__ in __nice__
-            # As a convenience we define a default __nice__ for these objects
-            return str(len(self))
-        else:
-            # In all other cases force the subclass to overload __nice__
-            raise NotImplementedError(f"Define the __nice__ method for {self.__class__!r}")
-    def __repr__(self):
-        """str: the string of the module"""
-        try:
-            nice = self.__nice__()
-            classname = self.__class__.__name__
-            return f"<{classname}({nice}) at {hex(id(self))}>"
-        except NotImplementedError as ex:
-            warnings.warn(str(ex), category=RuntimeWarning)
-            return object.__repr__(self)
-    def __str__(self):
-        """str: the string of the module"""
-        try:
-            classname = self.__class__.__name__
-            nice = self.__nice__()
-            return f"<{classname}({nice})>"
-        except NotImplementedError as ex:
-            warnings.warn(str(ex), category=RuntimeWarning)
-            return object.__repr__(self)
-def ensure_rng(rng=None):
-    """Coerces input into a random number generator.
-    If the input is None, then a global random state is returned.
-    If the input is a numeric value, then that is used as a seed to construct a
-    random state. Otherwise the input is returned as-is.
-    Adapted from [1]_.
-    Args:
-        rng (int | numpy.random.RandomState | None):
-            if None, then defaults to the global rng. Otherwise this can be an
-            integer or a RandomState class
-    Returns:
-        (numpy.random.RandomState) : rng -
-            a numpy random number generator
-    References:
-        .. [1] https://gitlab.kitware.com/computer-vision/kwarray/blob/master/kwarray/util_random.py#L270  # noqa: E501
-    """
-    if rng is None:
-        rng = np.random.mtrand._rand
-    elif isinstance(rng, int):
-        rng = np.random.RandomState(rng)
-    else:
-        rng = rng
-    return rng
-def random_boxes(num=1, scale=1, rng=None):
-    """Simple version of ``kwimage.Boxes.random``
-    Returns:
-        Tensor: shape (n, 4) in x1, y1, x2, y2 format.
-    References:
-        https://gitlab.kitware.com/computer-vision/kwimage/blob/master/kwimage/structs/boxes.py#L1390
-    Example:
-        >>> num = 3
-        >>> scale = 512
-        >>> rng = 0
-        >>> boxes = random_boxes(num, scale, rng)
-        >>> print(boxes)
-        tensor([[280.9925, 278.9802, 308.6148, 366.1769],
-                [216.9113, 330.6978, 224.0446, 456.5878],
-                [405.3632, 196.3221, 493.3953, 270.7942]])
-    """
-    rng = ensure_rng(rng)
-    tlbr = rng.rand(num, 4).astype(np.float32)
-    tl_x = np.minimum(tlbr[:, 0], tlbr[:, 2])
-    tl_y = np.minimum(tlbr[:, 1], tlbr[:, 3])
-    br_x = np.maximum(tlbr[:, 0], tlbr[:, 2])
-    br_y = np.maximum(tlbr[:, 1], tlbr[:, 3])
-    tlbr[:, 0] = tl_x * scale
-    tlbr[:, 1] = tl_y * scale
-    tlbr[:, 2] = br_x * scale
-    tlbr[:, 3] = br_y * scale
-    boxes = torch.from_numpy(tlbr)
-    return boxes
-class ModelEma(torch.nn.Module):
-    def __init__(self, model, decay=0.9997, device=None):
-        super(ModelEma, self).__init__()
-        # make a copy of the model for accumulating moving average of weights
-        self.module = deepcopy(model)
-        self.module.eval()
-        # import ipdb; ipdb.set_trace()
-        self.decay = decay
-        self.device = device  # perform ema on different device from model if set
-        if self.device is not None:
-            self.module.to(device=device)
-    def _update(self, model, update_fn):
-        with torch.no_grad():
-            for ema_v, model_v in zip(
-                self.module.state_dict().values(), model.state_dict().values()
-            ):
-                if self.device is not None:
-                    model_v = model_v.to(device=self.device)
-                ema_v.copy_(update_fn(ema_v, model_v))
-    def update(self, model):
-        self._update(model, update_fn=lambda e, m: self.decay * e + (1.0 - self.decay) * m)
-    def set(self, model):
-        self._update(model, update_fn=lambda e, m: m)
-class BestMetricSingle:
-    def __init__(self, init_res=0.0, better="large") -> None:
-        self.init_res = init_res
-        self.best_res = init_res
-        self.best_ep = -1
-        self.better = better
-        assert better in ["large", "small"]
-    def isbetter(self, new_res, old_res):
-        if self.better == "large":
-            return new_res > old_res
-        if self.better == "small":
-            return new_res < old_res
-    def update(self, new_res, ep):
-        if self.isbetter(new_res, self.best_res):
-            self.best_res = new_res
-            self.best_ep = ep
-            return True
-        return False
-    def __str__(self) -> str:
-        return "best_res: {}\t best_ep: {}".format(self.best_res, self.best_ep)
-    def __repr__(self) -> str:
-        return self.__str__()
-    def summary(self) -> dict:
-        return {
-            "best_res": self.best_res,
-            "best_ep": self.best_ep,
-        }
-class BestMetricHolder:
-    def __init__(self, init_res=0.0, better="large", use_ema=False) -> None:
-        self.best_all = BestMetricSingle(init_res, better)
-        self.use_ema = use_ema
-        if use_ema:
-            self.best_ema = BestMetricSingle(init_res, better)
-            self.best_regular = BestMetricSingle(init_res, better)
-    def update(self, new_res, epoch, is_ema=False):
-        """
-        return if the results is the best.
-        """
-        if not self.use_ema:
-            return self.best_all.update(new_res, epoch)
-        else:
-            if is_ema:
-                self.best_ema.update(new_res, epoch)
-                return self.best_all.update(new_res, epoch)
-            else:
-                self.best_regular.update(new_res, epoch)
-                return self.best_all.update(new_res, epoch)
-    def summary(self):
-        if not self.use_ema:
-            return self.best_all.summary()
-        res = {}
-        res.update({f"all_{k}": v for k, v in self.best_all.summary().items()})
-        res.update({f"regular_{k}": v for k, v in self.best_regular.summary().items()})
-        res.update({f"ema_{k}": v for k, v in self.best_ema.summary().items()})
-        return res
-    def __repr__(self) -> str:
-        return json.dumps(self.summary(), indent=2)
-    def __str__(self) -> str:
-        return self.__repr__()
-def targets_to(targets: List[Dict[str, Any]], device):
-    """Moves the target dicts to the given device."""
-    excluded_keys = [
-        "questionId",
-        "tokens_positive",
-        "strings_positive",
-        "tokens",
-        "dataset_name",
-        "sentence_id",
-        "original_img_id",
-        "nb_eval",
-        "task_id",
-        "original_id",
-        "token_span",
-        "caption",
-        "dataset_type",
-    ]
-    return [
-        {k: v.to(device) if k not in excluded_keys else v for k, v in t.items()} for t in targets
-    ]
-def get_phrases_from_posmap(
-    posmap: torch.BoolTensor, tokenized: Dict, tokenizer: AutoTokenizer
-)->str:
-    assert isinstance(posmap, torch.Tensor), "posmap must be torch.Tensor"
-    if posmap.dim() == 1:
-        non_zero_idx = posmap.nonzero(as_tuple=True)[0].tolist()
-        token_ids = [tokenized["input_ids"][i] for i in non_zero_idx]
-        return tokenizer.decode(token_ids)
-    else:
-        raise NotImplementedError("posmap must be 1-dim")

spaces/ChandraMohanNayal/AutoGPT/ui/api.py DELETED Viewed

@@ -1,146 +0,0 @@
-import os, sys
-import utils
-import uuid
-import json
-import subprocess, threading
-FILE_DIR = os.path.dirname(os.path.abspath(__file__))
-REPO_DIR = os.path.dirname(FILE_DIR)
-STATE_DIR = os.path.join(FILE_DIR, "state")
-sys.path.append(REPO_DIR)
-if not os.path.exists(STATE_DIR):
-    os.mkdir(STATE_DIR)
-import time
-def get_openai_api_key():
-    return os.getenv("OPENAI_API_KEY")
-running_apis = []
-def get_state(state_file):
-    with open(state_file, "r") as f:
-        state = json.load(f)
-    return state
-def set_state(state_file, state):
-    with open(state_file, "w") as f:
-        json.dump(state, f)
-class AutoAPI:
-    def __init__(self, openai_key, ai_name, ai_role, top_5_goals):
-        self.openai_key = openai_key
-        hex = uuid.uuid4().hex
-        print(hex)
-        self.state_file = os.path.join(STATE_DIR, f"state_{hex}.json")
-        self.log_file = os.path.join(STATE_DIR, f"log_{hex}.json")
-        newline = "\n"
-        with open(os.path.join(REPO_DIR, "ai_settings.yaml"), "w") as f:
-            f.write(
-                f"""ai_goals:
-{newline.join([f'- {goal[0]}' for goal in top_5_goals if goal[0]])}
-ai_name: {ai_name}
-ai_role: {ai_role}
-"""
-            )
-        state = {
-            "pending_input": None,
-            "awaiting_input": False,
-            "messages": [],
-            "last_message_read_index": -1,
-        }
-        set_state(self.state_file, state)
-        with open(self.log_file, "w") as f:
-            subprocess.Popen(
-                [
-                    "python",
-                    os.path.join(REPO_DIR, "ui", "api.py"),
-                    openai_key,
-                    self.state_file,
-                ],
-                cwd=REPO_DIR,
-                stdout=f,
-                stderr=f,
-            )
-    def send_message(self, message="Y"):
-        state = get_state(self.state_file)
-        state["pending_input"] = message
-        state["awaiting_input"] = False
-        set_state(self.state_file, state)
-    def get_chatbot_response(self):
-        while True:
-            state = get_state(self.state_file)
-            if (
-                state["awaiting_input"]
-                and state["last_message_read_index"] >= len(state["messages"]) - 1
-            ):
-                break
-            if state["last_message_read_index"] >= len(state["messages"]) - 1:
-                time.sleep(1)
-            else:
-                state["last_message_read_index"] += 1
-                title, content = state["messages"][state["last_message_read_index"]]
-                yield (f"**{title.strip()}** " if title else "") + utils.remove_color(
-                    content
-                ).replace("\n", "<br />")
-                set_state(self.state_file, state)
-if __name__ == "__main__":
-    print(sys.argv)
-    _, openai_key, state_file = sys.argv
-    os.environ["OPENAI_API_KEY"] = openai_key
-    import autogpt.config.config
-    from autogpt.logs import logger
-    from autogpt.cli import main
-    import autogpt.utils
-    from autogpt.spinner import Spinner
-    def add_message(title, content):
-        state = get_state(state_file)
-        state["messages"].append((title, content))
-        set_state(state_file, state)
-    def typewriter_log(title="", title_color="", content="", *args, **kwargs):
-        add_message(title, content)
-    def warn(message, title="", *args, **kwargs):
-        add_message(title, message)
-    def error(title, message="", *args, **kwargs):
-        add_message(title, message)
-    def clean_input(prompt=""):
-        add_message(None, prompt)
-        state = get_state(state_file)
-        state["awaiting_input"] = True
-        set_state(state_file, state)
-        while state["pending_input"] is None:
-            state = get_state(state_file)
-            print("Waiting for input...")
-            time.sleep(1)
-        print("Got input")
-        pending_input = state["pending_input"]
-        state["pending_input"] = None
-        set_state(state_file, state)
-        return pending_input
-    def spinner_start():
-        add_message(None, "Thinking...")
-    logger.typewriter_log = typewriter_log
-    logger.warn = warn
-    logger.error = error
-    autogpt.utils.clean_input = clean_input
-    Spinner.spin = spinner_start
-    sys.argv = sys.argv[:1]
-    main()

spaces/Chintan-Donda/KKMS-KSSW-HF/src/mandi_price.py DELETED Viewed

@@ -1,33 +0,0 @@
-import requests
-class MANDI_PRICE:
-    def __init__(self):
-        self.base_url = "https://enam.gov.in/web/Ajax_ctrl/trade_data_list"
-        # "https://enam.gov.in/web/dashboard/trade-data",
-        # "https://enam.gov.in/web/dashboard/trade_data_list",
-    def get_mandi_price(self,
-        state_name,
-        apmc_name,
-        commodity_name,
-        from_date,
-        to_date
-    ):
-        # Prepare the payload for POST request
-        payload = f"language=en&stateName={state_name}&apmcName={apmc_name}&commodityName={commodity_name}&fromDate={from_date}&toDate={to_date}"
-        headers = {
-            "Content-type": "application/x-www-form-urlencoded; charset=UTF-8",
-            "Referer": "https://enam.gov.in/web/dashboard/trade-data",
-            "Accept": "application/json, text/javascript, */*; q=0.01",
-        }
-        response = requests.post(
-            self.base_url,
-            json=payload,
-            headers=headers,
-        )
-        return response.json()