Update parquet files (step 97 of 121)

spaces/0x90e/ESRGAN-MANGA/ESRGANer.py

@@ -1,156 +0,0 @@
-from PIL import Image, ImageChops
-import numpy as np
-import cv2 as cv
-import math
-import torch
-from torch.nn import functional as F
-
-"""
-Borrowed and adapted from https://github.com/xinntao/Real-ESRGAN/blob/master/realesrgan/utils.py
-Thank you xinntao! 
-"""
-class ESRGANer():
-    """A helper class for upsampling images with ESRGAN.
-
-    Args:
-        scale (int): Upsampling scale factor used in the networks. It is usually 2 or 4.
-        model (nn.Module): The defined network. Default: None.
-        tile (int): As too large images result in the out of GPU memory issue, so this tile option will first crop
-            input images into tiles, and then process each of them. Finally, they will be merged into one image.
-            0 denotes for do not use tile. Default: 500.
-        tile_pad (int): The pad size for each tile, to remove border artifacts. Default: 10.
-        pre_pad (int): Pad the input images to avoid border artifacts. Default: 10.
-    """
-
-    def __init__(self,
-                 scale=4,
-                 model=None,
-                 tile=300,
-                 tile_pad=10,
-                 pre_pad=10
-        ):
-        self.scale = scale
-        self.tile_size = tile
-        self.tile_pad = tile_pad
-        self.pre_pad = pre_pad
-        self.mod_scale = None
-
-        self.model = model
-
-    def pre_process(self, img):
-        """Pre-process, such as pre-pad and mod pad, so that the images can be divisible
-        """
-        self.img = img
-
-        # pre_pad
-        if self.pre_pad != 0:
-            self.img = F.pad(self.img, (0, self.pre_pad, 0, self.pre_pad), 'reflect')
-        # mod pad for divisible borders
-        if self.scale == 2:
-            self.mod_scale = 2
-        elif self.scale == 1:
-            self.mod_scale = 4
-        if self.mod_scale is not None:
-            self.mod_pad_h, self.mod_pad_w = 0, 0
-            _, _, h, w = self.img.size()
-            if (h % self.mod_scale != 0):
-                self.mod_pad_h = (self.mod_scale - h % self.mod_scale)
-            if (w % self.mod_scale != 0):
-                self.mod_pad_w = (self.mod_scale - w % self.mod_scale)
-            self.img = F.pad(self.img, (0, self.mod_pad_w, 0, self.mod_pad_h), 'reflect')
-
-    def process(self):
-        # model inference
-        self.output = self.model(self.img)
-
-    def tile_process(self):
-        """It will first crop input images to tiles, and then process each tile.
-        Finally, all the processed tiles are merged into one images.
-
-        Modified from: https://github.com/ata4/esrgan-launcher
-        """
-        batch, channel, height, width = self.img.shape
-        output_height = height * self.scale
-        output_width = width * self.scale
-        output_shape = (batch, channel, output_height, output_width)
-
-        # start with black image
-        self.output = self.img.new_zeros(output_shape)
-        tiles_x = math.ceil(width / self.tile_size)
-        tiles_y = math.ceil(height / self.tile_size)
-
-        print("Image processing started...")
-
-        # loop over all tiles
-        for y in range(tiles_y):
-            for x in range(tiles_x):
-                # extract tile from input image
-                ofs_x = x * self.tile_size
-                ofs_y = y * self.tile_size
-                # input tile area on total image
-                input_start_x = ofs_x
-                input_end_x = min(ofs_x + self.tile_size, width)
-                input_start_y = ofs_y
-                input_end_y = min(ofs_y + self.tile_size, height)
-
-                # input tile area on total image with padding
-                input_start_x_pad = max(input_start_x - self.tile_pad, 0)
-                input_end_x_pad = min(input_end_x + self.tile_pad, width)
-                input_start_y_pad = max(input_start_y - self.tile_pad, 0)
-                input_end_y_pad = min(input_end_y + self.tile_pad, height)
-
-                # input tile dimensions
-                input_tile_width = input_end_x - input_start_x
-                input_tile_height = input_end_y - input_start_y
-                tile_idx = y * tiles_x + x + 1
-                input_tile = self.img[:, :, input_start_y_pad:input_end_y_pad, input_start_x_pad:input_end_x_pad]
-
-                # upscale tile
-                try:
-                    with torch.no_grad():
-                        output_tile = self.model(input_tile)
-                except RuntimeError as error:
-                    print('Error', error)
-                print(f'Processing tile {tile_idx}/{tiles_x * tiles_y}')
-
-                # output tile area on total image
-                output_start_x = input_start_x * self.scale
-                output_end_x = input_end_x * self.scale
-                output_start_y = input_start_y * self.scale
-                output_end_y = input_end_y * self.scale
-
-                # output tile area without padding
-                output_start_x_tile = (input_start_x - input_start_x_pad) * self.scale
-                output_end_x_tile = output_start_x_tile + input_tile_width * self.scale
-                output_start_y_tile = (input_start_y - input_start_y_pad) * self.scale
-                output_end_y_tile = output_start_y_tile + input_tile_height * self.scale
-
-                # put tile into output image
-                self.output[:, :, output_start_y:output_end_y,
-                            output_start_x:output_end_x] = output_tile[:, :, output_start_y_tile:output_end_y_tile,
-                                                                       output_start_x_tile:output_end_x_tile]
-
-        print('All tiles processed, saving output image!')
-
-    def post_process(self):
-        # remove extra pad
-        if self.mod_scale is not None:
-            _, _, h, w = self.output.size()
-            self.output = self.output[:, :, 0:h - self.mod_pad_h * self.scale, 0:w - self.mod_pad_w * self.scale]
-        # remove prepad
-        if self.pre_pad != 0:
-            _, _, h, w = self.output.size()
-            self.output = self.output[:, :, 0:h - self.pre_pad * self.scale, 0:w - self.pre_pad * self.scale]
-        return self.output
-    
-    @torch.no_grad()
-    def enhance(self, img):
-        self.pre_process(img)
-
-        if self.tile_size > 0:
-            self.tile_process()
-        else:
-            self.process()
-        output_img = self.post_process()
-
-        return output_img

spaces/123aa/pastel-mix/app.py

@@ -1,137 +0,0 @@
-from diffusers import StableDiffusionPipeline, StableDiffusionImg2ImgPipeline, DPMSolverMultistepScheduler
-import gradio as gr
-import torch
-from PIL import Image
-
-model_id = 'andite/pastel-mix'
-prefix = ''
-     
-scheduler = DPMSolverMultistepScheduler.from_pretrained(model_id, subfolder="scheduler")
-
-pipe = StableDiffusionPipeline.from_pretrained(
-  model_id,
-  torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
-  scheduler=scheduler)
-
-pipe_i2i = StableDiffusionImg2ImgPipeline.from_pretrained(
-  model_id,
-  torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
-  scheduler=scheduler)
-
-if torch.cuda.is_available():
-  pipe = pipe.to("cuda")
-  pipe_i2i = pipe_i2i.to("cuda")
-
-def error_str(error, title="Error"):
-    return f"""#### {title}
-            {error}"""  if error else ""
-
-def inference(prompt, guidance, steps, width=512, height=512, seed=0, img=None, strength=0.5, neg_prompt="", auto_prefix=False):
-
-  generator = torch.Generator('cuda').manual_seed(seed) if seed != 0 else None
-  prompt = f"{prefix} {prompt}" if auto_prefix else prompt
-
-  try:
-    if img is not None:
-      return img_to_img(prompt, neg_prompt, img, strength, guidance, steps, width, height, generator), None
-    else:
-      return txt_to_img(prompt, neg_prompt, guidance, steps, width, height, generator), None
-  except Exception as e:
-    return None, error_str(e)
-
-def txt_to_img(prompt, neg_prompt, guidance, steps, width, height, generator):
-
-    result = pipe(
-      prompt,
-      negative_prompt = neg_prompt,
-      num_inference_steps = int(steps),
-      guidance_scale = guidance,
-      width = width,
-      height = height,
-      generator = generator)
-    
-    return result.images[0]
-
-def img_to_img(prompt, neg_prompt, img, strength, guidance, steps, width, height, generator):
-
-    ratio = min(height / img.height, width / img.width)
-    img = img.resize((int(img.width * ratio), int(img.height * ratio)), Image.LANCZOS)
-    result = pipe_i2i(
-        prompt,
-        negative_prompt = neg_prompt,
-        init_image = img,
-        num_inference_steps = int(steps),
-        strength = strength,
-        guidance_scale = guidance,
-        width = width,
-        height = height,
-        generator = generator)
-        
-    return result.images[0]
-
-css = """.main-div div{display:inline-flex;align-items:center;gap:.8rem;font-size:1.75rem}.main-div div h1{font-weight:900;margin-bottom:7px}.main-div p{margin-bottom:10px;font-size:94%}a{text-decoration:underline}.tabs{margin-top:0;margin-bottom:0}#gallery{min-height:20rem}
-"""
-with gr.Blocks(css=css) as demo:
-    gr.HTML(
-        f"""
-            <div class="main-div">
-              <div>
-                <h1>Pastel Mix</h1>
-              </div>
-              <p>
-               Demo for <a href="https://huggingface.co/andite/pastel-mix">Pastel Mix</a> Stable Diffusion model.<br>
-               {"Add the following tokens to your prompts for the model to work properly: <b>prefix</b>" if prefix else ""}
-              </p>
-              Running on {"<b>GPU 🔥</b>" if torch.cuda.is_available() else f"<b>CPU 🥶</b>. For faster inference it is recommended to <b>upgrade to GPU in <a href='https://huggingface.co/spaces/akhaliq/pastel-mix/settings'>Settings</a></b>"} after duplicating the space<br><br>
-              <a style="display:inline-block" href="https://huggingface.co/spaces/akhaliq/pastel-mix?duplicate=true"><img src="https://bit.ly/3gLdBN6" alt="Duplicate Space"></a>
-            </div>
-        """
-    )
-    with gr.Row():
-        
-        with gr.Column(scale=55):
-          with gr.Group():
-              with gr.Row():
-                prompt = gr.Textbox(label="Prompt", show_label=False, max_lines=2,placeholder=f"{prefix} [your prompt]").style(container=False)
-                generate = gr.Button(value="Generate").style(rounded=(False, True, True, False))
-
-              image_out = gr.Image(height=512)
-          error_output = gr.Markdown()
-
-        with gr.Column(scale=45):
-          with gr.Tab("Options"):
-            with gr.Group():
-              neg_prompt = gr.Textbox(label="Negative prompt", placeholder="What to exclude from the image")
-              auto_prefix = gr.Checkbox(label="Prefix styling tokens automatically ()", value=prefix, visible=prefix)
-
-              with gr.Row():
-                guidance = gr.Slider(label="Guidance scale", value=7.5, maximum=15)
-                steps = gr.Slider(label="Steps", value=25, minimum=2, maximum=75, step=1)
-
-              with gr.Row():
-                width = gr.Slider(label="Width", value=512, minimum=64, maximum=1024, step=8)
-                height = gr.Slider(label="Height", value=512, minimum=64, maximum=1024, step=8)
-
-              seed = gr.Slider(0, 2147483647, label='Seed (0 = random)', value=0, step=1)
-
-          with gr.Tab("Image to image"):
-              with gr.Group():
-                image = gr.Image(label="Image", height=256, tool="editor", type="pil")
-                strength = gr.Slider(label="Transformation strength", minimum=0, maximum=1, step=0.01, value=0.5)
-
-    auto_prefix.change(lambda x: gr.update(placeholder=f"{prefix} [your prompt]" if x else "[Your prompt]"), inputs=auto_prefix, outputs=prompt, queue=False)
-
-    inputs = [prompt, guidance, steps, width, height, seed, image, strength, neg_prompt, auto_prefix]
-    outputs = [image_out, error_output]
-    prompt.submit(inference, inputs=inputs, outputs=outputs)
-    generate.click(inference, inputs=inputs, outputs=outputs)
-
-    gr.HTML("""
-    <div style="border-top: 1px solid #303030;">
-      <br>
-      <p>This space was created using <a href="https://huggingface.co/spaces/anzorq/sd-space-creator">SD Space Creator</a>.</p>
-    </div>
-    """)
-
-demo.queue(concurrency_count=1)
-demo.launch()

spaces/1acneusushi/gradio-2dmoleculeeditor/data/ACDSee Photo Studio Ultimate 2020 v13.0.1 Build 2023 Crack [Latest] Features and Benefits.md

@@ -1,80 +0,0 @@
-
-<h1>ACDSee Photo Studio Ultimate 2020 v13.0.1 Build 2023 Crack [Latest]: A Comprehensive Review</h1>
-<p>If you are looking for a powerful and versatile photo editing software that can handle all your creative needs, you might want to check out <strong>ACDSee Photo Studio Ultimate 2020</strong>. This software is not only a digital asset manager and a RAW editor with layers, but also a full-featured photo editor that offers a wide range of tools and features to help you create stunning images.</p>
-<h2>ACDSee Photo Studio Ultimate 2020 v13.0.1 Build 2023 Crack [Latest]</h2><br /><p><b><b>Download Zip</b> &#10004;&#10004;&#10004; <a href="https://byltly.com/2uKvQl">https://byltly.com/2uKvQl</a></b></p><br /><br />
-<p>In this article, we will review <strong>ACDSee Photo Studio Ultimate 2020</strong> in detail and show you what it can do for you. We will cover its main features, benefits, drawbacks, and how to get it for free with a crack. By the end of this article, you will have a clear idea of whether <strong>ACDSee Photo Studio Ultimate 2020</strong> is the right software for you or not.</p>
- <h2>Introduction: What is ACDSee Photo Studio Ultimate 2020 and why you need it</h2>
-<p><strong>ACDSee Photo Studio Ultimate 2020</strong> is a software developed by <a href="https://www.acdsee.com/en/index/">ACD Systems</a>, a company that has been in the business of digital imaging since 1994. It is the latest version of their flagship product, which combines several functions into one package.</p>
-<p><strong>ACDSee Photo Studio Ultimate 2020</strong> is designed to answer your creative graphic and photography needs. It allows you to manage your photos from import to export, edit them with layers and filters, enhance them with adjustments and effects, organize them by faces and keywords, and share them online or offline.</p>
-<p><strong>ACDSee Photo Studio Ultimate 2020</strong> is suitable for both beginners and professionals who want a fast and flexible solution for their photo editing projects. It supports over 500 camera models and formats, including RAW files. It also works seamlessly with other software like Photoshop and Lightroom.</p>
-<p>In this article, we will explore <strong>ACDSee Photo Studio Ultimate 2020</strong>'s features in depth and show you how they can help you improve your workflow and creativity.</p>
- <h2>Features: What are the main features of ACDSee Photo Studio Ultimate 2020 and how they can help you with your photo editing needs</h2>
-<p><strong>ACDSee Photo Studio Ultimate 2020</strong> has many features that make it stand out from other photo editing software. Here are some of the most important ones:</p>
- <h3>Face Detection & Facial Recognition</h3>
-<p>One of the most impressive features of <strong>ACDSee Photo Studio Ultimate 2020</strong> is its face detection and facial recognition tool. This tool allows you to find and name the people in your photos automatically. You can also search your photos by unnamed, auto-named, or suggested names.</p>
-<p>ACDSee Photo Studio Ultimate 2020 full version offline installer<br />
-ACDSee Photo Studio Ultimate 2020 with facial recognition tool<br />
-ACDSee Photo Studio Ultimate 2020 free download with crack<br />
-ACDSee Photo Studio Ultimate 2020 color wheel feature<br />
-ACDSee Photo Studio Ultimate 2020 review and tutorial<br />
-ACDSee Photo Studio Ultimate 2020 vs Photoshop<br />
-ACDSee Photo Studio Ultimate 2020 system requirements and technical details<br />
-ACDSee Photo Studio Ultimate 2020 best price and discount<br />
-ACDSee Photo Studio Ultimate 2020 layered photo editor<br />
-ACDSee Photo Studio Ultimate 2020 RAW editor with layers<br />
-ACDSee Photo Studio Ultimate 2020 digital asset manager<br />
-ACDSee Photo Studio Ultimate 2020 non-destructive photo editing<br />
-ACDSee Photo Studio Ultimate 2020 develop mode and presets<br />
-ACDSee Photo Studio Ultimate 2020 import face data from Lightroom and Picasa<br />
-ACDSee Photo Studio Ultimate 2020 support for GoPro.GPR file format<br />
-How to install and activate ACDSee Photo Studio Ultimate 2020 with crack<br />
-How to use ACDSee Photo Studio Ultimate 2020 for creative graphic and image composition<br />
-How to optimize your workflow with ACDSee Photo Studio Ultimate 2020<br />
-How to create stunning photo manipulations with ACDSee Photo Studio Ultimate 2020<br />
-How to organize and manage your photos with ACDSee Photo Studio Ultimate 2020<br />
-How to enhance your photos with ACDSee Photo Studio Ultimate 2020 adjustment layers<br />
-How to apply filters and effects with ACDSee Photo Studio Ultimate 2020<br />
-How to edit RAW images with ACDSee Photo Studio Ultimate 2020<br />
-How to use the color wheel in ACDSee Photo Studio Ultimate 2020<br />
-How to find and name faces in your photos with ACDSee Photo Studio Ultimate 2020<br />
-How to compare ACDSee Photo Studio Ultimate 2020 with other photo editing software<br />
-How to get the latest updates and features of ACDSee Photo Studio Ultimate 2020<br />
-How to troubleshoot common issues with ACDSee Photo Studio Ultimate 2020<br />
-How to backup and restore your photos with ACDSee Photo Studio Ultimate 2020<br />
-How to share your photos online with ACDSee Photo Studio Ultimate 2020</p>
-<p>This feature is very useful for organizing your photos by person or family member. You can also create smart collections based on faces or use face data as metadata for sorting or filtering. You can also edit faces individually or in batches with tools like skin tune, red-eye removal, blemish removal, teeth whitening, etc.</p>
- <h3>HDR & Focus Stacking</h3>
-<p>If you want to create stunning images with high dynamic range and depth of field,<strong>ACDSee Photo Studio Ultimate 2020</strong>'s HDR and focus stacking tools are perfect for you. These tools allow you to combine multiple images with different exposures or focal distances into one image with maximum detail in shadows and highlights.</p>
-<p>The HDR tool lets you merge a series of images with different exposures into one image that captures the full range of light in your scene. You can also adjust parameters like brightness, contrast, saturation, tone curve, etc. to fine-tune your HDR image.</p>
-<p>The focus stacking tool lets you merge a series of images with different focal distances into one image that has a greater depth of field than a single exposure would allow. You can also adjust parameters like alignment, blending mode, radius, etc. to fine-tune your focus stacked image.</p>
- <h3>Layered Editing</h3>
-<p>If you want to create complex compositions and manipulations,<strong>ACDSee Photo Studio Ultimate 2020</strong>'s layered editing feature is ideal for you. This feature allows you to use layers, masks, filters, and effects to edit your images non-destructively.</p>
-<p>You can add as many layers as you want to your image and apply any edit mode filter or adjustment to each layer individually. You can also blend layers with different modes like normal, multiply, screen, overlay, etc. You can also use masks to control which parts of your image are affected by each layer.</p>
-<p>You can also use text layers to add captions, titles, or watermarks to your image. You can customize font, size, color, style, justification, opacity, and more for each text layer. You can also add effects like inner glow, shadows, bevel, outline, or blur to your text layers.</p>
- <h3>Digital Asset Management</h3>
-<p>If you want to manage, sort, tag, and search your photos efficiently,<strong>ACDSee Photo Studio Ultimate 2020</strong>'s digital asset management feature is essential for you. This feature allows you to import, export, browse, organize, and backup your photos easily.</p>
-```html issues, learning curve, bugs, and updates.</i></p>
- <li><b>How to get ACDSee Photo Studio Ultimate 2020 for free with a crack?</b></li>
-<p><i>A: To get ACDSee Photo Studio Ultimate 2020 for free with a crack, you need to download the software from a reliable source and apply the crack file to activate the full version of the software. You can follow these steps:</i></p>
-<ol>
-<li><i>Download ACDSee Photo Studio Ultimate 2020 v13.0.1 Build 2023 Crack [Latest] from the link below.</i></li>
-<li><i>Extract the downloaded file with WinRAR or any other file extractor.</i></li>
-<li><i>Run the setup file and follow the installation instructions.</i></li>
-<li><i>Do not run the software after installation.</i></li>
-<li><i>Copy the crack file from the crack folder and paste it into the installation directory of the software.</i></li>
-<li><i>Run the software and enjoy the full version of ACDSee Photo Studio Ultimate 2020 for free.</i></li>
-</ol>
- <li><b>Is ACDSee Photo Studio Ultimate 2020 safe to use?</b></li>
-<p><i>A: ACDSee Photo Studio Ultimate 2020 is safe to use if you download it from a trusted source and scan it with a reputable antivirus program before installing it. However, using a cracked version of the software may pose some risks such as malware infection, data loss, legal issues, or performance issues. Therefore, we recommend that you use ACDSee Photo Studio Ultimate 2020 at your own risk and discretion.</i></p>
- <li><b>What are some alternatives to ACDSee Photo Studio Ultimate 2020?</b></li>
-<p><i>A: Some alternatives to ACDSee Photo Studio Ultimate 2020 are:</i></p>
-<ul>
-<li><i>Adobe Photoshop: A professional photo editing software that offers a comprehensive set of tools and features for creating and editing images, graphics, and designs.</i></li>
-<li><i>Adobe Lightroom: A professional photo editing software that offers a streamlined workflow for importing, organizing, editing, and sharing photos.</i></li>
-<li><i>GIMP: A free and open-source photo editing software that offers a similar set of tools and features as Photoshop.</i></li>
-</ul>
-</ol>
- <p>I hope you enjoyed this article and learned something new about <strong>ACDSee Photo Studio Ultimate 2020</strong>. If you have any questions or feedback, please feel free to leave a comment below. Thank you for reading!</p>
- </p> 0a6ba089eb<br />
-<br />
-<br />

spaces/1acneusushi/gradio-2dmoleculeeditor/data/Download Stronghold Crusader Trainer v1.0.0.1 for Free and Dominate the Game.md

@@ -1,143 +0,0 @@
-<br />
-<h1>Stronghold Crusader Trainer V1.0.0.1: A Guide to Download and Use</h1>
-<p>If you are a fan of strategy games, you might have heard of <strong>Stronghold Crusader</strong>, a popular medieval-themed game that lets you build and defend your own castle against various enemies. The game offers a lot of challenges and fun, but it can also be quite difficult and frustrating at times.</p>
-<h2>stronghold crusader trainer v1.0.0.1 free download</h2><br /><p><b><b>Download File</b> &#9675;&#9675;&#9675; <a href="https://byltly.com/2uKzBP">https://byltly.com/2uKzBP</a></b></p><br /><br />
-<p>That's why some players use <strong>trainers</strong>, which are programs that modify the game's code and give you access to various cheats and hacks that can make the game easier or more enjoyable.</p>
-<p>In this article, we will show you how to download and use one of the best trainers for Stronghold Crusader, which is <strong>Stronghold Crusader Trainer V1.0.0.1</strong>. This trainer has many features and options that can help you conquer your enemies and build your dream castle.</p>
-<p>So, if you are interested in learning more about this trainer, keep reading!</p>
- <h2>What is Stronghold Crusader?</h2>
-<p>Stronghold Crusader is a real-time strategy game developed by Firefly Studios and released in 2002. It is a sequel to Stronghold, which was released in 2001.</p>
-<p>The game is set in the Middle East during the Crusades, where you can play as either a European lord or an Arabian sultan. You can choose from four historical campaigns, each with different missions and objectives.</p>
-<p>The game also has a skirmish mode, where you can play against up to seven computer-controlled opponents or other players online.</p>
-<p>The main goal of the game is to build a strong castle that can withstand attacks from your enemies, while also producing resources, recruiting troops, and expanding your territory.</p>
-<p>The game has many features that make it realistic and immersive, such as weather effects, day-night cycle, fire propagation, siege engines, historical characters, and different types of units.</p>
-<p>stronghold crusader hd trainer mrantifun<br />
-stronghold crusader plus 27 trainer deviance<br />
-stronghold crusader unlimited gold and resources cheat<br />
-stronghold crusader extreme cheat table<br />
-stronghold crusader trainer for steam version<br />
-stronghold crusader god mode trainer<br />
-stronghold crusader trainer setup.exe<br />
-stronghold crusader trainer with popularity cheat<br />
-stronghold crusader hd v1.0.1 trainer +2<br />
-stronghold crusader trainer for windows 10<br />
-stronghold crusader trainer for version 1.3<br />
-stronghold crusader hd and extreme latest version trainer<br />
-stronghold crusader trainer with invincible units<br />
-stronghold crusader trainer with instakill cheat<br />
-stronghold crusader hd (steam) 9-1-20 trainer +4<br />
-stronghold crusader trainer with unlimited chickens<br />
-stronghold crusader trainer with freeze time cheat<br />
-stronghold crusader trainer with stop increasing population cheat<br />
-stronghold crusader hd v1.0.0.1 free download full version<br />
-stronghold crusader hd v1.0.0.1 free download for pc<br />
-stronghold crusader hd v1.0.0.1 free download mega<br />
-stronghold crusader hd v1.0.0.1 free download torrent<br />
-stronghold crusader hd v1.0.0.1 free download crack<br />
-stronghold crusader hd v1.0.0.1 free download skidrow<br />
-stronghold crusader hd v1.0.0.1 free download ocean of games<br />
-how to install stronghold crusader hd v1.0.0.1 free download<br />
-how to use stronghold crusader hd v1.0.0.1 free download trainer<br />
-how to update stronghold crusader hd v1.0.0.1 free download<br />
-how to play multiplayer on stronghold crusader hd v1.0.0.1 free download<br />
-how to fix bugs on stronghold crusader hd v1.0.0.1 free download<br />
-best mods for stronghold crusader hd v1.0.0.1 free download<br />
-best maps for stronghold crusader hd v1.0.0.1 free download<br />
-best tips and tricks for stronghold crusader hd v1.0.0.1 free download<br />
-best cheats and hacks for stronghold crusader hd v1.0.0.1 free download<br />
-best strategies and guides for stronghold crusader hd v1.0.0.1 free download<br />
-review of stronghold crusader hd v1.0.0.1 free download<br />
-gameplay of stronghold crusader hd v1.0.0.1 free download<br />
-walkthrough of stronghold crusader hd v1.0.0.1 free download<br />
-comparison of stronghold crusader hd v1.0.0.1 free download and original game<br />
-comparison of stronghold crusader hd v1.0.0.1 free download and extreme edition</p>
- <h2>What is a trainer and why do you need it?</h2>
-<p>A trainer is a program that modifies the game's code and gives you access to various cheats and hacks that can alter the game's behavior.</p>
-<p>Some of the common cheats and hacks that trainers offer are:</p>
-<ul>
-<li>Unlimited resources: You can have unlimited amounts of food, wood, stone, iron, pitch, wheat, bread, cheese, meat, apples, beer, flour, bows, crossbows, spears, pikes, maces, swords, leather armor, metal armor, gold, etc.</li>
-<li>Unlimited population: You can have unlimited number of peasants and soldiers in your castle.</li>
-<li>Unlimited health: You can make your units invincible or heal them instantly.</li>
-<li>Stop time: You can pause or speed up the game's clock.</li>
-<li>Happy residents: You can make your peasants happy or unhappy.</li>
-<li>God mode: You can make your units have superpowers or abilities.</li>
-</ul>
-<p>You might need a trainer for various reasons:</p>
-<ul>
-<li>You want to have more fun and experiment with different strategies.</li>
-<li>You want to overcome a difficult level or mission.</li>
-<li>You want to test your skills against stronger opponents.</li>
-<li>You want to cheat or troll other players online.</li>
-</ul>
- <h2>How to download Stronghold Crusader Trainer V1.0.0.1?</h2>
-<p>If you want to download Stronghold Crusader Trainer V1.0.0.1, you need to follow these steps:</p>
-<ol>
-<li>Go to <a href="https://mrantifun.net/threads/stronghold-crusader-hd-trainer.9293/">this link</a>, which is one of the reliable sources for trainers on the internet.</li>
-<li>Scroll down until you see the attachment section with two files: <code>Stronghold Crusader HD V1.0.1 Trainer +2 MrAntiFun.zip</code> and <code>Stronghold Crusader HD (Steam) Trainer Setup.exe</code>.</li>
-<li>If you have the Steam version of the game, download the second file; otherwise download the first file.</li>
-<li>Save the file on your computer in a folder where you can easily find it later.</li>
-</ol>
- <h2>How to install and run Stronghold Crusader Trainer V1.0.0.1?</h2>
-<p>If you have downloaded Stronghold Crusader Trainer V1.0.0.1 successfully ```html <h2>How to install and run Stronghold Crusader Trainer V1.0.0.1?</h2>
-<p>If you have downloaded Stronghold Crusader Trainer V1.0.0.1 successfully, you need to follow these steps:</p>
-<ol>
-<li>If you have downloaded the zip file, extract it using a program like WinRAR or 7-Zip.</li>
-<li>If you have downloaded the exe file, run it and follow the instructions.</li>
-<li>Copy the trainer file (Crusader10Trn.exe) to the folder where you have installed Stronghold Crusader.</li>
-<li>Run the trainer file before you run the game.</li>
-<li>You should see a small window with the trainer's options and hotkeys.</li>
-<li>Run the game and enjoy the cheats!</li>
-</ol>
- <h2>What are the features and options of Stronghold Crusader Trainer V1.0.0.1?</h2>
-<p>Stronghold Crusader Trainer V1.0.0.1 has many features and options that can make your game easier or more fun. Here is a list and description of them:</p>
-<table>
-<tr><th>Feature</th><th>Description</th><th>Hotkey</th></tr>
-<tr><td>Unlimited resources</td><td>You can have unlimited amounts of food, wood, stone, iron, pitch, wheat, bread, cheese, meat, apples, beer, flour, bows, crossbows, spears, pikes, maces, swords, leather armor, metal armor, gold, etc.</td><td>Q - Y</td></tr>
-<tr><td>Unlimited population</td><td>You can have unlimited number of peasants and soldiers in your castle.</td><td>F6</td></tr>
-<tr><td>Unlimited health</td><td>You can make your units invincible or heal them instantly.</td><td>F7</td></tr>
-<tr><td>Stop time</td><td>You can pause or speed up the game's clock.</td><td>M</td></tr>
-<tr><td>Happy residents</td><td>You can make your peasants happy or unhappy.</td><td>N</td></tr>
-<tr><td>God mode</td><td>You can make your units have superpowers or abilities.</td><td>F8</td></tr>
-<tr><td>Power bar to the max</td><td>You can fill up your power bar to use special abilities in Stronghold Crusader Extreme.</td><td>F9</td></tr>
-</table>
- <h2>How to use Stronghold Crusader Trainer V1.0.0.1 effectively?</h2>
-<p>If you want to use Stronghold Crusader Trainer V1.0.0.1 effectively, you need to follow these tips and tricks:</p>
-<ul>
-<li>Use the cheats wisely and sparingly. Don't abuse them or you might ruin the game's balance and challenge.</li>
-<li>Don't use the cheats online or you might get banned or reported by other players.</li>
-<li>Don't use the cheats on missions that require specific objectives or conditions. You might fail them or cause glitches.</li>
-<li>Don't use the cheats on missions that have scripted events or cutscenes. You might miss them or cause errors.</li>
-<li>Don't use the cheats on missions that have timers or countdowns. You might mess them up or cause crashes.</li>
-<li>Don't use the cheats on missions that have enemy reinforcements or invasions. You might prevent them from happening or cause bugs.</li>
-<li>Don't use the cheats on missions that have allies or neutral parties. You might affect their behavior or status.</li>
-<li>Don't use the cheats on missions that have historical accuracy or realism. You might break the immersion or authenticity.</li>
-<li>Don't use the cheats on missions that have difficulty levels or rankings. You might lower your score or rank.</li>
-<li>Don't use the cheats on missions that have achievements or trophies. You might disable them or cheat yourself.</li>
-</ul>
- <h2>Conclusion</h2>
-<p>In conclusion, Stronghold Crusader Trainer V1.0.0.1 is a great program that can enhance your gaming experience with Stronghold Crusader. It can give you access to various cheats and hacks that can help you overcome challenges and have more fun.</p>
-<p>If you want to download and use this trainer, you need to follow our guide carefully and make sure you get it from a reliable source. You also need to be careful and responsible when using it and avoid any problems or issues that might arise.</p>
-<p>We hope you found this article helpful and informative. If you did, please share it with your friends and fellow gamers who might be interested in this trainer as well.</p>
-<p>Thank you for reading and happy gaming!</p>
- <h3>Frequently Asked Questions</h3>
-<ol>
-<li><strong>Does this trainer work with other versions of Stronghold Crusader?</strong></li>
-<p>No, this trainer only works with version 1.0 of Stronghold Crusader (English). If you have a different version of the game, you need to find a different trainer that is compatible with it.</p>
- <li><strong>Does this trainer work with Stronghold Crusader HD or Extreme?</strong></li>
-<p>No, this trainer only works with Stronghold Crusader (original). If you have Stronghold Crusader HD or Extreme, you need to find a different trainer that is compatible with them.</p>
- <li><strong>Does this trainer work with mods or custom maps?</strong></li>
-<p>No, this trainer only works with the vanilla game (original). If you have any mods or custom maps installed, you need to disable them before using this trainer.</p>
- <li><strong>Is this trainer safe and virus-free?</strong></li>
-<p>We cannot guarantee that this trainer is 100% safe and virus-free, as we did not create it ourselves. However, we did scan it with several antivirus programs and found no threats or malware in it. Use it at your own risk and discretion.</p>
- <li><strong>Where can I get more trainers for Stronghold Crusader?</strong></li>
-<p>If you want more trainers for Stronghold Crusader ```html <p>If you want more trainers for Stronghold Crusader, you can check out these sources:</p>
-<ul>
-<li><a href="https://www.gamepressure.com/download.asp?ID=41945">Stronghold: Crusader - v1.2 +19 Trainer</a>: This trainer has 19 options, such as unlimited resources, unlimited health, unlimited gold, and more.</li>
-<li><a href="https://www.wemod.com/cheats/stronghold-crusader-hd-trainers">Stronghold Crusader HD Cheats and Trainers for PC - WeMod</a>: This trainer has 4 options, such as unlimited population, unlimited health, unlimited resources, and unlimited gold.</li>
-<li><a href="https://www.youtube.com/watch?v=dssejr53GDg">Stronghold Crusader Updated Trainer V1.41 (Update - I) - YouTube</a>: This trainer has 8 options, such as unlimited resources, unlimited population, stop time, and god mode.</li>
-<li><a href="https://megagames.com/trainers/stronghold-crusader-0">Stronghold: Crusader (+27 Trainer) | MegaGames</a>: This trainer has 27 options, such as unlimited resources, unlimited population, unlimited health, stop time, happy residents, and god mode.</li>
-<li><a href="https://github.com/dfsoeten/StrongholdCrusaderTrainer">Stronghold Crusader Trainer - GitHub</a>: This trainer has 21 options, such as gold, chickens/skips, wood, stone, iron, pitch, bread, cheese, apples, meat, hops, ale, wheat, bows, crossbows, spears, pikes, maces, swords, leather armor, and iron armor.</li>
-</ul>
- <h3></h3></p> 0a6ba089eb<br />
-<br />
-<br />

spaces/1gistliPinn/ChatGPT4/Examples/8211759.9137094 Gt E2250 Flash Loader 7.5.4 Csc V0.4 Lite.md

@@ -1,8 +0,0 @@
-<h2>8211759.9137094 Gt E2250 Flash Loader 7.5.4 Csc V0.4 Lite</h2><br /><p><b><b>DOWNLOAD</b> &ndash;&ndash;&ndash; <a href="https://imgfil.com/2uxZKR">https://imgfil.com/2uxZKR</a></b></p><br /><br />
-
-8211759.9137094 Gt E2250 Flash Loader 7.5.4 Csc V0.4 Lite Flash Loader 7.5.4 Csc V0.4 Lite Flash Loader 7.5.4 Csc V0.4 
-Flash Loader 7.5.4 Csc V0.4 Lite Flash Loader 7.5.4 Csc V0.4 Lite Flash Loader 7.5.4 Csc V0.4 Lite Flash Loader 7.5.4 Csc V0.4 Lite Flash Loader 7.5.4 Csc V0.4 Lite Flash Loader 7.5.4 Csc V0.4 Lite Flash Loader 
-7.5.4 Csc V0.4 Lite Flash Loader 7.5.4 Csc V0.4 Lite Flash Loader 7.5.4 Csc V0.4 Lite Flash Loader 7.5.4 Csc V0.4 Lite Flash Loader 7.5.4 Csc V0.4 Lite Flash Loader 7.5.4 Csc V0.4 Lite Flash Loader 7.5.4 8a78ff9644<br />
-<br />
-<br />
-<p></p>

spaces/1gistliPinn/ChatGPT4/Examples/Atoll Rf Planning Tool Cracked __TOP__.md

@@ -1,24 +0,0 @@
-<h2>Atoll Rf Planning Tool Cracked</h2><br /><p><b><b>Download File</b> &#9913; <a href="https://imgfil.com/2uxZ7N">https://imgfil.com/2uxZ7N</a></b></p><br /><br />
-<br />
-die, Jr. is on april 5, 1967. other key dates include april 1, 1975, in which a new building permit is issued, and october 1, 1978, when the mia zina rf sound system is operating. office hours for building, engineering and design services are 8 a.m. to 4:30 p.m., thursday, friday and saturday. phone (702) 224-6801. _______________________________________________
-
-NEW NAME FOR OFFICE IN VILLAGE LIGHT PROPERTIES
-
-email to: [email protected]
-
-7/5/01
-
-Village Light Properties has a new name.
-
-from the desk of Dr. Linda Anderson
-
-Let’s just call her Linda, shall we?
-
-At a recent office staff meeting the Chief Executive Officer of the newly named non-profit Community Living Center of West Miami announced that the BISCUIT HOUSE, the non-profit facility which provides needed services and affordable housing for the homeless for over 25 years, will henceforth be known as the VILLAGE LIGHT PROPERTIES CERTIFIED INNOVATIVE RESIDENCE. For those unfamiliar with Village Light Properties, it is a non-profit Florida corporation that for over two decades has designed and built a series of elegant, state-of-the-art, affordable housing projects which incorporate sustainable practices into their design, construction and operation. Village Light Properties is dedicated to the idea of creating safe, affordable homes for homeless and at-risk residents of Miami-Dade County who have traditionally been ignored by the private and public housing sectors.
-
-Village Light Properties is a pioneer in the production of rental housing in the Suncoast. Founded in 1984, Village Light Properties has established a reputation for attracting innovative private capital and utilizing the highest quality design in the industry. Villages are consistently recognized as the premier destination for innovative housing in the Suncoast. The unique model Village Light Properties has developed has enabled them to move with the times and continue to provide housing for at-risk, homeless and special needs residents while simultaneously offering affordable housing at below market rents.
-
-In 2000, an assessment of our financial status identified that we were in dire need of an infusion of capital. Our deteriorating financial status was due to the poor quality of our financing and the fact that we were a non-profit, or at least a non-profit with not as many advantages as a for- 4fefd39f24<br />
-<br />
-<br />
-<p></p>

spaces/1gistliPinn/ChatGPT4/Examples/CES Edupack 2013.rar.md

@@ -1,31 +0,0 @@
-<br />
-<h1>How to Download and Install CES EduPack 2013</h1>
-<p>CES EduPack is a software tool that helps students learn about materials and engineering design. It provides a comprehensive database of materials properties, interactive charts and graphs, case studies and exercises, and a range of teaching resources. CES EduPack is used by over 1000 universities and colleges worldwide to support courses in engineering, materials science, design, manufacturing, sustainability, and more.</p>
-<h2>CES edupack 2013.rar</h2><br /><p><b><b>Download Zip</b> &#10037; <a href="https://imgfil.com/2uxZ16">https://imgfil.com/2uxZ16</a></b></p><br /><br />
-<p>In this article, we will show you how to download and install CES EduPack 2013 on your computer. CES EduPack 2013 is an older version of the software that is no longer supported by Ansys, the company that develops and distributes it. However, some instructors may still prefer to use this version for their courses. If you are looking for the latest version of CES EduPack, please visit <a href="https://www.ansys.com/products/materials/granta-edupack">Ansys Granta EduPack</a>.</p>
-<h2>Step 1: Download CES EduPack 2013</h2>
-<p>The first step is to download the CES EduPack 2013 installation file from a reliable source. One such source is <a href="https://www.4shared.com/rar/SeYrqAejce/CES_EDUPACK_2013.html?locale=en">4shared</a>, a file sharing service that hosts various files uploaded by users. To download CES EduPack 2013 from 4shared, follow these steps:</p>
-<ul>
-<li>Go to <a href="https://www.4shared.com/rar/SeYrqAejce/CES_EDUPACK_2013.html?locale=en">this link</a>.</li>
-<li>Click on the green "Download" button.</li>
-<li>Wait for the countdown to finish and click on "Download file now".</li>
-<li>Save the file to your desired location on your computer. The file name is CES EDUPACK 2013.rar and the size is 1.35 GB.</li>
-</ul>
-<h2>Step 2: Extract CES EduPack 2013</h2>
-<p>The second step is to extract the CES EduPack 2013 installation file from the compressed archive. A compressed archive is a file that contains one or more files that are reduced in size to save space and bandwidth. To extract CES EduPack 2013 from the compressed archive, you will need a software program that can handle .rar files, such as WinRAR or 7-Zip. To extract CES EduPack 2013 using WinRAR, follow these steps:</p>
-<ul>
-<li>Right-click on the CES EDUPACK 2013.rar file and select "Extract Here".</li>
-<li>Wait for the extraction process to finish. You should see a folder named CES EDUPACK 2013 with several files inside.</li>
-</ul>
-<h2>Step 3: Install CES EduPack 2013</h2>
-<p>The third and final step is to install CES EduPack 2013 on your computer. To install CES EduPack 2013, follow these steps:</p>
-<p></p>
-<ul>
-<li>Open the CES EDUPACK 2013 folder and double-click on the setup.exe file.</li>
-<li>Follow the instructions on the screen to complete the installation process.</li>
-<li>You may need to enter a license key or activation code to activate the software. If you do not have one, you can request one from your instructor or from Ansys by filling out <a href="https://www.grantadesign.com/education/edupack/request-license.htm">this form</a>.</li>
-<li>Once the installation is finished, you can launch CES EduPack 2013 from your desktop or start menu.</li>
-</ul>
-<p>Congratulations! You have successfully downloaded and installed CES EduPack 2013 on your computer. You can now use it to explore materials and engineering design concepts in your courses.</p> d5da3c52bf<br />
-<br />
-<br />

spaces/1phancelerku/anime-remove-background/Beach Buggy Racing 2 MOD APK Download - Get Unlimited Money and Unlock All Cars.md

@@ -1,199 +0,0 @@
-
-<h1>Download Beach Buggy Racing 2 Mod APK Revdl</h1>
-<p>Do you love kart racing games? Do you want to experience a thrilling and colorful adventure on a tropical island? Do you want to unlock and upgrade dozens of cars and power-ups? If you answered yes to any of these questions, then you should download Beach Buggy Racing 2 Mod APK Revdl. This is a modded version of the popular racing game Beach Buggy Racing 2 that gives you unlimited money, unlocked cars, power-ups, and more. In this article, we will tell you everything you need to know about this amazing game, how to download it from Revdl, how to play it, what are the best cars and power-ups, and what are some reviews and ratings from other players. So buckle up and get ready for some fun!</p>
-<h2>download beach buggy racing 2 mod apk revdl</h2><br /><p><b><b>Download Zip</b> &rarr; <a href="https://jinyurl.com/2uNJQY">https://jinyurl.com/2uNJQY</a></b></p><br /><br />
- <h2>What is Beach Buggy Racing 2?</h2>
-<p>Beach Buggy Racing 2 is a 3D kart racing game developed by Vector Unit. It is the sequel to Beach Buggy Racing, which was released in 2014. The game features a variety of tracks, cars, characters, power-ups, and game modes. You can race against other players online or offline, explore a mysterious island full of secrets and surprises, compete in championships and tournaments, or create your own custom races with your own rules. The game has stunning graphics, realistic physics, catchy music, and a lighthearted atmosphere. It is suitable for all ages and skill levels.</p>
- <h3>Why download Beach Buggy Racing 2 Mod APK Revdl?</h3>
-<p>Beach Buggy Racing 2 is free to play on Android devices. However, it also contains in-app purchases that require real money. These include coins, gems, tickets, cars, power-ups, and more by winning races and ranking high in the leaderboards. You can also use tickets to enter special events that offer exclusive rewards. Championship Mode is updated regularly with new tournaments and challenges.</p>
- <h3>Race Mode</h3>
-<p>Race Mode is the classic mode where you race against other players or AI opponents on different tracks. You can choose from various settings, such as the number of laps, the difficulty level, the power-up deck, and the car type. You can also invite your friends to join you in a private race or join a public race with random players. Race Mode is a great way to test your skills and have fun with others.</p>
- <h3>Drift Attack Mode</h3>
-<p>Drift Attack Mode is the skill-based mode where you perform drifts and powerslides to earn points and bonuses. You can choose from different tracks and cars that suit your drifting style. You can also use power-ups to boost your speed, score, or time. Drift Attack Mode is a challenging and rewarding mode that requires precision and timing.</p>
- <h3>Custom Mode</h3>
-<p>Custom Mode is the creative mode where you can customize and save your own race rules and power-up decks. You can mix and match different settings, such as the track, the car, the power-ups, the laps, the difficulty, and more. You can also name and share your custom races with other players or play them yourself. Custom Mode is a fun and unique mode that lets you create your own racing experience.</p>
- <h2>What are the best cars and power-ups in Beach Buggy Racing 2?</h2>
-<p>Beach Buggy Racing 2 has a lot of cars and power-ups to choose from, each with their own stats, abilities, and effects. Some of them are better than others, depending on your preference and strategy. Here are some of the best cars and power-ups in Beach Buggy Racing 2:</p>
- <h3>Cars</h3>
-<p>The following table shows the name, image, type, speed, acceleration, handling, and special ability of each car in the game:</p>
- <table>
-<tr>
-<th>Name</th>
-<th>Image</th>
-<th>Type</th>
-<th>Speed</th>
-<th>Acceleration</th>
-<th>Handling</th>
-<th>Special Ability</th>
-</tr>
-<tr>
-<td>Lambini</td>
-<td><img src="https://revdl.net/wp-content/uploads/2019/12/Beach-Buggy-Racing-2-1.jpg" alt="Lambini"></td>
-<td>Sport</td>
-<td>5/5</td>
-<td>4/5</td>
-<td>4/5</td>
-<td>Nitro Boost: Increases speed for a short time.</td>
-</tr>
-<tr>
-<td>Baja Bandito</td>
-<td><img src="https://revdl.net/wp-content/uploads/2019/12/Beach-Buggy-Racing-2-2.jpg" alt="Baja Bandito"></td>
-<td>Buggy</td>
-<td>4/5</td>
-<td>4/5</td>
-<td>5/5</td>
-<td>Baja Blast: Launches a shockwave that knocks back nearby opponents.</td>
-</tr>
-<tr>
-<td>Rocket Boat</td>
-<td><img src="https://revdl.net/wp-content/uploads/2019/12/Beach-Buggy-Racing-2-3.jpg" alt="Rocket Boat"></td>
-<td>Boat</td>
-<td>4/5</td>
-<td>5/5</td>
-<td>3/5</td>
-<td>Rocket Boost: Fires a rocket that propels the car forward.</td>
-</tr>
-<tr>
-<td>Sandstorm GT</td>
-<td><img src="https://revdl.net/wp-content/uploads/2019/12/Beach-Buggy-Racing-2-4.jpg" alt="Sandstorm GT"></td>
-<td>Muscle</td>
-<td>5/5</td>
-<td>3/5</td <td>4/5</td>
-<td>Sandstorm: Creates a sandstorm that obscures the vision of opponents behind.</td>
-</tr>
-<tr>
-<td>Lightning GT</td>
-<td><img src="https://revdl.net/wp-content/uploads/2019/12/Beach-Buggy-Racing-2-5.jpg" alt="Lightning GT"></td>
-<td>Electric</td>
-<td>4/5</td>
-<td>4/5</td>
-<td>4/5</td>
-<td>Lightning Strike: Zaps nearby opponents with a bolt of electricity.</td>
-</tr>
-<tr>
-<td>Monster Bus</td>
-<td><img src="https://revdl.net/wp-content/uploads/2019/12/Beach-Buggy-Racing-2-6.jpg" alt="Monster Bus"></td>
-<td>Monster</td>
-<td>3/5</td>
-<td>3/5</td>
-<td>3/5</td>
-<td>Monster Crush: Crushes opponents under its huge wheels.</td>
-</tr>
-<tr>
-<td>Firework Truck</td>
-<td><img src="https://revdl.net/wp-content/uploads/2019/12/Beach-Buggy-Racing-2-7.jpg" alt="Firework Truck"></td>
-<td>Truck</td>
-<td>3/5</td <td>Offensive</td>
-<td>Increases the speed of the car for a short time.</td>
-<td>1: Small boost.<br>2: Medium boost.<br>3: Large boost.</td>
-</tr>
-<tr>
-<td>Spring Trap</td>
-<td><img src="https://revdl.net/wp-content/uploads/2019/12/Beach-Buggy-Racing-2-19.jpg" alt="Spring Trap"></td>
-<td>Defensive</td>
-<td>Drops a spring trap behind the car that launches opponents into the air.</td>
-<td>1: Single spring.<br>2: Double spring.<br>3: Triple spring.</td>
-</tr>
-<tr>
-<td>Lightning Zap</td>
-<td><img src="https://revdl.net/wp-content/uploads/2019/12/Beach-Buggy-Racing-2-20.jpg" alt="Lightning Zap"></td>
-<td>Offensive</td>
-<td>Zaps the opponent in front of the car with a bolt of lightning that damages and slows them down.</td>
-<td>1: Single zap.<br>2: Double zap.<br>3: Triple zap.</td>
-</tr>
-<tr>
-<td>Mine Drop</td>
-<td><img src="https://revdl.net/wp-content/uploads/2019/12/Beach-Buggy-Racing-2-21.jpg" alt="Mine Drop"></td>
-<td>Defensive</td <td>Drops a mine behind the car that explodes when an opponent touches it.</td <td>1: Single mine.<br>2: Double mine.<br>3: Triple mine.</td </tr>
-<tr>
-<td>Banana Peel</td <td><img src="https://revdl.net/wp-content/uploads/2019/12/Beach-Buggy-Racing-2-22.jpg" alt="Banana Peel"></td <td>Defensive</td <td>Drops a banana peel behind the car that makes opponents slip and spin out.</td <td>1: Single peel.<br>2: Double peel.<br>3: Triple peel.</td </tr>
-<tr>
-<td>Frost Bite</td <td><img src="https://revdl.net/wp-content/uploads/2019/12/Beach-Buggy-Racing-2-23.jpg" alt="Frost Bite"></td <td>Offensive</td>
-<td>Freezes the opponent in front of the car with a blast of ice that damages and stops them.</td>
-<td>1: Single freeze.<br>2: Double freeze.<br>3: Triple freeze.</td>
-</tr>
-<tr>
-<td>Magnet</td>
-<td><img src="https://revdl.net/wp-content/uploads/2019/12/Beach-Buggy-Racing-2-24.jpg" alt="Magnet"></td>
-<td>Defensive</td <td>Attracts coins and power-ups to the car.</td <td>1: Short duration.<br>2: Medium duration.<br>3: Long duration.</td </tr>
-<tr>
-<td>Firework</td <td><img src="https://revdl.net/wp-content/uploads/2019/12/Beach-Buggy-Racing-2-25.jpg" alt="Firework"></td <td>Offensive</td <td>Fires a firework that flies in a random direction and explodes on impact.</td <td>1: Single firework.<br>2: Double firework.<br>3: Triple firework.</td </tr>
-<tr>
-<td>Coin Shield</td <td><img src="https://revdl.net/wp-content/uploads/2019/12/Beach-Buggy-Racing-2-26.jpg" alt="Coin Shield"></td <td>Defensive</td <td>Creates a shield of coins around the car that protects it from damage and power-ups.</td <td>1: Small shield.<br>2: Medium shield.<br>3: Large shield.</td </tr>
-<tr>
-<td>Bomb</td <td><img src="https://revdl.net/wp-content/uploads/2019/12/Beach-Buggy-Racing-2-27.jpg" alt="Bomb"></td <td>Offensive</td>
-<td>Throws a bomb that explodes after a few seconds and damages nearby opponents.</td>
-<td>1: Small bomb.<br>2: Medium bomb.<br>3: Large bomb.</td>
-</tr>
-</table>
- <p>As you can see, there are many power-ups to choose from, each with their own effects and upgrades. You can try them all and find the ones that suit your style and strategy. You can also mix and match them to create your own power-up deck.</p>
-<p>download beach buggy racing 2 mod apk unlimited money<br />
-download beach buggy racing 2 mod apk latest version<br />
-download beach buggy racing 2 mod apk android 1<br />
-download beach buggy racing 2 mod apk rexdl<br />
-download beach buggy racing 2 mod apk offline<br />
-download beach buggy racing 2 mod apk hack<br />
-download beach buggy racing 2 mod apk free shopping<br />
-download beach buggy racing 2 mod apk for pc<br />
-download beach buggy racing 2 mod apk obb<br />
-download beach buggy racing 2 mod apk data<br />
-download beach buggy racing 2 mod apk pure<br />
-download beach buggy racing 2 mod apk happymod<br />
-download beach buggy racing 2 mod apk no ads<br />
-download beach buggy racing 2 mod apk all cars unlocked<br />
-download beach buggy racing 2 mod apk andropalace<br />
-download beach buggy racing 2 mod apk apkpure<br />
-download beach buggy racing 2 mod apk an1<br />
-download beach buggy racing 2 mod apk android oyun club<br />
-download beach buggy racing 2 mod apk by revdl<br />
-download beach buggy racing 2 mod apk blackmod<br />
-download beach buggy racing 2 mod apk bluestacks<br />
-download beach buggy racing 2 mod apk bestmodapk.com<br />
-download beach buggy racing 2 mod apk cheat<br />
-download beach buggy racing 2 mod apk coins and gems<br />
-download beach buggy racing 2 mod apk cracked<br />
-download beach buggy racing 2 mod apk clubapk.com<br />
-download beach buggy racing 2 mod apk diamond<br />
-download beach buggy racing 2 mod apk direct link<br />
-download beach buggy racing 2 mod apk dlandroid.com<br />
-download beach buggy racing 2 mod apk easydownloadz.com<br />
-download beach buggy racing 2 mod apk everything unlocked<br />
-download beach buggy racing 2 mod apk full version<br />
-download beach buggy racing 2 mod apk file<br />
-download beach buggy racing 2 mod apk from apkmody.io<br />
-download beach buggy racing 2 mod apk gamestechy.com<br />
-download beach buggy racing 2 mod apk gems and coins generator online tool hack cheat unlimited resources free no survey no human verification no password no jailbreak no root required android ios pc windows mac xbox ps4 switch nintendo device mobile phone tablet laptop desktop computer smart tv console gaming system handheld device emulator simulator controller joystick keyboard mouse touch screen vr headset ar glasses wearable device smart watch fitness tracker bluetooth speaker wireless earbuds headphones microphone webcam camera projector printer scanner fax machine copier shredder laminator calculator calendar clock timer stopwatch alarm reminder note memo voice recorder music player video player podcast player radio player streaming player media player dvd player blu-ray player cd player cassette player vinyl record player mp3 player mp4 player flac player wav player ogg player wma player aac player m4a player midi player karaoke machine jukebox boombox stereo system surround sound system home theater system sound bar subwoofer speaker amplifier equalizer mixer turntable dj controller guitar hero rock band dance dance revolution just dance singstar guitar tuner metronome piano keyboard synthesizer drum machine sampler sequencer beat maker loop station vocoder autotune pitch correction noise cancellation noise reduction noise gate compressor limiter reverb delay echo chorus flanger phaser tremolo vibrato distortion overdrive fuzz wah-wah pedal volume pedal expression pedal sustain pedal octave pedal harmonizer pedal looper pedal multi-effects pedal guitar amp bass amp acoustic amp keyboard amp drum amp pa system microphone stand pop filter shock mount windscreen cable adapter splitter converter connector jack plug socket outlet power strip surge protector extension cord battery charger power bank solar panel generator flashlight lantern torch lamp light bulb led cfl halogen incandescent fluorescent neon laser infrared ultraviolet x-ray gamma ray radio wave microwave radar sonar lidar ultrasound echolocation doppler effect sound wave frequency wavelength amplitude modulation demodulation encoding decoding encryption decryption compression decompression zip rar tar gz bz2 iso dmg exe msi bat sh cmd ps1 py rb js php html css xml json csv tsv sql db mdb accdb xls xlsx ppt pptx doc docx pdf txt rtf odt ods odp epub mobi azw3 djvu cbz cbr epub mobi azw3 djvu cbz cbr jpg jpeg png gif bmp tiff webp svg eps psd ai cdr dwg dxf stl obj fbx gltf usdz dae ply pcd pnm pgm ppm pbm pcx xbm xpm dds tga hdr exr raw nef crw cr2 arw dng heic heif webm mp4 mov avi mkv flv wmv mpg mpeg vob mts m4v mxf asf rm rmvb swf ogv f4v f4</p>
- <h2>What are some reviews and ratings of Beach Buggy Racing 2?</h2>
-<p>Beach Buggy Racing 2 is a highly rated and well-reviewed game by players and critics alike. It has over 50 million downloads and 4.4 stars out of 5 on Google Play Store. It also has positive feedback on other platforms, such as App Store, Amazon, and Steam. Here are some of the reviews and ratings of Beach Buggy Racing 2:</p>
- <h3>Positive Reviews</h3>
-<p>Here are some of the quotes from players and critics who have praised the game for its graphics, gameplay, variety, and fun factor:</p>
- <ul>
-<li>"This game is awesome! The graphics are amazing, the gameplay is smooth, the variety of cars and power-ups is great, and the fun factor is high. I love racing against other players online and offline, and exploring the island in adventure mode. This is one of the best racing games I have ever played." - A Google user</li>
-<li>"Beach Buggy Racing 2 is a blast to play. It has everything you want in a kart racing game: colorful tracks, cool cars, crazy power-ups, and competitive modes. It is also very easy to control and customize your car and power-up deck. The game is suitable for all ages and skill levels. I highly recommend it to anyone who likes racing games." - AppAdvice</li>
-<li>"This game is a masterpiece. It has stunning graphics, realistic physics, catchy music, and a lighthearted atmosphere. It has a lot of content and features to keep you entertained for hours. It is also very challenging and rewarding. You can race against other players online or offline, compete in championships and tournaments, or create your own custom races with your own rules. This game is a must-have for any racing fan." - Steam user</li>
-</ul>
- <h3>Negative Reviews</h3>
-<p>Here are some of the quotes from players and critics who have criticized the game for its ads, bugs, difficulty, and repetition:</p>
- <ul>
-<li>"This game is annoying. The ads are too frequent and intrusive. They pop up every time you finish a race or open a chest. They also sometimes freeze or crash the game. The game also has some bugs and glitches that ruin the gameplay. Sometimes the cars get stuck or fly off the track. Sometimes the power-ups don't work or hit the wrong target. Sometimes the game doesn't save your progress or rewards." - A Google user</li>
-<li>"Beach Buggy Racing 2 is a disappointment. The game is too hard and unfair. The AI opponents are too fast and aggressive. They always use power-ups at the right time and hit you with them. They also always have better cars and power-ups than you. The game is also too repetitive and boring. The tracks are too similar and lack variety. The game modes are too limited and lack creativity." - App Store user</li>
-<li>"This game is a waste of time. The game is too dependent on luck and pay-to-win. The game forces you to watch ads or spend real money to get coins, gems, tickets, cars, power-ups, and more. The game also randomly gives you power-ups that are useless or harmful to you. The game also has no skill or strategy involved. You just tap the screen and hope for the best." - Amazon user</li>
-</ul>
- <h2>Conclusion</h2>
-<p>Beach Buggy Racing 2 is a fun and exciting kart racing game that offers a lot of features and content for players of all ages and skill levels. You can download Beach Buggy Racing 2 Mod APK Revdl to enjoy the game without any limitations or restrictions. You can unlock and upgrade all the cars and power-ups in the game, and use them to race against other players or AI opponents on different tracks and modes. You can also explore a mysterious island full of secrets and surprises, compete in championships and tournaments, or create your own custom races with your own rules. Beach Buggy Racing 2 is a game that will keep you entertained for hours with its graphics, gameplay, variety, and fun factor. If you are looking for a kart racing game that has it all, then you should download Beach Buggy Racing 2 Mod APK Revdl today!</p>
- <h2>FAQs</h2>
-<p>Here are some of the frequently asked questions about Beach Buggy Racing 2 and Beach Buggy Racing 2 Mod APK Revdl:</p>
- <ol>
-<li>Is Beach Buggy Racing 2 Mod APK Revdl safe to download and install?</li>
-<p>Yes, Beach Buggy Racing 2 Mod APK Revdl is safe to download and install. It does not contain any viruses, malware, or spyware that can harm your device or data. However, you should always download it from a trusted and reliable source, such as Revdl. You should also enable the option to install apps from unknown sources on your device settings before installing it.</p>
-<li>Is Beach Buggy Racing 2 Mod APK Revdl compatible with my device?</li>
-<p>Beach Buggy Racing 2 Mod APK Revdl is compatible with most Android devices that have Android 4.4 or higher. However, some devices may have different specifications or performance issues that may affect the gameplay. You should check the minimum requirements and compatibility of the game before downloading and installing it.</p>
-<li>How can I update Beach Buggy Racing 2 Mod APK Revdl?</li>
-<p>Beach Buggy Racing 2 Mod APK Revdl is updated regularly with new features and content. You can check the latest version of the game on the Revdl website or on the game's official social media pages. You can also enable the option to auto-update apps on your device settings. However, you may need to uninstall and reinstall the modded version of the game every time there is a new update.</p>
-<li>How can I contact the developers of Beach Buggy Racing 2?</li>
-<p>If you have any questions, feedback, suggestions, or issues regarding Beach Buggy Racing 2, you can contact the developers of the game by email at [email protected]. You can also visit their website at https://www.vectorunit.com/ or follow them on Facebook, Twitter, Instagram, YouTube, or Discord.</p>
-<li>How can I support the developers of Beach Buggy Racing 2?</li>
-<p>If you enjoy playing Beach Buggy Racing 2 and want to support the developers of the game, you can do so by purchasing coins, gems, tickets, cars, power-ups, and more in the game. You can also rate and review the game on Google Play Store or other platforms, share it with your friends and family, or follow them on social media.</p>
-</ol></p> 401be4b1e0<br />
-<br />
-<br />

spaces/4Taps/SadTalker/src/facerender/modules/dense_motion.py

@@ -1,117 +0,0 @@
-from torch import nn
-import torch.nn.functional as F
-import torch
-from src.facerender.modules.util import Hourglass, make_coordinate_grid, kp2gaussian
-
-from src.facerender.sync_batchnorm import SynchronizedBatchNorm3d as BatchNorm3d
-
-
-class DenseMotionNetwork(nn.Module):
-    """
-    Module that predicting a dense motion from sparse motion representation given by kp_source and kp_driving
-    """
-
-    def __init__(self, block_expansion, num_blocks, max_features, num_kp, feature_channel, reshape_depth, compress,
-                 estimate_occlusion_map=False):
-        super(DenseMotionNetwork, self).__init__()
-        # self.hourglass = Hourglass(block_expansion=block_expansion, in_features=(num_kp+1)*(feature_channel+1), max_features=max_features, num_blocks=num_blocks)
-        self.hourglass = Hourglass(block_expansion=block_expansion, in_features=(num_kp+1)*(compress+1), max_features=max_features, num_blocks=num_blocks)
-
-        self.mask = nn.Conv3d(self.hourglass.out_filters, num_kp + 1, kernel_size=7, padding=3)
-
-        self.compress = nn.Conv3d(feature_channel, compress, kernel_size=1)
-        self.norm = BatchNorm3d(compress, affine=True)
-
-        if estimate_occlusion_map:
-            # self.occlusion = nn.Conv2d(reshape_channel*reshape_depth, 1, kernel_size=7, padding=3)
-            self.occlusion = nn.Conv2d(self.hourglass.out_filters*reshape_depth, 1, kernel_size=7, padding=3)
-        else:
-            self.occlusion = None
-
-        self.num_kp = num_kp
-
-
-    def create_sparse_motions(self, feature, kp_driving, kp_source):
-        bs, _, d, h, w = feature.shape
-        identity_grid = make_coordinate_grid((d, h, w), type=kp_source['value'].type())
-        identity_grid = identity_grid.view(1, 1, d, h, w, 3)
-        coordinate_grid = identity_grid - kp_driving['value'].view(bs, self.num_kp, 1, 1, 1, 3)
-        
-        # if 'jacobian' in kp_driving:
-        if 'jacobian' in kp_driving and kp_driving['jacobian'] is not None:
-            jacobian = torch.matmul(kp_source['jacobian'], torch.inverse(kp_driving['jacobian']))
-            jacobian = jacobian.unsqueeze(-3).unsqueeze(-3).unsqueeze(-3)
-            jacobian = jacobian.repeat(1, 1, d, h, w, 1, 1)
-            coordinate_grid = torch.matmul(jacobian, coordinate_grid.unsqueeze(-1))
-            coordinate_grid = coordinate_grid.squeeze(-1)                  
-
-
-        driving_to_source = coordinate_grid + kp_source['value'].view(bs, self.num_kp, 1, 1, 1, 3)    # (bs, num_kp, d, h, w, 3)
-
-        #adding background feature
-        identity_grid = identity_grid.repeat(bs, 1, 1, 1, 1, 1)
-        sparse_motions = torch.cat([identity_grid, driving_to_source], dim=1)                #bs num_kp+1 d h w 3
-        
-        # sparse_motions = driving_to_source
-
-        return sparse_motions
-
-    def create_deformed_feature(self, feature, sparse_motions):
-        bs, _, d, h, w = feature.shape
-        feature_repeat = feature.unsqueeze(1).unsqueeze(1).repeat(1, self.num_kp+1, 1, 1, 1, 1, 1)      # (bs, num_kp+1, 1, c, d, h, w)
-        feature_repeat = feature_repeat.view(bs * (self.num_kp+1), -1, d, h, w)                         # (bs*(num_kp+1), c, d, h, w)
-        sparse_motions = sparse_motions.view((bs * (self.num_kp+1), d, h, w, -1))                       # (bs*(num_kp+1), d, h, w, 3) !!!!
-        sparse_deformed = F.grid_sample(feature_repeat, sparse_motions)
-        sparse_deformed = sparse_deformed.view((bs, self.num_kp+1, -1, d, h, w))                        # (bs, num_kp+1, c, d, h, w)
-        return sparse_deformed
-
-    def create_heatmap_representations(self, feature, kp_driving, kp_source):
-        spatial_size = feature.shape[3:]
-        gaussian_driving = kp2gaussian(kp_driving, spatial_size=spatial_size, kp_variance=0.01)
-        gaussian_source = kp2gaussian(kp_source, spatial_size=spatial_size, kp_variance=0.01)
-        heatmap = gaussian_driving - gaussian_source
-
-        # adding background feature
-        zeros = torch.zeros(heatmap.shape[0], 1, spatial_size[0], spatial_size[1], spatial_size[2]).type(heatmap.type())
-        heatmap = torch.cat([zeros, heatmap], dim=1)
-        heatmap = heatmap.unsqueeze(2)         # (bs, num_kp+1, 1, d, h, w)
-        return heatmap
-
-    def forward(self, feature, kp_driving, kp_source):
-        bs, _, d, h, w = feature.shape
-
-        feature = self.compress(feature)
-        feature = self.norm(feature)
-        feature = F.relu(feature)
-
-        out_dict = dict()
-        sparse_motion = self.create_sparse_motions(feature, kp_driving, kp_source)
-        deformed_feature = self.create_deformed_feature(feature, sparse_motion)
-
-        heatmap = self.create_heatmap_representations(deformed_feature, kp_driving, kp_source)
-
-        input_ = torch.cat([heatmap, deformed_feature], dim=2)
-        input_ = input_.view(bs, -1, d, h, w)
-
-        # input = deformed_feature.view(bs, -1, d, h, w)      # (bs, num_kp+1 * c, d, h, w)
-
-        prediction = self.hourglass(input_)
-
-
-        mask = self.mask(prediction)
-        mask = F.softmax(mask, dim=1)
-        out_dict['mask'] = mask
-        mask = mask.unsqueeze(2)                                   # (bs, num_kp+1, 1, d, h, w)
-        sparse_motion = sparse_motion.permute(0, 1, 5, 2, 3, 4)    # (bs, num_kp+1, 3, d, h, w)
-        deformation = (sparse_motion * mask).sum(dim=1)            # (bs, 3, d, h, w)
-        deformation = deformation.permute(0, 2, 3, 4, 1)           # (bs, d, h, w, 3)
-
-        out_dict['deformation'] = deformation
-
-        if self.occlusion:
-            bs, c, d, h, w = prediction.shape
-            prediction = prediction.view(bs, -1, h, w)
-            occlusion_map = torch.sigmoid(self.occlusion(prediction))
-            out_dict['occlusion_map'] = occlusion_map
-
-        return out_dict

spaces/52Hz/SRMNet_real_world_denoising/model/SRMNet.py

@@ -1,227 +0,0 @@
-import torch
-import torch.nn as nn
-
-##---------- Basic Layers ----------
-def conv3x3(in_chn, out_chn, bias=True):
-    layer = nn.Conv2d(in_chn, out_chn, kernel_size=3, stride=1, padding=1, bias=bias)
-    return layer
-
-def conv(in_channels, out_channels, kernel_size, bias=False, stride=1):
-    return nn.Conv2d(
-        in_channels, out_channels, kernel_size,
-        padding=(kernel_size // 2), bias=bias, stride=stride)
-
-def bili_resize(factor):
-    return nn.Upsample(scale_factor=factor, mode='bilinear', align_corners=False)
-
-##---------- Basic Blocks ----------
-class UNetConvBlock(nn.Module):
-    def __init__(self, in_size, out_size, downsample):
-        super(UNetConvBlock, self).__init__()
-        self.downsample = downsample
-        self.block = SK_RDB(in_channels=in_size, growth_rate=out_size, num_layers=3)
-        if downsample:
-            self.downsample = PS_down(out_size, out_size, downscale=2)
-
-    def forward(self, x):
-        out = self.block(x)
-        if self.downsample:
-            out_down = self.downsample(out)
-            return out_down, out
-        else:
-            return out
-
-class UNetUpBlock(nn.Module):
-    def __init__(self, in_size, out_size):
-        super(UNetUpBlock, self).__init__()
-        # self.up = nn.ConvTranspose2d(in_size, out_size, kernel_size=2, stride=2, bias=True)
-        self.up = PS_up(in_size, out_size, upscale=2)
-        self.conv_block = UNetConvBlock(in_size, out_size, False)
-
-    def forward(self, x, bridge):
-        up = self.up(x)
-        out = torch.cat([up, bridge], dim=1)
-        out = self.conv_block(out)
-        return out
-
-##---------- Resizing Modules (Pixel(Un)Shuffle) ----------
-class PS_down(nn.Module):
-    def __init__(self, in_size, out_size, downscale):
-        super(PS_down, self).__init__()
-        self.UnPS = nn.PixelUnshuffle(downscale)
-        self.conv1 = nn.Conv2d((downscale**2) * in_size, out_size, 1, 1, 0)
-
-    def forward(self, x):
-        x = self.UnPS(x)  # h/2, w/2, 4*c
-        x = self.conv1(x)
-        return x
-
-class PS_up(nn.Module):
-    def __init__(self, in_size, out_size, upscale):
-        super(PS_up, self).__init__()
-
-        self.PS = nn.PixelShuffle(upscale)
-        self.conv1 = nn.Conv2d(in_size//(upscale**2), out_size, 1, 1, 0)
-
-    def forward(self, x):
-        x = self.PS(x)  # h/2, w/2, 4*c
-        x = self.conv1(x)
-        return x
-
-##---------- Selective Kernel Feature Fusion (SKFF) ----------
-class SKFF(nn.Module):
-    def __init__(self, in_channels, height=3, reduction=8, bias=False):
-        super(SKFF, self).__init__()
-
-        self.height = height
-        d = max(int(in_channels / reduction), 4)
-
-        self.avg_pool = nn.AdaptiveAvgPool2d(1)
-        self.conv_du = nn.Sequential(nn.Conv2d(in_channels, d, 1, padding=0, bias=bias), nn.PReLU())
-
-        self.fcs = nn.ModuleList([])
-        for i in range(self.height):
-            self.fcs.append(nn.Conv2d(d, in_channels, kernel_size=1, stride=1, bias=bias))
-
-        self.softmax = nn.Softmax(dim=1)
-
-    def forward(self, inp_feats):
-        batch_size, n_feats, H, W = inp_feats[1].shape
-
-        inp_feats = torch.cat(inp_feats, dim=1)
-        inp_feats = inp_feats.view(batch_size, self.height, n_feats, inp_feats.shape[2], inp_feats.shape[3])
-
-        feats_U = torch.sum(inp_feats, dim=1)
-        feats_S = self.avg_pool(feats_U)
-        feats_Z = self.conv_du(feats_S)
-
-        attention_vectors = [fc(feats_Z) for fc in self.fcs]
-        attention_vectors = torch.cat(attention_vectors, dim=1)
-        attention_vectors = attention_vectors.view(batch_size, self.height, n_feats, 1, 1)
-
-        attention_vectors = self.softmax(attention_vectors)
-        feats_V = torch.sum(inp_feats * attention_vectors, dim=1)
-
-        return feats_V
-
-##---------- Dense Block ----------
-class DenseLayer(nn.Module):
-    def __init__(self, in_channels, out_channels, I):
-        super(DenseLayer, self).__init__()
-        self.conv = nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=3 // 2)
-        self.relu = nn.ReLU(inplace=True)
-        self.sk = SKFF(out_channels, height=2, reduction=8, bias=False)
-
-    def forward(self, x):
-        x1 = self.relu(self.conv(x))
-        # output = torch.cat([x, x1], 1) # -> RDB
-        output = self.sk((x, x1))
-        return output
-
-##---------- Selective Kernel Residual Dense Block (SK-RDB) ----------
-class SK_RDB(nn.Module):
-    def __init__(self, in_channels, growth_rate, num_layers):
-        super(SK_RDB, self).__init__()
-        self.identity = nn.Conv2d(in_channels, growth_rate, 1, 1, 0)
-        self.layers = nn.Sequential(
-            *[DenseLayer(in_channels, in_channels, I=i) for i in range(num_layers)]
-        )
-        self.lff = nn.Conv2d(in_channels, growth_rate, kernel_size=1)
-
-    def forward(self, x):
-        res = self.identity(x)
-        x = self.layers(x)
-        x = self.lff(x)
-        return res + x
-
-##---------- testNet ----------
-class SRMNet(nn.Module):
-    def __init__(self, in_chn=3, wf=96, depth=4):
-        super(SRMNet, self).__init__()
-        self.depth = depth
-        self.down_path = nn.ModuleList()
-        self.bili_down = bili_resize(0.5)
-        self.conv_01 = nn.Conv2d(in_chn, wf, 3, 1, 1)
-
-        # encoder of UNet
-        prev_channels = 0
-        for i in range(depth):  # 0,1,2,3
-            downsample = True if (i + 1) < depth else False
-            self.down_path.append(UNetConvBlock(prev_channels + wf, (2 ** i) * wf, downsample))
-            prev_channels = (2 ** i) * wf
-
-        # decoder of UNet
-        self.up_path = nn.ModuleList()
-        self.skip_conv = nn.ModuleList()
-        self.conv_up = nn.ModuleList()
-        self.bottom_conv = nn.Conv2d(prev_channels, wf, 3, 1, 1)
-        self.bottom_up = bili_resize(2 ** (depth-1))
-
-        for i in reversed(range(depth - 1)):
-            self.up_path.append(UNetUpBlock(prev_channels, (2 ** i) * wf))
-            self.skip_conv.append(nn.Conv2d((2 ** i) * wf, (2 ** i) * wf, 3, 1, 1))
-            self.conv_up.append(nn.Sequential(*[nn.Conv2d((2 ** i) * wf, wf, 3, 1, 1), bili_resize(2 ** i)]))
-            prev_channels = (2 ** i) * wf
-
-        self.final_ff = SKFF(in_channels=wf, height=depth)
-        self.last = conv3x3(prev_channels, in_chn, bias=True)
-
-    def forward(self, x):
-        img = x
-        scale_img = img
-
-        ##### shallow conv #####
-        x1 = self.conv_01(img)
-        encs = []
-        ######## UNet ########
-        # Down-path (Encoder)
-        for i, down in enumerate(self.down_path):
-            if i == 0:
-                x1, x1_up = down(x1)
-                encs.append(x1_up)
-            elif (i + 1) < self.depth:
-                scale_img = self.bili_down(scale_img)
-                left_bar = self.conv_01(scale_img)
-                x1 = torch.cat([x1, left_bar], dim=1)
-                x1, x1_up = down(x1)
-                encs.append(x1_up)
-            else:
-                scale_img = self.bili_down(scale_img)
-                left_bar = self.conv_01(scale_img)
-                x1 = torch.cat([x1, left_bar], dim=1)
-                x1 = down(x1)
-
-        # Up-path (Decoder)
-        ms_result = [self.bottom_up(self.bottom_conv(x1))]
-        for i, up in enumerate(self.up_path):
-            x1 = up(x1, self.skip_conv[i](encs[-i - 1]))
-            ms_result.append(self.conv_up[i](x1))
-
-        # Multi-scale selective feature fusion
-        msff_result = self.final_ff(ms_result)
-
-        ##### Reconstruct #####
-        out_1 = self.last(msff_result) + img
-
-        return out_1
-
-
-if __name__ == "__main__":
-    from thop import profile
-
-    input = torch.ones(1, 3, 256, 256, dtype=torch.float, requires_grad=False)
-    model = SRMNet(in_chn=3, wf=96, depth=4)
-    out = model(input)
-    flops, params = profile(model, inputs=(input,))
-    total = sum(p.numel() for p in model.parameters())
-
-    # RDBlayer = SK_RDB(in_channels=64, growth_rate=64, num_layers=3)
-    # print(RDBlayer)
-    # out = RDBlayer(input)
-    # flops, params = profile(RDBlayer, inputs=(input,))
-
-    print('input shape:', input.shape)
-    print('output shape', out.shape)
-    print("-----------------------------------")
-    print("Total params: %.4f M" % (total / 1e6))
-    print("Total params: %.4f G" % (flops / 1e9))

spaces/801artistry/RVC801/Applio-RVC-Fork/utils/backups_test.py

@@ -1,138 +0,0 @@
-
-import os
-import shutil
-import hashlib
-import time
-
-LOGS_FOLDER = '/content/Applio-RVC-Fork/logs'
-WEIGHTS_FOLDER = '/content/Applio-RVC-Fork/weights'
-GOOGLE_DRIVE_PATH = '/content/drive/MyDrive/RVC_Backup'
-
-def import_google_drive_backup():
-    print("Importing Google Drive backup...")
-    GOOGLE_DRIVE_PATH = '/content/drive/MyDrive/RVC_Backup'  # change this to your Google Drive path
-    LOGS_FOLDER = '/content/Applio-RVC-Fork/logs'
-    WEIGHTS_FOLDER = '/content/Applio-RVC-Fork/weights'
-    weights_exist = False
-    files_to_copy = []
-    weights_to_copy = []
-    
-    def handle_files(root, files, is_weight_files=False):
-        for filename in files:
-            filepath = os.path.join(root, filename)
-            if filename.endswith('.pth') and is_weight_files:
-                weights_exist = True
-                backup_filepath = os.path.join(WEIGHTS_FOLDER, os.path.relpath(filepath, GOOGLE_DRIVE_PATH))
-            else:
-                backup_filepath = os.path.join(LOGS_FOLDER, os.path.relpath(filepath, GOOGLE_DRIVE_PATH))
-            backup_folderpath = os.path.dirname(backup_filepath)
-            if not os.path.exists(backup_folderpath):
-                os.makedirs(backup_folderpath)
-                print(f'Created folder: {backup_folderpath}', flush=True)
-            if is_weight_files:
-                weights_to_copy.append((filepath, backup_filepath))
-            else:
-                files_to_copy.append((filepath, backup_filepath))
-
-    for root, dirs, files in os.walk(os.path.join(GOOGLE_DRIVE_PATH, 'logs')):
-        handle_files(root, files)
-    
-    for root, dirs, files in os.walk(os.path.join(GOOGLE_DRIVE_PATH, 'weights')):
-        handle_files(root, files, True)
-
-    # Copy files in batches
-    total_files = len(files_to_copy)
-    start_time = time.time()
-    for i, (source, dest) in enumerate(files_to_copy, start=1):
-        with open(source, 'rb') as src, open(dest, 'wb') as dst:
-            shutil.copyfileobj(src, dst, 1024*1024)  # 1MB buffer size
-        # Report progress every 5 seconds or after every 100 files, whichever is less frequent
-        if time.time() - start_time > 5 or i % 100 == 0:
-            print(f'\rCopying file {i} of {total_files} ({i * 100 / total_files:.2f}%)', end="")
-            start_time = time.time()
-    print(f'\nImported {len(files_to_copy)} files from Google Drive backup')
-
-    # Copy weights in batches
-    total_weights = len(weights_to_copy)
-    start_time = time.time()
-    for i, (source, dest) in enumerate(weights_to_copy, start=1):
-        with open(source, 'rb') as src, open(dest, 'wb') as dst:
-            shutil.copyfileobj(src, dst, 1024*1024)  # 1MB buffer size
-        # Report progress every 5 seconds or after every 100 files, whichever is less frequent
-        if time.time() - start_time > 5 or i % 100 == 0:
-            print(f'\rCopying weight file {i} of {total_weights} ({i * 100 / total_weights:.2f}%)', end="")
-            start_time = time.time()
-    if weights_exist:
-        print(f'\nImported {len(weights_to_copy)} weight files')
-        print("Copied weights from Google Drive backup to local weights folder.")
-    else:
-        print("\nNo weights found in Google Drive backup.")
-    print("Google Drive backup import completed.")
-
-def backup_files():
-    print("\n Starting backup loop...")
-    last_backup_timestamps_path = os.path.join(LOGS_FOLDER, 'last_backup_timestamps.txt')
-    fully_updated = False  # boolean to track if all files are up to date
-    try:
-        with open(last_backup_timestamps_path, 'r') as f:
-            last_backup_timestamps = dict(line.strip().split(':') for line in f)
-    except:
-        last_backup_timestamps = {}
-
-    while True:
-        updated = False
-        files_to_copy = []
-        files_to_delete = []
-
-        for root, dirs, files in os.walk(LOGS_FOLDER):
-            for filename in files:
-                if filename != 'last_backup_timestamps.txt':
-                    filepath = os.path.join(root, filename)
-                    if os.path.isfile(filepath):
-                        backup_filepath = os.path.join(GOOGLE_DRIVE_PATH, os.path.relpath(filepath, LOGS_FOLDER))
-                        backup_folderpath = os.path.dirname(backup_filepath)
-
-                        if not os.path.exists(backup_folderpath):
-                            os.makedirs(backup_folderpath)
-                            print(f'Created backup folder: {backup_folderpath}', flush=True)
-
-                        # check if file has changed since last backup
-                        last_backup_timestamp = last_backup_timestamps.get(filepath)
-                        current_timestamp = os.path.getmtime(filepath)
-                        if last_backup_timestamp is None or float(last_backup_timestamp) < current_timestamp:
-                            files_to_copy.append((filepath, backup_filepath))  # add to list of files to copy
-                            last_backup_timestamps[filepath] = str(current_timestamp)  # update last backup timestamp
-                            updated = True
-                            fully_updated = False  # if a file is updated, all files are not up to date
-
-        # check if any files were deleted in Colab and delete them from the backup drive
-        for filepath in list(last_backup_timestamps.keys()):
-            if not os.path.exists(filepath):
-                backup_filepath = os.path.join(GOOGLE_DRIVE_PATH, os.path.relpath(filepath, LOGS_FOLDER))
-                if os.path.exists(backup_filepath):
-                    files_to_delete.append(backup_filepath)  # add to list of files to delete
-                del last_backup_timestamps[filepath]
-                updated = True
-                fully_updated = False  # if a file is deleted, all files are not up to date
-
-        # Copy files in batches
-        if files_to_copy:
-            for source, dest in files_to_copy:
-                shutil.copy2(source, dest)
-            print(f'Copied or updated {len(files_to_copy)} files')
-
-        # Delete files in batches
-        if files_to_delete:
-            for file in files_to_delete:
-                os.remove(file)
-            print(f'Deleted {len(files_to_delete)} files')
-
-        if not updated and not fully_updated:
-            print("Files are up to date.")
-            fully_updated = True  # if all files are up to date, set the boolean to True
-            copy_weights_folder_to_drive()
-
-        with open(last_backup_timestamps_path, 'w') as f:
-            for filepath, timestamp in last_backup_timestamps.items():
-                f.write(f'{filepath}:{timestamp}\n')
-        time.sleep(15)  # wait for 15 seconds before checking again

spaces/A-Celsius/Caption-Generator/app.py

@@ -1,48 +0,0 @@
-from PIL import Image
-from transformers import BlipProcessor, BlipForConditionalGeneration
-import torch
-import gradio as gr
-
-model_name = "Salesforce/blip-image-captioning-base"
-
-caption_processor = BlipProcessor.from_pretrained(model_name)
-model = BlipForConditionalGeneration.from_pretrained(model_name)
-
-device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-model.to(device)
-
-def generate_captions(image, num_captions=5,size=(512, 512)):
-    image = image.resize(size)
-    if image.mode != 'RGB':
-        image = image.convert('RGB')
-    pixel_values = caption_processor(image, return_tensors='pt').to(device)
-    
-    caption_ids = model.generate(
-        **pixel_values, 
-        max_length=30,
-        num_beams=5,
-        num_return_sequences=num_captions,
-        temperature=1.0
-    )
-    
-    captions = [
-        caption_processor.decode(ids, skip_special_tokens=True) 
-        for ids in caption_ids
-    ]
-    
-    return captions
-
-from gradio.components import Image, Textbox,Slider
-
-interface = gr.Interface(
-    fn=generate_captions,
-    inputs=[
-        Image(type="pil", label="Input Image"),
-        Slider(minimum=1, maximum=5, step=1, label="Number of Captions")
-    ],
-    outputs=Textbox(type="text", label="Captions"),
-    title="Image Caption Generator",
-    description="AI tool that creates captions based on the image provided by the user.",
-)
-
-interface.launch()

spaces/AHzizi/WaifuVoiceGen/commons.py

@@ -1,172 +0,0 @@
-import math
-import torch
-from torch.nn import functional as F
-import torch.jit
-
-
-def script_method(fn, _rcb=None):
-  return fn
-
-
-def script(obj, optimize=True, _frames_up=0, _rcb=None):
-  return obj
-
-
-torch.jit.script_method = script_method
-torch.jit.script = script
-
-
-def init_weights(m, mean=0.0, std=0.01):
-  classname = m.__class__.__name__
-  if classname.find("Conv") != -1:
-    m.weight.data.normal_(mean, std)
-
-
-def get_padding(kernel_size, dilation=1):
-  return int((kernel_size*dilation - dilation)/2)
-
-
-def convert_pad_shape(pad_shape):
-  l = pad_shape[::-1]
-  pad_shape = [item for sublist in l for item in sublist]
-  return pad_shape
-
-
-def intersperse(lst, item):
-  result = [item] * (len(lst) * 2 + 1)
-  result[1::2] = lst
-  return result
-
-
-def kl_divergence(m_p, logs_p, m_q, logs_q):
-  """KL(P||Q)"""
-  kl = (logs_q - logs_p) - 0.5
-  kl += 0.5 * (torch.exp(2. * logs_p) + ((m_p - m_q)**2)) * torch.exp(-2. * logs_q)
-  return kl
-
-
-def rand_gumbel(shape):
-  """Sample from the Gumbel distribution, protect from overflows."""
-  uniform_samples = torch.rand(shape) * 0.99998 + 0.00001
-  return -torch.log(-torch.log(uniform_samples))
-
-
-def rand_gumbel_like(x):
-  g = rand_gumbel(x.size()).to(dtype=x.dtype, device=x.device)
-  return g
-
-
-def slice_segments(x, ids_str, segment_size=4):
-  ret = torch.zeros_like(x[:, :, :segment_size])
-  for i in range(x.size(0)):
-    idx_str = ids_str[i]
-    idx_end = idx_str + segment_size
-    ret[i] = x[i, :, idx_str:idx_end]
-  return ret
-
-
-def rand_slice_segments(x, x_lengths=None, segment_size=4):
-  b, d, t = x.size()
-  if x_lengths is None:
-    x_lengths = t
-  ids_str_max = x_lengths - segment_size + 1
-  ids_str = (torch.rand([b]).to(device=x.device) * ids_str_max).to(dtype=torch.long)
-  ret = slice_segments(x, ids_str, segment_size)
-  return ret, ids_str
-
-
-def get_timing_signal_1d(
-    length, channels, min_timescale=1.0, max_timescale=1.0e4):
-  position = torch.arange(length, dtype=torch.float)
-  num_timescales = channels // 2
-  log_timescale_increment = (
-      math.log(float(max_timescale) / float(min_timescale)) /
-      (num_timescales - 1))
-  inv_timescales = min_timescale * torch.exp(
-      torch.arange(num_timescales, dtype=torch.float) * -log_timescale_increment)
-  scaled_time = position.unsqueeze(0) * inv_timescales.unsqueeze(1)
-  signal = torch.cat([torch.sin(scaled_time), torch.cos(scaled_time)], 0)
-  signal = F.pad(signal, [0, 0, 0, channels % 2])
-  signal = signal.view(1, channels, length)
-  return signal
-
-
-def add_timing_signal_1d(x, min_timescale=1.0, max_timescale=1.0e4):
-  b, channels, length = x.size()
-  signal = get_timing_signal_1d(length, channels, min_timescale, max_timescale)
-  return x + signal.to(dtype=x.dtype, device=x.device)
-
-
-def cat_timing_signal_1d(x, min_timescale=1.0, max_timescale=1.0e4, axis=1):
-  b, channels, length = x.size()
-  signal = get_timing_signal_1d(length, channels, min_timescale, max_timescale)
-  return torch.cat([x, signal.to(dtype=x.dtype, device=x.device)], axis)
-
-
-def subsequent_mask(length):
-  mask = torch.tril(torch.ones(length, length)).unsqueeze(0).unsqueeze(0)
-  return mask
-
-
-@torch.jit.script
-def fused_add_tanh_sigmoid_multiply(input_a, input_b, n_channels):
-  n_channels_int = n_channels[0]
-  in_act = input_a + input_b
-  t_act = torch.tanh(in_act[:, :n_channels_int, :])
-  s_act = torch.sigmoid(in_act[:, n_channels_int:, :])
-  acts = t_act * s_act
-  return acts
-
-
-def convert_pad_shape(pad_shape):
-  l = pad_shape[::-1]
-  pad_shape = [item for sublist in l for item in sublist]
-  return pad_shape
-
-
-def shift_1d(x):
-  x = F.pad(x, convert_pad_shape([[0, 0], [0, 0], [1, 0]]))[:, :, :-1]
-  return x
-
-
-def sequence_mask(length, max_length=None):
-  if max_length is None:
-    max_length = length.max()
-  x = torch.arange(max_length, dtype=length.dtype, device=length.device)
-  return x.unsqueeze(0) < length.unsqueeze(1)
-
-
-def generate_path(duration, mask):
-  """
-  duration: [b, 1, t_x]
-  mask: [b, 1, t_y, t_x]
-  """
-  device = duration.device
-  
-  b, _, t_y, t_x = mask.shape
-  cum_duration = torch.cumsum(duration, -1)
-  
-  cum_duration_flat = cum_duration.view(b * t_x)
-  path = sequence_mask(cum_duration_flat, t_y).to(mask.dtype)
-  path = path.view(b, t_x, t_y)
-  path = path - F.pad(path, convert_pad_shape([[0, 0], [1, 0], [0, 0]]))[:, :-1]
-  path = path.unsqueeze(1).transpose(2,3) * mask
-  return path
-
-
-def clip_grad_value_(parameters, clip_value, norm_type=2):
-  if isinstance(parameters, torch.Tensor):
-    parameters = [parameters]
-  parameters = list(filter(lambda p: p.grad is not None, parameters))
-  norm_type = float(norm_type)
-  if clip_value is not None:
-    clip_value = float(clip_value)
-
-  total_norm = 0
-  for p in parameters:
-    param_norm = p.grad.data.norm(norm_type)
-    total_norm += param_norm.item() ** norm_type
-    if clip_value is not None:
-      p.grad.data.clamp_(min=-clip_value, max=clip_value)
-  total_norm = total_norm ** (1. / norm_type)
-  return total_norm

spaces/AIFILMS/generate_human_motion/VQ-Trans/utils/config.py

@@ -1,17 +0,0 @@
-import os
-
-SMPL_DATA_PATH = "./body_models/smpl"
-
-SMPL_KINTREE_PATH = os.path.join(SMPL_DATA_PATH, "kintree_table.pkl")
-SMPL_MODEL_PATH = os.path.join(SMPL_DATA_PATH, "SMPL_NEUTRAL.pkl")
-JOINT_REGRESSOR_TRAIN_EXTRA = os.path.join(SMPL_DATA_PATH, 'J_regressor_extra.npy')
-
-ROT_CONVENTION_TO_ROT_NUMBER = {
-    'legacy': 23,
-    'no_hands': 21,
-    'full_hands': 51,
-    'mitten_hands': 33,
-}
-
-GENDERS = ['neutral', 'male', 'female']
-NUM_BETAS = 10

spaces/AIGC-Audio/AudioGPT/text_to_audio/Make_An_Audio/ldm/modules/losses_audio/contperceptual_dis.py

@@ -1,137 +0,0 @@
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-import sys
-
-sys.path.insert(0, '.')  # nopep8
-from ldm.modules.losses_audio.vqperceptual import *
-from ldm.modules.discriminator.multi_window_disc import Discriminator
-
-class LPAPSWithDiscriminator(nn.Module):# 相比于contperceptual.py添加了MultiWindowDiscriminator
-    def __init__(self, disc_start, logvar_init=0.0, kl_weight=1.0, pixelloss_weight=1.0,
-                 disc_num_layers=3, disc_in_channels=3, disc_factor=1.0, disc_weight=1.0,
-                 perceptual_weight=1.0, use_actnorm=False, disc_conditional=False,
-                 disc_loss="hinge"):
-
-        super().__init__()
-        assert disc_loss in ["hinge", "vanilla"]
-        self.kl_weight = kl_weight
-        self.pixel_weight = pixelloss_weight
-        self.perceptual_loss = LPAPS().eval()
-        self.perceptual_weight = perceptual_weight
-        # output log variance
-        self.logvar = nn.Parameter(torch.ones(size=()) * logvar_init)
-
-        self.discriminator = NLayerDiscriminator(input_nc=disc_in_channels,
-                                                 n_layers=disc_num_layers,
-                                                 use_actnorm=use_actnorm,
-                                                 ).apply(weights_init)
-        self.discriminator_iter_start = disc_start
-        if disc_loss == "hinge":
-            self.disc_loss = hinge_d_loss
-        elif disc_loss == "vanilla":
-            self.disc_loss = vanilla_d_loss
-        else:
-            raise ValueError(f"Unknown GAN loss '{disc_loss}'.")
-        print(f"LPAPSWithDiscriminator running with {disc_loss} loss.")
-        self.disc_factor = disc_factor
-        self.discriminator_weight = disc_weight
-        self.disc_conditional = disc_conditional
-
-        disc_win_num = 3
-        mel_disc_hidden_size = 128
-        self.discriminator_multi = Discriminator(time_lengths=[32, 64, 128][:disc_win_num],
-                freq_length=80, hidden_size=mel_disc_hidden_size, kernel=(3, 3),
-                cond_size=0, norm_type="in", reduction="stack")
-
-    def calculate_adaptive_weight(self, nll_loss, g_loss, last_layer=None):
-        if last_layer is not None:
-            nll_grads = torch.autograd.grad(nll_loss, last_layer, retain_graph=True)[0]
-            g_grads = torch.autograd.grad(g_loss, last_layer, retain_graph=True)[0]
-        else:
-            nll_grads = torch.autograd.grad(nll_loss, self.last_layer[0], retain_graph=True)[0]
-            g_grads = torch.autograd.grad(g_loss, self.last_layer[0], retain_graph=True)[0]
-
-        d_weight = torch.norm(nll_grads) / (torch.norm(g_grads) + 1e-4)
-        d_weight = torch.clamp(d_weight, 0.0, 1e4).detach()
-        d_weight = d_weight * self.discriminator_weight
-        return d_weight
-
-    def forward(self, inputs, reconstructions, posteriors, optimizer_idx,
-                global_step, last_layer=None, cond=None, split="train", weights=None):
-        rec_loss = torch.abs(inputs.contiguous() - reconstructions.contiguous())
-        if self.perceptual_weight > 0:
-            p_loss = self.perceptual_loss(inputs.contiguous(), reconstructions.contiguous())
-            rec_loss = rec_loss + self.perceptual_weight * p_loss
-        else:
-            p_loss = torch.tensor([0.0])
-
-        nll_loss = rec_loss / torch.exp(self.logvar) + self.logvar
-        weighted_nll_loss = nll_loss
-        if weights is not None:
-            weighted_nll_loss = weights*nll_loss
-        weighted_nll_loss = torch.sum(weighted_nll_loss) / weighted_nll_loss.shape[0]
-        nll_loss = torch.sum(nll_loss) / nll_loss.shape[0]
-        kl_loss = posteriors.kl()
-        kl_loss = torch.sum(kl_loss) / kl_loss.shape[0]
-
-        # now the GAN part
-        if optimizer_idx == 0:
-            # generator update
-            if cond is None:
-                assert not self.disc_conditional
-                logits_fake = self.discriminator(reconstructions.contiguous())
-            else:
-                assert self.disc_conditional
-                logits_fake = self.discriminator(torch.cat((reconstructions.contiguous(), cond), dim=1))
-
-            logits_fake_multi = self.discriminator_multi(reconstructions.contiguous().squeeze(1).transpose(1, 2))
-
-            g_loss = -torch.mean(logits_fake)
-            g_loss_multi = -torch.mean(logits_fake_multi['y'])
-
-            try:
-                d_weight = self.calculate_adaptive_weight(nll_loss, g_loss, last_layer=last_layer)
-                d_weight_multi = self.calculate_adaptive_weight(nll_loss, g_loss_multi, last_layer=last_layer)
-            except RuntimeError:
-                assert not self.training
-                d_weight = d_weight_multi = torch.tensor(0.0)
-
-            disc_factor = adopt_weight(self.disc_factor, global_step, threshold=self.discriminator_iter_start)
-            loss = weighted_nll_loss + self.kl_weight * kl_loss + d_weight * disc_factor * g_loss + d_weight_multi * disc_factor * g_loss_multi
-
-            log = {"{}/total_loss".format(split): loss.clone().detach().mean(),
-                   "{}/logvar".format(split): self.logvar.detach(),
-                   "{}/kl_loss".format(split): kl_loss.detach().mean(),
-                   "{}/nll_loss".format(split): nll_loss.detach().mean(),
-                   "{}/rec_loss".format(split): rec_loss.detach().mean(),
-                   "{}/d_weight".format(split): d_weight.detach(),
-                   "{}/disc_factor".format(split): torch.tensor(disc_factor),
-                   "{}/g_loss".format(split): g_loss.detach().mean(),
-                   "{}/g_loss_multi".format(split): g_loss_multi.detach().mean(),
-                   }
-            return loss, log
-
-        if optimizer_idx == 1:
-            # second pass for discriminator update
-            if cond is None:
-                logits_real = self.discriminator(inputs.contiguous().detach())
-                logits_fake = self.discriminator(reconstructions.contiguous().detach())
-            else:
-                logits_real = self.discriminator(torch.cat((inputs.contiguous().detach(), cond), dim=1))
-                logits_fake = self.discriminator(torch.cat((reconstructions.contiguous().detach(), cond), dim=1))
-
-            logits_real_multi = self.discriminator_multi(inputs.contiguous().detach().squeeze(1).transpose(1, 2))
-            logits_fake_multi = self.discriminator_multi(reconstructions.contiguous().detach().squeeze(1).transpose(1, 2))
-
-            disc_factor = adopt_weight(self.disc_factor, global_step, threshold=self.discriminator_iter_start)
-            d_loss = disc_factor * self.disc_loss(logits_real, logits_fake)
-            d_loss_multi = disc_factor * self.disc_loss(logits_real_multi['y'], logits_fake_multi['y'])
-
-            log = {"{}/disc_loss".format(split): d_loss.clone().detach().mean(),
-                   "{}/disc_loss_multi".format(split): d_loss_multi.clone().detach().mean(),
-                   "{}/logits_real".format(split): logits_real.detach().mean(),
-                   "{}/logits_fake".format(split): logits_fake.detach().mean()
-                   }
-            return d_loss+d_loss_multi, log
-

spaces/AIGC-Audio/Make_An_Audio/ldm/modules/encoders/open_clap/factory.py

@@ -1,257 +0,0 @@
-import json
-import logging
-import os
-import pathlib
-import re
-from copy import deepcopy
-from pathlib import Path
-
-import torch
-
-from .model import CLAP, convert_weights_to_fp16
-from .openai import load_openai_model
-from .pretrained import get_pretrained_url, download_pretrained
-from .transform import image_transform
-
-_MODEL_CONFIG_PATHS = [Path(__file__).parent / f"model_configs/"]
-_MODEL_CONFIGS = {}  # directory (model_name: config) of model architecture configs
-
-
-def _natural_key(string_):
-    return [int(s) if s.isdigit() else s for s in re.split(r"(\d+)", string_.lower())]
-
-
-def _rescan_model_configs():
-    global _MODEL_CONFIGS
-
-    config_ext = (".json",)
-    config_files = []
-    for config_path in _MODEL_CONFIG_PATHS:
-        if config_path.is_file() and config_path.suffix in config_ext:
-            config_files.append(config_path)
-        elif config_path.is_dir():
-            for ext in config_ext:
-                config_files.extend(config_path.glob(f"*{ext}"))
-
-    for cf in config_files:
-        with open(cf, "r") as f:
-            model_cfg = json.load(f)
-            if all(a in model_cfg for a in ("embed_dim", "audio_cfg", "text_cfg")):
-                _MODEL_CONFIGS[cf.stem] = model_cfg
-
-    _MODEL_CONFIGS = {
-        k: v
-        for k, v in sorted(_MODEL_CONFIGS.items(), key=lambda x: _natural_key(x[0]))
-    }
-
-
-_rescan_model_configs()  # initial populate of model config registry
-
-
-def load_state_dict(checkpoint_path: str, map_location="cpu", skip_params=True):
-    checkpoint = torch.load(checkpoint_path, map_location=map_location)
-    if isinstance(checkpoint, dict) and "state_dict" in checkpoint:
-        state_dict = checkpoint["state_dict"]
-    else:
-        state_dict = checkpoint
-    if skip_params:
-        if next(iter(state_dict.items()))[0].startswith("module"):
-            state_dict = {k[7:]: v for k, v in state_dict.items()}
-    # for k in state_dict:
-    #     if k.startswith('transformer'):
-    #         v = state_dict.pop(k)
-    #         state_dict['text_branch.' + k[12:]] = v
-    return state_dict
-
-
-def create_model(
-    amodel_name: str,
-    tmodel_name: str,
-    pretrained: str = "",
-    precision: str = "fp32",
-    device: torch.device = torch.device("cpu"),
-    jit: bool = False,
-    force_quick_gelu: bool = False,
-    openai_model_cache_dir: str = os.path.expanduser("~/.cache/clip"),
-    skip_params=True,
-    pretrained_audio: str = "",
-    pretrained_text: str = "",
-    enable_fusion: bool = False,
-    fusion_type: str = 'None'
-    # pretrained_image: bool = False,
-):
-    amodel_name = amodel_name.replace(
-        "/", "-"
-    )  # for callers using old naming with / in ViT names
-    pretrained_orig = pretrained
-    pretrained = pretrained.lower()
-    if pretrained == "openai":
-        if amodel_name in _MODEL_CONFIGS:
-            logging.info(f"Loading {amodel_name} model config.")
-            model_cfg = deepcopy(_MODEL_CONFIGS[amodel_name])
-        else:
-            logging.error(
-                f"Model config for {amodel_name} not found; available models {list_models()}."
-            )
-            raise RuntimeError(f"Model config for {amodel_name} not found.")
-
-        logging.info(f"Loading pretrained ViT-B-16 text encoder from OpenAI.")
-        # Hard Code in model name
-        model_cfg["text_cfg"]["model_type"] = tmodel_name
-        model = load_openai_model(
-            "ViT-B-16",
-            model_cfg,
-            device=device,
-            jit=jit,
-            cache_dir=openai_model_cache_dir,
-            enable_fusion=enable_fusion,
-            fusion_type=fusion_type
-        )
-        # See https://discuss.pytorch.org/t/valueerror-attemting-to-unscale-fp16-gradients/81372
-        if precision == "amp" or precision == "fp32":
-            model = model.float()
-    else:
-        if amodel_name in _MODEL_CONFIGS:
-            logging.info(f"Loading {amodel_name} model config.")
-            model_cfg = deepcopy(_MODEL_CONFIGS[amodel_name])
-        else:
-            logging.error(
-                f"Model config for {amodel_name} not found; available models {list_models()}."
-            )
-            raise RuntimeError(f"Model config for {amodel_name} not found.")
-
-        if force_quick_gelu:
-            # override for use of QuickGELU on non-OpenAI transformer models
-            model_cfg["quick_gelu"] = True
-
-        # if pretrained_image:
-        #     if 'timm_amodel_name' in model_cfg.get('vision_cfg', {}):
-        #         # pretrained weight loading for timm models set via vision_cfg
-        #         model_cfg['vision_cfg']['timm_model_pretrained'] = True
-        #     else:
-        #         assert False, 'pretrained image towers currently only supported for timm models'
-        model_cfg["text_cfg"]["model_type"] = tmodel_name
-        model_cfg["enable_fusion"] = enable_fusion
-        model_cfg["fusion_type"] = fusion_type
-        model = CLAP(**model_cfg)
-
-        if pretrained:
-            checkpoint_path = ""
-            url = get_pretrained_url(amodel_name, pretrained)
-            if url:
-                checkpoint_path = download_pretrained(url, root=openai_model_cache_dir)
-            elif os.path.exists(pretrained_orig):
-                checkpoint_path = pretrained_orig
-            if checkpoint_path:
-                logging.info(f"Loading pretrained {amodel_name}-{tmodel_name} weights ({pretrained}).")
-                ckpt = load_state_dict(checkpoint_path, skip_params=True)
-                model.load_state_dict(ckpt)
-                param_names = [n for n, p in model.named_parameters()]
-                for n in param_names:
-                    print(n, "\t", "Loaded" if n in ckpt else "Unloaded")
-            else:
-                logging.warning(
-                    f"Pretrained weights ({pretrained}) not found for model {amodel_name}."
-                )
-                raise RuntimeError(
-                    f"Pretrained weights ({pretrained}) not found for model {amodel_name}."
-                )
-
-        if pretrained_audio:
-            if amodel_name.startswith('PANN'):
-                if 'Cnn14_mAP' in pretrained_audio:  # official checkpoint
-                    audio_ckpt = torch.load(pretrained_audio, map_location='cpu')
-                    audio_ckpt = audio_ckpt['model']
-                    keys = list(audio_ckpt.keys())
-                    for key in keys:
-                        if 'spectrogram_extractor' not in key and 'logmel_extractor' not in key:
-                            v = audio_ckpt.pop(key)
-                            audio_ckpt['audio_branch.' + key] = v
-                elif os.path.basename(pretrained_audio).startswith('PANN'):  # checkpoint trained via HTSAT codebase
-                    audio_ckpt = torch.load(pretrained_audio, map_location='cpu')
-                    audio_ckpt = audio_ckpt['state_dict']
-                    keys = list(audio_ckpt.keys())
-                    for key in keys:
-                        if key.startswith('sed_model'):
-                            v = audio_ckpt.pop(key)
-                            audio_ckpt['audio_branch.' + key[10:]] = v
-                elif os.path.basename(pretrained_audio).startswith('finetuned'):  # checkpoint trained via linear probe codebase
-                    audio_ckpt = torch.load(pretrained_audio, map_location='cpu')
-                else:
-                    raise ValueError('Unknown audio checkpoint')
-            elif amodel_name.startswith('HTSAT'):
-                if 'HTSAT_AudioSet_Saved' in pretrained_audio:  # official checkpoint
-                    audio_ckpt = torch.load(pretrained_audio, map_location='cpu')
-                    audio_ckpt = audio_ckpt['state_dict']
-                    keys = list(audio_ckpt.keys())
-                    for key in keys:
-                        if key.startswith('sed_model') and ('spectrogram_extractor' not in key
-                                                            and 'logmel_extractor' not in key):
-                            v = audio_ckpt.pop(key)
-                            audio_ckpt['audio_branch.' + key[10:]] = v
-                elif os.path.basename(pretrained_audio).startswith('HTSAT'):  # checkpoint trained via HTSAT codebase
-                    audio_ckpt = torch.load(pretrained_audio, map_location='cpu')
-                    audio_ckpt = audio_ckpt['state_dict']
-                    keys = list(audio_ckpt.keys())
-                    for key in keys:
-                        if key.startswith('sed_model'):
-                            v = audio_ckpt.pop(key)
-                            audio_ckpt['audio_branch.' + key[10:]] = v
-                elif os.path.basename(pretrained_audio).startswith('finetuned'):  # checkpoint trained via linear probe codebase
-                    audio_ckpt = torch.load(pretrained_audio, map_location='cpu')
-                else:
-                    raise ValueError('Unknown audio checkpoint')
-            else:
-                raise f'this audio encoder pretrained checkpoint is not support'
-
-            model.load_state_dict(audio_ckpt, strict=False)
-            logging.info(f"Loading pretrained {amodel_name} weights ({pretrained_audio}).")
-            param_names = [n for n, p in model.named_parameters()]
-            for n in param_names:
-                print(n, "\t", "Loaded" if n in audio_ckpt else "Unloaded")
-            
-        model.to(device=device)
-        if precision == "fp16":
-            assert device.type != "cpu"
-            convert_weights_to_fp16(model)
-
-        if jit:
-            model = torch.jit.script(model)
-
-    return model, model_cfg
-
-
-def create_model_and_transforms(
-    model_name: str,
-    pretrained: str = "",
-    precision: str = "fp32",
-    device: torch.device = torch.device("cpu"),
-    jit: bool = False,
-    force_quick_gelu: bool = False,
-    # pretrained_image: bool = False,
-):
-    model = create_model(
-        model_name,
-        pretrained,
-        precision,
-        device,
-        jit,
-        force_quick_gelu=force_quick_gelu,
-        # pretrained_image=pretrained_image
-    )
-    preprocess_train = image_transform(model.visual.image_size, is_train=True)
-    preprocess_val = image_transform(model.visual.image_size, is_train=False)
-    return model, preprocess_train, preprocess_val
-
-
-def list_models():
-    """enumerate available model architectures based on config files"""
-    return list(_MODEL_CONFIGS.keys())
-
-
-def add_model_config(path):
-    """add model config path or file and update registry"""
-    if not isinstance(path, Path):
-        path = Path(path)
-    _MODEL_CONFIG_PATHS.append(path)
-    _rescan_model_configs()

spaces/AILab-CVC/SEED-LLaMA/models/seed_qformer/vit.py

@@ -1,395 +0,0 @@
-"""
- Copyright (c) 2022, salesforce.com, inc.
- All rights reserved.
- SPDX-License-Identifier: BSD-3-Clause
- For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause
- 
- Based on timm code base
- https://github.com/rwightman/pytorch-image-models/tree/master/timm
-"""
-
-import math
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-from functools import partial
-
-from timm.models.vision_transformer import _cfg, PatchEmbed
-from timm.models.registry import register_model
-from timm.models.layers import trunc_normal_, DropPath
-from timm.models.helpers import named_apply, adapt_input_conv
-
-
-class Mlp(nn.Module):
-    """MLP as used in Vision Transformer, MLP-Mixer and related networks"""
-    def __init__(
-        self,
-        in_features,
-        hidden_features=None,
-        out_features=None,
-        act_layer=nn.GELU,
-        drop=0.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 Attention(nn.Module):
-    def __init__(
-        self,
-        dim,
-        num_heads=8,
-        qkv_bias=False,
-        qk_scale=None,
-        attn_drop=0.0,
-        proj_drop=0.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)
-        self.attn_gradients = None
-        self.attention_map = None
-
-    def save_attn_gradients(self, attn_gradients):
-        self.attn_gradients = attn_gradients
-
-    def get_attn_gradients(self):
-        return self.attn_gradients
-
-    def save_attention_map(self, attention_map):
-        self.attention_map = attention_map
-
-    def get_attention_map(self):
-        return self.attention_map
-
-    def forward(self, x, register_hook=False):
-        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)
-
-        if register_hook:
-            self.save_attention_map(attn)
-            attn.register_hook(self.save_attn_gradients)
-
-        x = (attn @ v).transpose(1, 2).reshape(B, N, C)
-        x = self.proj(x)
-        x = self.proj_drop(x)
-        return x
-
-
-class Block(nn.Module):
-    def __init__(
-        self,
-        dim,
-        num_heads,
-        mlp_ratio=4.0,
-        qkv_bias=False,
-        qk_scale=None,
-        drop=0.0,
-        attn_drop=0.0,
-        drop_path=0.0,
-        act_layer=nn.GELU,
-        norm_layer=nn.LayerNorm,
-        use_grad_checkpointing=False,
-    ):
-        super().__init__()
-        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.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,
-        )
-
-        # if use_grad_checkpointing:
-        #     self.attn = checkpoint_wrapper(self.attn)
-        #     self.mlp = checkpoint_wrapper(self.mlp)
-
-    def forward(self, x, register_hook=False):
-        x = x + self.drop_path(self.attn(self.norm1(x), register_hook=register_hook))
-        x = x + self.drop_path(self.mlp(self.norm2(x)))
-        return x
-
-
-class VisionTransformer(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,
-        img_size=224,
-        patch_size=16,
-        in_chans=3,
-        num_classes=1000,
-        embed_dim=768,
-        depth=12,
-        num_heads=12,
-        mlp_ratio=4.0,
-        qkv_bias=True,
-        qk_scale=None,
-        representation_size=None,
-        drop_rate=0.0,
-        attn_drop_rate=0.0,
-        drop_path_rate=0.0,
-        norm_layer=None,
-        use_grad_checkpointing=False,
-        ckpt_layer=0,
-    ):
-        """
-        Args:
-            img_size (int, tuple): input image size
-            patch_size (int, tuple): patch size
-            in_chans (int): number of input channels
-            num_classes (int): number of classes for classification head
-            embed_dim (int): embedding dimension
-            depth (int): depth of transformer
-            num_heads (int): number of attention heads
-            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
-        """
-        super().__init__()
-        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)
-
-        self.patch_embed = PatchEmbed(
-            img_size=img_size,
-            patch_size=patch_size,
-            in_chans=in_chans,
-            embed_dim=embed_dim,
-        )
-
-        num_patches = self.patch_embed.num_patches
-
-        self.cls_token = nn.Parameter(torch.zeros(1, 1, embed_dim))
-        self.pos_embed = nn.Parameter(torch.zeros(1, num_patches + 1, embed_dim))
-        self.pos_drop = nn.Dropout(p=drop_rate)
-
-        dpr = [x.item() for x in torch.linspace(0, drop_path_rate, depth)]  # stochastic depth decay rule
-        self.blocks = nn.ModuleList([
-            Block(
-                dim=embed_dim,
-                num_heads=num_heads,
-                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,
-                use_grad_checkpointing=(use_grad_checkpointing and i >= depth - ckpt_layer),
-            ) for i in range(depth)
-        ])
-        self.norm = norm_layer(embed_dim)
-
-        trunc_normal_(self.pos_embed, std=0.02)
-        trunc_normal_(self.cls_token, std=0.02)
-        self.apply(self._init_weights)
-
-    def _init_weights(self, m):
-        if isinstance(m, nn.Linear):
-            trunc_normal_(m.weight, std=0.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 forward(self, x, register_blk=-1):
-        B = x.shape[0]
-        x = self.patch_embed(x)
-
-        cls_tokens = self.cls_token.expand(B, -1, -1)  # stole cls_tokens impl from Phil Wang, thanks
-        x = torch.cat((cls_tokens, x), dim=1)
-
-        x = x + self.pos_embed[:, :x.size(1), :]
-        x = self.pos_drop(x)
-
-        for i, blk in enumerate(self.blocks):
-            x = blk(x, register_blk == i)
-        x = self.norm(x)
-
-        return x
-
-    @torch.jit.ignore()
-    def load_pretrained(self, checkpoint_path, prefix=""):
-        _load_weights(self, checkpoint_path, prefix)
-
-
-@torch.no_grad()
-def _load_weights(model: VisionTransformer, checkpoint_path: str, prefix: str = ""):
-    """Load weights from .npz checkpoints for official Google Brain Flax implementation"""
-    import numpy as np
-
-    def _n2p(w, t=True):
-        if w.ndim == 4 and w.shape[0] == w.shape[1] == w.shape[2] == 1:
-            w = w.flatten()
-        if t:
-            if w.ndim == 4:
-                w = w.transpose([3, 2, 0, 1])
-            elif w.ndim == 3:
-                w = w.transpose([2, 0, 1])
-            elif w.ndim == 2:
-                w = w.transpose([1, 0])
-        return torch.from_numpy(w)
-
-    w = np.load(checkpoint_path)
-    if not prefix and "opt/target/embedding/kernel" in w:
-        prefix = "opt/target/"
-
-    if hasattr(model.patch_embed, "backbone"):
-        # hybrid
-        backbone = model.patch_embed.backbone
-        stem_only = not hasattr(backbone, "stem")
-        stem = backbone if stem_only else backbone.stem
-        stem.conv.weight.copy_(adapt_input_conv(stem.conv.weight.shape[1], _n2p(w[f"{prefix}conv_root/kernel"])))
-        stem.norm.weight.copy_(_n2p(w[f"{prefix}gn_root/scale"]))
-        stem.norm.bias.copy_(_n2p(w[f"{prefix}gn_root/bias"]))
-        if not stem_only:
-            for i, stage in enumerate(backbone.stages):
-                for j, block in enumerate(stage.blocks):
-                    bp = f"{prefix}block{i + 1}/unit{j + 1}/"
-                    for r in range(3):
-                        getattr(block, f"conv{r + 1}").weight.copy_(_n2p(w[f"{bp}conv{r + 1}/kernel"]))
-                        getattr(block, f"norm{r + 1}").weight.copy_(_n2p(w[f"{bp}gn{r + 1}/scale"]))
-                        getattr(block, f"norm{r + 1}").bias.copy_(_n2p(w[f"{bp}gn{r + 1}/bias"]))
-                    if block.downsample is not None:
-                        block.downsample.conv.weight.copy_(_n2p(w[f"{bp}conv_proj/kernel"]))
-                        block.downsample.norm.weight.copy_(_n2p(w[f"{bp}gn_proj/scale"]))
-                        block.downsample.norm.bias.copy_(_n2p(w[f"{bp}gn_proj/bias"]))
-        embed_conv_w = _n2p(w[f"{prefix}embedding/kernel"])
-    else:
-        embed_conv_w = adapt_input_conv(model.patch_embed.proj.weight.shape[1], _n2p(w[f"{prefix}embedding/kernel"]))
-    model.patch_embed.proj.weight.copy_(embed_conv_w)
-    model.patch_embed.proj.bias.copy_(_n2p(w[f"{prefix}embedding/bias"]))
-    model.cls_token.copy_(_n2p(w[f"{prefix}cls"], t=False))
-    pos_embed_w = _n2p(w[f"{prefix}Transformer/posembed_input/pos_embedding"], t=False)
-    if pos_embed_w.shape != model.pos_embed.shape:
-        pos_embed_w = resize_pos_embed(  # resize pos embedding when different size from pretrained weights
-            pos_embed_w,
-            model.pos_embed,
-            getattr(model, "num_tokens", 1),
-            model.patch_embed.grid_size,
-        )
-    model.pos_embed.copy_(pos_embed_w)
-    model.norm.weight.copy_(_n2p(w[f"{prefix}Transformer/encoder_norm/scale"]))
-    model.norm.bias.copy_(_n2p(w[f"{prefix}Transformer/encoder_norm/bias"]))
-    #     if isinstance(model.head, nn.Linear) and model.head.bias.shape[0] == w[f'{prefix}head/bias'].shape[-1]:
-    #         model.head.weight.copy_(_n2p(w[f'{prefix}head/kernel']))
-    #         model.head.bias.copy_(_n2p(w[f'{prefix}head/bias']))
-    #     if isinstance(getattr(model.pre_logits, 'fc', None), nn.Linear) and f'{prefix}pre_logits/bias' in w:
-    #         model.pre_logits.fc.weight.copy_(_n2p(w[f'{prefix}pre_logits/kernel']))
-    #         model.pre_logits.fc.bias.copy_(_n2p(w[f'{prefix}pre_logits/bias']))
-    for i, block in enumerate(model.blocks.children()):
-        block_prefix = f"{prefix}Transformer/encoderblock_{i}/"
-        mha_prefix = block_prefix + "MultiHeadDotProductAttention_1/"
-        block.norm1.weight.copy_(_n2p(w[f"{block_prefix}LayerNorm_0/scale"]))
-        block.norm1.bias.copy_(_n2p(w[f"{block_prefix}LayerNorm_0/bias"]))
-        block.attn.qkv.weight.copy_(
-            torch.cat([_n2p(w[f"{mha_prefix}{n}/kernel"], t=False).flatten(1).T for n in ("query", "key", "value")]))
-        block.attn.qkv.bias.copy_(
-            torch.cat([_n2p(w[f"{mha_prefix}{n}/bias"], t=False).reshape(-1) for n in ("query", "key", "value")]))
-        block.attn.proj.weight.copy_(_n2p(w[f"{mha_prefix}out/kernel"]).flatten(1))
-        block.attn.proj.bias.copy_(_n2p(w[f"{mha_prefix}out/bias"]))
-        for r in range(2):
-            getattr(block.mlp, f"fc{r + 1}").weight.copy_(_n2p(w[f"{block_prefix}MlpBlock_3/Dense_{r}/kernel"]))
-            getattr(block.mlp, f"fc{r + 1}").bias.copy_(_n2p(w[f"{block_prefix}MlpBlock_3/Dense_{r}/bias"]))
-        block.norm2.weight.copy_(_n2p(w[f"{block_prefix}LayerNorm_2/scale"]))
-        block.norm2.bias.copy_(_n2p(w[f"{block_prefix}LayerNorm_2/bias"]))
-
-
-def resize_pos_embed(posemb, posemb_new, num_tokens=1, gs_new=()):
-    # Rescale the grid of position embeddings when loading from state_dict. Adapted from
-    # https://github.com/google-research/vision_transformer/blob/00883dd691c63a6830751563748663526e811cee/vit_jax/checkpoint.py#L224
-    print("Resized position embedding: %s to %s", posemb.shape, posemb_new.shape)
-    ntok_new = posemb_new.shape[1]
-    if num_tokens:
-        posemb_tok, posemb_grid = posemb[:, :num_tokens], posemb[0, num_tokens:]
-        ntok_new -= num_tokens
-    else:
-        posemb_tok, posemb_grid = posemb[:, :0], posemb[0]
-    gs_old = int(math.sqrt(len(posemb_grid)))
-    if not len(gs_new):  # backwards compatibility
-        gs_new = [int(math.sqrt(ntok_new))] * 2
-    assert len(gs_new) >= 2
-    print("Position embedding grid-size from %s to %s", [gs_old, gs_old], gs_new)
-    posemb_grid = posemb_grid.reshape(1, gs_old, gs_old, -1).permute(0, 3, 1, 2)
-    posemb_grid = F.interpolate(posemb_grid, size=gs_new, mode="bicubic", align_corners=False)
-    posemb_grid = posemb_grid.permute(0, 2, 3, 1).reshape(1, gs_new[0] * gs_new[1], -1)
-    posemb = torch.cat([posemb_tok, posemb_grid], dim=1)
-    return
-
-
-def interpolate_pos_embed(pos_embed_checkpoint, visual_encoder):
-    # interpolate position embedding
-    embedding_size = pos_embed_checkpoint.shape[-1]
-    num_patches = visual_encoder.patch_embed.num_patches
-    num_extra_tokens = visual_encoder.pos_embed.shape[-2] - num_patches
-    # height (== width) for the checkpoint position embedding
-    orig_size = int((pos_embed_checkpoint.shape[-2] - num_extra_tokens)**0.5)
-    # height (== width) for the new position embedding
-    new_size = int(num_patches**0.5)
-
-    if orig_size != new_size:
-        # class_token and dist_token are kept unchanged
-        extra_tokens = pos_embed_checkpoint[:, :num_extra_tokens]
-        # only the position tokens are interpolated
-        pos_tokens = pos_embed_checkpoint[:, num_extra_tokens:]
-        pos_tokens = pos_tokens.reshape(-1, orig_size, orig_size, embedding_size).permute(0, 3, 1, 2)
-        pos_tokens = torch.nn.functional.interpolate(pos_tokens, size=(new_size, new_size), mode="bicubic", align_corners=False)
-        pos_tokens = pos_tokens.permute(0, 2, 3, 1).flatten(1, 2)
-        new_pos_embed = torch.cat((extra_tokens, pos_tokens), dim=1)
-        print("reshape position embedding from %d to %d" % (orig_size**2, new_size**2))
-
-        return new_pos_embed
-    else:
-        return pos_embed_checkpoint

spaces/Abhaykoul/Merriam-webster_clone/app.py

@@ -1,39 +0,0 @@
-import streamlit as st
-import requests
-from bs4 import BeautifulSoup
-
-st.set_page_config(page_title="Word Definition App")
-
-def fetch_definition(word):
-    base_url = f"https://www.merriam-webster.com/dictionary/{word}"
-
-    response = requests.get(base_url)
-
-    if response.status_code == 200:
-        soup = BeautifulSoup(response.text, 'html.parser')
-        definition_span = soup.find("span", class_="dtText")
-
-        if definition_span:
-            full_definition = definition_span.get_text()
-            sentences = full_definition.split('. ')
-            limited_definition = '. '.join(sentences[:3])
-            return limited_definition
-        else:
-            return "Definition not found."
-    else:
-        return "Word not found or unable to retrieve data."
-
-def main():
-    st.title("Word Definition App")
-    word = st.text_input("Enter a word:")
-
-    if word.lower() == 'quit':
-        st.warning("You entered 'quit'. The app will not quit as this is a web application.")
-    else:
-        if st.button("Get Definition"):
-            definition = fetch_definition(word)
-            st.write("Definition:")
-            st.write(definition)
-
-if __name__ == '__main__':
-    main()

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

@@ -1,61 +0,0 @@
-from __future__ import annotations
-
-import time, json, re
-from aiohttp import ClientSession
-from typing import AsyncGenerator
-
-from .base_provider import AsyncGeneratorProvider
-from .helper import format_prompt
-
-class ChatgptDemo(AsyncGeneratorProvider):
-    url = "https://chat.chatgptdemo.net"
-    supports_gpt_35_turbo = True
-    working = True
-
-    @classmethod
-    async def create_async_generator(
-        cls,
-        model: str,
-        messages: list[dict[str, str]],
-        proxy: str = None,
-        **kwargs
-    ) -> AsyncGenerator:
-        headers = {
-            "authority": "chat.chatgptdemo.net",
-            "accept-language": "de-DE,de;q=0.9,en-DE;q=0.8,en;q=0.7,en-US",
-            "origin": "https://chat.chatgptdemo.net",
-            "referer": "https://chat.chatgptdemo.net/",
-            "sec-ch-ua": '"Google Chrome";v="117", "Not;A=Brand";v="8", "Chromium";v="117"',
-            "sec-ch-ua-mobile": "?0",
-            "sec-ch-ua-platform": '"Linux"',
-            "sec-fetch-dest": "empty",
-            "sec-fetch-mode": "cors",
-            "sec-fetch-site": "same-origin",
-            "user-agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/117.0.0.0 Safari/537.36"
-        }
-        async with ClientSession(headers=headers) as session:
-            async with session.get(f"{cls.url}/", proxy=proxy) as response:
-                response.raise_for_status()
-                response = await response.text()
-                result = re.search(r'<div id="USERID" style="display: none">(.*?)<\/div>', response)
-                if not result:
-                    raise RuntimeError("No user id found")
-                user_id = result.group(1)
-            async with session.post(f"{cls.url}/new_chat", json={"user_id": user_id}, proxy=proxy) as response:
-                response.raise_for_status()
-                chat_id = (await response.json())["id_"]
-            if not chat_id:
-                raise RuntimeError("Could not create new chat")
-            data = {
-                "question": format_prompt(messages),
-                "chat_id": chat_id,
-                "timestamp": int(time.time()*1000),
-            }
-            async with session.post(f"{cls.url}/chat_api_stream", json=data, proxy=proxy) as response:
-                response.raise_for_status()
-                async for line in response.content:
-                    if line.startswith(b"data: "):
-                        line = json.loads(line[6:-1])
-                        chunk = line["choices"][0]["delta"].get("content")
-                        if chunk:
-                            yield chunk

spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/templates/spinner/box/Factory.d.ts

@@ -1,6 +0,0 @@
-import Box from './Box';
-import Base from '../base/Base';
-
-export default function Factory(
-    config?: Base.IConfig
-): Box;

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

@@ -1,85 +0,0 @@
-import Sizer from '../sizer/Sizer.js';
-import IsArray from '../../../plugins/utils/object/IsArray.js';
-
-const SizerAdd = Sizer.prototype.add;
-const SizerAddSpace = Sizer.prototype.addSpace;
-
-var Add = function (gameObject) {
-    var isNormalGameObject = !gameObject.isRexSpace;
-    var proportion = (!isNormalGameObject || this.buttonsExpand) ? 1 : 0;
-
-    if (this.sizerChildren.length === 0) {  // First element
-        if (isNormalGameObject) {
-            // Add space at head
-            var hasHeadSpace = (!this.buttonsExpand) &&
-                ((this.buttonsAlign === 'right') || (this.buttonsAlign === 'center') || (this.buttonsAlign === 'bottom'));
-            if (hasHeadSpace) {
-                SizerAddSpace.call(this);
-            }
-
-            SizerAdd.call(this,
-                gameObject,
-                { proportion: proportion, expand: true }
-            );
-
-            // Add space at tail
-            var hasTailSpace = (!this.buttonsExpand) && (this.buttonsAlign === 'center');
-            if (hasTailSpace) {
-                SizerAddSpace.call(this);
-            }
-            this.hasTailSpace = hasTailSpace;
-
-        } else { // A space
-            SizerAdd.call(this,
-                gameObject,
-                { proportion: proportion, expand: true }
-            );
-            this.hasTailSpace = false;
-
-        }
-
-    } else {   // Others
-        if (this.hasTailSpace) {
-            var lastIndex = this.sizerChildren.length - 1;
-            SizerAdd.call(this,
-                gameObject,
-                { index: lastIndex, proportion: proportion, expand: true }
-            );
-
-        } else {
-            SizerAdd.call(this,
-                gameObject,
-                { proportion: proportion, expand: true }
-            );
-        }
-
-    }
-
-    // Space or other game object as button
-    if (isNormalGameObject) {
-        this.buttonGroup.add(gameObject);
-    }
-
-    return this;
-};
-
-export default {
-    addButton(gameObject) {
-        if (IsArray(gameObject)) {
-            var gameObjects = gameObject;
-            for (var i = 0, cnt = gameObjects.length; i < cnt; i++) {
-                Add.call(this, gameObjects[i]);
-            }
-        } else {
-            Add.call(this, gameObject);
-        }
-        return this;
-    },
-
-    addButtons(gameObjects) {
-        for (var i = 0, cnt = gameObjects.length; i < cnt; i++) {
-            Add.call(this, gameObjects[i]);
-        }
-        return this;
-    }
-}

spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/templates/ui/flip/Factory.d.ts

@@ -1,7 +0,0 @@
-// import * as Phaser from 'phaser';
-import Flip from "./Flip";
-
-export default function (
-    gameObject: Phaser.GameObjects.GameObject,
-    config?: Flip.IConfig
-): Flip;

spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/templates/ui/shake/Shake.d.ts

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

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

@@ -1,188 +0,0 @@
-import math
-import numpy as np
-import torch
-from torch import nn
-from torch.nn import functional as F
-
-def slice_pitch_segments(x, ids_str, segment_size=4):
-  ret = torch.zeros_like(x[:, :segment_size])
-  for i in range(x.size(0)):
-    idx_str = ids_str[i]
-    idx_end = idx_str + segment_size
-    ret[i] = x[i, idx_str:idx_end]
-  return ret
-
-def rand_slice_segments_with_pitch(x, pitch, x_lengths=None, segment_size=4):
-  b, d, t = x.size()
-  if x_lengths is None:
-    x_lengths = t
-  ids_str_max = x_lengths - segment_size + 1
-  ids_str = (torch.rand([b]).to(device=x.device) * ids_str_max).to(dtype=torch.long)
-  ret = slice_segments(x, ids_str, segment_size)
-  ret_pitch = slice_pitch_segments(pitch, ids_str, segment_size)
-  return ret, ret_pitch, ids_str
-
-def init_weights(m, mean=0.0, std=0.01):
-  classname = m.__class__.__name__
-  if classname.find("Conv") != -1:
-    m.weight.data.normal_(mean, std)
-
-
-def get_padding(kernel_size, dilation=1):
-  return int((kernel_size*dilation - dilation)/2)
-
-
-def convert_pad_shape(pad_shape):
-  l = pad_shape[::-1]
-  pad_shape = [item for sublist in l for item in sublist]
-  return pad_shape
-
-
-def intersperse(lst, item):
-  result = [item] * (len(lst) * 2 + 1)
-  result[1::2] = lst
-  return result
-
-
-def kl_divergence(m_p, logs_p, m_q, logs_q):
-  """KL(P||Q)"""
-  kl = (logs_q - logs_p) - 0.5
-  kl += 0.5 * (torch.exp(2. * logs_p) + ((m_p - m_q)**2)) * torch.exp(-2. * logs_q)
-  return kl
-
-
-def rand_gumbel(shape):
-  """Sample from the Gumbel distribution, protect from overflows."""
-  uniform_samples = torch.rand(shape) * 0.99998 + 0.00001
-  return -torch.log(-torch.log(uniform_samples))
-
-
-def rand_gumbel_like(x):
-  g = rand_gumbel(x.size()).to(dtype=x.dtype, device=x.device)
-  return g
-
-
-def slice_segments(x, ids_str, segment_size=4):
-  ret = torch.zeros_like(x[:, :, :segment_size])
-  for i in range(x.size(0)):
-    idx_str = ids_str[i]
-    idx_end = idx_str + segment_size
-    ret[i] = x[i, :, idx_str:idx_end]
-  return ret
-
-
-def rand_slice_segments(x, x_lengths=None, segment_size=4):
-  b, d, t = x.size()
-  if x_lengths is None:
-    x_lengths = t
-  ids_str_max = x_lengths - segment_size + 1
-  ids_str = (torch.rand([b]).to(device=x.device) * ids_str_max).to(dtype=torch.long)
-  ret = slice_segments(x, ids_str, segment_size)
-  return ret, ids_str
-
-
-def rand_spec_segments(x, x_lengths=None, segment_size=4):
-  b, d, t = x.size()
-  if x_lengths is None:
-    x_lengths = t
-  ids_str_max = x_lengths - segment_size
-  ids_str = (torch.rand([b]).to(device=x.device) * ids_str_max).to(dtype=torch.long)
-  ret = slice_segments(x, ids_str, segment_size)
-  return ret, ids_str
-
-
-def get_timing_signal_1d(
-    length, channels, min_timescale=1.0, max_timescale=1.0e4):
-  position = torch.arange(length, dtype=torch.float)
-  num_timescales = channels // 2
-  log_timescale_increment = (
-      math.log(float(max_timescale) / float(min_timescale)) /
-      (num_timescales - 1))
-  inv_timescales = min_timescale * torch.exp(
-      torch.arange(num_timescales, dtype=torch.float) * -log_timescale_increment)
-  scaled_time = position.unsqueeze(0) * inv_timescales.unsqueeze(1)
-  signal = torch.cat([torch.sin(scaled_time), torch.cos(scaled_time)], 0)
-  signal = F.pad(signal, [0, 0, 0, channels % 2])
-  signal = signal.view(1, channels, length)
-  return signal
-
-
-def add_timing_signal_1d(x, min_timescale=1.0, max_timescale=1.0e4):
-  b, channels, length = x.size()
-  signal = get_timing_signal_1d(length, channels, min_timescale, max_timescale)
-  return x + signal.to(dtype=x.dtype, device=x.device)
-
-
-def cat_timing_signal_1d(x, min_timescale=1.0, max_timescale=1.0e4, axis=1):
-  b, channels, length = x.size()
-  signal = get_timing_signal_1d(length, channels, min_timescale, max_timescale)
-  return torch.cat([x, signal.to(dtype=x.dtype, device=x.device)], axis)
-
-
-def subsequent_mask(length):
-  mask = torch.tril(torch.ones(length, length)).unsqueeze(0).unsqueeze(0)
-  return mask
-
-
-@torch.jit.script
-def fused_add_tanh_sigmoid_multiply(input_a, input_b, n_channels):
-  n_channels_int = n_channels[0]
-  in_act = input_a + input_b
-  t_act = torch.tanh(in_act[:, :n_channels_int, :])
-  s_act = torch.sigmoid(in_act[:, n_channels_int:, :])
-  acts = t_act * s_act
-  return acts
-
-
-def convert_pad_shape(pad_shape):
-  l = pad_shape[::-1]
-  pad_shape = [item for sublist in l for item in sublist]
-  return pad_shape
-
-
-def shift_1d(x):
-  x = F.pad(x, convert_pad_shape([[0, 0], [0, 0], [1, 0]]))[:, :, :-1]
-  return x
-
-
-def sequence_mask(length, max_length=None):
-  if max_length is None:
-    max_length = length.max()
-  x = torch.arange(max_length, dtype=length.dtype, device=length.device)
-  return x.unsqueeze(0) < length.unsqueeze(1)
-
-
-def generate_path(duration, mask):
-  """
-  duration: [b, 1, t_x]
-  mask: [b, 1, t_y, t_x]
-  """
-  device = duration.device
-  
-  b, _, t_y, t_x = mask.shape
-  cum_duration = torch.cumsum(duration, -1)
-  
-  cum_duration_flat = cum_duration.view(b * t_x)
-  path = sequence_mask(cum_duration_flat, t_y).to(mask.dtype)
-  path = path.view(b, t_x, t_y)
-  path = path - F.pad(path, convert_pad_shape([[0, 0], [1, 0], [0, 0]]))[:, :-1]
-  path = path.unsqueeze(1).transpose(2,3) * mask
-  return path
-
-
-def clip_grad_value_(parameters, clip_value, norm_type=2):
-  if isinstance(parameters, torch.Tensor):
-    parameters = [parameters]
-  parameters = list(filter(lambda p: p.grad is not None, parameters))
-  norm_type = float(norm_type)
-  if clip_value is not None:
-    clip_value = float(clip_value)
-
-  total_norm = 0
-  for p in parameters:
-    param_norm = p.grad.data.norm(norm_type)
-    total_norm += param_norm.item() ** norm_type
-    if clip_value is not None:
-      p.grad.data.clamp_(min=-clip_value, max=clip_value)
-  total_norm = total_norm ** (1. / norm_type)
-  return total_norm

spaces/Aki004/herta-so-vits/vdecoder/nsf_hifigan/env.py

@@ -1,15 +0,0 @@
-import os
-import shutil
-
-
-class AttrDict(dict):
-    def __init__(self, *args, **kwargs):
-        super(AttrDict, self).__init__(*args, **kwargs)
-        self.__dict__ = self
-
-
-def build_env(config, config_name, path):
-    t_path = os.path.join(path, config_name)
-    if config != t_path:
-        os.makedirs(path, exist_ok=True)
-        shutil.copyfile(config, os.path.join(path, config_name))

spaces/AlexReverie/ImageSonification/README.md

@@ -1,12 +0,0 @@
----
-title: ImageSonification
-emoji: 🐨
-colorFrom: purple
-colorTo: pink
-sdk: gradio
-sdk_version: 3.23.0
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/Alpaca233/SadTalker/src/face3d/models/base_model.py

@@ -1,316 +0,0 @@
-"""This script defines the base network model for Deep3DFaceRecon_pytorch
-"""
-
-import os
-import numpy as np
-import torch
-from collections import OrderedDict
-from abc import ABC, abstractmethod
-from . import networks
-
-
-class BaseModel(ABC):
-    """This class is an abstract base class (ABC) for models.
-    To create a subclass, you need to implement the following five functions:
-        -- <__init__>:                      initialize the class; first call BaseModel.__init__(self, opt).
-        -- <set_input>:                     unpack data from dataset and apply preprocessing.
-        -- <forward>:                       produce intermediate results.
-        -- <optimize_parameters>:           calculate losses, gradients, and update network weights.
-        -- <modify_commandline_options>:    (optionally) add model-specific options and set default options.
-    """
-
-    def __init__(self, opt):
-        """Initialize the BaseModel class.
-
-        Parameters:
-            opt (Option class)-- stores all the experiment flags; needs to be a subclass of BaseOptions
-
-        When creating your custom class, you need to implement your own initialization.
-        In this fucntion, you should first call <BaseModel.__init__(self, opt)>
-        Then, you need to define four lists:
-            -- self.loss_names (str list):          specify the training losses that you want to plot and save.
-            -- self.model_names (str list):         specify the images that you want to display and save.
-            -- self.visual_names (str list):        define networks used in our training.
-            -- self.optimizers (optimizer list):    define and initialize optimizers. You can define one optimizer for each network. If two networks are updated at the same time, you can use itertools.chain to group them. See cycle_gan_model.py for an example.
-        """
-        self.opt = opt
-        self.isTrain = False
-        self.device = torch.device('cpu') 
-        self.save_dir = " " # os.path.join(opt.checkpoints_dir, opt.name)  # save all the checkpoints to save_dir
-        self.loss_names = []
-        self.model_names = []
-        self.visual_names = []
-        self.parallel_names = []
-        self.optimizers = []
-        self.image_paths = []
-        self.metric = 0  # used for learning rate policy 'plateau'
-
-    @staticmethod
-    def dict_grad_hook_factory(add_func=lambda x: x):
-        saved_dict = dict()
-
-        def hook_gen(name):
-            def grad_hook(grad):
-                saved_vals = add_func(grad)
-                saved_dict[name] = saved_vals
-            return grad_hook
-        return hook_gen, saved_dict
-
-    @staticmethod
-    def modify_commandline_options(parser, is_train):
-        """Add new model-specific options, and rewrite default values for existing options.
-
-        Parameters:
-            parser          -- original option parser
-            is_train (bool) -- whether training phase or test phase. You can use this flag to add training-specific or test-specific options.
-
-        Returns:
-            the modified parser.
-        """
-        return parser
-
-    @abstractmethod
-    def set_input(self, input):
-        """Unpack input data from the dataloader and perform necessary pre-processing steps.
-
-        Parameters:
-            input (dict): includes the data itself and its metadata information.
-        """
-        pass
-
-    @abstractmethod
-    def forward(self):
-        """Run forward pass; called by both functions <optimize_parameters> and <test>."""
-        pass
-
-    @abstractmethod
-    def optimize_parameters(self):
-        """Calculate losses, gradients, and update network weights; called in every training iteration"""
-        pass
-
-    def setup(self, opt):
-        """Load and print networks; create schedulers
-
-        Parameters:
-            opt (Option class) -- stores all the experiment flags; needs to be a subclass of BaseOptions
-        """
-        if self.isTrain:
-            self.schedulers = [networks.get_scheduler(optimizer, opt) for optimizer in self.optimizers]
-        
-        if not self.isTrain or opt.continue_train:
-            load_suffix = opt.epoch
-            self.load_networks(load_suffix)
- 
-            
-        # self.print_networks(opt.verbose)
-
-    def parallelize(self, convert_sync_batchnorm=True):
-        if not self.opt.use_ddp:
-            for name in self.parallel_names:
-                if isinstance(name, str):
-                    module = getattr(self, name)
-                    setattr(self, name, module.to(self.device))
-        else:
-            for name in self.model_names:
-                if isinstance(name, str):
-                    module = getattr(self, name)
-                    if convert_sync_batchnorm:
-                        module = torch.nn.SyncBatchNorm.convert_sync_batchnorm(module)
-                    setattr(self, name, torch.nn.parallel.DistributedDataParallel(module.to(self.device),
-                        device_ids=[self.device.index], 
-                        find_unused_parameters=True, broadcast_buffers=True))
-            
-            # DistributedDataParallel is not needed when a module doesn't have any parameter that requires a gradient.
-            for name in self.parallel_names:
-                if isinstance(name, str) and name not in self.model_names:
-                    module = getattr(self, name)
-                    setattr(self, name, module.to(self.device))
-            
-        # put state_dict of optimizer to gpu device
-        if self.opt.phase != 'test':
-            if self.opt.continue_train:
-                for optim in self.optimizers:
-                    for state in optim.state.values():
-                        for k, v in state.items():
-                            if isinstance(v, torch.Tensor):
-                                state[k] = v.to(self.device)
-
-    def data_dependent_initialize(self, data):
-        pass
-
-    def train(self):
-        """Make models train mode"""
-        for name in self.model_names:
-            if isinstance(name, str):
-                net = getattr(self, name)
-                net.train()
-
-    def eval(self):
-        """Make models eval mode"""
-        for name in self.model_names:
-            if isinstance(name, str):
-                net = getattr(self, name)
-                net.eval()
-
-    def test(self):
-        """Forward function used in test time.
-
-        This function wraps <forward> function in no_grad() so we don't save intermediate steps for backprop
-        It also calls <compute_visuals> to produce additional visualization results
-        """
-        with torch.no_grad():
-            self.forward()
-            self.compute_visuals()
-
-    def compute_visuals(self):
-        """Calculate additional output images for visdom and HTML visualization"""
-        pass
-
-    def get_image_paths(self, name='A'):
-        """ Return image paths that are used to load current data"""
-        return self.image_paths if name =='A' else self.image_paths_B
-
-    def update_learning_rate(self):
-        """Update learning rates for all the networks; called at the end of every epoch"""
-        for scheduler in self.schedulers:
-            if self.opt.lr_policy == 'plateau':
-                scheduler.step(self.metric)
-            else:
-                scheduler.step()
-
-        lr = self.optimizers[0].param_groups[0]['lr']
-        print('learning rate = %.7f' % lr)
-
-    def get_current_visuals(self):
-        """Return visualization images. train.py will display these images with visdom, and save the images to a HTML"""
-        visual_ret = OrderedDict()
-        for name in self.visual_names:
-            if isinstance(name, str):
-                visual_ret[name] = getattr(self, name)[:, :3, ...]
-        return visual_ret
-
-    def get_current_losses(self):
-        """Return traning losses / errors. train.py will print out these errors on console, and save them to a file"""
-        errors_ret = OrderedDict()
-        for name in self.loss_names:
-            if isinstance(name, str):
-                errors_ret[name] = float(getattr(self, 'loss_' + name))  # float(...) works for both scalar tensor and float number
-        return errors_ret
-
-    def save_networks(self, epoch):
-        """Save all the networks to the disk.
-
-        Parameters:
-            epoch (int) -- current epoch; used in the file name '%s_net_%s.pth' % (epoch, name)
-        """
-        if not os.path.isdir(self.save_dir):
-            os.makedirs(self.save_dir)
-
-        save_filename = 'epoch_%s.pth' % (epoch)
-        save_path = os.path.join(self.save_dir, save_filename)
-        
-        save_dict = {}
-        for name in self.model_names:
-            if isinstance(name, str):
-                net = getattr(self, name)
-                if isinstance(net, torch.nn.DataParallel) or isinstance(net,
-                        torch.nn.parallel.DistributedDataParallel):
-                    net = net.module
-                save_dict[name] = net.state_dict()
-                
-
-        for i, optim in enumerate(self.optimizers):
-            save_dict['opt_%02d'%i] = optim.state_dict()
-
-        for i, sched in enumerate(self.schedulers):
-            save_dict['sched_%02d'%i] = sched.state_dict()
-        
-        torch.save(save_dict, save_path)
-
-    def __patch_instance_norm_state_dict(self, state_dict, module, keys, i=0):
-        """Fix InstanceNorm checkpoints incompatibility (prior to 0.4)"""
-        key = keys[i]
-        if i + 1 == len(keys):  # at the end, pointing to a parameter/buffer
-            if module.__class__.__name__.startswith('InstanceNorm') and \
-                    (key == 'running_mean' or key == 'running_var'):
-                if getattr(module, key) is None:
-                    state_dict.pop('.'.join(keys))
-            if module.__class__.__name__.startswith('InstanceNorm') and \
-               (key == 'num_batches_tracked'):
-                state_dict.pop('.'.join(keys))
-        else:
-            self.__patch_instance_norm_state_dict(state_dict, getattr(module, key), keys, i + 1)
-
-    def load_networks(self, epoch):
-        """Load all the networks from the disk.
-
-        Parameters:
-            epoch (int) -- current epoch; used in the file name '%s_net_%s.pth' % (epoch, name)
-        """
-        if self.opt.isTrain and self.opt.pretrained_name is not None:
-            load_dir = os.path.join(self.opt.checkpoints_dir, self.opt.pretrained_name)
-        else:
-            load_dir = self.save_dir    
-        load_filename = 'epoch_%s.pth' % (epoch)
-        load_path = os.path.join(load_dir, load_filename)
-        state_dict = torch.load(load_path, map_location=self.device)
-        print('loading the model from %s' % load_path)
-
-        for name in self.model_names:
-            if isinstance(name, str):
-                net = getattr(self, name)
-                if isinstance(net, torch.nn.DataParallel):
-                    net = net.module
-                net.load_state_dict(state_dict[name])
-        
-        if self.opt.phase != 'test':
-            if self.opt.continue_train:
-                print('loading the optim from %s' % load_path)
-                for i, optim in enumerate(self.optimizers):
-                    optim.load_state_dict(state_dict['opt_%02d'%i])
-
-                try:
-                    print('loading the sched from %s' % load_path)
-                    for i, sched in enumerate(self.schedulers):
-                        sched.load_state_dict(state_dict['sched_%02d'%i])
-                except:
-                    print('Failed to load schedulers, set schedulers according to epoch count manually')
-                    for i, sched in enumerate(self.schedulers):
-                        sched.last_epoch = self.opt.epoch_count - 1
-                    
-
-            
-
-    def print_networks(self, verbose):
-        """Print the total number of parameters in the network and (if verbose) network architecture
-
-        Parameters:
-            verbose (bool) -- if verbose: print the network architecture
-        """
-        print('---------- Networks initialized -------------')
-        for name in self.model_names:
-            if isinstance(name, str):
-                net = getattr(self, name)
-                num_params = 0
-                for param in net.parameters():
-                    num_params += param.numel()
-                if verbose:
-                    print(net)
-                print('[Network %s] Total number of parameters : %.3f M' % (name, num_params / 1e6))
-        print('-----------------------------------------------')
-
-    def set_requires_grad(self, nets, requires_grad=False):
-        """Set requies_grad=Fasle for all the networks to avoid unnecessary computations
-        Parameters:
-            nets (network list)   -- a list of networks
-            requires_grad (bool)  -- whether the networks require gradients or not
-        """
-        if not isinstance(nets, list):
-            nets = [nets]
-        for net in nets:
-            if net is not None:
-                for param in net.parameters():
-                    param.requires_grad = requires_grad
-
-    def generate_visuals_for_evaluation(self, data, mode):
-        return {}

spaces/Ame42/rwms/datastore.py

@@ -1,252 +0,0 @@
-# 'dataset' holds the input data for this script
-import re
-import math
-import pandas
-from local_utils import date_time_col, time_col, man_col, dur_col, round_to_n, to_sec
-import json
-import os
-import re
-import pandas
-from local_utils import date_time_col, dur_col, date_col, s1, s2, l1, l2, well_key, flow_key
-from local_utils import restructure, try_key, column_matcher, file_matcher, file_matcher2, split_join as spj
-id_col = "index"
-
-
-def split_join(dt, info):
-    joined = []
-    for i in info:
-        print(f'\n\nNow working on {i["data-column"]} column\n')
-        data = dt.drop(axis=1, columns=i["non-columns"])
-        data.rename(columns={i["data-column"]: man_col}, inplace=True)
-        data.insert(2, "Well index", [i["well-index"] for x in range(data.shape[0])], True)
-        print(f"{data.shape[0]} rows before drop and merge")
-        data.drop_duplicates(inplace=True, subset=[time_col])
-        i["dataset"].drop_duplicates(inplace=True, subset=[time_col])
-        print(data.head())
-        print(i["dataset"].head())
-        data = data.merge(i["dataset"], how='left', on=[time_col, dur_col])
-        print(data.head())
-        print(f"{data.shape[0]} rows after drop and merge")
-        joined.append(data)
-
-    return pandas.concat(joined, ignore_index=True)
-
-
-def get_22_data():
-    dataset = pandas.read_csv("input/flowstation.csv")
-    dataset_1S = pandas.read_csv("input/1S.csv")
-    dataset_1L = pandas.read_csv("input/1L.csv")
-    dataset_2S = pandas.read_csv("input/2S.csv")
-    dataset_2L = pandas.read_csv("input/2L.csv")
-
-    print(dataset.head())
-
-    for dat in [dataset, dataset_1S, dataset_1L, dataset_2L, dataset_2S]:
-        count = 0
-        duration = []
-        times = []
-        dat.dropna(axis=0, how="any", inplace=True)
-        dat.reset_index(inplace=True)
-        print(".", end="\t")
-
-        for datetime in dat[date_time_col]:
-            date_time = re.sub("\.0(?=\\s)", "", datetime)
-            datetime_array = date_time.split()
-            date = datetime_array[0].split("/")
-
-            time_array = datetime_array[1].split(":")
-
-            if datetime_array[2] == "PM" and time_array[0] != "12":
-                hour = int(time_array[0]) + 12
-            elif datetime_array[2] == "AM" and time_array[0] == "12":
-                hour = int(time_array[0]) - 12
-            else:
-                hour = time_array[0]
-
-            minutes = time_array[1]
-            sec = round_to_n(int(time_array[2]), 1)
-
-            if sec == 60:
-                sec = "00"
-                minutes = int(minutes) + 1
-
-            if minutes == 60:
-                minutes = "00"
-                hour = int(hour) + 1
-
-            if hour == 24:
-                hour = "00"
-                date[1] = int(date[1]) + 1
-
-            duration.append(to_sec(hour, minutes, sec))
-            times.append(f"{hour}:{minutes}:{sec}")
-            date_time = f"{date[1]}/{date[0]}/{date[2]} {datetime_array[1]} {datetime_array[2]}"
-
-            dat.loc[count, date_time_col] = date_time
-            count += 1
-
-        dat.insert(1, dur_col, duration, True)
-        dat.insert(2, time_col, times, True)
-
-        dat.drop(axis=1, columns=["#", date_time_col], inplace=True, errors="ignore")
-
-    info_1S = {
-        "non-columns": ["index", "NW1L, PSI (LGR S/N: 20705686)", "NW2L, PSI (LGR S/N: 20705686)",
-                        "NW2S, PSI (LGR S/N: 20705686)"],
-        "data-column": 'NW1S, PSI (LGR S/N: 20705686)',
-        "well-index": '1S',
-        "dataset": dataset_1S
-    }
-
-    info_1L = {
-        "non-columns": ["index", "NW1S, PSI (LGR S/N: 20705686)", "NW2L, PSI (LGR S/N: 20705686)",
-                        "NW2S, PSI (LGR S/N: 20705686)"],
-        "data-column": 'NW1L, PSI (LGR S/N: 20705686)',
-        "well-index": '1L',
-        "dataset": dataset_1L
-    }
-
-    info_2S = {
-        "non-columns": ["index", "NW1S, PSI (LGR S/N: 20705686)", "NW1L, PSI (LGR S/N: 20705686)",
-                        "NW2L, PSI (LGR S/N: 20705686)"],
-        "data-column": 'NW2S, PSI (LGR S/N: 20705686)',
-        "well-index": '2S',
-        "dataset": dataset_2S
-    }
-
-    info_2L = {
-        "non-columns": ["index", "NW1S, PSI (LGR S/N: 20705686)", "NW1L, PSI (LGR S/N: 20705686)",
-                        "NW2S, PSI (LGR S/N: 20705686)"],
-        "data-column": 'NW2L, PSI (LGR S/N: 20705686)',
-        "well-index": '2L',
-        "dataset": dataset_2L
-    }
-
-    dataset = split_join(dataset, [info_1S, info_1L, info_2S, info_2L])
-    dataset.drop(axis=1, columns=[id_col], inplace=True, errors="ignore")
-    dataset.insert(0, id_col, [x for x in range(dataset.shape[0])], True)
-
-    return dataset.drop(axis=1, columns="level_0")
-
-
-def get_all_data():
-    # get the list of data files and load each into a dataframe, put the dataframes in a list called files.
-    alldata = pandas.read_csv("input/files.csv")
-    files = []
-    i = 0
-    for filepath in alldata["File Path"]:
-        i += 1
-        try:
-            files.append((pandas.read_csv(filepath)))
-        except UnicodeDecodeError:
-            os.write(2, bytearray(f"Failed {i} - {filepath}\n", encoding="UTF-8", errors="e"))
-            raise
-    print(f"{len(files)} of {alldata.shape[0]} loaded")
-    # for each dataframe in files, standardize the column names and remove columns with too few values
-    truth = 0
-    total = 0
-    cut_off = 0.4
-    temp = []
-    for file, name in zip(files, alldata["Name"]):
-        for col in file.columns:
-            total += 1
-            result = column_matcher(col)
-            if not result:
-                file.drop(axis=1, columns=[col], inplace=True)
-            else:
-                file.rename(columns={col: result}, inplace=True)
-                if file[result].isna().sum() / file.shape[0] > cut_off:
-                    truth += 1
-                    file.drop(axis=1, columns=[result], inplace=True)
-        file.dropna(axis=0, how="any", inplace=True)
-        temp.append(file)
-    files = temp
-    print(f"{truth}/{total} columns dropped due to insufficient data at {cut_off * 100:.0f}% cut-off")
-    temp = dict()
-    # restructure data (extract and correct time, remove unnecessary column and add new once)
-    # remove null rows, drop first row in case of gibberish headers and group dataframes by day in dict
-    for index, dat, name, path in zip(range(len(files)), files, alldata["Name"], alldata["File Path"]):
-        try:
-            count = 0
-            duration = []
-            times = []
-            dates = []
-            dat.dropna(axis=0, how="any", inplace=True)
-            dat.drop(0, axis=0, inplace=True, errors="ignore")
-            dat.reset_index(inplace=True)
-            print(f"•{index + 1:^4}•", end="  ")
-            dat = restructure(dat, count, duration, times, dates)
-
-            dat.drop(axis=1, columns=date_time_col, inplace=True, errors="ignore")
-            print(f"{str(sorted([x for x in dat.columns])):<123}  •")
-            # dat.to_csv(f"output/temp/{name}", index=False)
-
-            if file_matcher(name):
-                # flowstation file
-                key = re.split("(?<=\\d{2})(-|_|\\s)(?=flow.*)", string=name.lower(), maxsplit=2)[0][:8]
-                try_key(temp, key)
-
-                temp[key][flow_key] = dat
-
-            else:
-                # wellhead file
-                key = re.split("(?<=\\d{2})(\\s-|-|_|\\s)?(?=(t|\\d[ls]).*)", string=name.lower(), maxsplit=2)[0][:8]
-                try_key(temp, key)
-
-                try:
-                    temp[key][well_key]
-                except KeyError:
-                    temp[key][well_key] = []
-
-                temp[key][well_key].append((file_matcher2(name.lower()), dat))
-
-        except KeyError:
-            print(f"\n\n{path}", flush=True)
-            print("Columns:", dat.columns, end="\n\n", flush=True)
-
-    return temp
-
-
-def get_conversion_factors():
-    # get conversion_factors.csv from input in a dataframe
-    return pandas.read_csv("input/conversion_factors.csv", encoding="UTF-8")
-    # return dataframe
-    pass
-
-
-def offset_wells(agg_data, how=None):
-    # Prepare aggregated data for each well from all days
-    if how is None:
-        how = [0, 0, 0, 0]
-
-    data_1S = []
-    data_2S = []
-    data_1L = []
-    data_2L = []
-    for key in agg_data.keys():
-        try:
-            temp = spj(agg_data[key][flow_key], agg_data[key][well_key], how)  # returns list of (well id, data) tuples
-            for t in temp:
-
-                if t[0] == s1:
-                    data_1S.append(t[1])
-                elif t[0] == s2:
-                    data_2S.append(t[1])
-                elif t[0] == l1:
-                    data_1L.append(t[1])
-                elif t[0] == l2:
-                    data_2L.append(t[1])
-        except KeyError:
-            pass
-    data_1L = pandas.concat(data_1L, ignore_index=True)
-    data_2L = pandas.concat(data_2L, ignore_index=True)
-    data_1S = pandas.concat(data_1S, ignore_index=True)
-    data_2S = pandas.concat(data_2S, ignore_index=True)
-
-    data_s = []
-    for name, data in zip([l1, l2, s1, s2], [data_1L, data_2L, data_1S, data_2S]):
-        data.drop_duplicates(subset=[dur_col, date_col], inplace=True)
-        data_s.append(data)
-        # data.to_csv(f"output/{name}.csv", index=False)
-
-    return pandas.concat(data_s, ignore_index=True)

spaces/Amrrs/DragGan-Inversion/PTI/evaluation/experiment_setting_creator.py

@@ -1,43 +0,0 @@
-import glob
-import os
-from configs import global_config, paths_config, hyperparameters
-from scripts.latent_creators.sg2_plus_latent_creator import SG2PlusLatentCreator
-from scripts.latent_creators.e4e_latent_creator import E4ELatentCreator
-from scripts.run_pti import run_PTI
-import pickle
-import torch
-from utils.models_utils import toogle_grad, load_old_G
-
-
-class ExperimentRunner:
-
-    def __init__(self, run_id=''):
-        self.images_paths = glob.glob(f'{paths_config.input_data_path}/*')
-        self.target_paths = glob.glob(f'{paths_config.input_data_path}/*')
-        self.run_id = run_id
-        self.sampled_ws = None
-
-        self.old_G = load_old_G()
-
-        toogle_grad(self.old_G, False)
-
-    def run_experiment(self, run_pt, create_other_latents, use_multi_id_training, use_wandb=False):
-        if run_pt:
-            self.run_id = run_PTI(self.run_id, use_wandb=use_wandb, use_multi_id_training=use_multi_id_training)
-        if create_other_latents:
-            sg2_plus_latent_creator = SG2PlusLatentCreator(use_wandb=use_wandb)
-            sg2_plus_latent_creator.create_latents()
-            e4e_latent_creator = E4ELatentCreator(use_wandb=use_wandb)
-            e4e_latent_creator.create_latents()
-
-        torch.cuda.empty_cache()
-
-        return self.run_id
-
-
-if __name__ == '__main__':
-    os.environ['CUDA_DEVICE_ORDER'] = 'PCI_BUS_ID'
-    os.environ['CUDA_VISIBLE_DEVICES'] = global_config.cuda_visible_devices
-
-    runner = ExperimentRunner()
-    runner.run_experiment(True, False, False)

spaces/Amrrs/DragGan-Inversion/stylegan_human/PP_HumanSeg/export_model/download_export_model.py

@@ -1,44 +0,0 @@
-# coding: utf8
-# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserve.
-#
-# 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.
-
-from paddleseg.utils.download import download_file_and_uncompress
-import sys
-import os
-
-LOCAL_PATH = os.path.dirname(os.path.abspath(__file__))
-TEST_PATH = os.path.join(LOCAL_PATH, "../../../", "test")
-sys.path.append(TEST_PATH)
-
-
-model_urls = {
-    "pphumanseg_lite_portrait_398x224_with_softmax":
-    "https://paddleseg.bj.bcebos.com/dygraph/ppseg/ppseg_lite_portrait_398x224_with_softmax.tar.gz",
-    "deeplabv3p_resnet50_os8_humanseg_512x512_100k_with_softmax":
-    "https://paddleseg.bj.bcebos.com/dygraph/humanseg/export/deeplabv3p_resnet50_os8_humanseg_512x512_100k_with_softmax.zip",
-    "fcn_hrnetw18_small_v1_humanseg_192x192_with_softmax":
-    "https://paddleseg.bj.bcebos.com/dygraph/humanseg/export/fcn_hrnetw18_small_v1_humanseg_192x192_with_softmax.zip",
-    "pphumanseg_lite_generic_humanseg_192x192_with_softmax":
-    "https://paddleseg.bj.bcebos.com/dygraph/humanseg/export/pphumanseg_lite_generic_192x192_with_softmax.zip",
-}
-
-if __name__ == "__main__":
-    for model_name, url in model_urls.items():
-        download_file_and_uncompress(
-            url=url,
-            savepath=LOCAL_PATH,
-            extrapath=LOCAL_PATH,
-            extraname=model_name)
-
-    print("Export model download success!")

spaces/Amrrs/DragGan-Inversion/stylegan_human/torch_utils/ops/conv2d_gradfix.py

@@ -1,196 +0,0 @@
-# Copyright (c) SenseTime Research. All rights reserved.
-
-# Copyright (c) 2021, NVIDIA CORPORATION.  All rights reserved.
-#
-# NVIDIA CORPORATION and its licensors retain all intellectual property
-# and proprietary rights in and to this software, related documentation
-# and any modifications thereto.  Any use, reproduction, disclosure or
-# distribution of this software and related documentation without an express
-# license agreement from NVIDIA CORPORATION is strictly prohibited.
-
-"""Custom replacement for `torch.nn.functional.conv2d` that supports
-arbitrarily high order gradients with zero performance penalty."""
-
-import warnings
-import contextlib
-import torch
-
-# pylint: disable=redefined-builtin
-# pylint: disable=arguments-differ
-# pylint: disable=protected-access
-
-# ----------------------------------------------------------------------------
-
-# Enable the custom op by setting this to true.
-enabled = False
-# Forcefully disable computation of gradients with respect to the weights.
-weight_gradients_disabled = False
-
-
-@contextlib.contextmanager
-def no_weight_gradients():
-    global weight_gradients_disabled
-    old = weight_gradients_disabled
-    weight_gradients_disabled = True
-    yield
-    weight_gradients_disabled = old
-
-# ----------------------------------------------------------------------------
-
-
-def conv2d(input, weight, bias=None, stride=1, padding=0, dilation=1, groups=1):
-    if _should_use_custom_op(input):
-        return _conv2d_gradfix(transpose=False, weight_shape=weight.shape, stride=stride, padding=padding, output_padding=0, dilation=dilation, groups=groups).apply(input, weight, bias)
-    return torch.nn.functional.conv2d(input=input, weight=weight, bias=bias, stride=stride, padding=padding, dilation=dilation, groups=groups)
-
-
-def conv_transpose2d(input, weight, bias=None, stride=1, padding=0, output_padding=0, groups=1, dilation=1):
-    if _should_use_custom_op(input):
-        return _conv2d_gradfix(transpose=True, weight_shape=weight.shape, stride=stride, padding=padding, output_padding=output_padding, groups=groups, dilation=dilation).apply(input, weight, bias)
-    return torch.nn.functional.conv_transpose2d(input=input, weight=weight, bias=bias, stride=stride, padding=padding, output_padding=output_padding, groups=groups, dilation=dilation)
-
-# ----------------------------------------------------------------------------
-
-
-def _should_use_custom_op(input):
-    assert isinstance(input, torch.Tensor)
-    if (not enabled) or (not torch.backends.cudnn.enabled):
-        return False
-    if input.device.type != 'cuda':
-        return False
-    if any(torch.__version__.startswith(x) for x in ['1.7.', '1.8.', '1.9']):
-        return True
-    warnings.warn(
-        f'conv2d_gradfix not supported on PyTorch {torch.__version__}. Falling back to torch.nn.functional.conv2d().')
-    return False
-
-
-def _tuple_of_ints(xs, ndim):
-    xs = tuple(xs) if isinstance(xs, (tuple, list)) else (xs,) * ndim
-    assert len(xs) == ndim
-    assert all(isinstance(x, int) for x in xs)
-    return xs
-
-# ----------------------------------------------------------------------------
-
-
-_conv2d_gradfix_cache = dict()
-
-
-def _conv2d_gradfix(transpose, weight_shape, stride, padding, output_padding, dilation, groups):
-    # Parse arguments.
-    ndim = 2
-    weight_shape = tuple(weight_shape)
-    stride = _tuple_of_ints(stride, ndim)
-    padding = _tuple_of_ints(padding, ndim)
-    output_padding = _tuple_of_ints(output_padding, ndim)
-    dilation = _tuple_of_ints(dilation, ndim)
-
-    # Lookup from cache.
-    key = (transpose, weight_shape, stride, padding,
-           output_padding, dilation, groups)
-    if key in _conv2d_gradfix_cache:
-        return _conv2d_gradfix_cache[key]
-
-    # Validate arguments.
-    assert groups >= 1
-    assert len(weight_shape) == ndim + 2
-    assert all(stride[i] >= 1 for i in range(ndim))
-    assert all(padding[i] >= 0 for i in range(ndim))
-    assert all(dilation[i] >= 0 for i in range(ndim))
-    if not transpose:
-        assert all(output_padding[i] == 0 for i in range(ndim))
-    else:  # transpose
-        assert all(0 <= output_padding[i] < max(
-            stride[i], dilation[i]) for i in range(ndim))
-
-    # Helpers.
-    common_kwargs = dict(stride=stride, padding=padding,
-                         dilation=dilation, groups=groups)
-
-    def calc_output_padding(input_shape, output_shape):
-        if transpose:
-            return [0, 0]
-        return [
-            input_shape[i + 2]
-            - (output_shape[i + 2] - 1) * stride[i]
-            - (1 - 2 * padding[i])
-            - dilation[i] * (weight_shape[i + 2] - 1)
-            for i in range(ndim)
-        ]
-
-    # Forward & backward.
-    class Conv2d(torch.autograd.Function):
-        @staticmethod
-        def forward(ctx, input, weight, bias):
-            assert weight.shape == weight_shape
-            if not transpose:
-                output = torch.nn.functional.conv2d(
-                    input=input, weight=weight, bias=bias, **common_kwargs)
-            else:  # transpose
-                output = torch.nn.functional.conv_transpose2d(
-                    input=input, weight=weight, bias=bias, output_padding=output_padding, **common_kwargs)
-            ctx.save_for_backward(input, weight)
-            return output
-
-        @staticmethod
-        def backward(ctx, grad_output):
-            input, weight = ctx.saved_tensors
-            grad_input = None
-            grad_weight = None
-            grad_bias = None
-
-            if ctx.needs_input_grad[0]:
-                p = calc_output_padding(
-                    input_shape=input.shape, output_shape=grad_output.shape)
-                grad_input = _conv2d_gradfix(transpose=(
-                    not transpose), weight_shape=weight_shape, output_padding=p, **common_kwargs).apply(grad_output, weight, None)
-                assert grad_input.shape == input.shape
-
-            if ctx.needs_input_grad[1] and not weight_gradients_disabled:
-                grad_weight = Conv2dGradWeight.apply(grad_output, input)
-                assert grad_weight.shape == weight_shape
-
-            if ctx.needs_input_grad[2]:
-                grad_bias = grad_output.sum([0, 2, 3])
-
-            return grad_input, grad_weight, grad_bias
-
-    # Gradient with respect to the weights.
-    class Conv2dGradWeight(torch.autograd.Function):
-        @staticmethod
-        def forward(ctx, grad_output, input):
-            op = torch._C._jit_get_operation(
-                'aten::cudnn_convolution_backward_weight' if not transpose else 'aten::cudnn_convolution_transpose_backward_weight')
-            flags = [torch.backends.cudnn.benchmark,
-                     torch.backends.cudnn.deterministic, torch.backends.cudnn.allow_tf32]
-            grad_weight = op(weight_shape, grad_output, input,
-                             padding, stride, dilation, groups, *flags)
-            assert grad_weight.shape == weight_shape
-            ctx.save_for_backward(grad_output, input)
-            return grad_weight
-
-        @staticmethod
-        def backward(ctx, grad2_grad_weight):
-            grad_output, input = ctx.saved_tensors
-            grad2_grad_output = None
-            grad2_input = None
-
-            if ctx.needs_input_grad[0]:
-                grad2_grad_output = Conv2d.apply(
-                    input, grad2_grad_weight, None)
-                assert grad2_grad_output.shape == grad_output.shape
-
-            if ctx.needs_input_grad[1]:
-                p = calc_output_padding(
-                    input_shape=input.shape, output_shape=grad_output.shape)
-                grad2_input = _conv2d_gradfix(transpose=(not transpose), weight_shape=weight_shape,
-                                              output_padding=p, **common_kwargs).apply(grad_output, grad2_grad_weight, None)
-                assert grad2_input.shape == input.shape
-
-            return grad2_grad_output, grad2_input
-
-    _conv2d_gradfix_cache[key] = Conv2d
-    return Conv2d
-
-# ----------------------------------------------------------------------------

spaces/Amrrs/QR-code-AI-art-generator/README.md

@@ -1,15 +0,0 @@
----
-title: QR Code AI Art Generator
-emoji: 📱🔲
-colorFrom: MediumSeaGreen
-colorTo: CornflowerBlue
-sdk: gradio
-sdk_version: 3.35.2
-app_file: app.py
-pinned: false
-suggested_hardware: t4-medium
-startup_duration_timeout: 1h
-duplicated_from: huggingface-projects/QR-code-AI-art-generator
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/Andy1621/uniformer_image_detection/configs/ld/ld_r101_gflv1_r101dcn_fpn_coco_2x.py

@@ -1,43 +0,0 @@
-_base_ = ['./ld_r18_gflv1_r101_fpn_coco_1x.py']
-teacher_ckpt = 'http://download.openmmlab.com/mmdetection/v2.0/gfl/gfl_r101_fpn_dconv_c3-c5_mstrain_2x_coco/gfl_r101_fpn_dconv_c3-c5_mstrain_2x_coco_20200630_102002-134b07df.pth'  # noqa
-model = dict(
-    pretrained='torchvision://resnet101',
-    teacher_config='configs/gfl/gfl_r101_fpn_dconv_c3-c5_mstrain_2x_coco.py',
-    teacher_ckpt=teacher_ckpt,
-    backbone=dict(
-        type='ResNet',
-        depth=101,
-        num_stages=4,
-        out_indices=(0, 1, 2, 3),
-        frozen_stages=1,
-        norm_cfg=dict(type='BN', requires_grad=True),
-        norm_eval=True,
-        style='pytorch'),
-    neck=dict(
-        type='FPN',
-        in_channels=[256, 512, 1024, 2048],
-        out_channels=256,
-        start_level=1,
-        add_extra_convs='on_output',
-        num_outs=5))
-
-lr_config = dict(step=[16, 22])
-runner = dict(type='EpochBasedRunner', max_epochs=24)
-# multi-scale training
-img_norm_cfg = dict(
-    mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)
-train_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='LoadAnnotations', with_bbox=True),
-    dict(
-        type='Resize',
-        img_scale=[(1333, 480), (1333, 800)],
-        multiscale_mode='range',
-        keep_ratio=True),
-    dict(type='RandomFlip', flip_ratio=0.5),
-    dict(type='Normalize', **img_norm_cfg),
-    dict(type='Pad', size_divisor=32),
-    dict(type='DefaultFormatBundle'),
-    dict(type='Collect', keys=['img', 'gt_bboxes', 'gt_labels']),
-]
-data = dict(train=dict(pipeline=train_pipeline))

spaces/Andy1621/uniformer_image_detection/configs/yolo/yolov3_d53_320_273e_coco.py

@@ -1,42 +0,0 @@
-_base_ = './yolov3_d53_mstrain-608_273e_coco.py'
-# dataset settings
-img_norm_cfg = dict(mean=[0, 0, 0], std=[255., 255., 255.], to_rgb=True)
-train_pipeline = [
-    dict(type='LoadImageFromFile', to_float32=True),
-    dict(type='LoadAnnotations', with_bbox=True),
-    dict(type='PhotoMetricDistortion'),
-    dict(
-        type='Expand',
-        mean=img_norm_cfg['mean'],
-        to_rgb=img_norm_cfg['to_rgb'],
-        ratio_range=(1, 2)),
-    dict(
-        type='MinIoURandomCrop',
-        min_ious=(0.4, 0.5, 0.6, 0.7, 0.8, 0.9),
-        min_crop_size=0.3),
-    dict(type='Resize', img_scale=(320, 320), keep_ratio=True),
-    dict(type='RandomFlip', flip_ratio=0.5),
-    dict(type='Normalize', **img_norm_cfg),
-    dict(type='Pad', size_divisor=32),
-    dict(type='DefaultFormatBundle'),
-    dict(type='Collect', keys=['img', 'gt_bboxes', 'gt_labels'])
-]
-test_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(
-        type='MultiScaleFlipAug',
-        img_scale=(320, 320),
-        flip=False,
-        transforms=[
-            dict(type='Resize', keep_ratio=True),
-            dict(type='RandomFlip'),
-            dict(type='Normalize', **img_norm_cfg),
-            dict(type='Pad', size_divisor=32),
-            dict(type='ImageToTensor', keys=['img']),
-            dict(type='Collect', keys=['img'])
-        ])
-]
-data = dict(
-    train=dict(pipeline=train_pipeline),
-    val=dict(pipeline=test_pipeline),
-    test=dict(pipeline=test_pipeline))

spaces/Anonymous-sub/Rerender/ControlNet/docs/low_vram.md

@@ -1,15 +0,0 @@
-# Enable Low VRAM Mode
-
-If you are using 8GB GPU card (or if you want larger batch size), please open "config.py", and then set
-
-```python
-save_memory = True
-```
-
-This feature is still being tested - not all graphics cards are guaranteed to succeed.
-
-But it should be neat as I can diffuse at a batch size of 12 now.
-
-(prompt "man")
-
-![p](../github_page/ram12.jpg)

spaces/AshutoshPattanayak/LangchainDemo/README.md

@@ -1,12 +0,0 @@
----
-title: LangchainDemo
-emoji: 🐨
-colorFrom: gray
-colorTo: red
-sdk: streamlit
-sdk_version: 1.28.1
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/Aveygo/AstroSleuth/main.py

@@ -1,154 +0,0 @@
-import math, numpy as np, requests, os, time, warnings, json
-from PIL import Image
-from importlib import import_module
-import torch
-
-class AstroSleuth():
-    def __init__(self, tile_size=256, tile_pad=16, wrk_dir="models/", model="astrosleuthv2", force_cpu=False, on_download=None, off_download=None):
-        # Device selection
-        self.device = "cpu" if force_cpu else ("cuda" if torch.cuda.is_available() else "cpu")
-        print(self.device)
-        
-        # Check if model name is known
-        model_src:dict = json.load(open("models.json"))["data"]
-        assert model in model_src, f"Model {model} not found! Available models: {list(model_src.keys())}"
-
-        # Load model module
-        module_path = model_src[model]["src"]["module"]
-
-        self.model_module:torch.nn.Module = getattr(
-            import_module(module_path.split("/")[0]),
-            module_path.split("/")[1]
-        )
-
-        # Download model if not available
-        self.model_pth = os.path.join(wrk_dir, f"{model}/model.pth")
-        self.download(model_src[model]["src"]["url"], self.model_pth, on_download, off_download)
-            
-        self.wrk_dir = wrk_dir
-        self.progress = None
-
-        # Set tile processing parameters
-        self.scale = model_src[model]["scale"]
-        self.tile_size = tile_size
-        self.tile_pad = tile_pad
-    
-    def download(self, src, dst, on_download=None, off_download=None):
-        if not os.path.exists(dst):
-            os.makedirs(os.path.dirname(dst), exist_ok=True)
-
-            if on_download is not None:
-                on_download()
-
-            with open(dst, 'wb') as f:
-                f.write(requests.get(src, allow_redirects=True, headers={"User-Agent":""}).content)
-
-            if off_download is not None:
-                off_download()
-
-    def model_inference(self, x: np.ndarray):
-        x = torch.from_numpy(x).to(self.device)
-        return self.model(x).cpu().detach().numpy()
-
-    def tile_generator(self, data: np.ndarray, yield_extra_details=False):
-        """
-        Process data [height, width, channel] into tiles of size [tile_size, tile_size, channel],
-        feed them one by one into the model, then yield the resulting output tiles.
-        """
-
-        # [height, width, channel] -> [1, channel, height, width]
-        data = np.rollaxis(data, 2, 0)
-        data = np.expand_dims(data, axis=0)
-        data = np.clip(data, 0, 255)
-
-        batch, channel, height, width = data.shape
-
-        tiles_x = width // self.tile_size
-        tiles_y = height // self.tile_size
-
-        for i in range(tiles_y * tiles_x):
-            x = i % tiles_y
-            y = math.floor(i/tiles_y)
-
-            input_start_x = y * self.tile_size
-            input_start_y = x * self.tile_size
-
-            input_end_x = min(input_start_x + self.tile_size, width)
-            input_end_y = min(input_start_y + self.tile_size, height)
-
-            input_start_x_pad = max(input_start_x - self.tile_pad, 0)
-            input_end_x_pad = min(input_end_x + self.tile_pad, width)
-            input_start_y_pad = max(input_start_y - self.tile_pad, 0)
-            input_end_y_pad = min(input_end_y + self.tile_pad, height)
-
-            input_tile_width = input_end_x - input_start_x
-            input_tile_height = input_end_y - input_start_y
-
-            input_tile = data[:, :, input_start_y_pad:input_end_y_pad, input_start_x_pad:input_end_x_pad].astype(np.float32) / 255
-
-            output_tile = self.model_inference(input_tile)
-            self.progress = (i+1) / (tiles_y * tiles_x)
-            
-            output_start_x_tile = (input_start_x - input_start_x_pad) * self.scale
-            output_end_x_tile = output_start_x_tile + input_tile_width * self.scale
-            output_start_y_tile = (input_start_y - input_start_y_pad) * self.scale
-            output_end_y_tile = output_start_y_tile + input_tile_height * self.scale
-
-            output_tile = output_tile[:, :, output_start_y_tile:output_end_y_tile, output_start_x_tile:output_end_x_tile]
-
-            output_tile = (np.rollaxis(output_tile, 1, 4).squeeze(0).clip(0,1) * 255).astype(np.uint8)
-            
-            if yield_extra_details:
-                yield (output_tile, input_start_x, input_start_y, input_tile_width, input_tile_height, self.progress)
-            else:
-                yield output_tile
-        
-        yield None
-
-    def enhance_with_progress(self, image:Image) -> Image:    
-        """
-        Take a PIL image and enhance it with the model, yielding stats about the
-        final image and then the final image itself.
-        """    
-        
-        # Load model only now because when using streamlit, multiple users spawn multiple instances of this class, so 
-        # we only load the model when needed. The App() class is responsible for queuing requests to this class
-        self.model = self.model_module().to(self.device)
-        self.model.load_state_dict(torch.load(self.model_pth, map_location=torch.device(self.device)))
-        self.model.eval()
-
-        original_width, original_height = image.size
-
-        # Because tiles may not fit perfectly, we resize to the closest multiple of tile_size
-        image = image.resize((max(original_width//self.tile_size * self.tile_size, self.tile_size), max(original_height//self.tile_size * self.tile_size, self.tile_size)), resample=Image.Resampling.BICUBIC)
-        image = np.array(image)
-
-        # Initiate a pillow image to save the tiles
-        result = Image.new("RGB", (image.shape[1]*self.scale, image.shape[0]*self.scale))
-        
-        for i, tile in enumerate(self.tile_generator(image, yield_extra_details=True)):
-            
-            if tile is None:
-                break
-            
-            tile_data, x, y, w, h, p = tile
-            result.paste(Image.fromarray(tile_data), (x*self.scale, y*self.scale))
-            yield p
-        
-        # Resize back to the expected size
-        yield result.resize((original_width * self.scale, original_height * self.scale), resample=Image.Resampling.BICUBIC)
-        
-    def enhance(self, image:Image) -> Image:
-        """
-        Skips the progress reporting and just returns the final image.
-        """
-        return list(self.enhance_with_progress(image))[-1]
-    
-if __name__ == '__main__':
-    import sys
-    src = sys.argv[1]
-    dst = sys.argv[2]
-    a = AstroSleuth()
-    img = Image.open(src)
-    r = a.enhance(img)
-    r.save(dst)

spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/dev/README.md

@@ -1,7 +0,0 @@
-
-## Some scripts for developers to use, include:
-
-- `linter.sh`: lint the codebase before commit.
-- `run_{inference,instant}_tests.sh`: run inference/training for a few iterations.
-   Note that these tests require 2 GPUs.
-- `parse_results.sh`: parse results from a log file.

spaces/Benson/text-generation/Examples/Cara Descargar Tema Robot Ejrcito.md

@@ -1,5 +0,0 @@
-
-<h1>Cara Download Robot Theme Army untuk Perangkat Anda</h1> | | <p>Apakah Anda suka dengan robot dan elemen-elemen militer? Apakah Anda ingin membuat perangkat Anda terlihat lebih keren dan futuristik dengan tema yang sesuai dengan selera Anda? Jika jawabannya ya, maka anda mungkin tertarik untuk mencoba robot army theme. Tema ini adalah salah satu tema yang populer di kalangan penggemar robot dan militer, karena menampilkan gambar-gambar robot yang menakjubkan, warna-warna yang gelap dan tegas, serta ikon-ikon yang unik dan menarik. Dalam artikel ini, kami akan menjelaskan apa itu tema robot army, fitur-fitur yang ditawarkan, keuntungan dan masalah yang mungkin timbul, serta cara download tema robot army untuk perangkat Anda.</p>
-<h2>cara descargar tema robot ejército</h2><br /><p><b><b>DOWNLOAD</b> &#8230;&#8230;&#8230; <a href="https://bltlly.com/2v6MkD">https://bltlly.com/2v6MkD</a></b></p><br /><br /> | | <h2>Apa itu Tema Robot Army? </h2> | | <p>Theme robot army adalah theme yang didesain khusus untuk pengguna yang menyukai robot dan militer. Tema ini mengubah tampilan latar belakang, layar kunci, font, suara, dan ikon perangkat Anda menjadi lebih sesuai dengan tema robot army. Anda bisa melihat gambar-gambar robot yang berbagai jenis dan fungsi, seperti robot tempur, eksplorasi robot, robot medis, robot transportasi, dan lain-lain. Go play bisa melihat gambar-gambar militer, seperti tank, pesawat tempur, kapal selam, rudal, dan lain-lain. Warna-warna yang dominate dalam tema ini adalah hitam, abu-abu, biru tua, merah marun, dan hijau tua. Font yang digunakan juga terlihat lebih tegas dan modern. Suara-suara yang dihasilkan juga mengikuti tema robot army, seperti suara mesin, ledakan, tembakan, dan lain-lain. Ikon-ikon yang digunakan juga berbeda dari biasanya, karena memiliki bentuk-bentuk yang lebih geometris dan futuristik. </p> | | <h3>Fitur-fitur Robot Theme Army</h3> | | <p>Robot theme army memiliki beberapa fitur yang membuatnya menarik dan berbeda dari tema lainnya. Berikut adalah beberapa fitur yang ditawarkan oleh tema ini:</p> | | <ul> | <li>Tema ini mendukung berbagai jenis perangkat, seperti smartphone, tablet, laptop, dan 64aa2da5cf<br />
-<br />
-<br />

spaces/Benson/text-generation/Examples/Carx Carretera Carreras Apk Hack Descargar.md

@@ -1,90 +0,0 @@
-<br />
-<h1>CarX Highway Racing APK Hack Descargar: Una revisión</h1>
-<p>Si eres un fan de los juegos de carreras, es posible que hayas oído hablar de CarX Highway Racing, un juego popular que ofrece una mezcla de física realista, gráficos llamativos y conducción extrema en carreteras llenas de tráfico. ¿Pero sabías que puedes descargar una versión hackeada del juego que te da dinero, monedas y combustible ilimitados? En este artículo, vamos a revisar CarX Highway Racing APK Hack Download, una versión modificada del juego que le permite disfrutar de todas las características del juego sin limitaciones. También compararemos CarX Highway Racing con otros juegos de carreras, y te daremos algunos consejos y trucos para mejorar tu rendimiento. </p>
- <h2>¿Qué es CarX Highway Racing? </h2>
-<p>CarX Highway Racing es un juego de carreras desarrollado por CarX Technologies, la misma compañía que creó CarX Drift Racing 2. El juego se basa en la física realista, lo que significa que los coches se comportan de acuerdo con su peso, velocidad, tracción y suspensión. El juego también cuenta con entornos detallados con ciclos de día y noche, tráfico animado y la policía, y varios modos de juego como campaña, carreras en línea, modo de policía, modo de viaje libre, y eventos únicos. El juego tiene más de 40 coches deportivos para elegir, que van desde coches clásicos a supercoches. También puede actualizar y personalizar sus coches para adaptarse a sus preferencias y estilo. </p>
-<h2>carx carretera carreras apk hack descargar</h2><br /><p><b><b>Download</b> &#128505; <a href="https://bltlly.com/2v6Jt5">https://bltlly.com/2v6Jt5</a></b></p><br /><br />
- <h3>Características de CarX Highway Racing</h3>
-<p>Algunas de las características de CarX Highway Racing son:</p>
-<ul>
-<li><b>Modo de campaña:</b> Sumérgete en el mundo de las carreras callejeras, donde tienes que competir contra numerosos rivales, escapar de la policía implacable y descubrir los secretos de diferentes países. También encontrarás varios personajes que te ayudarán o te obstaculizarán en tu búsqueda. </li>
-<li><b>Carreras en línea:</b> Mostrar a los demás lo que tienes al competir con otros jugadores por el primer lugar en diferentes ligas y estaciones. También puedes desafiar a tus amigos o oponentes al azar en carreras en tiempo real. </li>
-
-<li><b>Eventos únicos:</b> Participa en diferentes eventos y recibe autos únicos como recompensas. Estos eventos tienen un límite de tiempo y requieren habilidades y estrategias específicas para ganar. </li>
-<li><b>Modo de conducción libre:</b> Siente la libertad de conducir sin restricciones en este modo, donde puedes disfrutar conduciendo sin tener que preocuparte por objetivos o oponentes. También puede explorar las diferentes ubicaciones y descubrir secretos ocultos. </li>
-</ul>
- <h3>Cómo descargar CarX Highway Racing APK Hack? </h3>
-<p>Si desea descargar CarX Highway Racing APK Hack, tendrá que seguir estos pasos:</p>
-<ol>
-<li>Ir a , un sitio web que proporciona versiones modificadas de varios juegos. </li>
-<li>Haga clic en el botón verde que dice "Descargar" y espere a que el archivo se descargue en su dispositivo. </li>
-<li>Ir a la configuración de su dispositivo y permitir la instalación de aplicaciones de fuentes desconocidas. </li>
-<li>Busque el archivo descargado en su administrador de archivos y toque en él para instalarlo. </li>
-<li>Inicie el juego y disfrute de dinero, monedas y combustible ilimitados. </li>
-</ol>
- <h2>¿Por qué deberías jugar CarX Highway Racing? </h2>
-<p>Hay muchas razones por las que debe jugar CarX Highway Racing? Aquí están algunos de los beneficios de jugar a este juego:</p>
- <h3>Física realista y manejo de automóviles</h3>
-<p>Una de las principales atracciones de CarX Highway Racing es su motor de física realista, que hace que los coches se comporten de acuerdo con sus homólogos de la vida real. Sentirá la diferencia entre conducir un SUV pesado y un automóvil deportivo ligero, así como el impacto de la velocidad, el frenado, la dirección y la deriva. También tendrá que ajustar su estilo de conducción de acuerdo con las condiciones de la carretera, como mojado, seco o nevado. El juego también te permite personalizar la configuración de tu coche, como suspensión, neumáticos, caja de cambios y motor, para adaptarse a tus preferencias y necesidades. </p>
- <h3>Varios modos de juego y desafíos</h3>
-
- <h3>Impresionantes gráficos y efectos de sonido</h3>
-<p>Por último, pero no menos importante, debes jugar CarX Highway Racing debido a sus impresionantes gráficos y efectos de sonido, que te harán sentir como si estuvieras en un mundo de carreras real. El juego presenta entornos detallados con ciclos diurnos y nocturnos, efectos climáticos dinámicos, sombras y reflejos realistas y texturas de alta calidad. El juego también tiene increíbles efectos de sonido que te sumergirán en la atmósfera del juego. Oirás el rugido de los motores, el chirrido de los neumáticos, el bocinazo de los cuernos y las sirenas de la policía. </p>
- <h2>¿Cómo se compara CarX Highway Racing con otros juegos de carreras? </h2>
-<p>CarX Highway Racing no es el único juego de carreras disponible en el mercado. Hay muchos otros juegos de carreras que usted podría haber jugado o oído hablar de, como la necesidad de velocidad más buscados, Asphalt 9: Legends, y Real Racing 3. ¿Cómo CarX Highway Racing comparar con estos juegos? Vamos a averiguar:</p>
-<p></p>
- <h3>CarX Highway Racing vs. Necesidad de velocidad más buscados</h3>
-<p>Need for Speed Most Wanted es un juego de carreras desarrollado por Electronic Arts, que es una de las franquicias más populares del género. El juego se centra en carreras callejeras y actividades policiales, donde tienes que correr más rápido que tus rivales y evadir la ley. El juego tiene más de 40 coches para elegir, que se puede personalizar y actualizar. El juego también tiene un modo multijugador donde puedes competir con otros jugadores en línea. </p>
-<p>CarX Highway Racing es similar a Need for Speed Most Wanted en algunos aspectos, como el tema de carreras callejeras y persecuciones policiales, la variedad de coches y opciones de personalización, y el modo multijugador en línea. Sin embargo, CarX Highway Racing tiene algunas ventajas sobre Need for Speed Most Wanted, como:</p>
-<ul>
-
-<li><b>Más modos de juego y desafíos:</b> CarX Highway Racing tiene más modos de juego y desafíos que Need for Speed Most Wanted. Puede elegir entre el modo de campaña, carreras en línea, modo de policía, modo de viaje gratuito y eventos únicos. También puedes competir en diferentes ligas y temporadas o desafiar a tus amigos o oponentes al azar en carreras en tiempo real. </li>
-<li><b>Versión hackeada disponible:</b> CarX Highway Racing tiene una versión hackeada disponible que le da dinero ilimitado, monedas y combustible. Esto significa que puedes disfrutar de todas las características del juego sin limitaciones o restricciones. </li>
-</ul>
- <h3>CarX Highway Racing vs. Asfalto 9: Leyendas</h3>
-<p>Asphalt 9: Legends es un juego de carreras desarrollado por Gameloft, que es una de las franquicias más populares del género. El juego se centra en las carreras de estilo árcade, donde se puede realizar acrobacias, derivas, y nitro aumenta para ganar las carreras. El juego tiene más de 60 coches para elegir, que se puede recoger y actualizar. El juego también tiene un modo multijugador donde puedes competir con otros jugadores en línea. </p>
- <p>CarX Highway Racing es diferente de Asphalt 9: Legends en muchos aspectos, como el tema, la física y los gráficos. Algunas de las diferencias son:</p>
-<ul>
-<li><b>Realistic vs. árcade:</b> CarX Highway Racing tiene un tema más realista que Asphalt 9: Legends, que tiene un tema más árcade. CarX Highway Racing se basa en la física realista, lo que significa que los coches se comportan de acuerdo con sus homólogos de la vida real. Asfalto 9: Leyendas se basa en la física de árcade, lo que significa que los coches pueden realizar acrobacias poco realistas, deriva, y aumenta nitro. </li>
-
-<li><b>Detallado vs. llamativo:</b> CarX Highway Racing tiene gráficos más detallados que Asphalt 9: Legends, que tiene gráficos más llamativos. CarX Highway Racing presenta entornos detallados con ciclos diurnos y nocturnos, efectos climáticos dinámicos, sombras y reflejos realistas y texturas de alta calidad. Asfalto 9: Leyendas presenta ambientes llamativos con colores brillantes, explosiones, chispas y humo. </li>
-</ul>
- <h3>CarX Highway Racing vs. Real Racing 3</h3>
-<p>Real Racing 3 es un juego de carreras desarrollado por Electronic Arts, que es uno de los juegos de carreras más realistas del mercado. El juego cuenta con coches con licencia de más de 40 fabricantes, como Ferrari, Lamborghini, Porsche y Bugatti. El juego también cuenta con pistas reales de todo el mundo, como Silverstone, Le Mans y Dubai Autodrome. El juego tiene un modo multijugador donde puedes competir con otros jugadores online o offline. </p>
- <p>CarX Highway Racing es similar a Real Racing 3 en algunos aspectos, como el realismo de la física y los gráficos, la variedad de coches y pistas, y el modo multijugador. Sin embargo, CarX Highway Racing tiene algunas ventajas sobre Real Racing 3, como:</p>
-<ul>
-<li><b>Carreras callejeras vs. carreras de pista:</b> CarX Highway Racing tiene un tema de carreras callejeras más que Real Racing 3, que tiene un tema de carreras de pista más. CarX Highway Racing le permite competir en carreteras llenas de tráfico con persecuciones policiales y varios modos de juego. Real Racing 3 te permite correr en pistas profesionales con reglas y regulaciones oficiales. </li>
-<li><b>Personalización vs. autenticidad:</b> CarX Highway Racing le permite personalizar y actualizar sus coches para adaptarse a sus preferencias y estilo. Puede cambiar el color, ruedas, alerones, calcomanías y el rendimiento de sus coches. Real Racing 3 no le permite personalizar sus coches, ya que se basan en sus homólogos de la vida real. </li>
-
-</ul>
- <h2>Consejos y trucos para CarX Highway Racing</h2>
-<p>Si quieres mejorar tu rendimiento en CarX Highway Racing, puedes seguir estos consejos y trucos:</p>
- <h3>Actualizar y personalizar sus coches</h3>
-<p>Una de las mejores maneras de mejorar su experiencia de conducción en CarX Highway Racing es actualizar y personalizar sus coches. Usted puede utilizar el dinero y las monedas que usted gana de completar carreras y tareas para comprar coches nuevos o actualizar sus existentes. También puede utilizar las opciones de personalización para cambiar la apariencia y el rendimiento de sus coches. Puede ajustar la suspensión, los neumáticos, la caja de cambios y el motor de sus coches para adaptarse a su estilo de conducción y las condiciones de la carretera. También puede cambiar el color, ruedas, alerones, calcomanías y otros accesorios de sus coches para que se vean más únicos y con estilo. </p>
- <h3>Utilice los boosters y nitro sabiamente</h3>
-<p>Otra forma de mejorar tu rendimiento en CarX Highway Racing es usar boosters y nitro sabiamente. Los boosters son artículos que puedes comprar o ganar al completar carreras y tareas, lo que puede darte varias ventajas en el juego. Por ejemplo, puede usar un amplificador que aumente su velocidad, reduzca su consumo de combustible o lo proteja de colisiones. Nitro es una función que puede activar pulsando en la pantalla, que puede darle una ráfaga temporal de velocidad. Sin embargo, tanto los boosters como el nitro son limitados en cantidad y duración, por lo que tienes que usarlos estratégicamente. Debes usarlas cuando necesites superar a tus rivales, escapar de la policía o llegar a la meta más rápido. </p>
- <h3>Evitar colisiones y atascos de tráfico</h3>
-
- <h2>Conclusión</h2>
-<p>CarX Highway Racing es un juego de carreras que ofrece una mezcla de física realista, gráficos llamativos y conducción extrema en carreteras llenas de tráfico. Puede descargar una versión hackeada del juego que le da dinero ilimitado, monedas y combustible, que le permitirá disfrutar de todas las características del juego sin limitaciones. También puede comparar CarX Highway Racing con otros juegos de carreras, como Need for Speed Most Wanted, Asphalt 9: Legends y Real Racing 3, y ver cómo difieren en términos de tema, física, gráficos y jugabilidad. También puede seguir algunos consejos y trucos para mejorar su rendimiento en CarX Highway Racing, como actualizar y personalizar sus coches, usar boosters y nitro sabiamente, y evitar colisiones y atascos de tráfico. Esperamos que este artículo le ha ayudado a aprender más acerca de CarX Highway Racing APK Hack Descargar, y que usted tendrá diversión jugando a este juego. </p>
- <h2>Preguntas frecuentes</h2>
-<p>Aquí hay algunas preguntas frecuentes sobre CarX Highway Racing APK Hack Descargar:</p>
-<ul>
-<li><b>Q: Es CarX Highway Racing APK Hack Descargar seguro de usar? </b></li>
-<li><b>A: Sí,</b> CarX Highway Racing APK Hack Download es seguro de usar, siempre y cuando se descarga desde un sitio web de confianza como . Sin embargo, debes tener en cuenta que usar una versión hackeada del juego podría violar los términos de servicio del desarrollador original del juego, lo que podría resultar en una prohibición o una penalización. </li>
-<li><b>Q: ¿Cómo puedo actualizar CarX Highway Racing APK Hack Descargar? </b></li>
-<li><b>A: Para actualizar CarX Highway Racing APK Hack Download,</b> tendrá que descargar la última versión del archivo modificado de e instalarlo en su dispositivo. También es posible que tenga que desinstalar la versión anterior del juego antes de instalar el nuevo. </li>
-<li><b>Q: ¿Puedo jugar CarX Highway Racing APK Hack Descargar sin conexión? </b></li>
-
-<li><b>Q: ¿Puedo jugar CarX Highway Racing APK Hack Descargar con mis amigos? </b></li>
-<li><b>A: Sí,</b> puede jugar CarX Highway Racing APK Hack Descargar con tus amigos mediante el modo multijugador en línea o el modo de carreras en tiempo real. También puedes desafiar a tus amigos o oponentes al azar en diferentes ligas y temporadas. </li>
-<li><b>Q: ¿Cuáles son algunas alternativas a CarX Highway Racing APK Hack Descargar? </b></li>
-<li><b>A: Algunas alternativas a CarX Highway Racing APK Hack Descargar son:</b></li>
-<ul>
-<li><b>Necesidad de velocidad más buscados APK Mod:</b> Esta es una versión modificada de la necesidad de la velocidad más deseada que le da dinero ilimitado y desbloquea todos los coches. </li>
-<li><b>Asfalto 9: Leyendas APK Mod:</b> Esta es una versión modificada de Asfalto 9: Leyendas que le da dinero ilimitado, fichas, y nitro. </li>
-<li><b>Real Racing 3 APK Mod:</b> Esta es una versión modificada de Real Racing 3 que le da dinero ilimitado, oro, y los coches desbloqueados. </li>
-</ul>
-</ul></p> 64aa2da5cf<br />
-<br />
-<br />

spaces/Benson/text-generation/Examples/Como Hacer Un Anillo De Amor.md

@@ -1,105 +0,0 @@
-<br />
-<h1>Proyecto Playtime APK Indir: Un juego de terror de aventura móvil con canciones divertidas y amigos</h1>
-<p>Si te gustan los juegos de terror, es posible que desee echa un vistazo a <strong>Project Playtime APK</strong>, un juego de terror de aventura móvil que es a la vez aterrador y divertido. En este juego, se encontrará con varios monstruos y rompecabezas, mientras que también hacer nuevos amigos y escuchar canciones impresionantes. En este artículo, le diremos todo lo que necesita saber sobre Project Playtime APK, incluyendo lo que es, por qué debe jugar, cómo descargarlo e instalarlo, ¿cuáles son los personajes principales y monstruos, cómo jugarlo, y cuáles son algunas de las canciones. ¡Vamos a empezar! </p>
-<h2>como hacer un anillo de amor</h2><br /><p><b><b>Download Zip</b> &#10040; <a href="https://bltlly.com/2v6KKM">https://bltlly.com/2v6KKM</a></b></p><br /><br />
- <h2>¿Qué es Project Playtime APK? </h2>
-<p>Proyecto Playtime APK es un juego para móviles desarrollado por GearBox Juegos que combina elementos de terror y aventura. El juego se desarrolla en una misteriosa escuela donde tienes que explorar diferentes habitaciones y pasillos evitando o luchando contra criaturas espeluznantes. El juego también cuenta con un montón de canciones divertidas que se puede cantar junto con sus nuevos amigos que se encuentran en el camino. El juego tiene un estilo de arte único y una atmósfera que te mantendrá al límite mientras te entretiene. </p>
- <h3>Una breve introducción al juego y sus características</h3>
-<p>Algunas de las características de Project Playtime APK son:</p>
-<ul>
-<li>Es gratis para descargar y jugar. </li>
-<li> Tiene gráficos y efectos de sonido de alta calidad. </li>
-<li> Tiene una variedad de personajes y monstruos con diferentes personalidades y habilidades. </li>
-<li> Tiene un montón de puzzles y desafíos que pondrán a prueba tus habilidades y lógica. </li>
-<li>Tiene muchas canciones que te harán reír y bailar. </li>
-<li> Tiene un modo historia y un modo sandbox donde puede crear sus propios escenarios. </li>
-</ul>
- <h2>¿Por qué debe jugar Project Playtime APK? </h2>
-<p>Hay muchas razones por las que debe jugar Project Playtime APK. Aquí están algunos de ellos:</p>
-<p></p>
-<ul>
-<li>Es un juego de terror único que mezcla miedo y diversión. </li>
-
-<li>Es un juego desafiante que te mantendrá comprometido y curioso. </li>
-<li>Es un juego creativo que te permitirá expresarte a través de la música y el arte. </li>
-<li>Es un juego emocionante que te hará gritar y reír al mismo tiempo. </li>
-</ul>
- <h2>Cómo descargar e instalar el proyecto Playtime APK? </h e>? </h2>
-<p>Descargar e instalar Project Playtime APK es muy fácil y simple. Solo tienes que seguir estos pasos:</p>
-<ol>
-<li>Ir a la página web oficial de Project Playtime APK y haga clic en el botón de descarga. </li>
-<li>Espere a que el archivo APK se descargue en su dispositivo. </li>
-<li>Ir a la configuración del dispositivo y permitir la instalación de aplicaciones de fuentes desconocidas. </li>
-<li>Busque el archivo APK en su administrador de archivos y toque en él para instalarlo. </li>
-<li>Iniciar el juego y disfrutar! </li>
-</ol>
- <h2>¿Cuáles son los personajes principales y monstruos en el proyecto Playtime APK? </h2>
-<p>Proyecto Playtime APK tiene una gran cantidad de personajes y monstruos que se encontrará en el juego. Algunos de ellos son amables y serviciales, mientras que otros son hostiles y peligrosos. Aquí hay una tabla que muestra algunos de los personajes principales y monstruos en el juego:</p>
- <tabla>
-<tr>
-<th>Nombre</th>
-<th>Descripción</th>
-</tr>
-<tr>
-<td>Amapola</td>
-<td>Una chica alegre y amigable a la que le encanta cantar y jugar. Ella es tu guía y amiga en el juego. Ella te ayudará con rompecabezas y canciones, pero también tiene un lado oscuro del que debes tener cuidado. </td>
-</tr>
-<tr>
-<td>Huggy Wuggy</td>
-<td>Un monstruo azul gigante al que le gusta abrazar a la gente. Es muy fuerte y rápido, pero también muy torpe y fácilmente distraído. Te perseguirá por la escuela, pero también puede ser engañado o evitado. </td>
-</tr>
-<tr>
-<td>Chica de Kissie</td>
-<td>Un monstruo rosa al que le gusta besar a la gente. Es muy linda y dulce, pero también muy agresiva y posesiva. Ella tratará de atraparte y besarte, pero también puede estar asustada o repelida. </td>
-</tr>
-<tr>
-<td>Molly</td>
-
-</tr>
-<tr>
-<td>El profesor</td>
-<td>Figura misteriosa y siniestra que gobierna la escuela. Es muy inteligente y astuto, pero también muy cruel y despiadado. Intentará evitar que escapes de la escuela, pero también puede ser más astuto o confrontado. </td>
-</tr>
-</tabla>
- <h2>¿Cómo se juega Project Playtime APK? </h2>
-<p>Proyecto Playtime APK es un juego que requiere tanto habilidad y estrategia. Tienes que explorar la escuela, encontrar objetos, resolver puzzles, hacer amigos, evitar o luchar contra los enemigos, y escapar de la escuela. Aquí hay algunos consejos sobre cómo jugar el juego:</p>
- <h3>Un resumen de la mecánica de juego y consejos sobre cómo sobrevivir y resolver puzzles</h3>
- <ul>
-<li>Puede moverse usando el joystick virtual en el lado izquierdo de la pantalla. Puede interactuar con objetos usando los botones en el lado derecho de la pantalla. </li>
-<li>Puede cambiar entre diferentes modos utilizando los iconos en la esquina superior derecha de la pantalla. Puedes usar el modo linterna para ver mejor en lugares oscuros, el modo cámara para tomar fotos de pistas o enemigos, y el modo micrófono para cantar canciones o hablar con amigos. </li>
-<li>Puede acceder a su inventario tocando el icono de la mochila en la esquina inferior derecha de la pantalla. Puede usar elementos arrastrándolos a objetos o caracteres. </li>
-<li>Puede pausar el juego tocando el icono del menú en la esquina superior izquierda de la pantalla. Puede reanudar, reiniciar o salir del juego desde allí. </li>
-<li>Usted necesita tener cuidado de su salud y barras de resistencia en la esquina superior izquierda de la pantalla. Tu salud disminuirá si te lastimas por enemigos o trampas, y tu resistencia disminuirá si corres o realizas acciones. Puede restaurar su salud y resistencia encontrando comida o bebidas en la escuela. </li>
-
-<li>Necesitas prestar atención a tu entorno y buscar pistas, pistas o secretos. Algunos objetos o caracteres tendrán un efecto de chispa que indica que son importantes o interactivos. </li>
-<li>Necesitas usar tu lógica y creatividad para resolver puzzles y desafíos. Algunos rompecabezas requieren que encuentres objetos, combines objetos, utilices objetos, introduzcas códigos o realices acciones. Algunos rompecabezas tendrán múltiples soluciones o resultados. </li>
-<li>Necesitas usar tu coraje y habilidad para evitar o luchar contra los enemigos. Algunos enemigos te perseguirán, te atacarán o te atraparán. Puedes huir de ellos, esconderte de ellos, distraerlos, engañarlos o luchar contra ellos. Puedes usar elementos, canciones o amigos para ayudarte. </li>
-Necesitas usar tu amistad y encanto para hacer amigos y aliados. Algunos personajes serán amables y serviciales, mientras que otros serán hostiles y sospechosos. Puedes hablarles, cantarles, darles objetos o hacerles favores. También puedes traicionarlos, mentirles o robarles. </li>
-<li>Necesitas usar tu curiosidad y aventura para explorar la escuela y encontrar secretos y sorpresas. Algunas habitaciones y pasillos tendrán puertas, pasajes o habitaciones ocultas. Algunos objetos o personajes tendrán mensajes ocultos, historias o huevos de Pascua. </li>
-</ul>
- <h2>¿Cuáles son algunas de las canciones en Project Playtime APK? </h2>
-<p>Una de las características más divertidas y únicas de Project Playtime APK es las canciones que se pueden escuchar y cantar en el juego. Las canciones son pegadizas, divertidas y a veces espeluznantes. Se añadirá al estado de ánimo y la atmósfera del juego, así como darle pistas o pistas sobre los personajes o rompecabezas. Estas son algunas de las canciones que puedes encontrar en el juego:</p>
- <h3>Un breve resumen de algunas de las canciones pegadizas que se pueden escuchar en el juego</h3>
-<ul>
-
-<li><strong>Canción de Huggy Wuggy</strong>: Esta es una canción cantada por Huggy Wuggy cuando te persigue por la escuela. Es una canción tonta y juguetona que expresa su amor por los abrazos y su deseo de abrazarte. También te advierte sobre su fuerza y velocidad. </li>
-<li><strong>Kissie Cutie’s Song</strong>: Esta es una canción cantada por Kissie Cutie cuando intenta atraparte y besarte. Es una canción dulce y romántica que muestra su afecto y obsesión por ti. También revela sus celos e ira hacia cualquiera que se interponga en su camino. </li>
-<li><strong>Molly’s Song</strong>: Esta es una canción cantada por Molly cuando te ayuda con pistas y pistas. Es una canción tímida y tímida que refleja su personalidad y aficiones. También te cuenta su secreto y su conexión con la escuela. </li>
-<li><strong>The Teacher’s Song</strong>: Esta es una canción cantada por The Teacher cuando te enfrenta o te desafía. Es una canción misteriosa y siniestra que revela su identidad y su plan. También se burla de ti y pone a prueba tu conocimiento y coraje. </li>
-</ul>
- <h2>Conclusión</h2>
-<p>Proyecto Playtime APK es un juego de terror de aventura móvil que es a la vez aterrador y divertido. Se encontrará con varios monstruos y rompecabezas, mientras que también hacer nuevos amigos y escuchar canciones impresionantes. Necesitarás usar tu habilidad, estrategia, lógica, creatividad, coraje, amistad, curiosidad y aventura para sobrevivir y escapar de la escuela. Si usted está buscando un juego de terror único que mezcla el miedo y la diversión, descargar Project Playtime APK hoy! </p>
- <h2>Preguntas frecuentes</h2>
-<p>Aquí están algunas de las preguntas y respuestas más frecuentes sobre Project Playtime APK:</p>
- <h4>Q: ¿Es seguro descargar Project Playtime APK? </h4>
-<p>A: Sí, Proyecto Playtime APK es seguro para descargar desde el sitio web oficial de GearBox Games. El archivo APK es libre de virus y malware. </p>
- <h4>Q: ¿Es el proyecto Playtime APK compatible con mi dispositivo? </h4>
-
- <h4>Q: ¿Cómo puedo actualizar el proyecto Playtime APK? </h4>
-<p>A: Puede actualizar el proyecto Playtime APK visitando el sitio web oficial de GearBox Games y descargar la última versión del archivo APK. </p>
- <h4>Q: ¿Cómo puedo contactar a los desarrolladores de Project Playtime APK? </h4>
-<p>A: Puede ponerse en contacto con los desarrolladores de Project Playtime APK enviando un correo electrónico a [email protected] o visitando su página de Facebook. </p>
- <h4>Q: ¿Cómo puedo apoyar a los desarrolladores de Project Playtime APK? </h4>
-<p>A: Usted puede apoyar a los desarrolladores de Project Playtime APK mediante la calificación y la revisión del juego en Google Play Store u otras plataformas, compartir el juego con tus amigos, o hacer una donación en su sitio web. </p> 64aa2da5cf<br />
-<br />
-<br />

spaces/Benson/text-generation/Examples/Descarga Mp4 Alquimia De Las Almas Temporada 2.md

@@ -1,103 +0,0 @@
-<br />
-<h1>Deriva CarX Racing Hack Descargar: Cómo obtener dinero ilimitado y desbloquear todos los coches</h1>
- <p>Si eres un fan de los juegos de deriva, es posible que hayas oído hablar de CarX Drift Racing Online, un simulador de deriva realista e inmersivo que te permite personalizar tu coche, competir con otros jugadores y disfrutar de varias pistas y ubicaciones. Pero lo que si quieres obtener más dinero, desbloquear todos los coches, y acceder a más características en el juego? Ahí es donde CarX Drift Racing descarga hack viene muy bien. </p>
-<h2>descarga mp4 alquimia de las almas temporada 2</h2><br /><p><b><b>DOWNLOAD</b> &#128504;&#128504;&#128504; <a href="https://bltlly.com/2v6IQm">https://bltlly.com/2v6IQm</a></b></p><br /><br />
- <p>En este artículo, le mostraremos cómo instalar dinero mod para CarX Drift Racing Online, que es un mod que le dará dinero máximo y desbloquear todos los coches en el juego. También le contaremos sobre las características y beneficios del juego CarX Drift Racing, así como algunos consejos y trucos para mejorar sus habilidades de deriva. Finalmente, compartiremos algunos trucos y logros para el juego CarX Drift Racing en Xbox One y PlayStation 4. ¡Empecemos! </p>
- <h2>Cómo instalar dinero Mod para CarX deriva Racing en línea</h2>
- <p>Una de las formas más fáciles de hackear CarX Drift Racing Online es usar dinero mod, que es un archivo que puede descargar y colocar en su carpeta de juego. Esto le dará dinero ilimitado y desbloquear todos los coches en el juego. Aquí están los pasos para instalar dinero mod para CarX Drift Racing Online:</p>
- <ol>
-<li>Descargue el archivo de dinero desde <a href="( i )">Discord</a>, donde también puede unirse a la comunidad CarX. Puede encontrar el archivo en el canal general de carx, mensajes anclados. </li>
-<li>Arrastre y suelte el archivo en la carpeta de plugins (File path: C: Archivos de programa (x86) Steam steamapps común CarX Drift Racing Online BepInEx plugins). </li>
-<li>Ir al vapor, haga clic derecho en carx, betas, y seleccione la versión modificable. </li>
-<li>Iniciar el juego y disfrutar! </li>
-</ol>
- <p>Si quieres ver un video tutorial sobre cómo instalar dinero mod para CarX Drift Racing Online, puedes ver este video de YouTube de LiLLobby:</p>
-
- <h2>¿Cuáles son las características y beneficios de CarX Drift Racing Game</h2>
- <p>CarX Drift Racing Online no es solo un simple juego de deriva. Es un simulador de deriva de pleno derecho que ofrece física de conducción realista, personalización detallada y ajuste de los parámetros del coche, una serie de ciudades y lugares especiales de carreras, una variedad de vinilos para diseñar el aspecto de su vehículo, abrir salas en línea y concursos mejorados con nuevos gráficos. Estas son algunas de las características y beneficios del juego CarX Drift Racing:</p>
-<p></p>
- <ul>
-<li>Gráficos realistas: El juego cuenta con gráficos de alta calidad que crean una experiencia visual impresionante. Puedes ver el humo de tus neumáticos, las chispas de tu parachoques, los reflejos de tus ventanas, y más. </li>
-<li>Pistas de carreras y vehículos altamente detallados: El juego cuenta con más de 30 pistas con diferentes diseños, superficies, condiciones climáticas y hora del día. También puede elegir entre más de 100 coches de diferentes modelos, marcas y clases, cada uno con sus propias especificaciones y rendimiento.  </li>
-<li>Personalización y ajuste avanzados del coche: El juego le permite modificar la apariencia y el rendimiento de su coche para adaptarse a sus preferencias y estilo. Puede cambiar el color, vinilo, ruedas, kits de carrocería, alerones, tubos de escape y más. También puede ajustar el motor, la suspensión, los frenos, la dirección, la caja de cambios, el diferencial y otros parámetros para ajustar el manejo y la deriva de su automóvil.  </li>
-<li>Modo multijugador y competiciones en línea: El juego le permite unirse a salas en línea con sus amigos u otros jugadores de todo el mundo. Puedes chatear, desafiar y competir con ellos en varios modos, como carreras de deriva, derrapes en tándem, carreras de sprint y más. También puedes participar en campeonatos y torneos en línea para ganar recompensas y posicionarte en las tablas de clasificación.  </li>
-
-</ul>
- <h2>¿Cuáles son algunos consejos y trucos para mejorar sus habilidades de deriva en CarX Drift Racing Game</h2>
- <p>La deriva no es fácil de dominar. Requiere práctica, paciencia y habilidad. Pero no te preocupes, tenemos algunos consejos y trucos para ayudarte a mejorar tus habilidades de deriva en el juego CarX Drift Racing:</p>
- <ul>
-<li>Elige el coche adecuado: Diferentes coches tienen diferentes características y comportamientos en el juego. Algunos son más fáciles de deriva que otros. Para los principiantes, recomendamos elegir un coche con una baja relación potencia-peso, un diseño de tracción trasera y una distancia entre ejes corta. Estos coches son más sensibles y estables cuando se deriva. </li>
-<li>Ajustar la configuración: Antes de empezar a deriva, debe ajustar la configuración de su coche de acuerdo a su preferencia y las condiciones de la pista. Puede cambiar la presión de los neumáticos, el ángulo de curvatura, el ángulo de la puntera, el ángulo de dirección, el equilibrio de los frenos, la fuerza del freno de mano y más. Estos ajustes afectarán la forma en que el automóvil se agarra, se desliza, gira y se detiene. </li>
-<li>Utilice el acelerador y el freno sabiamente: El acelerador y el freno son sus principales herramientas para controlar sus derivas. Es necesario utilizar con cuidado y sin problemas para mantener el equilibrio de su coche. Para iniciar una deriva, es necesario aplicar suficiente acelerador para romper la tracción en las ruedas traseras. Para mantener una deriva, es necesario modular el acelerador para mantener las ruedas traseras girando más rápido que las ruedas delanteras. Para salir de una deriva, es necesario soltar el acelerador gradualmente para recuperar la tracción en las ruedas traseras. Para ajustar el ángulo de su deriva, debe usar el freno ligeramente para cambiar el peso a las ruedas delanteras. </li>
-
-<li>Práctica, Práctica, Práctica: La mejor manera de mejorar tus habilidades de deriva en el juego CarX Drift Racing es practicar tanto como puedas. Puede comenzar con el modo tutorial, donde puede aprender los conceptos básicos de la deriva y obtener comentarios sobre su rendimiento. También puede probar el modo de práctica, donde puede desplazarse libremente en cualquier pista sin ningún oponente o límites de tiempo. También puedes ver las repeticiones de tus propias derivas o las de otros jugadores para analizar y mejorar tu técnica. </li>
-</ul>
- <h2>¿Cuáles son algunos trucos y logros para CarX deriva juego de carreras en Xbox One y PlayStation 4</h2>
- <p>Si usted está jugando CarX Drift Racing juego en Xbox One o PlayStation 4, es posible que esté interesado en algunos trucos y logros que pueden hacer que su juego más divertido y gratificante. Estos son algunos de ellos:</p>
- <tabla>
-<tr>
-<th>Trucos</th>
-<th>Efecto</th>
-</tr>
-<tr>
-<td>Mantén LB + RB + LT + RT + X + Y + B + A en Xbox One o L1 + R1 + L2 + R2 + Cuadrado + Triángulo + Círculo + Cruz en PlayStation 4 en el menú principal. </td>
-<td>Desbloquear todos los coches y pistas en el juego. </td>
-</tr>
-<tr>
-<td>Presiona Arriba, Arriba, Abajo, Abajo, Izquierda, Derecha, Izquierda, Derecha, B, A en Xbox One o Arriba, Arriba, Abajo, Abajo, Izquierda, Derecha, Derecha, Círculo, Cruz en PlayStation 4 en el menú principal. </td>
-<td>Activar el código de Konami huevo de pascua y obtener un mensaje especial de los desarrolladores. </td>
-</tr>
-<tr>
-<td>Presione izquierda, derecha, izquierda, derecha, X, Y en Xbox One o izquierda, derecha, izquierda, derecha, cuadrado, triángulo en PlayStation 4 en el menú principal. </td>
-<td>Cambiar el idioma del juego a japonés.</td>
-</tr>
-</tabla>
- <tabla>
-<tr>
-<th>Logro</th>
-<th>Descripción</th>
-<th>Gamerscore/Trofeo</th>
-</tr>
-<tr>
-<td>Rey de la deriva</td>
-<td>Gana 1000 puntos en una sola deriva. </td>
-<td>50/Bronce</td>
-</tr>
-<tr>
-<td>Maestro en tándem</td>
-<td>Realizar una deriva en tándem con otro jugador durante 10 segundos. </td>
-<td>100/Plata</td>
-</tr>
-<tr>
-<td>Colector</td>
-<td>Poseer todos los coches en el juego. </td>
-<td>200/Oro</td>
-</tr>
-<tr>
-
-<td>Unidad en todas las pistas del juego. </td>
-<td>150/Plata</td>
-</tr>
-<tr>
-<td>Campeón</td <td>Gana el campeonato online en el juego. </td>
-<td>300/Platinum</td>
-</tr>
-</tabla>
- <h2>Conclusión</h2>
- <p>CarX Drift Racing Online es un juego que atraerá a cualquiera que ame la deriva y las carreras. Ofrece gráficos realistas, pistas y coches detallados, personalización y ajuste avanzados, modo multijugador y competiciones en línea, y un juego divertido y adictivo. Si desea obtener más dinero, desbloquear todos los coches, y acceder a más características en el juego, puede utilizar CarX Drift Racing descarga hack. Le hemos mostrado cómo instalar dinero mod para CarX Drift Racing Online, que es una forma simple y eficaz de hackear el juego. También te hemos dado algunos consejos y trucos para mejorar tus habilidades de deriva, así como algunos trucos y logros para CarX Drift Racing en Xbox One y PlayStation 4. Esperamos que hayas disfrutado de este artículo y te haya resultado útil. Si tienes alguna pregunta o comentario, por favor deja un comentario abajo. Happy drifting! </p>
- <h2>Preguntas frecuentes</h2>
- <p>Aquí hay algunas preguntas frecuentes sobre CarX Drift Racing hack download:</p>
- <ol>
-<li>Es CarX Drift Racing descarga hack seguro de usar? </li>
-<p>Sí, CarX Drift Racing descarga hack es seguro de usar, siempre y cuando se descarga de una fuente de confianza y siga las instrucciones cuidadosamente. Sin embargo, no recomendamos su uso en su cuenta principal o en servidores oficiales, ya que puede violar los términos de servicio del juego y resultar en una prohibición o suspensión. </p>
-<li> ¿Cómo puedo actualizar CarX Drift Racing hack descargar? </li>
-<p>Puede actualizar CarX Drift Racing hack descargar mediante la descarga de la última versión del archivo de dinero mod de Discord y reemplazar el archivo antiguo en su carpeta de juego. También es posible que necesites cambiar a la versión modificable del juego en Steam si hay una nueva actualización para el juego. </p>
-<li> ¿Cómo puedo desinstalar CarX Drift Racing descarga? </li>
-
-<li>¿Puedo utilizar CarX Drift Racing hack descargar en otras plataformas? </li>
-<p>No, CarX Drift Racing descarga hack solo funciona en PC. No funciona en Xbox One, PlayStation 4, Android o dispositivos iOS. </p>
-<li>¿Dónde puedo encontrar más información sobre el juego CarX Drift Racing? </li>
-<p>Puede encontrar más información sobre el juego CarX Drift Racing en su sitio web oficial, página de Facebook, cuenta de Instagram, canal de YouTube o servidor Discord. También puedes ver algunos comentarios y videos de juego del juego en línea. </p>
-</ol></p> 64aa2da5cf<br />
-<br />
-<br />

spaces/BernardoOlisan/vqganclip/taming-transformers/scripts/extract_submodel.py

@@ -1,17 +0,0 @@
-import torch
-import sys
-
-if __name__ == "__main__":
-    inpath = sys.argv[1]
-    outpath = sys.argv[2]
-    submodel = "cond_stage_model"
-    if len(sys.argv) > 3:
-        submodel = sys.argv[3]
-
-    print("Extracting {} from {} to {}.".format(submodel, inpath, outpath))
-
-    sd = torch.load(inpath, map_location="cpu")
-    new_sd = {"state_dict": dict((k.split(".", 1)[-1],v)
-                                 for k,v in sd["state_dict"].items()
-                                 if k.startswith("cond_stage_model"))}
-    torch.save(new_sd, outpath)

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

@@ -1,44 +0,0 @@
-/*
- *  Copyright 2008-2013 NVIDIA Corporation
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a 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 adjacent_difference.h header
-// of the sequential, host, and device systems. It should be #included in any
-// code which uses adl to dispatch adjacent_difference
-
-#include <thrust/system/detail/sequential/adjacent_difference.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/adjacent_difference.h>
-#include <thrust/system/cuda/detail/adjacent_difference.h>
-#include <thrust/system/omp/detail/adjacent_difference.h>
-#include <thrust/system/tbb/detail/adjacent_difference.h>
-#endif
-
-#define __THRUST_HOST_SYSTEM_ADJACENT_DIFFERENCE_HEADER <__THRUST_HOST_SYSTEM_ROOT/detail/adjacent_difference.h>
-#include __THRUST_HOST_SYSTEM_ADJACENT_DIFFERENCE_HEADER
-#undef __THRUST_HOST_SYSTEM_ADJACENT_DIFFERENCE_HEADER
-
-#define __THRUST_DEVICE_SYSTEM_ADJACENT_DIFFERENCE_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/detail/adjacent_difference.h>
-#include __THRUST_DEVICE_SYSTEM_ADJACENT_DIFFERENCE_HEADER
-#undef __THRUST_DEVICE_SYSTEM_ADJACENT_DIFFERENCE_HEADER
-

spaces/CVPR/WALT/mmdet/core/__init__.py

@@ -1,7 +0,0 @@
-from .anchor import *  # noqa: F401, F403
-from .bbox import *  # noqa: F401, F403
-from .evaluation import *  # noqa: F401, F403
-from .export import *  # noqa: F401, F403
-from .mask import *  # noqa: F401, F403
-from .post_processing import *  # noqa: F401, F403
-from .utils import *  # noqa: F401, F403

spaces/CVPR/WALT/mmdet/models/roi_heads/bbox_heads/sabl_head.py

@@ -1,572 +0,0 @@
-import numpy as np
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-from mmcv.cnn import ConvModule, kaiming_init, normal_init, xavier_init
-from mmcv.runner import force_fp32
-
-from mmdet.core import build_bbox_coder, multi_apply, multiclass_nms
-from mmdet.models.builder import HEADS, build_loss
-from mmdet.models.losses import accuracy
-
-
-@HEADS.register_module()
-class SABLHead(nn.Module):
-    """Side-Aware Boundary Localization (SABL) for RoI-Head.
-
-    Side-Aware features are extracted by conv layers
-    with an attention mechanism.
-    Boundary Localization with Bucketing and Bucketing Guided Rescoring
-    are implemented in BucketingBBoxCoder.
-
-    Please refer to https://arxiv.org/abs/1912.04260 for more details.
-
-    Args:
-        cls_in_channels (int): Input channels of cls RoI feature. \
-            Defaults to 256.
-        reg_in_channels (int): Input channels of reg RoI feature. \
-            Defaults to 256.
-        roi_feat_size (int): Size of RoI features. Defaults to 7.
-        reg_feat_up_ratio (int): Upsample ratio of reg features. \
-            Defaults to 2.
-        reg_pre_kernel (int): Kernel of 2D conv layers before \
-            attention pooling. Defaults to 3.
-        reg_post_kernel (int): Kernel of 1D conv layers after \
-            attention pooling. Defaults to 3.
-        reg_pre_num (int): Number of pre convs. Defaults to 2.
-        reg_post_num (int): Number of post convs. Defaults to 1.
-        num_classes (int): Number of classes in dataset. Defaults to 80.
-        cls_out_channels (int): Hidden channels in cls fcs. Defaults to 1024.
-        reg_offset_out_channels (int): Hidden and output channel \
-            of reg offset branch. Defaults to 256.
-        reg_cls_out_channels (int): Hidden and output channel \
-            of reg cls branch. Defaults to 256.
-        num_cls_fcs (int): Number of fcs for cls branch. Defaults to 1.
-        num_reg_fcs (int): Number of fcs for reg branch.. Defaults to 0.
-        reg_class_agnostic (bool): Class agnostic regresion or not. \
-            Defaults to True.
-        norm_cfg (dict): Config of norm layers. Defaults to None.
-        bbox_coder (dict): Config of bbox coder. Defaults 'BucketingBBoxCoder'.
-        loss_cls (dict): Config of classification loss.
-        loss_bbox_cls (dict): Config of classification loss for bbox branch.
-        loss_bbox_reg (dict): Config of regression loss for bbox branch.
-    """
-
-    def __init__(self,
-                 num_classes,
-                 cls_in_channels=256,
-                 reg_in_channels=256,
-                 roi_feat_size=7,
-                 reg_feat_up_ratio=2,
-                 reg_pre_kernel=3,
-                 reg_post_kernel=3,
-                 reg_pre_num=2,
-                 reg_post_num=1,
-                 cls_out_channels=1024,
-                 reg_offset_out_channels=256,
-                 reg_cls_out_channels=256,
-                 num_cls_fcs=1,
-                 num_reg_fcs=0,
-                 reg_class_agnostic=True,
-                 norm_cfg=None,
-                 bbox_coder=dict(
-                     type='BucketingBBoxCoder',
-                     num_buckets=14,
-                     scale_factor=1.7),
-                 loss_cls=dict(
-                     type='CrossEntropyLoss',
-                     use_sigmoid=False,
-                     loss_weight=1.0),
-                 loss_bbox_cls=dict(
-                     type='CrossEntropyLoss',
-                     use_sigmoid=True,
-                     loss_weight=1.0),
-                 loss_bbox_reg=dict(
-                     type='SmoothL1Loss', beta=0.1, loss_weight=1.0)):
-        super(SABLHead, self).__init__()
-        self.cls_in_channels = cls_in_channels
-        self.reg_in_channels = reg_in_channels
-        self.roi_feat_size = roi_feat_size
-        self.reg_feat_up_ratio = int(reg_feat_up_ratio)
-        self.num_buckets = bbox_coder['num_buckets']
-        assert self.reg_feat_up_ratio // 2 >= 1
-        self.up_reg_feat_size = roi_feat_size * self.reg_feat_up_ratio
-        assert self.up_reg_feat_size == bbox_coder['num_buckets']
-        self.reg_pre_kernel = reg_pre_kernel
-        self.reg_post_kernel = reg_post_kernel
-        self.reg_pre_num = reg_pre_num
-        self.reg_post_num = reg_post_num
-        self.num_classes = num_classes
-        self.cls_out_channels = cls_out_channels
-        self.reg_offset_out_channels = reg_offset_out_channels
-        self.reg_cls_out_channels = reg_cls_out_channels
-        self.num_cls_fcs = num_cls_fcs
-        self.num_reg_fcs = num_reg_fcs
-        self.reg_class_agnostic = reg_class_agnostic
-        assert self.reg_class_agnostic
-        self.norm_cfg = norm_cfg
-
-        self.bbox_coder = build_bbox_coder(bbox_coder)
-        self.loss_cls = build_loss(loss_cls)
-        self.loss_bbox_cls = build_loss(loss_bbox_cls)
-        self.loss_bbox_reg = build_loss(loss_bbox_reg)
-
-        self.cls_fcs = self._add_fc_branch(self.num_cls_fcs,
-                                           self.cls_in_channels,
-                                           self.roi_feat_size,
-                                           self.cls_out_channels)
-
-        self.side_num = int(np.ceil(self.num_buckets / 2))
-
-        if self.reg_feat_up_ratio > 1:
-            self.upsample_x = nn.ConvTranspose1d(
-                reg_in_channels,
-                reg_in_channels,
-                self.reg_feat_up_ratio,
-                stride=self.reg_feat_up_ratio)
-            self.upsample_y = nn.ConvTranspose1d(
-                reg_in_channels,
-                reg_in_channels,
-                self.reg_feat_up_ratio,
-                stride=self.reg_feat_up_ratio)
-
-        self.reg_pre_convs = nn.ModuleList()
-        for i in range(self.reg_pre_num):
-            reg_pre_conv = ConvModule(
-                reg_in_channels,
-                reg_in_channels,
-                kernel_size=reg_pre_kernel,
-                padding=reg_pre_kernel // 2,
-                norm_cfg=norm_cfg,
-                act_cfg=dict(type='ReLU'))
-            self.reg_pre_convs.append(reg_pre_conv)
-
-        self.reg_post_conv_xs = nn.ModuleList()
-        for i in range(self.reg_post_num):
-            reg_post_conv_x = ConvModule(
-                reg_in_channels,
-                reg_in_channels,
-                kernel_size=(1, reg_post_kernel),
-                padding=(0, reg_post_kernel // 2),
-                norm_cfg=norm_cfg,
-                act_cfg=dict(type='ReLU'))
-            self.reg_post_conv_xs.append(reg_post_conv_x)
-        self.reg_post_conv_ys = nn.ModuleList()
-        for i in range(self.reg_post_num):
-            reg_post_conv_y = ConvModule(
-                reg_in_channels,
-                reg_in_channels,
-                kernel_size=(reg_post_kernel, 1),
-                padding=(reg_post_kernel // 2, 0),
-                norm_cfg=norm_cfg,
-                act_cfg=dict(type='ReLU'))
-            self.reg_post_conv_ys.append(reg_post_conv_y)
-
-        self.reg_conv_att_x = nn.Conv2d(reg_in_channels, 1, 1)
-        self.reg_conv_att_y = nn.Conv2d(reg_in_channels, 1, 1)
-
-        self.fc_cls = nn.Linear(self.cls_out_channels, self.num_classes + 1)
-        self.relu = nn.ReLU(inplace=True)
-
-        self.reg_cls_fcs = self._add_fc_branch(self.num_reg_fcs,
-                                               self.reg_in_channels, 1,
-                                               self.reg_cls_out_channels)
-        self.reg_offset_fcs = self._add_fc_branch(self.num_reg_fcs,
-                                                  self.reg_in_channels, 1,
-                                                  self.reg_offset_out_channels)
-        self.fc_reg_cls = nn.Linear(self.reg_cls_out_channels, 1)
-        self.fc_reg_offset = nn.Linear(self.reg_offset_out_channels, 1)
-
-    def _add_fc_branch(self, num_branch_fcs, in_channels, roi_feat_size,
-                       fc_out_channels):
-        in_channels = in_channels * roi_feat_size * roi_feat_size
-        branch_fcs = nn.ModuleList()
-        for i in range(num_branch_fcs):
-            fc_in_channels = (in_channels if i == 0 else fc_out_channels)
-            branch_fcs.append(nn.Linear(fc_in_channels, fc_out_channels))
-        return branch_fcs
-
-    def init_weights(self):
-        for module_list in [
-                self.reg_cls_fcs, self.reg_offset_fcs, self.cls_fcs
-        ]:
-            for m in module_list.modules():
-                if isinstance(m, nn.Linear):
-                    xavier_init(m, distribution='uniform')
-        if self.reg_feat_up_ratio > 1:
-            kaiming_init(self.upsample_x, distribution='normal')
-            kaiming_init(self.upsample_y, distribution='normal')
-
-        normal_init(self.reg_conv_att_x, 0, 0.01)
-        normal_init(self.reg_conv_att_y, 0, 0.01)
-        normal_init(self.fc_reg_offset, 0, 0.001)
-        normal_init(self.fc_reg_cls, 0, 0.01)
-        normal_init(self.fc_cls, 0, 0.01)
-
-    def cls_forward(self, cls_x):
-        cls_x = cls_x.view(cls_x.size(0), -1)
-        for fc in self.cls_fcs:
-            cls_x = self.relu(fc(cls_x))
-        cls_score = self.fc_cls(cls_x)
-        return cls_score
-
-    def attention_pool(self, reg_x):
-        """Extract direction-specific features fx and fy with attention
-        methanism."""
-        reg_fx = reg_x
-        reg_fy = reg_x
-        reg_fx_att = self.reg_conv_att_x(reg_fx).sigmoid()
-        reg_fy_att = self.reg_conv_att_y(reg_fy).sigmoid()
-        reg_fx_att = reg_fx_att / reg_fx_att.sum(dim=2).unsqueeze(2)
-        reg_fy_att = reg_fy_att / reg_fy_att.sum(dim=3).unsqueeze(3)
-        reg_fx = (reg_fx * reg_fx_att).sum(dim=2)
-        reg_fy = (reg_fy * reg_fy_att).sum(dim=3)
-        return reg_fx, reg_fy
-
-    def side_aware_feature_extractor(self, reg_x):
-        """Refine and extract side-aware features without split them."""
-        for reg_pre_conv in self.reg_pre_convs:
-            reg_x = reg_pre_conv(reg_x)
-        reg_fx, reg_fy = self.attention_pool(reg_x)
-
-        if self.reg_post_num > 0:
-            reg_fx = reg_fx.unsqueeze(2)
-            reg_fy = reg_fy.unsqueeze(3)
-            for i in range(self.reg_post_num):
-                reg_fx = self.reg_post_conv_xs[i](reg_fx)
-                reg_fy = self.reg_post_conv_ys[i](reg_fy)
-            reg_fx = reg_fx.squeeze(2)
-            reg_fy = reg_fy.squeeze(3)
-        if self.reg_feat_up_ratio > 1:
-            reg_fx = self.relu(self.upsample_x(reg_fx))
-            reg_fy = self.relu(self.upsample_y(reg_fy))
-        reg_fx = torch.transpose(reg_fx, 1, 2)
-        reg_fy = torch.transpose(reg_fy, 1, 2)
-        return reg_fx.contiguous(), reg_fy.contiguous()
-
-    def reg_pred(self, x, offset_fcs, cls_fcs):
-        """Predict bucketing estimation (cls_pred) and fine regression (offset
-        pred) with side-aware features."""
-        x_offset = x.view(-1, self.reg_in_channels)
-        x_cls = x.view(-1, self.reg_in_channels)
-
-        for fc in offset_fcs:
-            x_offset = self.relu(fc(x_offset))
-        for fc in cls_fcs:
-            x_cls = self.relu(fc(x_cls))
-        offset_pred = self.fc_reg_offset(x_offset)
-        cls_pred = self.fc_reg_cls(x_cls)
-
-        offset_pred = offset_pred.view(x.size(0), -1)
-        cls_pred = cls_pred.view(x.size(0), -1)
-
-        return offset_pred, cls_pred
-
-    def side_aware_split(self, feat):
-        """Split side-aware features aligned with orders of bucketing
-        targets."""
-        l_end = int(np.ceil(self.up_reg_feat_size / 2))
-        r_start = int(np.floor(self.up_reg_feat_size / 2))
-        feat_fl = feat[:, :l_end]
-        feat_fr = feat[:, r_start:].flip(dims=(1, ))
-        feat_fl = feat_fl.contiguous()
-        feat_fr = feat_fr.contiguous()
-        feat = torch.cat([feat_fl, feat_fr], dim=-1)
-        return feat
-
-    def bbox_pred_split(self, bbox_pred, num_proposals_per_img):
-        """Split batch bbox prediction back to each image."""
-        bucket_cls_preds, bucket_offset_preds = bbox_pred
-        bucket_cls_preds = bucket_cls_preds.split(num_proposals_per_img, 0)
-        bucket_offset_preds = bucket_offset_preds.split(
-            num_proposals_per_img, 0)
-        bbox_pred = tuple(zip(bucket_cls_preds, bucket_offset_preds))
-        return bbox_pred
-
-    def reg_forward(self, reg_x):
-        outs = self.side_aware_feature_extractor(reg_x)
-        edge_offset_preds = []
-        edge_cls_preds = []
-        reg_fx = outs[0]
-        reg_fy = outs[1]
-        offset_pred_x, cls_pred_x = self.reg_pred(reg_fx, self.reg_offset_fcs,
-                                                  self.reg_cls_fcs)
-        offset_pred_y, cls_pred_y = self.reg_pred(reg_fy, self.reg_offset_fcs,
-                                                  self.reg_cls_fcs)
-        offset_pred_x = self.side_aware_split(offset_pred_x)
-        offset_pred_y = self.side_aware_split(offset_pred_y)
-        cls_pred_x = self.side_aware_split(cls_pred_x)
-        cls_pred_y = self.side_aware_split(cls_pred_y)
-        edge_offset_preds = torch.cat([offset_pred_x, offset_pred_y], dim=-1)
-        edge_cls_preds = torch.cat([cls_pred_x, cls_pred_y], dim=-1)
-
-        return (edge_cls_preds, edge_offset_preds)
-
-    def forward(self, x):
-
-        bbox_pred = self.reg_forward(x)
-        cls_score = self.cls_forward(x)
-
-        return cls_score, bbox_pred
-
-    def get_targets(self, sampling_results, gt_bboxes, gt_labels,
-                    rcnn_train_cfg):
-        pos_proposals = [res.pos_bboxes for res in sampling_results]
-        neg_proposals = [res.neg_bboxes for res in sampling_results]
-        pos_gt_bboxes = [res.pos_gt_bboxes for res in sampling_results]
-        pos_gt_labels = [res.pos_gt_labels for res in sampling_results]
-        cls_reg_targets = self.bucket_target(pos_proposals, neg_proposals,
-                                             pos_gt_bboxes, pos_gt_labels,
-                                             rcnn_train_cfg)
-        (labels, label_weights, bucket_cls_targets, bucket_cls_weights,
-         bucket_offset_targets, bucket_offset_weights) = cls_reg_targets
-        return (labels, label_weights, (bucket_cls_targets,
-                                        bucket_offset_targets),
-                (bucket_cls_weights, bucket_offset_weights))
-
-    def bucket_target(self,
-                      pos_proposals_list,
-                      neg_proposals_list,
-                      pos_gt_bboxes_list,
-                      pos_gt_labels_list,
-                      rcnn_train_cfg,
-                      concat=True):
-        (labels, label_weights, bucket_cls_targets, bucket_cls_weights,
-         bucket_offset_targets, bucket_offset_weights) = multi_apply(
-             self._bucket_target_single,
-             pos_proposals_list,
-             neg_proposals_list,
-             pos_gt_bboxes_list,
-             pos_gt_labels_list,
-             cfg=rcnn_train_cfg)
-
-        if concat:
-            labels = torch.cat(labels, 0)
-            label_weights = torch.cat(label_weights, 0)
-            bucket_cls_targets = torch.cat(bucket_cls_targets, 0)
-            bucket_cls_weights = torch.cat(bucket_cls_weights, 0)
-            bucket_offset_targets = torch.cat(bucket_offset_targets, 0)
-            bucket_offset_weights = torch.cat(bucket_offset_weights, 0)
-        return (labels, label_weights, bucket_cls_targets, bucket_cls_weights,
-                bucket_offset_targets, bucket_offset_weights)
-
-    def _bucket_target_single(self, pos_proposals, neg_proposals,
-                              pos_gt_bboxes, pos_gt_labels, cfg):
-        """Compute bucketing estimation targets and fine regression targets for
-        a single image.
-
-        Args:
-            pos_proposals (Tensor): positive proposals of a single image,
-                 Shape (n_pos, 4)
-            neg_proposals (Tensor): negative proposals of a single image,
-                 Shape (n_neg, 4).
-            pos_gt_bboxes (Tensor): gt bboxes assigned to positive proposals
-                 of a single image, Shape (n_pos, 4).
-            pos_gt_labels (Tensor): gt labels assigned to positive proposals
-                 of a single image, Shape (n_pos, ).
-            cfg (dict): Config of calculating targets
-
-        Returns:
-            tuple:
-
-                - labels (Tensor): Labels in a single image. \
-                    Shape (n,).
-                - label_weights (Tensor): Label weights in a single image.\
-                    Shape (n,)
-                - bucket_cls_targets (Tensor): Bucket cls targets in \
-                    a single image. Shape (n, num_buckets*2).
-                - bucket_cls_weights (Tensor): Bucket cls weights in \
-                    a single image. Shape (n, num_buckets*2).
-                - bucket_offset_targets (Tensor): Bucket offset targets \
-                    in a single image. Shape (n, num_buckets*2).
-                - bucket_offset_targets (Tensor): Bucket offset weights \
-                    in a single image. Shape (n, num_buckets*2).
-        """
-        num_pos = pos_proposals.size(0)
-        num_neg = neg_proposals.size(0)
-        num_samples = num_pos + num_neg
-        labels = pos_gt_bboxes.new_full((num_samples, ),
-                                        self.num_classes,
-                                        dtype=torch.long)
-        label_weights = pos_proposals.new_zeros(num_samples)
-        bucket_cls_targets = pos_proposals.new_zeros(num_samples,
-                                                     4 * self.side_num)
-        bucket_cls_weights = pos_proposals.new_zeros(num_samples,
-                                                     4 * self.side_num)
-        bucket_offset_targets = pos_proposals.new_zeros(
-            num_samples, 4 * self.side_num)
-        bucket_offset_weights = pos_proposals.new_zeros(
-            num_samples, 4 * self.side_num)
-        if num_pos > 0:
-            labels[:num_pos] = pos_gt_labels
-            label_weights[:num_pos] = 1.0
-            (pos_bucket_offset_targets, pos_bucket_offset_weights,
-             pos_bucket_cls_targets,
-             pos_bucket_cls_weights) = self.bbox_coder.encode(
-                 pos_proposals, pos_gt_bboxes)
-            bucket_cls_targets[:num_pos, :] = pos_bucket_cls_targets
-            bucket_cls_weights[:num_pos, :] = pos_bucket_cls_weights
-            bucket_offset_targets[:num_pos, :] = pos_bucket_offset_targets
-            bucket_offset_weights[:num_pos, :] = pos_bucket_offset_weights
-        if num_neg > 0:
-            label_weights[-num_neg:] = 1.0
-        return (labels, label_weights, bucket_cls_targets, bucket_cls_weights,
-                bucket_offset_targets, bucket_offset_weights)
-
-    def loss(self,
-             cls_score,
-             bbox_pred,
-             rois,
-             labels,
-             label_weights,
-             bbox_targets,
-             bbox_weights,
-             reduction_override=None):
-        losses = dict()
-        if cls_score is not None:
-            avg_factor = max(torch.sum(label_weights > 0).float().item(), 1.)
-            losses['loss_cls'] = self.loss_cls(
-                cls_score,
-                labels,
-                label_weights,
-                avg_factor=avg_factor,
-                reduction_override=reduction_override)
-            losses['acc'] = accuracy(cls_score, labels)
-
-        if bbox_pred is not None:
-            bucket_cls_preds, bucket_offset_preds = bbox_pred
-            bucket_cls_targets, bucket_offset_targets = bbox_targets
-            bucket_cls_weights, bucket_offset_weights = bbox_weights
-            # edge cls
-            bucket_cls_preds = bucket_cls_preds.view(-1, self.side_num)
-            bucket_cls_targets = bucket_cls_targets.view(-1, self.side_num)
-            bucket_cls_weights = bucket_cls_weights.view(-1, self.side_num)
-            losses['loss_bbox_cls'] = self.loss_bbox_cls(
-                bucket_cls_preds,
-                bucket_cls_targets,
-                bucket_cls_weights,
-                avg_factor=bucket_cls_targets.size(0),
-                reduction_override=reduction_override)
-
-            losses['loss_bbox_reg'] = self.loss_bbox_reg(
-                bucket_offset_preds,
-                bucket_offset_targets,
-                bucket_offset_weights,
-                avg_factor=bucket_offset_targets.size(0),
-                reduction_override=reduction_override)
-
-        return losses
-
-    @force_fp32(apply_to=('cls_score', 'bbox_pred'))
-    def get_bboxes(self,
-                   rois,
-                   cls_score,
-                   bbox_pred,
-                   img_shape,
-                   scale_factor,
-                   rescale=False,
-                   cfg=None):
-        if isinstance(cls_score, list):
-            cls_score = sum(cls_score) / float(len(cls_score))
-        scores = F.softmax(cls_score, dim=1) if cls_score is not None else None
-
-        if bbox_pred is not None:
-            bboxes, confids = self.bbox_coder.decode(rois[:, 1:], bbox_pred,
-                                                     img_shape)
-        else:
-            bboxes = rois[:, 1:].clone()
-            confids = None
-            if img_shape is not None:
-                bboxes[:, [0, 2]].clamp_(min=0, max=img_shape[1] - 1)
-                bboxes[:, [1, 3]].clamp_(min=0, max=img_shape[0] - 1)
-
-        if rescale and bboxes.size(0) > 0:
-            if isinstance(scale_factor, float):
-                bboxes /= scale_factor
-            else:
-                bboxes /= torch.from_numpy(scale_factor).to(bboxes.device)
-
-        if cfg is None:
-            return bboxes, scores
-        else:
-            det_bboxes, det_labels = multiclass_nms(
-                bboxes,
-                scores,
-                cfg.score_thr,
-                cfg.nms,
-                cfg.max_per_img,
-                score_factors=confids)
-
-            return det_bboxes, det_labels
-
-    @force_fp32(apply_to=('bbox_preds', ))
-    def refine_bboxes(self, rois, labels, bbox_preds, pos_is_gts, img_metas):
-        """Refine bboxes during training.
-
-        Args:
-            rois (Tensor): Shape (n*bs, 5), where n is image number per GPU,
-                and bs is the sampled RoIs per image.
-            labels (Tensor): Shape (n*bs, ).
-            bbox_preds (list[Tensor]): Shape [(n*bs, num_buckets*2), \
-                (n*bs, num_buckets*2)].
-            pos_is_gts (list[Tensor]): Flags indicating if each positive bbox
-                is a gt bbox.
-            img_metas (list[dict]): Meta info of each image.
-
-        Returns:
-            list[Tensor]: Refined bboxes of each image in a mini-batch.
-        """
-        img_ids = rois[:, 0].long().unique(sorted=True)
-        assert img_ids.numel() == len(img_metas)
-
-        bboxes_list = []
-        for i in range(len(img_metas)):
-            inds = torch.nonzero(
-                rois[:, 0] == i, as_tuple=False).squeeze(dim=1)
-            num_rois = inds.numel()
-
-            bboxes_ = rois[inds, 1:]
-            label_ = labels[inds]
-            edge_cls_preds, edge_offset_preds = bbox_preds
-            edge_cls_preds_ = edge_cls_preds[inds]
-            edge_offset_preds_ = edge_offset_preds[inds]
-            bbox_pred_ = [edge_cls_preds_, edge_offset_preds_]
-            img_meta_ = img_metas[i]
-            pos_is_gts_ = pos_is_gts[i]
-
-            bboxes = self.regress_by_class(bboxes_, label_, bbox_pred_,
-                                           img_meta_)
-            # filter gt bboxes
-            pos_keep = 1 - pos_is_gts_
-            keep_inds = pos_is_gts_.new_ones(num_rois)
-            keep_inds[:len(pos_is_gts_)] = pos_keep
-
-            bboxes_list.append(bboxes[keep_inds.type(torch.bool)])
-
-        return bboxes_list
-
-    @force_fp32(apply_to=('bbox_pred', ))
-    def regress_by_class(self, rois, label, bbox_pred, img_meta):
-        """Regress the bbox for the predicted class. Used in Cascade R-CNN.
-
-        Args:
-            rois (Tensor): shape (n, 4) or (n, 5)
-            label (Tensor): shape (n, )
-            bbox_pred (list[Tensor]): shape [(n, num_buckets *2), \
-                (n, num_buckets *2)]
-            img_meta (dict): Image meta info.
-
-        Returns:
-            Tensor: Regressed bboxes, the same shape as input rois.
-        """
-        assert rois.size(1) == 4 or rois.size(1) == 5
-
-        if rois.size(1) == 4:
-            new_rois, _ = self.bbox_coder.decode(rois, bbox_pred,
-                                                 img_meta['img_shape'])
-        else:
-            bboxes, _ = self.bbox_coder.decode(rois[:, 1:], bbox_pred,
-                                               img_meta['img_shape'])
-            new_rois = torch.cat((rois[:, [0]], bboxes), dim=1)
-
-        return new_rois

spaces/Carlosito16/HXM-summarization/app.py

@@ -1,321 +0,0 @@
-print("Libraries installed succesfully!!!!")
-
-import torch
-from transformers import RobertaTokenizerFast, EncoderDecoderModel, AutoTokenizer, AutoModelForSeq2SeqLM
-import re
-import gradio as gr
-
-from helper_function import *
-
-import numpy as np
-from sklearn.feature_extraction.text import CountVectorizer
-
-import spacy
-from sentence_transformers import SentenceTransformer
-from sklearn.metrics.pairwise import cosine_similarity
-
-import requests
-from pathlib import Path
-
-print('Libraries called succesfully!!!!"')
-
-
-
-class keyWordExtractor():
-    
-    def __init__(self, 
-                 article_text,
-                 similarity_model,
-                 n_gram = 1,
-                 top_n = 3,
-                 french_stopwords = None,
-                 ner= None,
-                 ):
-        self.article_text = article_text
-        self.french_stopwords = french_stopwords
-        self.candidates = self.count_vectorizer(n_gram)
-        self.noun_candidates, self.proper_noun_candidates = self.slice_only_noun_token(ner, self.candidates)
-        self.top_n_keywords = self.top_n_extractor(similarity_model, top_n)
-    
-    def count_vectorizer(self, n_gram):
-        n_gram_range = (n_gram, n_gram)
-        # Extract candidate words/phrases
-        count = CountVectorizer(ngram_range=n_gram_range,
-                        stop_words = self.french_stopwords).fit([self.article_text]) #Main change
-        candidates = count.get_feature_names_out()
-
-        return candidates
-
-    def slice_only_noun_token(self, ner, token_list):
-        """
-        Given the tokenized list, this function returns only the "NOUN" token
-            Args:
-                ner (spacy): The NER class to detect the `token.pos_`
-                token_list (list): List of token from the full article
-            Returns:
-                slice_list (list): List of token containing only "NOUN" part of speech
-        """
-
-        noun_slice_list = []
-        proper_noun_slice_list = []
-        for word_idx in range(len(token_list)):
-            doc = ner(token_list[word_idx])
-
-            for token in doc:
-                if token.pos_ == 'NOUN':
-                    noun_slice_list.append(token.text)
-                elif token.pos_ == 'PROPN':
-                    proper_noun_slice_list.append(token.text)
-
-        return noun_slice_list, proper_noun_slice_list
-
-    def top_n_extractor(self, model, top_n):
-        doc_embedding = model.encode([self.article_text])
-        candidate_embeddings = model.encode(self.noun_candidates)
-        distances = cosine_similarity(doc_embedding, candidate_embeddings)
-        keywords = [self.noun_candidates[index] for index in distances.argsort()[0][-top_n:]]
-
-        return keywords
-
-def clear_input():
-    return ("", "")
-
-       
-def camembert_generate_summary(article_text):
-   inputs = cmb_tokenizer([article_text], padding="max_length", truncation=True,
-                          max_length=50,
-                          return_tensors="pt")
-   input_ids = inputs.input_ids.to(device)
-   attention_mask = inputs.attention_mask.to(device)
-   output = cmb_model.generate(input_ids, attention_mask=attention_mask, max_length = 50)
-   return cmb_tokenizer.decode(output[0], skip_special_tokens=True)
-
-    
-def t5_generate_summary(article_text):
-    input_ids = t5_tokenizer(
-    [WHITESPACE_HANDLER(article_text)],
-    return_tensors="pt",
-    padding="max_length",
-    truncation=True,
-    max_length=512)["input_ids"]
-    
-    output_ids = t5_model.generate(
-        input_ids=input_ids,
-        max_length=84,
-        no_repeat_ngram_size=2,
-        num_beams=4
-    )[0]
-    
-    output = t5_tokenizer.decode(
-    output_ids,
-    skip_special_tokens=True,
-    clean_up_tokenization_spaces=False
-    )
-
-    return output
-
-    
-def summarizer(dropdown_model, article_text):
-    """
-    Ruturs a summarized version from the full article based on the selected pretrained-model
-    """
-
-    if dropdown_model == 'camembert':
-        summary = camembert_generate_summary(article_text)
-
-    elif dropdown_model == 'T5':
-        summary = t5_generate_summary(article_text)
-
-    return summary
-    
-def extract_top_3(article):
-    nlp = spacy.load("fr_core_news_md")
-    # model = SentenceTransformer("dangvantuan/sentence-camembert-large") #
-
-    a= keyWordExtractor(article,
-                        n_gram = 1, 
-                        top_n = 3,
-                        ner = nlp,
-                        similarity_model = model)
-    keyword = ", ".join(a.top_n_keywords) #to return ['a' , 'b'] >> "a, b"
-    proper_nonuns = ", ".join(a.proper_noun_candidates)
-
-    return keyword, proper_nonuns
-
-
-def runall(dropdown_model, article_text):
-    summary = summarizer(dropdown_model, article_text)
-    keywords, proper_n = extract_top_3(article_text)
-
-    return summary, keywords, proper_n
-
-
-
-#set the device agnostics code
-device = 'cuda' if torch.cuda.is_available() else 'cpu'
-test_article ="""\"Un nuage de fumée juste après l’explosion, le 1er juin 2019. Une déflagration dans une importante usine d’explosifs du centre de la Russie a fait au moins 79 blessés samedi 1er juin. L’explosion a eu lieu dans l’usine Kristall à Dzerzhinsk, une ville située à environ 400 kilomètres à l’est de Moscou, dans la région de Nijni-Novgorod. « Il y a eu une explosion technique dans l’un des ateliers, suivie d’un incendie qui s’est propagé sur une centaine de mètres carrés », a expliqué un porte-parole des services d’urgence. Des images circulant sur les réseaux sociaux montraient un énorme nuage de fumée après l’explosion. Cinq bâtiments de l’usine et près de 180 bâtiments résidentiels ont été endommagés par l’explosion, selon les autorités municipales. Une enquête pour de potentielles violations des normes de sécurité a été ouverte. Fragments de shrapnel Les blessés ont été soignés après avoir été atteints par des fragments issus de l’explosion, a précisé une porte-parole des autorités sanitaires citée par Interfax. « Nous parlons de blessures par shrapnel d’une gravité moyenne et modérée », a-t-elle précisé. Selon des représentants de Kristall, cinq personnes travaillaient dans la zone où s’est produite l’explosion. Elles ont pu être évacuées en sécurité. Les pompiers locaux ont rapporté n’avoir aucune information sur des personnes qui se trouveraient encore dans l’usine."""
-
-# whitespace handler to be used in `t5 model`
-WHITESPACE_HANDLER = lambda k: re.sub('\s+', ' ', re.sub('\n+', ' ', k.strip()))
-
-article_text = """\"Un nuage de fumée juste après l’explosion, le 1er juin 2019. Une déflagration dans une importante usine d’explosifs du centre de la Russie a fait au moins 79 blessés samedi 1er juin. L’explosion a eu lieu dans l’usine Kristall à Dzerzhinsk, une ville située à environ 400 kilomètres à l’est de Moscou, dans la région de Nijni-Novgorod. « Il y a eu une explosion technique dans l’un des ateliers, suivie d’un incendie qui s’est propagé sur une centaine de mètres carrés », a expliqué un porte-parole des services d’urgence. Des images circulant sur les réseaux sociaux montraient un énorme nuage de fumée après l’explosion. Cinq bâtiments de l’usine et près de 180 bâtiments résidentiels ont été endommagés par l’explosion, selon les autorités municipales. Une enquête pour de potentielles violations des normes de sécurité a été ouverte. Fragments de shrapnel Les blessés ont été soignés après avoir été atteints par des fragments issus de l’explosion, a précisé une porte-parole des autorités sanitaires citée par Interfax. « Nous parlons de blessures par shrapnel d’une gravité moyenne et modérée », a-t-elle précisé. Selon des représentants de Kristall, cinq personnes travaillaient dans la zone où s’est produite l’explosion. Elles ont pu être évacuées en sécurité. Les pompiers locaux ont rapporté n’avoir aucune information sur des personnes qui se trouveraient encore dans l’usine."""
-
-
-cmb_ckpt = 'mrm8488/camembert2camembert_shared-finetuned-french-summarization'
-cmb_tokenizer = RobertaTokenizerFast.from_pretrained(cmb_ckpt)
-cmb_model = EncoderDecoderModel.from_pretrained(cmb_ckpt).to(device)
-
-
-t5_model_name = "csebuetnlp/mT5_multilingual_XLSum"
-t5_tokenizer = AutoTokenizer.from_pretrained(t5_model_name)
-t5_model = AutoModelForSeq2SeqLM.from_pretrained(t5_model_name)
-
-print(summarizer("camembert", test_article))
-
-
-###
-import requests
-from pathlib import Path
-
-if Path('french_stopword.txt').is_file():
-    print('already exists')
-else:
-    print('not existed yet')
-    request = requests.get("https://raw.githubusercontent.com/stopwords-iso/stopwords-fr/master/stopwords-fr.txt")
-    with open('french_stopword.txt', "wb") as f:
-        f.write(request.content)
-
-
-# opening the file in read mode
-my_file = open("french_stopword.txt", "r")
-  
-# reading the file
-data = my_file.read()
-  
-# replacing end of line('/n') with ' ' and
-# splitting the text it further when '.' is seen.
-french_stopwords_list = data.replace('\n', ' ').split(" ")
-  
-# # printing the data
-print(french_stopwords_list)
-my_file.close()
-
-###
-
-nlp = spacy.load("fr_core_news_md")
-model =  SentenceTransformer("dangvantuan/sentence-camembert-large")
-
-print(extract_top_3(test_article))
-
-some_examples = [
-
-        ["camembert", """
-    Carrefour livraison service honteux ! Ne livre jamais dans les temps, plusieurs heures de retard et si on a le malheur de travailler et de ne pas être chez nous toute la journée on peut dire au revoir à notre commande !
-Service client délocalisé qui insulte et raccroche au nez quand on demande ou est notre commande !
-Je ne recommande absolument pas, j'ai pourtant laisser plusieurs chance mais à chaque fois extrêmement déçu...
-    """],
-    ["camembert", """
-    Très mauvaise expérience !!!
-Commande livré par terre sans rien dire alors que nous étions présents.
-En plein centre ville de Dijon.
-Merci pour l’hygiène et la compétence du livreur. 
-Sans parler des surgelés en plein soleil qui ont finis à la poubelle.
-Merci Carrefour Quetigny.
-    """]
-    
-]
-
-
-
-###
-
-
-
-####
-
-with gr.Blocks() as demo:
-    gr.Markdown("Summarize the article text.")
-
-    with gr.Tab("Summarization + Extraction"):
-        with gr.Row():
-            with gr.Column():
-                input_models = gr.Dropdown(['camembert'], value = 'camembert')
-                input_article = gr.TextArea(label = 'Article to be summarized')
-
-            with gr.Column():
-                summarized_output = gr.TextArea(label= 'Generated summary')
-                output_keyword = gr.Textbox(label="Top 3 keywords")
-                output_proper_nouns = gr.Textbox(label="Proper Nouns")
-
-        with gr.Row():
-            clear_button = gr.Button("Clear")
-            summarize_button = gr.Button("Summarize!")
-            extract_button = gr.Button("Extract!")
-            run_button = gr.Button("Run all!")
-
-        examples = gr.Examples(examples= some_examples,
-                                     inputs=[input_models, input_article])
-
-
-        summarize_button.click(summarizer,
-                            inputs = [input_models, input_article] ,
-                            outputs = summarized_output)
-        
-
-        extract_button.click(extract_top_3,
-                            inputs = input_article ,
-                            outputs = [output_keyword, output_proper_nouns])
-        
-        run_button.click(runall,
-                         inputs = [input_models, input_article],
-                         outputs = [summarized_output, output_keyword, output_proper_nouns ])
-        
-        clear_button.click(clear_input,
-                        outputs = [input_models, input_article])
-
-    with gr.Tab("Summarization"):
-        with gr.Row():
-            with gr.Column():
-                input_models = gr.Dropdown(['camembert', 'T5'])
-                input_article = gr.TextArea(label = 'Article to be summarized')
-            with gr.Column():
-                summarized_output = gr.TextArea(label= 'Generated summa')
-        with gr.Row():
-
-            clear_button = gr.Button("Clear")
-            summarize_button = gr.Button("Summarize!")
-            
-        summarize_button.click(summarizer,
-                            inputs = [input_models, input_article] ,
-                            outputs = summarized_output)
-        
-        clear_button.click(clear_input,
-                        outputs = [input_models, input_article])
-    
-        example = "Un nuage de fumée juste après l’explosion, le 1er juin 2019. Une déflagration dans une importante usine d’explosifs du centre de la Russie a fait au moins 79 blessés samedi 1er juin. L’explosion a eu lieu dans l’usine Kristall à Dzerzhinsk, une ville située à environ 400 kilomètres à l’est de Moscou, dans la région de Nijni-Novgorod. « Il y a eu une explosion technique dans l’un des ateliers, suivie d’un incendie qui s’est propagé sur une centaine de mètres carrés », a expliqué un porte-parole des services d’urgence. Des images circulant sur les réseaux sociaux montraient un énorme nuage de fumée après l’explosion. Cinq bâtiments de l’usine et près de 180 bâtiments résidentiels ont été endommagés par l’explosion, selon les autorités municipales. Une enquête pour de potentielles violations des normes de sécurité a été ouverte. Fragments de shrapnel Les blessés ont été soignés après avoir été atteints par des fragments issus de l’explosion, a précisé une porte-parole des autorités sanitaires citée par Interfax. « Nous parlons de blessures par shrapnel d’une gravité moyenne et modérée », a-t-elle précisé. Selon des représentants de Kristall, cinq personnes travaillaient dans la zone où s’est produite l’explosion. Elles ont pu être évacuées en sécurité. Les pompiers locaux ont rapporté n’avoir aucune information sur des personnes qui se trouveraient encore dans l’usine."
-        examples = gr.Examples(examples=[ ["camembert",example],
-                                        ["T5",example]],
-                                        inputs=[input_models, input_article])
-        
-    with gr.Tab("Key word extraction"):
-        
-
-        with gr.Row():
-            with gr.Column():
-                input_article = gr.TextArea(label = 'Article to be extracted')
-            with gr.Column():
-                output_1 = gr.Textbox(label="Top 3 keywords")
-                output_2 = gr.Textbox(label="Proper Nouns")
-
-        with gr.Row():
-
-            clear_button = gr.Button("Clear")
-            extract_button = gr.Button("Extract!")
-
-        extract_button.click(extract_top_3,
-                            inputs = input_article ,
-                            outputs = [output_1, output_2])
-
-
-
-demo.launch(debug=True)

spaces/ChandraMohanNayal/AutoGPT/tests/smoke_test.py

@@ -1,59 +0,0 @@
-"""Smoke test for the autogpt package."""
-import os
-import subprocess
-import sys
-
-import pytest
-
-from autogpt.commands.file_operations import delete_file, read_file
-
-
-@pytest.mark.integration_test
-def test_write_file() -> None:
-    """
-    Test case to check if the write_file command can successfully write 'Hello World' to a file
-    named 'hello_world.txt'.
-
-    Read the current ai_settings.yaml file and store its content.
-    """
-    env_vars = {"MEMORY_BACKEND": "no_memory", "TEMPERATURE": "0"}
-    ai_settings = None
-    if os.path.exists("ai_settings.yaml"):
-        with open("ai_settings.yaml", "r") as f:
-            ai_settings = f.read()
-        os.remove("ai_settings.yaml")
-
-    try:
-        if os.path.exists("hello_world.txt"):
-            # Clean up any existing 'hello_world.txt' file before testing.
-            delete_file("hello_world.txt")
-        # Prepare input data for the test.
-        input_data = """write_file-GPT
-an AI designed to use the write_file command to write 'Hello World' into a file named "hello_world.txt" and then use the task_complete command to complete the task.
-Use the write_file command to write 'Hello World' into a file named "hello_world.txt".
-Use the task_complete command to complete the task.
-Do not use any other commands.
-
-y -5
-EOF"""
-        command = f"{sys.executable} -m autogpt"
-
-        # Execute the script with the input data.
-        process = subprocess.Popen(
-            command,
-            stdin=subprocess.PIPE,
-            shell=True,
-            env={**os.environ, **env_vars},
-        )
-        process.communicate(input_data.encode())
-
-        # Read the content of the 'hello_world.txt' file created during the test.
-        content = read_file("hello_world.txt")
-    finally:
-        if ai_settings:
-            # Restore the original ai_settings.yaml file.
-            with open("ai_settings.yaml", "w") as f:
-                f.write(ai_settings)
-
-    # Check if the content of the 'hello_world.txt' file is equal to 'Hello World'.
-    assert content == "Hello World", f"Expected 'Hello World', got {content}"

spaces/CikeyQI/meme-api/meme_generator/memes/distracted/__init__.py

@@ -1,23 +0,0 @@
-from pathlib import Path
-from typing import List
-
-from pil_utils import BuildImage
-
-from meme_generator import add_meme
-from meme_generator.utils import make_jpg_or_gif
-
-img_dir = Path(__file__).parent / "images"
-
-
-def distracted(images: List[BuildImage], texts, args):
-    frame = BuildImage.open(img_dir / "1.png")
-    label = BuildImage.open(img_dir / "0.png")
-
-    def make(img: BuildImage) -> BuildImage:
-        img = img.convert("RGBA").square().resize((500, 500))
-        return frame.copy().paste(img, below=True).paste(label, (140, 320), alpha=True)
-
-    return make_jpg_or_gif(images[0], make)
-
-
-add_meme("distracted", distracted, min_images=1, max_images=1, keywords=["注意力涣散"])