Update parquet files (step 26 of 296)

spaces/17TheWord/RealESRGAN/inference_realesrgan_video.py

@@ -1,199 +0,0 @@
-import argparse
-import glob
-import mimetypes
-import os
-import queue
-import shutil
-import torch
-from basicsr.archs.rrdbnet_arch import RRDBNet
-from basicsr.utils.logger import AvgTimer
-from tqdm import tqdm
-
-from realesrgan import IOConsumer, PrefetchReader, RealESRGANer
-from realesrgan.archs.srvgg_arch import SRVGGNetCompact
-
-
-def main():
-    """Inference demo for Real-ESRGAN.
-    It mainly for restoring anime videos.
-
-    """
-    parser = argparse.ArgumentParser()
-    parser.add_argument('-i', '--input', type=str, default='inputs', help='Input image or folder')
-    parser.add_argument(
-        '-n',
-        '--model_name',
-        type=str,
-        default='RealESRGAN_x4plus',
-        help=('Model names: RealESRGAN_x4plus | RealESRNet_x4plus | RealESRGAN_x4plus_anime_6B | RealESRGAN_x2plus'
-              'RealESRGANv2-anime-xsx2 | RealESRGANv2-animevideo-xsx2-nousm | RealESRGANv2-animevideo-xsx2'
-              'RealESRGANv2-anime-xsx4 | RealESRGANv2-animevideo-xsx4-nousm | RealESRGANv2-animevideo-xsx4'))
-    parser.add_argument('-o', '--output', type=str, default='results', help='Output folder')
-    parser.add_argument('-s', '--outscale', type=float, default=4, help='The final upsampling scale of the image')
-    parser.add_argument('--suffix', type=str, default='out', help='Suffix of the restored video')
-    parser.add_argument('-t', '--tile', type=int, default=0, help='Tile size, 0 for no tile during testing')
-    parser.add_argument('--tile_pad', type=int, default=10, help='Tile padding')
-    parser.add_argument('--pre_pad', type=int, default=0, help='Pre padding size at each border')
-    parser.add_argument('--face_enhance', action='store_true', help='Use GFPGAN to enhance face')
-    parser.add_argument('--half', action='store_true', help='Use half precision during inference')
-    parser.add_argument('-v', '--video', action='store_true', help='Output a video using ffmpeg')
-    parser.add_argument('-a', '--audio', action='store_true', help='Keep audio')
-    parser.add_argument('--fps', type=float, default=None, help='FPS of the output video')
-    parser.add_argument('--consumer', type=int, default=4, help='Number of IO consumers')
-
-    parser.add_argument(
-        '--alpha_upsampler',
-        type=str,
-        default='realesrgan',
-        help='The upsampler for the alpha channels. Options: realesrgan | bicubic')
-    parser.add_argument(
-        '--ext',
-        type=str,
-        default='auto',
-        help='Image extension. Options: auto | jpg | png, auto means using the same extension as inputs')
-    args = parser.parse_args()
-
-    # ---------------------- determine models according to model names ---------------------- #
-    args.model_name = args.model_name.split('.')[0]
-    if args.model_name in ['RealESRGAN_x4plus', 'RealESRNet_x4plus']:  # x4 RRDBNet model
-        model = RRDBNet(num_in_ch=3, num_out_ch=3, num_feat=64, num_block=23, num_grow_ch=32, scale=4)
-        netscale = 4
-    elif args.model_name in ['RealESRGAN_x4plus_anime_6B']:  # x4 RRDBNet model with 6 blocks
-        model = RRDBNet(num_in_ch=3, num_out_ch=3, num_feat=64, num_block=6, num_grow_ch=32, scale=4)
-        netscale = 4
-    elif args.model_name in ['RealESRGAN_x2plus']:  # x2 RRDBNet model
-        model = RRDBNet(num_in_ch=3, num_out_ch=3, num_feat=64, num_block=23, num_grow_ch=32, scale=2)
-        netscale = 2
-    elif args.model_name in [
-            'RealESRGANv2-anime-xsx2', 'RealESRGANv2-animevideo-xsx2-nousm', 'RealESRGANv2-animevideo-xsx2'
-    ]:  # x2 VGG-style model (XS size)
-        model = SRVGGNetCompact(num_in_ch=3, num_out_ch=3, num_feat=64, num_conv=16, upscale=2, act_type='prelu')
-        netscale = 2
-    elif args.model_name in [
-            'RealESRGANv2-anime-xsx4', 'RealESRGANv2-animevideo-xsx4-nousm', 'RealESRGANv2-animevideo-xsx4'
-    ]:  # x4 VGG-style model (XS size)
-        model = SRVGGNetCompact(num_in_ch=3, num_out_ch=3, num_feat=64, num_conv=16, upscale=4, act_type='prelu')
-        netscale = 4
-
-    # ---------------------- determine model paths ---------------------- #
-    model_path = os.path.join('experiments/pretrained_models', args.model_name + '.pth')
-    if not os.path.isfile(model_path):
-        model_path = os.path.join('realesrgan/weights', args.model_name + '.pth')
-    if not os.path.isfile(model_path):
-        raise ValueError(f'Model {args.model_name} does not exist.')
-
-    # restorer
-    upsampler = RealESRGANer(
-        scale=netscale,
-        model_path=model_path,
-        model=model,
-        tile=args.tile,
-        tile_pad=args.tile_pad,
-        pre_pad=args.pre_pad,
-        half=args.half)
-
-    if args.face_enhance:  # Use GFPGAN for face enhancement
-        from gfpgan import GFPGANer
-        face_enhancer = GFPGANer(
-            model_path='https://github.com/TencentARC/GFPGAN/releases/download/v0.2.0/GFPGANCleanv1-NoCE-C2.pth',
-            upscale=args.outscale,
-            arch='clean',
-            channel_multiplier=2,
-            bg_upsampler=upsampler)
-    os.makedirs(args.output, exist_ok=True)
-    # for saving restored frames
-    save_frame_folder = os.path.join(args.output, 'frames_tmpout')
-    os.makedirs(save_frame_folder, exist_ok=True)
-
-    if mimetypes.guess_type(args.input)[0].startswith('video'):  # is a video file
-        video_name = os.path.splitext(os.path.basename(args.input))[0]
-        frame_folder = os.path.join('tmp_frames', video_name)
-        os.makedirs(frame_folder, exist_ok=True)
-        # use ffmpeg to extract frames
-        os.system(f'ffmpeg -i {args.input} -qscale:v 1 -qmin 1 -qmax 1 -vsync 0  {frame_folder}/frame%08d.png')
-        # get image path list
-        paths = sorted(glob.glob(os.path.join(frame_folder, '*')))
-        if args.video:
-            if args.fps is None:
-                # get input video fps
-                import ffmpeg
-                probe = ffmpeg.probe(args.input)
-                video_streams = [stream for stream in probe['streams'] if stream['codec_type'] == 'video']
-                args.fps = eval(video_streams[0]['avg_frame_rate'])
-    elif mimetypes.guess_type(args.input)[0].startswith('image'):  # is an image file
-        paths = [args.input]
-        video_name = 'video'
-    else:
-        paths = sorted(glob.glob(os.path.join(args.input, '*')))
-        video_name = 'video'
-
-    timer = AvgTimer()
-    timer.start()
-    pbar = tqdm(total=len(paths), unit='frame', desc='inference')
-    # set up prefetch reader
-    reader = PrefetchReader(paths, num_prefetch_queue=4)
-    reader.start()
-
-    que = queue.Queue()
-    consumers = [IOConsumer(args, que, f'IO_{i}') for i in range(args.consumer)]
-    for consumer in consumers:
-        consumer.start()
-
-    for idx, (path, img) in enumerate(zip(paths, reader)):
-        imgname, extension = os.path.splitext(os.path.basename(path))
-        if len(img.shape) == 3 and img.shape[2] == 4:
-            img_mode = 'RGBA'
-        else:
-            img_mode = None
-
-        try:
-            if args.face_enhance:
-                _, _, output = face_enhancer.enhance(img, has_aligned=False, only_center_face=False, paste_back=True)
-            else:
-                output, _ = upsampler.enhance(img, outscale=args.outscale)
-        except RuntimeError as error:
-            print('Error', error)
-            print('If you encounter CUDA out of memory, try to set --tile with a smaller number.')
-
-        else:
-            if args.ext == 'auto':
-                extension = extension[1:]
-            else:
-                extension = args.ext
-            if img_mode == 'RGBA':  # RGBA images should be saved in png format
-                extension = 'png'
-            save_path = os.path.join(save_frame_folder, f'{imgname}_out.{extension}')
-
-            que.put({'output': output, 'save_path': save_path})
-
-        pbar.update(1)
-        torch.cuda.synchronize()
-        timer.record()
-        avg_fps = 1. / (timer.get_avg_time() + 1e-7)
-        pbar.set_description(f'idx {idx}, fps {avg_fps:.2f}')
-
-    for _ in range(args.consumer):
-        que.put('quit')
-    for consumer in consumers:
-        consumer.join()
-    pbar.close()
-
-    # merge frames to video
-    if args.video:
-        video_save_path = os.path.join(args.output, f'{video_name}_{args.suffix}.mp4')
-        if args.audio:
-            os.system(
-                f'ffmpeg -r {args.fps} -i {save_frame_folder}/frame%08d_out.{extension} -i {args.input}'
-                f' -map 0:v:0 -map 1:a:0 -c:a copy -c:v libx264 -r {args.fps} -pix_fmt yuv420p  {video_save_path}')
-        else:
-            os.system(f'ffmpeg -r {args.fps} -i {save_frame_folder}/frame%08d_out.{extension} '
-                      f'-c:v libx264 -r {args.fps} -pix_fmt yuv420p {video_save_path}')
-
-        # delete tmp file
-        shutil.rmtree(save_frame_folder)
-        if os.path.isdir(frame_folder):
-            shutil.rmtree(frame_folder)
-
-
-if __name__ == '__main__':
-    main()

spaces/1acneusushi/gradio-2dmoleculeeditor/data/Download Solid Converter Pdf 7.2 Full Crack.md

@@ -1,27 +0,0 @@
-
-<h1>Download Solid Converter PDF 7.2 Full Crack for Free</h1>
-<p>Solid Converter PDF is a powerful and professional software that can convert PDF files to various formats, such as Word, Excel, PowerPoint, HTML, etc. It can also create PDF files from any printable document. It has many features and functions that can help you edit, modify, or secure your PDF files as you wish.</p>
-<h2>download solid converter pdf 7.2 full crack</h2><br /><p><b><b>Download File</b> &rarr;&rarr;&rarr; <a href="https://byltly.com/2uKyO4">https://byltly.com/2uKyO4</a></b></p><br /><br />
-<p>However, Solid Converter PDF is not a free software. You need to pay a license fee to use it without any limitations or watermarks. If you don't want to spend money on it, you might be tempted to download Solid Converter PDF 7.2 full crack for free from some websites or torrents. But is it really a good idea?</p>
-<p>The answer is no. Downloading Solid Converter PDF 7.2 full crack for free is illegal and risky. Here are some reasons why you should avoid it:</p>
-<ul>
-<li>It violates the intellectual property rights of the software developer and the law. You may face legal consequences or penalties if you are caught using a cracked software.</li>
-<li>It may contain malware or viruses that can harm your computer or steal your personal information. You may lose your important data or compromise your privacy and security.</li>
-<li>It may not work properly or have some errors or bugs. You may experience crashes, freezes, or poor performance when using a cracked software.</li>
-<li>It may not be compatible with your system or other software. You may encounter some conflicts or issues when installing or running a cracked software.</li>
-<li>It may not be updated or supported by the software developer. You may miss out on the latest features, improvements, or fixes of the software.</li>
-</ul>
-<p>Therefore, downloading Solid Converter PDF 7.2 full crack for free is not worth it. You may end up wasting your time, money, or resources on a faulty or dangerous software. Instead, you should use a legal and safe way to get Solid Converter PDF 7.2 full version.</p>
-<p>One of the best options is to use the official website of Solid Converter PDF and download the trial version of the software. The trial version allows you to use the software for 15 days with all the features and functions available. You can then decide whether to buy the license or not.</p>
-<p>To download the trial version of Solid Converter PDF 7.2 full version, you can follow these steps:</p>
-<p></p>
-<ol>
-<li>Go to the official website of Solid Converter PDF and click on the "Download" button.</li>
-<li>Save the installation file on your computer and run it.</li>
-<li>Follow the instructions to install the software on your computer.</li>
-<li>Launch the software and enter your email address to activate the trial version.</li>
-<li>Enjoy using the software for 15 days with all the features and functions available.</li>
-</ol>
-<p>Congratulations! You have successfully downloaded Solid Converter PDF 7.2 full version for free in a legal and safe way. You can now convert, create, or edit your PDF files with ease and confidence.</p> ddb901b051<br />
-<br />
-<br />

spaces/1acneusushi/gradio-2dmoleculeeditor/data/Extreme surebet money maker 9.6.0 Serial Key keygen Unlock the Full Potential of Your Betting Software.md

@@ -1,251 +0,0 @@
-
-<h1>Extreme Surebet Money Maker 9.6.0 Serial Key Keygen: How to Make Money with Arbitrage Betting</h1>
- <p>Are you looking for a way to make money online without risking your hard-earned cash? Do you want to learn how to exploit the differences in odds between different bookmakers and guarantee a profit no matter what the outcome of an event? If so, then you might be interested in arbitrage betting, also known as sure betting or arbing.</p>
-<h2>Extreme surebet money maker 9.6.0 Serial Key keygen</h2><br /><p><b><b>Download Zip</b> &#9733;&#9733;&#9733; <a href="https://byltly.com/2uKzjA">https://byltly.com/2uKzjA</a></b></p><br /><br />
- <p>Arbitrage betting is a technique that involves placing bets on all possible outcomes of an event at odds that guarantee a profit regardless of the result. It is possible because bookmakers have different opinions and methods of setting their odds, which creates discrepancies that can be exploited by smart bettors.</p>
- <p>In this article, we will explain what arbitrage betting is, how it works, and what are the benefits and risks of using it. We will also introduce you to Extreme Surebet Money Maker 9.6.0, a software that helps you find and place arbitrage bets with ease. We will show you how to download, install, and use this software to make money with arbitrage betting. Finally, we will give you some tips and tricks for successful arbitrage betting with Extreme Surebet Money Maker 9.6.0.</p>
- <h2>What is Arbitrage Betting?</h2>
- <h3>Definition and Examples</h3>
- <p>Arbitrage betting is a form of betting that involves placing bets on all possible outcomes of an event at odds that guarantee a profit regardless of the result. It is based on the principle of the law of one price, which states that in an efficient market, the same asset should have the same price everywhere.</p>
- <p>For example, let's say that there is a tennis match between Player A and Player B. You find two bookmakers that offer different odds for this match:</p>
- <table>
-<tr>
-<th>Bookmaker 1</th>
-<th>Bookmaker 2</th>
-</tr>
-<tr>
-<td>Player A: 1.80</td>
-<td>Player A: 2.00</td>
-</tr>
-<tr>
-<td>Player B: 2.00</td>
-<td>Player B: 1.80</td>
-</tr>
-</table>
- <p>You can see that there is an arbitrage opportunity here, because you can bet on both players at different bookmakers and lock in a profit no matter who wins. To do this, you need to calculate how much to bet on each player using this formula:</p>
-<p>How to get Extreme surebet money maker 9.6.0 license code<br />
-Extreme surebet money maker 9.6.0 crack download free<br />
-Extreme surebet money maker 9.6.0 activation key generator<br />
-Extreme surebet money maker 9.6.0 full version with serial number<br />
-Extreme surebet money maker 9.6.0 registration key online<br />
-Extreme surebet money maker 9.6.0 patch file download<br />
-Extreme surebet money maker 9.6.0 product key finder<br />
-Extreme surebet money maker 9.6.0 keygen torrent link<br />
-Extreme surebet money maker 9.6.0 serial code for windows<br />
-Extreme surebet money maker 9.6.0 unlock code for mac<br />
-Extreme surebet money maker 9.6.0 cracked software download<br />
-Extreme surebet money maker 9.6.0 serial key free trial<br />
-Extreme surebet money maker 9.6.0 activation code no survey<br />
-Extreme surebet money maker 9.6.0 full crack with keygen<br />
-Extreme surebet money maker 9.6.0 license key email and password<br />
-Extreme surebet money maker 9.6.0 crack file download link<br />
-Extreme surebet money maker 9.6.0 key generator software<br />
-Extreme surebet money maker 9.6.0 serial number for pc<br />
-Extreme surebet money maker 9.6.0 code generator online<br />
-Extreme surebet money maker 9.6.0 crack version download<br />
-Extreme surebet money maker 9.6.0 serial key working<br />
-Extreme surebet money maker 9.6.0 activation key free download<br />
-Extreme surebet money maker 9.6.0 full version with keygen download<br />
-Extreme surebet money maker 9.6.0 registration key crack<br />
-Extreme surebet money maker 9.6.0 patch download link<br />
-Extreme surebet money maker 9.6.0 product key generator online<br />
-Extreme surebet money maker 9.6.0 keygen download free<br />
-Extreme surebet money maker 9.6.0 serial code for mac<br />
-Extreme surebet money maker 9.6.0 unlock code for windows<br />
-Extreme surebet money maker 9.6.0 cracked version download link<br />
-Extreme surebet money maker 9.6.0 serial key no survey<br />
-Extreme surebet money maker 9.6.0 activation code working<br />
-Extreme surebet money maker 9.6.0 full crack download link<br />
-Extreme surebet money maker 9.6.0 license key generator software<br />
-Extreme surebet money maker 9.6.0 crack file free download<br />
-Extreme surebet money maker 9.6.0 key generator online free<br />
-Extreme surebet money maker 9.6 serial number for windows and mac <br />
-Extreme surebet money maker v9 .60 code generator no survey <br />
-Download extreme SureBet Money Maker v96 .00 full version with crack and keygen <br />
-How to activate extreme SureBet Money Maker v96 .00 with serial key</p>
- <pre><code>Bet on Player A = (Total Stake * Odds on Player B) / (Odds on Player A + Odds on Player B) Bet on Player B = (Total Stake * Odds on Player A) / (Odds on Player A + Odds on Player B) </code></pre>
- <p>Let's say that your total stake is $1000. Using the formula above, you get:</p>
- <pre><code>Bet on Player A = ($1000 * 1.80) / (1.80 + 2.00) = $473.68 Bet on Player B = ($1000 * 2.00) / (1.80 + 2.00) = $526.32 </code></pre>
- <p>You place these bets at the respective bookmakers and wait for the match to end. If Player A wins, you get:</p>
- <pre><code>$473.68 * 2.00 = $947.36 $526.32 * 0 = $0 Total Return = $947.36 Profit = $947.36 - $1000 = -$52.64 </code></pre>
- <p>If Player B wins, you get:</p>
- <pre><code>$473.68 * 0 = $0 $526.32 * 1.80 = $947.38 Total Return = $947.38 Profit = $947.38 - $1000 = -$52.62 </code></pre>
- <p>In both cases, you make a profit of around $52, which is about 5% of your total stake.</p>
- <h3>Benefits and Risks</h3>
- <p>Arbitrage betting has several benefits over conventional betting:</p>
- <ul>
-<li>It eliminates the risk of losing money by covering all possible outcomes.</li>
-<li>It exploits the inefficiencies in the market and takes advantage of the differences in odds between bookmakers.</li>
-<li>It does not depend on luck or skill, but only on mathematics and logic.</li>
-<li>It can be applied to any sport or event that has two or more possible outcomes.</li>
-<li>It can generate consistent and steady profits over time.</li>
-</ul>
- <p>However, arbitrage betting also has some risks and challenges:</p>
- <ul>
-<li>It requires a lot of time, effort, and research to find arbitrage opportunities.</li>
-<li>It requires a large bankroll to place bets on all outcomes and cover the fees and commissions.</li>
-<li>It requires fast and accurate calculations to determine the optimal stakes and profits.</li>
-<li>It requires quick and careful execution to place bets before the odds change or disappear.</li>
-<li>It may attract attention from bookmakers who may limit or close your accounts if they suspect you of arbing.</li>
-</ul>
- <p>To overcome these risks and challenges, you need a reliable tool that can help you find and place arbitrage bets with ease.</p>
- <h2>What is Extreme Surebet Money Maker 9.6.0?</h2>
- <h3>Features and Functions</h3>
- <p>Extreme Surebet Money Maker 9.6.0 is a software that helps you find and place arbitrage bets with ease.</p>
- <p>This software has several features and functions that make it one of the best tools for arbitrage betting:</p>
- <ul>
-<li>It scans over 100 online bookmakers and sports exchanges for arbitrage opportunities in real time.</li>
-<li>It supports over 20 sports and hundreds of markets, including pre-match and live events.</li>
-<li>It calculates the optimal stakes and profits for each arbitrage opportunity automatically.</li>
-<li>It displays all the relevant information for each arbitrage opportunity in a clear and user-friendly interface.</li>
-<li>It allows you to place bets directly from the software with one click using its integrated browser.</li>
-<li>It updates the odds and availability of each arbitrage opportunity constantly.</li>
-<li>It alerts you when new arbitrage opportunities are found or when existing ones change or disappear.</li>
-<li>It keeps track of your bets history, results, profits, losses, balance, ROI, etc.</li>
-<li>It allows you to customize your settings according to your preferences, such as minimum profit percentage, maximum stake size, currency, etc.</li>
-<li>It provides customer support via email or live chat.</li>
-</ul>
- <h3>How to Download and Install</h3>
- <p>To download and install Extreme Surebet Money Maker 9.6.0, you need to follow these steps:</p>
- <ol>
-<li>Visit the official website of Extreme Surebet Money Maker at <a href="https://www.extremesurebet.com/">https://www.extremesurebet.com/</a>.</li>
-<li>Select your preferred language from the drop-down menu at the top right corner of the page.</li>
-<li>Select your preferred payment method from the options available on the page.</li>
-<li>Select your preferred subscription plan from the options available on the page.</li>
-<li>Fulfill your payment details and confirm your order.</li>
-<li>You will receive an email with your serial key keygen and a link to download the software.</li>
-<li>Click on the link to download the software file to your computer.</li>
-<li>Run the software file as an administrator to install it on your computer.</li>
-<li>You will be prompted to enter your serial key keygen during the installation process.</li>
-with your email and password.</li>
-<li>After the installation is complete, you can launch the software and log in with your account.</li>
-<li>You can now start using the software to find and place arbitrage bets.</li>
-</ol>
- <h2>How to Use Extreme Surebet Money Maker 9.6.0 to Find and Place Arbitrage Bets</h2>
- <h3>Step 1: Choose Your Bookmakers and Sports</h3>
- <p>The first step to use Extreme Surebet Money Maker 9.6.0 is to choose your bookmakers and sports.</p>
- <p>To do this, you need to:</p>
- <ol>
-<li>Click on the "Settings" button at the top left corner of the software.</li>
-<li>Click on the "Bookmakers" tab on the left side of the settings window.</li>
-<li>Select the bookmakers that you have accounts with and that you want to use for arbitrage betting.</li>
-<li>Enter your login details for each bookmaker in the corresponding fields.</li>
-<li>Click on the "Save" button at the bottom of the settings window.</li>
-<li>Click on the "Sports" tab on the left side of the settings window.</li>
-<li>Select the sports that you are interested in and that you want to scan for arbitrage opportunities.</li>
-<li>Click on the "Save" button at the bottom of the settings window.</li>
-<li>Close the settings window.</li>
-</ol>
- <h3>Step 2: Scan for Arbitrage Opportunities</h3>
- <p>The second step to use Extreme Surebet Money Maker 9.6.0 is to scan for arbitrage opportunities.</p>
- <p>To do this, you need to:</p>
- <ol>
-<li>Click on the "Scan" button at the top right corner of the software.</li>
-<li>The software will start scanning over 100 online bookmakers and sports exchanges for arbitrage opportunities in real time.</li>
-<li>You will see a list of arbitrage opportunities on the main screen of the software, sorted by profit percentage from highest to lowest.</li>
-<li>You can filter the list by sport, market, bookmaker, profit percentage, stake size, etc. using the options at the top of the screen.</li>
-<li>You can also search for a specific event or outcome using the search box at the top of the screen.</li>
-</ol>
- <h3>Step 3: Calculate Your Stakes and Profits</h3>
- <p>The third step to use Extreme Surebet Money Maker 9.6.0 is to calculate your stakes and profits for each arbitrage opportunity.</p>
- <p>To do this, you need to:</p>
- <ol>
-<li>Select an arbitrage opportunity from the list by clicking on it.</li>
-<li>You will see a pop-up window with all the relevant information for that arbitrage opportunity, such as event name, date, time, outcomes, odds, bookmakers, etc.</li>
-<li>You will also see a calculator that shows you how much to bet on each outcome and how much profit you will make regardless of the result.</li>
-<li>You can adjust your total stake size using the slider or by entering a specific amount in the field below it.</li>
-<li>The calculator will automatically update your stakes and profits according to your total stake size and currency.</li>
-</ol>
- <h3>Step 4: Place Your Bets Quickly and Carefully</h3>
- <p>The fourth and final step to use Extreme Surebet Money Maker 9.6.0 is to place your bets quickly and carefully on each outcome at each bookmaker.</p>
- <p>To do this, you need to:</p>
- <ol>
-<li>Click on the "Bet" button next to each outcome in the pop-up window.</li>
-the bookmaker's website where you can place your bet.</li>
-<li>Log in to your bookmaker account if you are not already logged in.</li>
-<li>Check the odds and availability of the outcome that you want to bet on.</li>
-<li>Enter your stake amount in the betting slip and confirm your bet.</li>
-<li>Repeat this process for each outcome at each bookmaker until you have placed all your bets.</li>
-<li>Close the pop-up window and the browser tabs.</li>
-</ol>
- <p>Congratulations! You have just placed an arbitrage bet and locked in a profit no matter what the result of the event.</p>
- <h2>Tips and Tricks for Successful Arbitrage Betting with Extreme Surebet Money Maker 9.6.0</h2>
- <h3>Use a VPN and Multiple Accounts</h3>
- <p>One of the main challenges of arbitrage betting is that bookmakers may limit or close your accounts if they suspect you of arbing. To avoid this, you should use a VPN and multiple accounts to hide your identity and location from bookmakers.</p>
- <p>A VPN is a service that allows you to connect to the internet through a different server in a different country. This way, you can access websites that are blocked or restricted in your region, and also mask your IP address and location from bookmakers.</p>
- <p>Multiple accounts are accounts that you create using different names, emails, addresses, phone numbers, etc. This way, you can spread your bets across different accounts and bookmakers, and also take advantage of different bonuses and promotions.</p>
- <p>You can use Extreme Surebet Money Maker 9.6.0 with a VPN and multiple accounts by following these steps:</p>
- <ol>
-<li>Choose a reliable VPN service that has servers in many countries and that does not keep logs of your activity.</li>
-<li>Download and install the VPN software on your computer.</li>
-<li>Connect to a server in a country where online gambling is legal and where the bookmakers that you want to use are available.</li>
-<li>Create multiple accounts with different bookmakers using different details and payment methods.</li>
-<li>Use Extreme Surebet Money Maker 9.6.0 as usual, but make sure to log in to your bookmaker accounts using the integrated browser of the software.</li>
-<li>Change your VPN server and bookmaker account regularly to avoid detection and suspicion from bookmakers.</li>
-</ol>
- <h3>Avoid Suspicious Bets and Mistakes</h3>
- <p>Another challenge of arbitrage betting is that some bets may be suspicious or mistaken, which may lead to canceled bets, reduced odds, or disputes with bookmakers. To avoid this, you should avoid suspicious bets and mistakes when placing arbitrage bets.</p>
- <p>Suspicious bets are bets that have unusually high odds, low limits, or rare markets. These may indicate that the bookmaker has made an error or that there is some insider information or manipulation involved. These bets may attract attention from bookmakers or other bettors, who may try to correct the odds or cancel the bets.</p>
- <p>Mistakes are errors that you make when placing arbitrage bets, such as entering the wrong stake amount, choosing the wrong outcome, or betting on the wrong event. These may result in losing money, missing out on profits, or having disputes with bookmakers.</p>
- <p>You can avoid suspicious bets and mistakes by following these tips:</p>
- <ul>
-<li>Check the odds and availability of each outcome at each bookmaker before placing your bets.</li>
-<li>Avoid betting on events or markets that have low liquidity, high volatility, or unusual patterns.</li>
-<li>Avoid betting on events or markets that are not familiar to you or that require specific knowledge or skills.</li>
-<li>Avoid betting on events or markets that have conflicting or incomplete information or rules.</li>
-<li>Avoid betting on events that are too close to start or end time.</li>
-<li>Avoid betting on events that have too many possible outcomes or variables.</li>
-<li>Avoid betting on events that have too high or too low profit percentages.</li>
-<li>Avoid betting on events that have too high or too low stake sizes.</li>
-<li>Avoid betting on events that have too many bookmakers involved.</li>
-<li>Avoid betting on events that have been canceled, postponed, suspended, or changed for any reason.</li>
-<li>Double-check your stakes and profits for each outcome at each bookmaker before confirming your bets.</li>
-</ul>
- <h3>Keep Track of Your Results and Bankroll</h3>
- <p>The final challenge of arbitrage betting is that it requires a lot of discipline and management to keep track of your results and bankroll. To do this, you should use Extreme Surebet Money Maker 9.6.0's features and functions to monitor and analyze your performance and finances.</p>
- <p>You can keep track of your results and bankroll by following these steps:</p>
- <ol>
-<li>Click on the "History" button at the top left corner of the software.</li>
-stakes, profits, losses, etc.</li>
-<li>You can filter the list by date, sport, market, bookmaker, profit percentage, stake size, etc. using the options at the top of the screen.</li>
-<li>You can also search for a specific bet or event using the search box at the top of the screen.</li>
-<li>You can export your bets history to a CSV file by clicking on the "Export" button at the bottom of the screen.</li>
-<li>Click on the "Statistics" button at the top left corner of the software.</li>
-<li>You will see a summary of your statistics, including total bets, total stakes, total profits, total losses, average profit percentage, average stake size, ROI, etc.</li>
-<li>You can filter the statistics by date, sport, market, bookmaker, profit percentage, stake size, etc. using the options at the top of the screen.</li>
-<li>You can also see a graph of your profits and losses over time by clicking on the "Graph" button at the bottom of the screen.</li>
-<li>Click on the "Balance" button at the top left corner of the software.</li>
-<li>You will see a list of all your bookmaker accounts and their balances.</li>
-<li>You can update your balances manually by entering the current amount in each account in the corresponding field.</li>
-<li>You can also update your balances automatically by clicking on the "Update" button at the bottom of the screen. This will open a new tab in your integrated browser that will take you to each bookmaker's website where you can check your balance.</li>
-</ol>
- <p>By keeping track of your results and bankroll, you can evaluate your performance and finances and make adjustments accordingly.</p>
- <h2>Conclusion</h2>
- <p>Arbitrage betting is a technique that involves placing bets on all possible outcomes of an event at odds that guarantee a profit regardless of the result. It is possible because bookmakers have different opinions and methods of setting their odds, which creates discrepancies that can be exploited by smart bettors.</p>
- <p>Arbitrage betting has several benefits over conventional betting, such as eliminating the risk of losing money, exploiting the inefficiencies in the market, and generating consistent and steady profits over time. However, arbitrage betting also has some risks and challenges, such as finding arbitrage opportunities, placing bets quickly and carefully, and avoiding detection and suspicion from bookmakers.</p>
- the odds and availability of each arbitrage opportunity constantly. It alerts you when new arbitrage opportunities are found or when existing ones change or disappear. It keeps track of your bets history, results, profits, losses, balance, ROI, etc. It allows you to customize your settings according to your preferences, such as minimum profit percentage, maximum stake size, currency, etc. It provides customer support via email or live chat.</p>
- <p>To use Extreme Surebet Money Maker 9.6.0, you need to download and install it on your computer. You need to choose your bookmakers and sports that you want to use for arbitrage betting. You need to scan for arbitrage opportunities and calculate your stakes and profits for each one. You need to place your bets quickly and carefully on each outcome at each bookmaker. You need to keep track of your results and bankroll and make adjustments accordingly.</p>
- <p>To succeed in arbitrage betting with Extreme Surebet Money Maker 9.6.0, you need to follow some tips and tricks, such as using a VPN and multiple accounts to hide your identity and location from bookmakers, avoiding suspicious bets and mistakes that may lead to canceled bets, reduced odds, or disputes with bookmakers, and monitoring and analyzing your performance and finances.</p>
- <p>If you are interested in arbitrage betting and want to make money with it without risking your hard-earned cash, then you should try Extreme Surebet Money Maker 9.6.0. It is one of the best tools for arbitrage betting that will help you find and place arbitrage bets with ease.</p>
- <h2>FAQs</h2>
- <p>Here are some frequently asked questions about Extreme Surebet Money Maker 9.6.0:</p>
- <h3>Q: How much does Extreme Surebet Money Maker 9.6.0 cost?</h3>
- <p>A: Extreme Surebet Money Maker 9.6.0 offers different subscription plans depending on the duration and features that you want to use. The prices range from $29 per month for the basic plan to $199 per month for the premium plan. You can also get discounts if you pay for longer periods in advance.</p>
- <h3>Q: How can I get a serial key keygen for Extreme Surebet Money Maker 9.6.0?</h3>
- <p>A: You can get a serial key keygen for Extreme Surebet Money Maker 9.6.0 by purchasing a subscription plan from the official website of Extreme Surebet Money Maker at <a href="https://www.extremesurebet.com/">https://www.extremesurebet.com/</a>. You will receive an email with your serial key keygen and a link to download the software after you confirm your order.</p>
- <h3>Q: How can I contact the customer support of Extreme Surebet Money Maker 9.6.0?</h3>
- <p>A: You can contact the customer support of Extreme Surebet Money Maker 9.6.0 by sending an email to <a href="mailto:[email protected]">[email protected]</a> or by using the live chat feature on the official website of Extreme Surebet Money Maker at <a href="https://www.extremesurebet.com/">https://www.extremesurebet.com/</a>. The customer support team is available 24/7 and will respond to your queries as soon as possible.</p>
- <h3>Q: Is Extreme Surebet Money Maker 9.6.0 safe and legal?</h3>
- <p>A: Extreme Surebet Money Maker 9.6.0 is safe and legal to use as long as you follow the terms and conditions of the software and the bookmakers that you use for arbitrage betting. The software does not contain any viruses or malware that may harm your computer or data. The software does not violate any laws or regulations that may prohibit or restrict online gambling or arbitrage betting in your region.</p>
- <h3>Q: What are the minimum system requirements for Extreme Surebet Money Maker 9.6.0?</h3>
- <p>A: The minimum system requirements for Extreme Surebet Money Maker 9.6.0 are:</p>
- <ul>
-<li>Operating System: Windows XP/Vista/7/8/10</li>
-<li>Processor: Intel Pentium 4 or higher</li>
-<li>Memory: 512 MB RAM or higher</li>
-<li>Disk Space: 100 MB free disk space or higher</li>
-<li>Internet Connection: Broadband or higher</li>
-</ul>
- </p> 0a6ba089eb<br />
-<br />
-<br />

spaces/1gistliPinn/ChatGPT4/Examples/Chota Bheem Dholakpur To Kathmandu Full Movie In Hindi Free Download.md

@@ -1,7 +0,0 @@
-<h2>chota bheem dholakpur to kathmandu full movie in hindi free download</h2><br /><p><b><b>Download Zip</b> --->>> <a href="https://imgfil.com/2uxXZ6">https://imgfil.com/2uxXZ6</a></b></p><br /><br />
-
-chota bheem dholakpur to kathmandu movie in hindi machan vikram kumar nithyayil ki gaal vikram kumar shyam pandit bholenath mukesh choti desh muharram vikram kumar choti karti
-chota bheem dekhi khushi choti bheem ki khushi choti bheem ki choti choti bheem khushi choti bheem ki choti choti bheem khushi choti bheem ki choti choti bheem khushi choti b 8a78ff9644<br />
-<br />
-<br />
-<p></p>

spaces/1gistliPinn/ChatGPT4/Examples/Dragon Age Inquisition Patch V.1.11 24 UPD.md

@@ -1,21 +0,0 @@
-
-<h1>Dragon Age: Inquisition Patch v.1.11 24: What You Need to Know</h1>
-<p>Dragon Age: Inquisition is a popular role-playing game developed by BioWare and published by Electronic Arts. The game was released in 2014 and has received several updates and expansions since then. The latest update, Patch v.1.11 24, was released on October 15, 2015 for PC, PlayStation 4, and Xbox One. Here are some of the features and improvements that this patch brings to the game.</p>
-<h2>The Golden Nug</h2>
-<p>If you have spent countless hours exploring the vast world of Thedas, you have probably collected a lot of items, codices, schematics, recipes, mounts, and decorations. Wouldn't it be nice if you could sync them across your different saved games? Well, now you can with the Golden Nug statue. This statue lets you sync your collectibles across games that are online and on the same platform. All you have to do is touch the statue in Haven or Skyhold with a post-game character, and then touch it again with another character to sync your current game. This way, you can enjoy your hard-earned rewards in any of your games.</p>
-<h2>Dragon Age: Inquisition Patch v.1.11 24</h2><br /><p><b><b>DOWNLOAD</b> &#9999; &#9999; &#9999; <a href="https://imgfil.com/2uxXMY">https://imgfil.com/2uxXMY</a></b></p><br /><br />
-<h2>The Wardrobe</h2>
-<p>Another feature that many players have requested is more options for the Inquisitor's casual attire. The default beige outfit may be practical for the Frostback Mountains, but it can get boring after a while. With the latest patch, you can access a wardrobe in Skyhold that contains a dozen new options for your Inquisitor's casual wear. You can choose from different colors, styles, and fabrics to suit your mood and personality. And don't worry, if you ever miss the beige outfit, you can always switch back to it anytime.</p>
-<h2>New Multiplayer Agent</h2>
-<p>The patch also adds a new multiplayer agent to the roster of the Inquisition's agents. Hissera, the Saarebas, is a powerful Qunari mage who can change her abilities depending on her stance. She has three stances: opening, flow, and finishing. Each stance has a different effect on her abilities, such as pulling enemies in, unleashing cold attacks, or boosting allies. Each time she casts an ability, she progresses to the next stance in the same order. Hissera is a unique and versatile character who can adapt to any situation.</p>
-<h2>Conclusion</h2>
-<p>Dragon Age: Inquisition Patch v.1.11 24 is a content update that adds new features and improvements to the game. It allows players to sync their collectibles across games with the Golden Nug statue, customize their Inquisitor's casual attire with the wardrobe, and play as a new multiplayer agent with Hissera, the Saarebas. The patch also fixes some bugs and glitches that may have affected the gameplay experience. If you are a fan of Dragon Age: Inquisition, you should definitely download this patch and enjoy the new content.</p>
-
-<h2>Respec Your Character</h2>
-<p>Dragon Age: Inquisition features the ability to respec a character's abilities and skills. To do so, you must approach the totem that can be found near the forging equipment. You can buy your first respec amulet for 1 gold, but subsequent ones will cost more. Respeccing can be useful if you want to try out different builds, optimize your character for certain situations, or correct any mistakes you made while leveling up. You can respec as many times as you want, as long as you have enough gold and amulets.</p>
-<h2>Use Math to Solve Astrariums</h2>
-<p>Astrariums are star puzzles that can be found in various locations in Thedas. Solving them will reveal hidden caves that contain valuable loot and secrets. However, some of them can be tricky and frustrating to solve. A simple trick to help you out is to use math. Look at the completed puzzle in the bottom left corner of the screen. If any of the star points have an odd number of paths, there will always be one more to balance things out. What this means is that you will always start on one of these points, and end on the other. If there are only stars with an even number of paths, you can start at any point, but you will have to finish at that same point.</p>
-<h2>Don't Neglect Your Search Button</h2>
-<p>It's easy to forget that you can trigger a search pulse by pressing down on the left control stick - as it's only mentioned briefly in the game. By using the search button, any interactive items in the area will ping and have an orange outline. If you see your compass start to pulse, hitting the search button will indicate the direction of hidden items, and will reveal them once you are close enough. This is very useful for finding resources, codex entries, loot, secrets, and quest items. You should use it often, especially in new areas or when exploring dungeons.</p> d5da3c52bf<br />
-<br />
-<br />

spaces/1gistliPinn/ChatGPT4/Examples/ESET Internet Security 11.2.49.0 64 Bit.md

@@ -1,6 +0,0 @@
-<h2>ESET Internet Security 11.2.49.0 64 bit</h2><br /><p><b><b>DOWNLOAD</b> &#9658;&#9658;&#9658;&#9658;&#9658; <a href="https://imgfil.com/2uy02C">https://imgfil.com/2uy02C</a></b></p><br /><br />
-<br />
-Try the latest version of iTunes (64-bit) 2020 for Windows Download iTunes for ... 9.0 Build 2496 (32-bit) MEmu 6.0.7.6 ESET Internet Security 11.2.49.0 K-Lite ... 1fdad05405<br />
-<br />
-<br />
-<p></p>

spaces/1line/AutoGPT/autogpt/memory/redismem.py

@@ -1,156 +0,0 @@
-"""Redis memory provider."""
-from __future__ import annotations
-
-from typing import Any
-
-import numpy as np
-import redis
-from colorama import Fore, Style
-from redis.commands.search.field import TextField, VectorField
-from redis.commands.search.indexDefinition import IndexDefinition, IndexType
-from redis.commands.search.query import Query
-
-from autogpt.llm_utils import create_embedding_with_ada
-from autogpt.logs import logger
-from autogpt.memory.base import MemoryProviderSingleton
-
-SCHEMA = [
-    TextField("data"),
-    VectorField(
-        "embedding",
-        "HNSW",
-        {"TYPE": "FLOAT32", "DIM": 1536, "DISTANCE_METRIC": "COSINE"},
-    ),
-]
-
-
-class RedisMemory(MemoryProviderSingleton):
-    def __init__(self, cfg):
-        """
-        Initializes the Redis memory provider.
-
-        Args:
-            cfg: The config object.
-
-        Returns: None
-        """
-        redis_host = cfg.redis_host
-        redis_port = cfg.redis_port
-        redis_password = cfg.redis_password
-        self.dimension = 1536
-        self.redis = redis.Redis(
-            host=redis_host,
-            port=redis_port,
-            password=redis_password,
-            db=0,  # Cannot be changed
-        )
-        self.cfg = cfg
-
-        # Check redis connection
-        try:
-            self.redis.ping()
-        except redis.ConnectionError as e:
-            logger.typewriter_log(
-                "FAILED TO CONNECT TO REDIS",
-                Fore.RED,
-                Style.BRIGHT + str(e) + Style.RESET_ALL,
-            )
-            logger.double_check(
-                "Please ensure you have setup and configured Redis properly for use. "
-                + f"You can check out {Fore.CYAN + Style.BRIGHT}"
-                f"https://github.com/Torantulino/Auto-GPT#redis-setup{Style.RESET_ALL}"
-                " to ensure you've set up everything correctly."
-            )
-            exit(1)
-
-        if cfg.wipe_redis_on_start:
-            self.redis.flushall()
-        try:
-            self.redis.ft(f"{cfg.memory_index}").create_index(
-                fields=SCHEMA,
-                definition=IndexDefinition(
-                    prefix=[f"{cfg.memory_index}:"], index_type=IndexType.HASH
-                ),
-            )
-        except Exception as e:
-            print("Error creating Redis search index: ", e)
-        existing_vec_num = self.redis.get(f"{cfg.memory_index}-vec_num")
-        self.vec_num = int(existing_vec_num.decode("utf-8")) if existing_vec_num else 0
-
-    def add(self, data: str) -> str:
-        """
-        Adds a data point to the memory.
-
-        Args:
-            data: The data to add.
-
-        Returns: Message indicating that the data has been added.
-        """
-        if "Command Error:" in data:
-            return ""
-        vector = create_embedding_with_ada(data)
-        vector = np.array(vector).astype(np.float32).tobytes()
-        data_dict = {b"data": data, "embedding": vector}
-        pipe = self.redis.pipeline()
-        pipe.hset(f"{self.cfg.memory_index}:{self.vec_num}", mapping=data_dict)
-        _text = (
-            f"Inserting data into memory at index: {self.vec_num}:\n" f"data: {data}"
-        )
-        self.vec_num += 1
-        pipe.set(f"{self.cfg.memory_index}-vec_num", self.vec_num)
-        pipe.execute()
-        return _text
-
-    def get(self, data: str) -> list[Any] | None:
-        """
-        Gets the data from the memory that is most relevant to the given data.
-
-        Args:
-            data: The data to compare to.
-
-        Returns: The most relevant data.
-        """
-        return self.get_relevant(data, 1)
-
-    def clear(self) -> str:
-        """
-        Clears the redis server.
-
-        Returns: A message indicating that the memory has been cleared.
-        """
-        self.redis.flushall()
-        return "Obliviated"
-
-    def get_relevant(self, data: str, num_relevant: int = 5) -> list[Any] | None:
-        """
-        Returns all the data in the memory that is relevant to the given data.
-        Args:
-            data: The data to compare to.
-            num_relevant: The number of relevant data to return.
-
-        Returns: A list of the most relevant data.
-        """
-        query_embedding = create_embedding_with_ada(data)
-        base_query = f"*=>[KNN {num_relevant} @embedding $vector AS vector_score]"
-        query = (
-            Query(base_query)
-            .return_fields("data", "vector_score")
-            .sort_by("vector_score")
-            .dialect(2)
-        )
-        query_vector = np.array(query_embedding).astype(np.float32).tobytes()
-
-        try:
-            results = self.redis.ft(f"{self.cfg.memory_index}").search(
-                query, query_params={"vector": query_vector}
-            )
-        except Exception as e:
-            print("Error calling Redis search: ", e)
-            return None
-        return [result.data for result in results.docs]
-
-    def get_stats(self):
-        """
-        Returns: The stats of the memory index.
-        """
-        return self.redis.ft(f"{self.cfg.memory_index}").info()

spaces/1pelhydcardo/ChatGPT-prompt-generator/assets/BlueJeans APK How to Download and Install the Best Video Conferencing App.md

@@ -1,100 +0,0 @@
-
-<h1>BlueJeans APK: A Guide to Download and Use the App</h1>
-<p>Are you looking for a video conferencing app that works well on your Android device? Do you want to have high-quality audio and video, easy integration with other apps, flexible meeting options, and enhanced security features? If so, you might want to check out BlueJeans APK.</p>
-<h2>bluejeans apk</h2><br /><p><b><b>Download</b> &#10042; <a href="https://urlin.us/2uT2jP">https://urlin.us/2uT2jP</a></b></p><br /><br />
-<h2>What is BlueJeans APK?</h2>
-<h3>BlueJeans APK is a free native app for Android devices that allows you to join and host video meetings, share your screen, chat with other participants, and more.</h3>
-<p>BlueJeans is a cloud-based video conferencing service that connects people across different devices and platforms. It is used by millions of people around the world for business meetings, online classes, webinars, events, and more.</p>
-<p>BlueJeans APK is the app version of BlueJeans that is designed specifically for Android-based tablets and smartphones. It is available in the Google Play Store and it is compatible with Android 5.0 and above.</p>
-<h2>Why use BlueJeans APK?</h2>
-<h3>BlueJeans APK offers many benefits for users who want to have seamless and secure video conferencing experiences on their mobile devices. Some of the advantages are:</h3>
-<h4>- High-quality audio and video with Dolby Voice technology</h4>
-<p>BlueJeans APK uses Dolby Voice technology to deliver crystal-clear sound and sharp video quality. Dolby Voice reduces background noise, enhances speech clarity, balances volume levels, and creates a natural and immersive sound experience. You can also adjust your audio and video settings according to your preferences and network conditions.</p>
-<p>bluejeans app download for android<br />
-bluejeans video conferencing apk free download<br />
-bluejeans apk latest version<br />
-bluejeans for windows 10 apk<br />
-bluejeans app network apk<br />
-bluejeans events app apk<br />
-bluejeans outlook plugin apk<br />
-bluejeans google calendar addon apk<br />
-bluejeans for linux apk<br />
-bluejeans for mac apk<br />
-bluejeans for vdi apk<br />
-bluejeans for iphone apk<br />
-bluejeans glass enterprise edition 2 apk<br />
-bluejeans screen sharing apk<br />
-bluejeans chat apk<br />
-bluejeans meeting moderator apk<br />
-bluejeans audio conferencing apk<br />
-bluejeans hd video quality apk<br />
-bluejeans dolby voice apk<br />
-bluejeans smart meetings apk<br />
-bluejeans command center apk<br />
-bluejeans relay apk<br />
-bluejeans rooms apk<br />
-bluejeans gateway for microsoft teams apk<br />
-bluejeans live streaming apk<br />
-bluejeans breakout sessions apk<br />
-bluejeans polling and q&a apk<br />
-bluejeans recording and transcription apk<br />
-bluejeans analytics and reporting apk<br />
-bluejeans security and compliance apk<br />
-bluejeans enterprise-grade scalability apk<br />
-bluejeans integrations with existing apps apk<br />
-bluejeans customer support and services apk<br />
-how to install bluejeans apk on android device<br />
-how to update bluejeans apk on android device<br />
-how to uninstall bluejeans apk on android device<br />
-how to use bluejeans apk on android device<br />
-how to join a meeting with bluejeans apk on android device<br />
-how to schedule a meeting with bluejeans apk on android device<br />
-how to invite others to a meeting with bluejeans apk on android device<br />
-how to mute/unmute yourself with bluejeans apk on android device<br />
-how to turn on/off your camera with bluejeans apk on android device<br />
-how to switch between speaker and gallery view with bluejeans apk on android device<br />
-how to share your screen with bluejeans apk on android device<br />
-how to chat with other participants with bluejeans apk on android device<br />
-how to raise your hand with bluejeans apk on android device<br />
-how to react with emojis with bluejeans apk on android device</p>
-<h4>- Easy integration with calendaring solutions and existing apps</h4>
-<p>BlueJeans APK integrates seamlessly with your calendar apps, such as Google Calendar, Outlook, or Gmail, and allows you to schedule, join, or invite others to meetings with just a few taps. You can also use BlueJeans APK with other apps that you use for work or education, such as Microsoft Teams, Slack, Zoom, Canvas, Moodle, and more. You can launch BlueJeans meetings from these apps or share content from them during your meetings.</p>
-<h4>- Flexible meeting options such as joining via phone, browser, or app</h4>
-<p>BlueJeans APK gives you the flexibility to join or host meetings in different ways. You can join a meeting via phone by dialing a local or toll-free number, via browser by clicking on a meeting link, or via app by entering a meeting ID or selecting a meeting from your calendar or history. You can also switch between these modes during a meeting if needed. For example, you can join a meeting via phone and then switch to the app to share your screen.</p>
-<h4>- Enhanced security features such as encryption, authentication, and moderation controls</h4>
-<p>BlueJeans APK ensures that your video meetings are secure and private. It uses encryption to protect your data and communication, authentication to verify your identity and access rights, and moderation controls to manage your meeting participants and settings. You can also lock your meetings, mute or remove participants, enable or disable chat and recording, and more.</p>
-<h2>How to download and install BlueJeans APK?</h2>
-<h3>You can download and install BlueJeans APK from the Google Play Store in a few simple steps. Here's how:</h3>
-<h4>- Open the Google Play Store app on your Android device and search for BlueJeans Video Conferencing</h4>
-<p>You can also use this link to go directly to the app page on the Google Play Store.</p>
-<h4>- Tap on the app icon and then tap on Install to start the download process</h4>
-<p>The app size is about 40 MB and it will take a few minutes to download depending on your network speed.</p>
-<h4>- Once the app is installed, tap on Open to launch it and sign in with your BlueJeans account credentials or create a new account if you don't have one</h4>
-<p>You can use your email address and password, your Google account, or your SSO (single sign-on) provider to sign in to BlueJeans APK. If you don't have an account yet, you can create one for free by tapping on Sign Up and following the instructions.</p>
-<h2>How to use BlueJeans APK?</h2>
-<h3>You can use BlueJeans APK to join or host video meetings, share your screen, chat with other participants, and more. Here are some of the main features and functions of the app:</h3>
-<h4>- To join a meeting, tap on the Join Meeting button on the home screen and enter the meeting ID or link, or select a meeting from your calendar or history</h4>
-<p>You can also scan a QR code or use voice commands to join a meeting. If you are joining as a guest, you will need to enter your name and email address before joining.</p>
-<h4>- To host a meeting, tap on the Schedule Meeting button on the home screen and enter the meeting details, such as title, date, time, invitees, etc., or select an existing meeting from your calendar or history</h4>
-<p>You can also customize your meeting settings, such as enabling or disabling video, audio, chat, recording, etc., before starting the meeting. You can also send invitations to your invitees via email or SMS.</p>
-<h4>- To share your screen, tap on the Share Screen button on the bottom toolbar during a meeting and choose what you want to share, such as your entire screen, an app, a file, etc.</h4>
-<p>You can also annotate your screen with different tools such as pen, highlighter, shape, text, etc. You can also pause or stop sharing your screen at any time.</p>
-<h4>- To chat with other participants, tap on the Chat button on the bottom toolbar during a meeting and type your message in the chat box or select an emoji or a sticker</h4>
-<p>You can also view the chat history, send private messages, or mute notifications. You can also access the chat feature from the home screen by tapping on the Chat icon on the top right corner.</p>
-<h2>Conclusion</h2>
-<h3>BlueJeans APK is a great app for Android users who want to have high-quality and secure video conferencing experiences on their mobile devices. It is easy to download, install, and use, and it offers many features and functions that enhance collaboration and communication. If you are looking for a reliable and versatile video conferencing app for your Android device, you should give BlueJeans APK a try.</h3>
-<p>Here are some FAQs that you might have about BlueJeans APK:</p>
-<ul>
-<li><b>Q: How much does BlueJeans APK cost?</b></li>
-<li>A: BlueJeans APK is free to download and use for personal or professional purposes. However, some features and functions may require a paid subscription or a trial account. You can check the pricing plans and options on the BlueJeans website.</li>
-<li><b>Q: How many participants can join a BlueJeans meeting?</b></li>
-<li>A: The number of participants that can join a BlueJeans meeting depends on your subscription plan or trial account. The standard plan allows up to 50 participants, the pro plan allows up to 75 participants, and the enterprise plan allows up to 100 participants. You can also request for custom plans for larger meetings.</li>
-<li><b>Q: How can I record a BlueJeans meeting?</b></li>
-<li>A: You can record a BlueJeans meeting by tapping on the Record button on the bottom toolbar during a meeting. You can also enable or disable automatic recording in your meeting settings. You can access your recordings from the home screen by tapping on the Recordings icon on the top right corner.</li>
-<li><b>Q: How can I share a BlueJeans meeting link?</b></li>
-<li>A: You can share a BlueJeans meeting link by tapping on the Share button on the bottom toolbar during a meeting. You can also copy or edit the link before sharing it via email, SMS, or other apps.</li>
-<li><b>Q: How can I get help or support for BlueJeans APK?</b></li>
-<li>A: You can get help or support for BlueJeans APK by tapping on the Help icon on the top left corner of the home screen. You can also visit the BlueJeans website or contact their customer service team for more assistance.</li>
-</ul></p> 197e85843d<br />
-<br />
-<br />

spaces/1pelhydcardo/ChatGPT-prompt-generator/assets/Chess TD Mod APK The Ultimate Strategy Game with Infinite Resources.md

@@ -1,109 +0,0 @@
-<br />
-<h1>Chess TD Mod APK: A New Strategy Game with Elemental Heroes</h1>
-<p>If you are looking for a new and exciting strategy game that combines chess and tower defense, you might want to try Chess TD Mod APK. This is a modified version of Chess TD APK, a popular game developed by VGames Studios. In this game, you can collect and use hero cards with different elemental attributes to defend your stronghold from the Dark Lord and his army. You can also upgrade and merge your heroes to make them more powerful and create your own unique combinations. Chess TD Mod APK offers you unlimited money, gems, and resources to help you complete the game faster and easier. You can also enjoy various game modes and challenges, such as campaign, battle, dual, dungeon, and more.</p>
- <h2>What is Chess TD Mod APK?</h2>
-<h3>A modified version of Chess TD APK</h3>
-<p>Chess TD Mod APK is a modified version of Chess TD APK, allowing you to easily complete all tasks and requests in the game. Instead of spending a lot of time and money to achieve rewards, you can use Chess TD Mod APK to reach your goals in a shorter time. You can get unlimited money, gems, and resources to buy and upgrade your hero cards, unlock new features, and access premium content. You can also enjoy faster loading speed, smoother gameplay, and no ads.</p>
-<h2>chess td mod apk</h2><br /><p><b><b>Download Zip</b> &rarr; <a href="https://urlin.us/2uSS6c">https://urlin.us/2uSS6c</a></b></p><br /><br />
- <h3>Features of Chess TD Mod APK</h3>
-<p>Chess TD Mod APK has many features that make it more fun and enjoyable than the original version. Some of the features are:</p>
-<ul>
-<li>Unlimited money, gems, and resources</li>
-<li>Free access to all hero cards</li>
-<li>No ads</li>
-<li>No root required</li>
-<li>Easy installation</li>
-<li>Compatible with most Android devices</li>
-<li>Regular updates</li>
-</ul>
- <h2>How to play Chess TD Mod APK?</h2>
-<h3>Mix and match hero cards with different elements</h3>
-<p>Chess TD Mod APK is a strategy game that requires you to use your brain and creativity to create the best combination of hero cards. There are five elements in the game: Light, Dark, Wood, Fire, and Water. Each element has its own specialty, strength, and weakness. There are also advantages and disadvantages between each element. You can use this knowledge to make a weak hero stronger against certain monsters or vice versa. You can also mix and match different elements to create new effects and synergies.</p>
- <h3>Upgrade and merge your heroes to make them stronger</h3>
-<p>Another important aspect of Chess TD Mod APK is upgrading and merging your heroes. You can use your money, gems, and resources to level up your hero cards and increase their stats and abilities. You can also merge two identical hero cards to create a new one with higher rarity and power. The more upgrades and merges you do, the better elemental power your heroes have.</p>
- <h3>Choose from different game modes and challenges</h3>
-<p>Chess TD Mod APK offers you various game modes and challenges to test your skills and strategy. You can choose from:</p>
-<ul>
-<li>Campaign mode: Travel across different maps and defeat strong monsters. Complete each map to get rewards.</li>
-<li>Battle mode: Fight against other players online and win trophies and rewards. Climb the global ranking system.</li>
-<li>Dual mode: Play with your partner and get through the dungeon together. Collect chess tokens and open chests.</li>
-<li>Dungeon mode: Escape from the dungeon by defeating waves of enemies. Collect cards and resources along the way.</li>
-<li>Tower climbing mode: Climb the tower by clearing each floor. Get rewards for each floor you clear.</li>
-<h3>Mission mode: Complete daily and weekly missions to get rewards. You can also get special rewards for completing all missions.</li>
-<li>Event mode: Participate in limited-time events and get exclusive rewards. You can also compete with other players in the event ranking system.</li>
-</ul>
- <h2>How to download and install Chess TD Mod APK?</h2>
-<h3>Download the APK file from a trusted source</h3>
-<p>To download Chess TD Mod APK, you need to find a reliable source that provides the latest version of the file. You can use the link below to download Chess TD Mod APK for free. The file size is about 100 MB, so make sure you have enough storage space on your device.</p>
-<p><a href="">Download Chess TD Mod APK here</a></p>
- <h3>Enable unknown sources on your device</h3>
-<p>Before you can install Chess TD Mod APK, you need to enable unknown sources on your device. This will allow you to install apps from sources other than the Google Play Store. To do this, follow these steps:</p>
-<p>chess td mod apk unlimited money<br />
-chess td mod apk latest version<br />
-chess td mod apk download<br />
-chess td mod apk android 1<br />
-chess td mod apk revdl<br />
-chess td mod apk no ads<br />
-chess td mod apk offline<br />
-chess td mod apk hack<br />
-chess td mod apk free shopping<br />
-chess td mod apk 2023<br />
-chess td mod apk rexdl<br />
-chess td mod apk happymod<br />
-chess td mod apk an1<br />
-chess td mod apk unlimited gems<br />
-chess td mod apk pure<br />
-chess td mod apk vip<br />
-chess td mod apk online<br />
-chess td mod apk update<br />
-chess td mod apk 8.7<br />
-chess td mod apk apkpure<br />
-chess td mod apk apkloli<br />
-chess td mod apk all unlocked<br />
-chess td mod apk cheat<br />
-chess td mod apk easy download<br />
-chess td mod apk for pc<br />
-chess td mod apk game<br />
-chess td mod apk ios<br />
-chess td mod apk latest 2023<br />
-chess td mod apk mediafıre<br />
-chess td mod apk new version<br />
-chess td mod apk obb<br />
-chess td mod apk premium<br />
-chess td mod apk pro<br />
-chess td mod apk unlimited everything<br />
-chess td mod apk versi terbaru<br />
-download game chess td mod apk<br />
-download gratis chess td mod apk<br />
-download lagu mp3 dan video mp4 \uE000chess\uE001 \uE000td\uE001 \uE000mod\uE001 \uE000apk\uE001 kualitas terbaik gratis - gudang lagu mp3 dan video mp4 download gratis stafaband planetlagu metrolagu bursalagu ilkpop matikiri wallkpop wapka mobi uyeshare youtube 4shared ss youtube online converter youtube to mp3 youtube to mp4 youtube downloader youtube converter youtube video downloader free download youtube downloader free download for windows 10 youtube downloader free download for windows 7 full version 32 bit clip dj clip dj mp3 clip dj mp4 clip dj music clip dj download clip dj converter clip dj video songs download clip dj hindi songs download pagalworld pagalworld mp3 song pagalworld mp4 videos download pagalworld movies pagalworld ringtone pagalworld song pagalworld video pagalworld 2023 song wapking wapking in wapking live wapking guru wapking cc wapking co wapking site wapking fun wapwon wapwon com wapwon live wapwon in wapwon pro wapwon video wapwon mp3 wapwon download tubidy tubidy mp3 tubidy mobi tubidy io tubidy music tubidy download tubidy mp4 tubidy mobile zonkewap zonkewap com zonkewap music zonkewap mp3 zonkewap games zonkewap videos zonkewap download zonkewap gospel music datafilehost datafilehost com datafilehost music datafilehost upload datafilehost search datafilehost file datafilehost free download datafilehost app fakaza fakaza com fakaza music fakaza 2023 fakaza mp3 fakaza gospel fakaza amapiano fakaza video zamob zamob co za zamob music zamob games zamob videos zamob downloads zamob gospel zamob south africa webmusic webmusic in webmusic live webmusic hindi webmusic bengali webmusic english webmusic ringtone webmusic a to z vidmate vidmate app vidmate download vidmate for pc vidmate install vidmate free download vidmate old version vidmate software djmaza djmaza info djmaza com djmaza songs djmaza bollywood songs djmaza link djmaza app djmaza remix songspk songspk com songspk name songspk songs songspk bollywood songspk hindi songspk old songs songspk pk mr jatt mr jatt com mr jatt 2023 mr jatt new punjabi song mr jatt top 20 songs mr jatt bollywood mr jatt ringtone mr jatt video masstamilan masstamilan in masstamilan songs masstamilan 2023 masstamilan tamil masstamilan new songs masstamilan bgm masstamilan video songs kuttyweb kuttyweb com kuttyweb songs kuttyweb tamil kuttyweb malayalam kuttyweb ringtone kuttyweb movies kuttyweb video songs ringtones ringtones for android ringtones for.</p>
-<ol>
-<li>Go to your device settings and look for security or privacy options.</li>
-<li>Find the option that says unknown sources or allow installation from unknown sources and toggle it on.</li>
-<li>A warning message will pop up. Tap OK to confirm.</li>
-</ol>
- <h3>Install the APK file and enjoy the game</h3>
-<p>Once you have enabled unknown sources, you can proceed to install Chess TD Mod APK. To do this, follow these steps:</p>
-<ol>
-<li>Locate the downloaded APK file on your device. You can use a file manager app to help you find it.</li>
-<li>Tap on the APK file and follow the instructions on the screen.</li>
-<li>Wait for the installation process to finish.</li>
-<li>Launch the game and enjoy playing Chess TD Mod APK.</li>
-</ol>
- <h2>Conclusion</h2>
-<p>Chess TD Mod APK is a fun and addictive strategy game that combines chess and tower defense elements. You can collect and use hero cards with different elemental attributes to defend your stronghold from the Dark Lord and his army. You can also upgrade and merge your heroes to make them more powerful and create your own unique combinations. Chess TD Mod APK offers you unlimited money, gems, and resources to help you complete the game faster and easier. You can also enjoy various game modes and challenges, such as campaign, battle, dual, dungeon, and more. If you are looking for a new and exciting strategy game that challenges your brain and creativity, you should try Chess TD Mod APK.</p>
- <h2>FAQs</h2>
-<p>Here are some frequently asked questions about Chess TD Mod APK:</p>
-<ul>
-<li><b>Q: Is Chess TD Mod APK safe to use?</b></li>
-<li>A: Yes, Chess TD Mod APK is safe to use as long as you download it from a trusted source. It does not contain any viruses or malware that can harm your device or data. However, you should always be careful when installing apps from unknown sources and scan them with an antivirus app before opening them.</li>
- <li><b>Q: Do I need an internet connection to play Chess TD Mod APK?</b></li>
-<li>A: No, you do not need an internet connection to play Chess TD Mod APK. You can play it offline without any problems. However, some features may require an internet connection, such as online battles, events, and updates.</li>
- <li><b>Q: How can I get more hero cards in Chess TD Mod APK?</b></li>
-<li>A: You can get more hero cards in Chess TD Mod APK by using your money, gems, and resources to buy them from the shop or open chests. You can also get them by completing missions, events, dungeons, and towers. You can also merge two identical hero cards to create a new one with higher rarity and power.</li>
- <li><b>Q: How can I contact the developer of Chess TD Mod APK?</b></li>
-<li>A: You can contact the developer of Chess TD Mod APK by visiting their official website or social media pages. You can also send them an email or leave a comment on their app page. They will try to respond to your queries and feedback as soon as possible.</li>
- <li><b>Q: Can I play Chess TD Mod APK on PC?</b></li>
-<li>A: Yes, you can play Chess TD Mod APK on PC by using an Android emulator. An Android emulator is a software that allows you to run Android apps on your PC. Some of the popular Android emulators are BlueStacks, NoxPlayer, LDPlayer, and MEmu. You can download any of these emulators from their official websites and install them on your PC. Then, you can download Chess TD Mod APK from the link above and install it on the emulator. After that, you can launch the game and enjoy playing Chess TD Mod APK on a bigger screen.</li>
-</ul></p> 197e85843d<br />
-<br />
-<br />

spaces/1pelhydcardo/ChatGPT-prompt-generator/assets/Download Bleach Vs Naruto 3.3 MOD with Ultimate Ninja Storm 4 Characters (Android).md

@@ -1,105 +0,0 @@
-
-<h1>Bleach vs Naruto Storm 4 APK: A Fan-Made Crossover Game for Android</h1>
- <p>If you are a fan of anime, you might have heard of Bleach and Naruto, two of the most popular and influential series in the genre. Both of them have spawned numerous manga, anime, movies, games, and merchandise over the years. But what if you could combine the characters and elements of both worlds in one game? That's exactly what Bleach vs Naruto Storm 4 APK offers.</p>
-<h2>bleach vs naruto storm 4 apk</h2><br /><p><b><b>Download</b> &#10022; <a href="https://urlin.us/2uSXJP">https://urlin.us/2uSXJP</a></b></p><br /><br />
- <h2>What is Bleach vs Naruto Storm 4 APK?</h2>
- <p>Bleach vs Naruto Storm 4 APK is a fan-made mod of the original <a href="(^1^)">Bleach vs Naruto</a> game, which is a 2D fighting game developed by the Chinese company 5Dplay. The mod features over 230 characters from both Bleach and Naruto, as well as a new interface, HUD, and soundtrack inspired by <a href="(^2^)">Naruto Shippuden: Ultimate Ninja Storm 4</a>, the latest installment of the official Naruto game series.</p>
- <h3>Features of the game</h3>
- <p>Some of the features that you can enjoy in Bleach vs Naruto Storm 4 APK are:</p>
- <ul>
-<li>A huge roster of characters from both anime, including main protagonists, antagonists, side characters, and even some guest characters from other series.</li>
-<li>A variety of modes to play, such as arcade, versus, team battle, survival, training, and online multiplayer.</li>
-<li>A dynamic and responsive combat system that allows you to perform combos, special moves, transformations, assists, and ultimate attacks.</li>
-<li>A high-quality graphics and sound that capture the essence and atmosphere of both anime.</li>
-<li>A regular update that adds new characters, stages, features, and bug fixes.</li>
-</ul>
- <h3>How to download and install the game</h3>
- <p>To download and install Bleach vs Naruto Storm 4 APK on your Android device, you need to follow these steps:</p>
- <ol>
-<li>Go to <a href="(^3^)">this link</a> and download the APK file. You can choose between the full version (2GB) or the lite version (800MB).</li>
-<li>Enable the installation of apps from unknown sources on your device. You can do this by going to Settings > Security > Unknown Sources and toggling it on.</li>
-<li>Locate the downloaded APK file on your device and tap on it to start the installation process.</li>
-<li>Follow the instructions on the screen and wait for the installation to finish.</li>
-<li>Launch the game from your app drawer and enjoy!</li>
-</ol>
- <h2>Why play Bleach vs Naruto Storm 4 APK?</h2>
- <p>Bleach vs Naruto Storm 4 APK is not just another fighting game. It is a tribute to two of the most iconic anime of all time. Here are some reasons why you should play it:</p>
-<p>bleach vs naruto storm 4 mod apk<br />
-bleach vs naruto ultimate ninja storm 4 climax apk<br />
-bleach vs naruto storm 4 android download<br />
-bleach vs naruto storm 4 apk free download<br />
-bleach vs naruto storm 4 apk offline<br />
-bleach vs naruto storm 4 apk obb<br />
-bleach vs naruto storm 4 apk mod menu<br />
-bleach vs naruto storm 4 apk unlimited money<br />
-bleach vs naruto storm 4 apk latest version<br />
-bleach vs naruto storm 4 apk full version<br />
-bleach vs naruto storm 4 apk english version<br />
-bleach vs naruto storm 4 apk for pc<br />
-bleach vs naruto storm 4 apk gameplay<br />
-bleach vs naruto storm 4 apk how to download<br />
-bleach vs naruto storm 4 apk highly compressed<br />
-bleach vs naruto storm 4 apk no verification<br />
-bleach vs naruto storm 4 apk online<br />
-bleach vs naruto storm 4 apk ppsspp<br />
-bleach vs naruto storm 4 apk revdl<br />
-bleach vs naruto storm 4 apk rexdl<br />
-bleach vs naruto storm 4 apk update<br />
-bleach vs naruto storm 4 apk uptodown<br />
-bleach vs naruto storm 4 apk youtube<br />
-bleach vs naruto shippuden ultimate ninja storm 4 apk<br />
-download game bleach vs naruto storm 4 apk<br />
-download game android bleach vs naruto storm 4 apk<br />
-download game offline bleach vs naruto storm 4 apk<br />
-download game online bleach vs naruto storm 4 apk<br />
-download game ppsspp bleach vs naruto storm 4 apk<br />
-download game mod bleach vs naruto storm 4 apk<br />
-download game terbaru bleach vs naruto storm 4 apk<br />
-download game gratis bleach vs naruto storm 4 apk<br />
-cara download game bleach vs naruto storm 4 apk<br />
-cara instal game bleach vs naruto storm 4 apk<br />
-cara main game bleach vs naruto storm 4 apk<br />
-cara update game bleach vs naruto storm 4 apk<br />
-review game bleach vs naruto storm 4 apk<br />
-tips and tricks game bleach vs naruto storm 4 apk<br />
-cheat codes game bleach vs naruto storm 4 apk<br />
-best characters game bleach vs naruto storm 4 apk<br />
-best team game bleach vs naruto storm 4 apk<br />
-best combo game bleach vs naruto storm 4 apk<br />
-best skills game bleach vs naruto storm 4 apk<br />
-best mode game bleach vs naruto storm 4 apk<br />
-best graphics game bleach vs naruto storm 4 apk<br />
-best sound game bleach vs naruto storm 4 apk<br />
-best controls game bleach vs naruto storm 4 apk<br />
-best settings game bleach vs naruto storm 4 apk</p>
- <h3>Enjoy the best of both anime worlds</h3>
- <p>If you love both Bleach and Naruto, you will surely appreciate how this game brings them together in a seamless and coherent way. You can see how the characters interact with each other, how their abilities match or clash, and how their stories intertwine. You can also relive some of the most memorable moments from both anime, such as Ichigo's fight with Aizen, Naruto's fight with Sasuke, or their team-ups against common enemies.</p>
- <h3>Experience intense and thrilling battles</h3>
- <p>The game's combat system is fast-paced, fluid, and satisfying. You can unleash your creativity and skill as you <p>combine different attacks, combos, and specials to defeat your opponents. You can also switch between characters, use assists, and activate ultimate attacks to turn the tide of the battle. The game's graphics and sound effects make the battles even more immersive and exciting.</p>
- <h3>Customize your favorite characters</h3>
- <p>The game allows you to customize your characters in various ways. You can change their costumes, accessories, hairstyles, and colors to suit your preferences. You can also equip them with different items that enhance their stats and abilities. You can even create your own original characters by mixing and matching different parts from existing ones.</p>
- <h2>Tips and tricks for playing Bleach vs Naruto Storm 4 APK</h2>
- <p>If you want to master the game and become a pro, here are some tips and tricks that you should know:</p>
- <h3>Learn the controls and combos</h3>
- <p>The game's controls are simple and intuitive, but you need to practice them to execute them smoothly. You can use the virtual buttons on the screen or connect a controller to your device for better accuracy. You can also adjust the button layout and size in the settings menu. The game has a tutorial mode that teaches you the basics of the game, such as movement, attack, defense, special, assist, and ultimate. You can also learn the combos of each character by checking their move list in the pause menu or by playing the training mode.</p>
- <h3>Choose the right character for your playstyle</h3>
- <p>The game has a diverse and balanced roster of characters, each with their own strengths and weaknesses. You should experiment with different characters and find the ones that suit your playstyle and preferences. Some characters are fast and agile, some are powerful and durable, some are ranged and versatile, and some are tricky and unpredictable. You should also consider the compatibility and synergy of your team members, as they can affect your performance and strategy.</p>
- <h3>Use the assist system wisely</h3>
- <p>The game has an assist system that allows you to call your teammates for help during the battle. You can use this system to extend your combos, break your opponent's defense, counter their attacks, or save yourself from danger. However, you should also be careful not to waste your assist gauge or leave yourself vulnerable to enemy attacks. You should also pay attention to the cooldown time of your assists, as they vary depending on the character.</p>
- <h2>Conclusion</h2>
- <p>Bleach vs Naruto Storm 4 APK is a fan-made crossover game that lets you enjoy the best of both anime worlds on your Android device. It has a huge roster of characters, a variety of modes, a dynamic combat system, a high-quality graphics and sound, and a regular update. It is a must-play game for any anime fan who loves fighting games. If you want to download and play Bleach vs Naruto Storm 4 APK, you can follow the steps above and start your epic adventure today!</p>
- <h2>FAQs</h2>
- <ul>
-<li><b>Q: Is Bleach vs Naruto Storm 4 APK safe to download?</b></li>
-<li>A: Yes, Bleach vs Naruto Storm 4 APK is safe to download as long as you use a trusted source like <a href="">this link</a>. However, you should always scan any file that you download with an antivirus software before installing it on your device.</li>
-<li><b>Q: Is Bleach vs Naruto Storm 4 APK free to play?</b></li>
-<li>A: Yes, Bleach vs Naruto Storm 4 APK is free to play and does not require any in-app purchases or subscriptions. However, you may encounter some ads while playing the game.</li>
-<li><b>Q: Can I play Bleach vs Naruto Storm 4 APK offline?</b></li>
-<li>A: Yes, you can play Bleach vs Naruto Storm 4 APK offline without any internet connection. However, you will need an internet connection to play the online multiplayer mode or to update the game.</li>
-<li><b>Q: Can I play Bleach vs Naruto Storm 4 APK on PC?</b></li>
-<li>A: Yes, you can play Bleach vs Naruto Storm 4 APK on PC by using an Android emulator like <a href="">Bluestacks</a> or <a href="">NoxPlayer</a>. However, you may experience some performance issues or compatibility problems depending on your PC specifications and settings.</li>
-<li><b>Q: How can I contact the developer of Bleach vs Naruto Storm 4 APK?</b></li>
-<li>A: You can contact the developer of Bleach vs Naruto Storm 4 APK by visiting their <a href="">Facebook page</a> or by sending them an email at <a href="mailto:bleachv [email protected]">[email protected]</a>.</li>
-</ul></p> 197e85843d<br />
-<br />
-<br />

spaces/1phancelerku/anime-remove-background/Amrutham-001300-Episodes-Telugu-UPDATED.md

@@ -1,78 +0,0 @@
-## Amrutham 001-300 episodes Telugu
-
-
-
- 
-
-  
-
- 
-
-**DOWNLOAD >>> [https://corppresinro.blogspot.com/?d=2txP1O](https://corppresinro.blogspot.com/?d=2txP1O)**
-
-
-
- 
-
- 
-
- 
-
- 
-
- 
-
-# Amrutham 001-300 Episodes Telugu
-
- 
-
-Amrutham is a popular sitcom in Telugu that aired from 2001 to 2007. It was produced by Just Yellow Media and is the longest running and most popular sitcom in Telugu. The show revolves around the lives of Amrutham, an aspiring restaurateur, and his friend Anji, who often get into trouble with their landlord Appaji and other characters. The show is known for its witty humor and hilarious situations.
-
- 
-
-If you are a fan of Amrutham or want to watch it for the first time, you can stream or download all the episodes online. Here are some options for you:
-
- 
-
-- You can watch Amrutham Season 1 streaming on Zee5 for free with ads. The season has 14 episodes, including the last episode "Tata Bye Bye Veedukolu" which has an unimaginable twist[^1^].
-
-- You can find a list of all the episodes of Amrutham on LiquiSearch[^2^]. The list has the episode titles and brief summaries of each episode. You can also find links to download some of the episodes from Torrent.
-
-- You can listen to some of the episodes of Amrutham on SoundCloud[^3^]. The episodes are in audio format and have the episode number and title in the description. You can also download the episodes from SoundCloud.
-
-
-
-Amrutham is a classic comedy show that will make you laugh out loud. Enjoy watching or listening to the episodes and have fun!
-
-
-
-Here are some more details about Amrutham and its characters:
-
-
-
-- Amrutham, played by Sivaji Raja and later by Naresh, is the main protagonist of the show. He is a naive and optimistic person who dreams of running a successful restaurant called Amrutha Vilas. He often comes up with crazy ideas to improve his business or to solve his problems, but they usually backfire and land him in trouble.
-
-- Anji, played by Gundu Hanumantha Rao and later by Harshavardhan, is Amrutham's best friend and partner in the restaurant. He is a smart and practical person who tries to help Amrutham with his schemes, but often ends up suffering the consequences. He is also afraid of Appaji and his wife.
-
-- Appaji, played by Inturi Vasu and later by Sivannarayana Naripeddi, is the landlord of Amrutham and Anji. He is a greedy and cunning person who always tries to exploit them for money or free food. He also has a belt that has sadistic powers and can make anyone obey him.
-
-- Sundaram, played by Vasu Inturi and later by Sivannarayana Naripeddi, is Appaji's son who works as a waiter in Amrutha Vilas. He is a loyal and innocent person who respects Amrutham and Anji. He often gets involved in their plans and faces Appaji's wrath.
-
-- Sanjeevini, played by Jhansi, is Amrutham's wife who works as a nurse. She is a sensible and caring person who loves Amrutham despite his flaws. She often tries to advise him or save him from his troubles.
-
-- Umadevi, played by Avasarala Kanyakumari and later by Bhargavi, is Anji's wife who works as a teacher. She is a strict and dominating person who often scolds Anji for his failures. She also has a crush on Appaji.
-
-
-
-The show also features many other characters who add to the comedy and chaos of the show. Some of them are Rubber Balaji, a film director who makes low-budget movies; Parandhamayya, an astrologer who gives fake predictions; Sarvam, a cook who works in Amrutha Vilas; Shanta, Appaji's aunt who tortures him; and Yama Dharma Raja, the god of death who visits Amrutham and Anji.
-
- 
-
-Amrutham is a show that has a cult following among Telugu audiences. It has won many awards and accolades for its humor and creativity. It has also been remade in Tamil as Veettukku Veedu Looty and in Kannada as Silli Lalli.
-
- dfd1c89656
-
- 
-
- 
-

spaces/1phancelerku/anime-remove-background/Crime Mysteries Find objects - A Challenging Hidden Object Mod APK.md

@@ -1,137 +0,0 @@
-
-<h1>Crime Mystery Find Objects Mod APK: A Fun and Challenging Puzzle Game</h1>
- <p>Do you love hidden object games? Do you enjoy solving mysteries and catching criminals? If you answered yes to both questions, then you might want to check out <strong>Crime Mystery Find Objects Mod APK</strong>, a fun and challenging puzzle game that will test your detective skills and keep you entertained for hours.</p>
- <h2>What is Crime Mystery Find Objects Mod APK?</h2>
- <h3>A hidden object game with a crime-solving twist</h3>
- <p>Crime Mystery Find Objects is a game developed by G5 Entertainment, a company that specializes in casual games for mobile devices. The game is part of the Crime Mysteries series, which features different locations and scenarios where you have to find hidden objects and clues, solve puzzles, and catch criminals.</p>
-<h2>crime mystery find objects mod apk</h2><br /><p><b><b>Download File</b> &rarr; <a href="https://jinyurl.com/2uNJ8I">https://jinyurl.com/2uNJ8I</a></b></p><br /><br />
- <p>The game has a captivating storyline that will immerse you in the world of crime investigation. You play as a detective who works for a secret organization called T.R.A.I.L., which stands for Tactical Reconnaissance And Investigation League. Your mission is to travel around the world, from Paris to Tokyo, and solve various cases involving murder, theft, kidnapping, and more.</p>
- <h3>A modded version of the original game with unlimited money and free purchases</h3>
- <p>Crime Mystery Find Objects Mod APK is a modified version of the original game that gives you some advantages over the regular version. The modded game has unlimited money and free purchases, which means you can buy anything you want in the game without spending real money. You can also unlock all the levels, locations, and items in the game without having to complete any tasks or achievements.</p>
- <p>The modded game is not available on the official app stores, such as Google Play or Apple Store. You have to download it from a third-party website that provides modded games. However, before you do that, you should be aware of some risks and precautions that come with installing modded games on your device.</p>
- <h2>How to download and install Crime Mystery Find Objects Mod APK?</h2>
- <h3>The steps to download and install the modded game</h3>
- <p>If you want to try Crime Mystery Find Objects Mod APK, here are the steps you need to follow:</p>
- <ol>
-<li>Find a reliable website that offers the modded game. You can use a search engine or ask for recommendations from other players who have tried the modded game.</li>
-<li>Download the modded game file from the website. Make sure it is compatible with your device and has the latest version of the game.</li>
-<li>Enable unknown sources on your device. This will allow you to install apps that are not from the official app stores. To do this, go to your device settings, then security, then unknown sources, and turn it on.</li>
-<li>Locate the downloaded file on your device and tap on it to start the installation process. Follow the instructions on your screen until the installation is complete.</li>
-<li>Launch the modded game and enjoy playing with unlimited money and free purchases.</li>
-</ol>
- <h3>The precautions to take before installing the modded game</h3>
- <p>While installing modded games can be fun and exciting, it can also be risky and dangerous. Here are some precautions you should take before installing Crime Mystery Find Objects Mod APK:</p>
- <ul>
-<li> - Backup your data before installing the modded game. Modded games can sometimes cause errors or crashes on your device, which can result in data loss or corruption. To avoid this, you should backup your important data, such as photos, videos, contacts, messages, etc., before installing the modded game. You can use a cloud service or an external storage device to do this. - Scan the modded game file for viruses or malware. Modded games can sometimes contain harmful or malicious code that can infect your device or steal your personal information. To prevent this, you should scan the modded game file with a reputable antivirus or anti-malware software before installing it. You can also check the reviews and ratings of the website that provides the modded game to see if other users have reported any issues or problems with the modded game. - Do not update the modded game from the official app stores. Modded games are usually not compatible with the official updates from the original game developers. If you update the modded game from the official app stores, you might lose the modded features or cause the game to stop working. To avoid this, you should disable automatic updates for the modded game on your device settings. You can also check the website that provides the modded game for any new versions or updates of the modded game.</ul>
- <h2>What are the features of Crime Mystery Find Objects Mod APK?</h2>
- <h3>The gameplay and graphics of the modded game</h3>
- <p>Crime Mystery Find Objects Mod APK has the same gameplay and graphics as the original game, but with some added features and improvements. The gameplay consists of finding hidden objects and clues in different scenes, solving puzzles and mini-games, and catching criminals. The graphics are realistic and detailed, with various locations and scenarios that will make you feel like a real detective.</p>
-<p>crime mystery hidden objects mod apk download<br />
-crime mystery match 3 puzzle mod apk free<br />
-crime mystery detective game mod apk unlimited<br />
-crime mystery adventure game mod apk offline<br />
-crime mystery hidden clues mod apk latest<br />
-crime mystery investigation game mod apk android<br />
-crime mystery find evidence mod apk hack<br />
-crime mystery solve cases mod apk online<br />
-crime mystery hidden scenes mod apk premium<br />
-crime mystery escape game mod apk full<br />
-crime mystery point and click mod apk pro<br />
-crime mystery hidden pictures mod apk cracked<br />
-crime mystery story game mod apk unlocked<br />
-crime mystery hidden puzzles mod apk modded<br />
-crime mystery interactive game mod apk updated<br />
-crime mystery hidden items mod apk no ads<br />
-crime mystery logic game mod apk cheats<br />
-crime mystery hidden numbers mod apk version<br />
-crime mystery role playing game mod apk free shopping<br />
-crime mystery hidden letters mod apk mega<br />
-crime mystery text game mod apk money<br />
-crime mystery hidden shapes mod apk vip<br />
-crime mystery trivia game mod apk gems<br />
-crime mystery hidden symbols mod apk unlimited lives<br />
-crime mystery word game mod apk coins<br />
-crime mystery find differences mod apk unlimited hints<br />
-crime mystery board game mod apk stars<br />
-crime mystery find words mod apk unlimited moves<br />
-crime mystery card game mod apk energy<br />
-crime mystery find pairs mod apk unlimited boosters<br />
-crime mystery dice game mod apk keys<br />
-crime mystery find colors mod apk unlimited time<br />
-crime mystery strategy game mod apk gold<br />
-crime mystery find patterns mod apk unlimited levels<br />
-crime mystery simulation game mod apk diamonds<br />
-crime mystery find shapes mod apk all unlocked<br />
-crime mystery action game mod apk hearts<br />
-crime mystery find numbers mod apk no timer<br />
-crime mystery puzzle game mod apk lives<br />
-crime mystery find letters mod apk no root</p>
- <p>Some of the features and improvements of the modded game are:</p>
- <ul>
-<li>You can play offline without an internet connection.</li>
-<li>You can zoom in and out of the scenes to find hidden objects more easily.</li>
-<li>You can use hints and skip buttons to help you solve puzzles and mini-games.</li>
-<li>You can customize your avatar and choose from different outfits and accessories.</li>
-<li>You can collect trophies and achievements for completing tasks and challenges.</li>
-</ul>
- <h3>The benefits and drawbacks of the modded game</h3>
- <p>Crime Mystery Find Objects Mod APK has some benefits and drawbacks that you should consider before playing it. Here are some of them:</p>
- <table>
-<tr>
-<th>Benefits</th>
-<th>Drawbacks</th>
-</tr>
-<tr>
-<td>You can enjoy unlimited money and free purchases in the game.</td>
-<td>You might lose the thrill and challenge of playing the game.</td>
-</tr>
-<tr>
-<td>You can unlock all the levels, locations, and items in the game.</td>
-<td>You might miss out on some of the fun and excitement of discovering new things in the game.</td>
-</tr>
-<tr>
-<td>You can play without any ads or interruptions in the game.</td>
-<td>You might not support the original game developers and their work.</td>
-</tr>
-<tr>
-<td>You can have more options and features in the game.</td>
-<td>You might encounter some bugs or glitches in the game.</td>
-</tr>
-</table>
- <h2>How to play Crime Mystery Find Objects Mod APK?</h2>
- <h3>The tips and tricks to find hidden objects and solve puzzles</h3>
- <p>If you want to play Crime Mystery Find Objects Mod APK like a pro, here are some tips and tricks that will help you find hidden objects and solve puzzles faster and easier:</p>
- <ul>
-<li>Pay attention to the scene description and objectives. They will give you hints about what to look for and what to do in each scene.</li>
-<li>Use your finger to swipe across the screen to explore every corner of the scene. You might find some hidden objects or clues that are not obvious at first glance.</li>
-<li>Tap on an object to select it. If it is correct, it will be marked off your list. If it is wrong, it will flash red and you will lose some time.</li>
-<li>If you get stuck, you can use hints or skip buttons to help you out. Hints will highlight an object or clue for you. Skip buttons will let you skip a puzzle or mini-game. However, you have a limited number of hints and skip buttons per scene, so use them wisely.</li>
-<li>Try to find hidden objects and solve puzzles as fast as possible. The faster you complete a scene, the higher your score will be. You will also earn more stars, coins, and rewards for finishing a scene quickly.</li>
-</ul>
- <h3>The challenges and rewards of the modded game</h3>
- <p>Crime Mystery Find Objects Mod APK has some challenges and rewards that will make you want to play more and improve your skills. Here are some of them:</p>
- <ul>
-<li>You can challenge yourself with different difficulty levels, from easy to expert. The higher the difficulty level, the more hidden objects and puzzles you have to find and solve, and the less time and hints you have.</li>
-<li>You can compete with other players from around the world on the global leaderboard. You can see your rank and score, and compare them with other players. You can also chat with other players and share tips and strategies.</li>
-<li>You can earn stars, coins, and rewards for completing scenes and tasks. Stars are used to unlock new levels and locations. Coins are used to buy items and upgrades in the game. Rewards are special items or bonuses that you can use in the game, such as extra time, extra hints, or extra skip buttons.</li>
-</ul>
- <h2>Conclusion</h2>
- <h3>A summary of the main points of the article</h3>
- <p>Crime Mystery Find Objects Mod APK is a fun and challenging puzzle game that will test your detective skills and keep you entertained for hours. It is a hidden object game with a crime-solving twist, where you have to find hidden objects and clues, solve puzzles and mini-games, and catch criminals. It is a modded version of the original game that gives you unlimited money and free purchases, which means you can buy anything you want in the game without spending real money. You can also unlock all the levels, locations, and items in the game without having to complete any tasks or achievements.</p>
- <p>However, before you download and install the modded game, you should be aware of some risks and precautions that come with installing modded games on your device. You should backup your data before installing the modded game, scan the modded game file for viruses or malware, and do not update the modded game from the official app stores. You should also consider the benefits and drawbacks of playing the modded game, such as having more options and features, but losing the thrill and challenge of playing the game.</p>
- <h3>A call to action for the readers to try the modded game</h3>
- <p>If you are looking for a new and exciting puzzle game to play on your device, you should give Crime Mystery Find Objects Mod APK a try. It is a game that will challenge your mind and entertain your eyes with its realistic and detailed graphics, captivating storyline, and various locations and scenarios. You will also enjoy having unlimited money and free purchases in the game, which will let you customize your avatar, buy items and upgrades, and unlock everything in the game. You will also have fun competing with other players on the global leaderboard, earning stars, coins, and rewards, and improving your detective skills.</p>
- <p>So what are you waiting for? Download Crime Mystery Find Objects Mod APK today and start solving mysteries and catching criminals like a pro!</p>
- <h2>FAQs</h2>
- <h3>What is Crime Mystery Find Objects Mod APK?</h3>
- <p>Crime Mystery Find Objects Mod APK is a modified version of the original game that gives you unlimited money and free purchases in the game.</p>
- <h3>How to download and install Crime Mystery Find Objects Mod APK?</h3>
- <p>You have to download it from a third-party website that provides modded games. Then, you have to enable unknown sources on your device, locate the downloaded file on your device, tap on it to start the installation process, and launch the modded game.</p>
- <h3>What are the features of Crime Mystery Find Objects Mod APK?</h3>
- <p>The modded game has the same gameplay and graphics as the original game, but with some added features and improvements. You can play offline without an internet connection, zoom in and out of the scenes, use hints and skip buttons, customize your avatar, collect trophies and achievements, etc.</p>
- <h3>How to play Crime Mystery Find Objects Mod APK?</h3>
- <p>You have to find hidden objects and clues in different scenes, solve puzzles and mini-games, and catch criminals. You can also challenge yourself with different difficulty levels, compete with other players on the global leaderboard, and earn stars, coins, and rewards.</p>
- <h3>Is Crime Mystery Find Objects Mod APK safe to play?</h3>
- <p>Crime Mystery Find Objects Mod APK is not an official game, so it might not be safe to play. You should take some precautions before installing the modded game, such as backing up your data, scanning the modded game file for viruses or malware, and not updating the modded game from the official app stores.</p> 401be4b1e0<br />
-<br />
-<br />

spaces/1phancelerku/anime-remove-background/Dragon Trail Hunter World - A Brand-New Tribal World for You to Discover.md

@@ -1,148 +0,0 @@
-<br />
-<h1>Dragon Trail: Hunter World - A New Island Tribal Adventure Game</h1>
-<p>Are you looking for a new and exciting role-playing game that will take you to a fantastical island full of dragons, pets, and adventures? If so, you might want to check out Dragon Trail: Hunter World, a brand-new game developed by TTHmobi. In this game, you will play as a youth chosen by the dragon, who will explore the secret of Loya Book with your father's belief. You will also collect various costumes, cute pets and mounts, team up with other players, and compete for the island supremacy. In this article, we will tell you everything you need to know about Dragon Trail: Hunter World, and how you can download and play it on your PC for a better gaming experience.</p>
- <h2>What is Dragon Trail: Hunter World?</h2>
-<p>Dragon Trail: Hunter World is a role-playing game that combines elements of fantasy, adventure, and tribal culture. It is set in a mysterious island called Star Island, where dragons and humans coexist peacefully. However, an evil force is threatening to destroy this harmony, and it is up to you to stop it. You will embark on a journey to uncover the secret of Loya Book, a legendary artifact that contains the power of the dragon. Along the way, you will meet many interesting characters, collect various pets and dragons, fight against enemies, and explore the beautiful scenery of Star Island.</p>
-<h2>dragon trail indir</h2><br /><p><b><b>DOWNLOAD</b> &#10004; <a href="https://jinyurl.com/2uNQqN">https://jinyurl.com/2uNQqN</a></b></p><br /><br />
- <h3>The story and the gameplay</h3>
-<p>The story of Dragon Trail: Hunter World is divided into chapters, each with its own plot and quests. You will follow the main character, who is a descendant of the dragon tribe, as he or she tries to fulfill his or her father's wish. You will also encounter other characters who will join your team or become your rivals. The game has a rich dialogue system that allows you to interact with different characters and choose your responses. Your choices will affect the outcome of the story and the relationship with other characters.</p>
-<p>The gameplay of Dragon Trail: Hunter World is mainly based on exploration, combat, and collection. You will be able to roam freely around Star Island, discovering new places, secrets, and treasures. You will also encounter various enemies, such as wild animals, monsters, and evil dragons. You will have to fight them using your skills, weapons, and pets. The game has a real-time combat system that requires you to tap or swipe on the screen to perform different actions. You can also use special skills that have cooldowns or consume energy. The game also has a multiplayer mode that allows you to team up with other players or compete against them in different modes.</p>
- <h3>The features and the graphics</h3>
-<p>Dragon Trail: Hunter World has many features that make it stand out from other role-playing games. Some of these features are:</p>
-<ul>
-<li>A huge open world that you can explore at your own pace.</li>
-<li>A variety of costumes, pets, mounts, weapons, and accessories that you can collect and customize.</li>
-<li>A mentor-disciple system that allows you to train with your master or apprentice everyday by completing missions.</li>
-<li>A guild system that allows you to join or create a guild with other players and participate in guild wars.</li>
-<li>A ranking system that shows your progress and achievements in different aspects of the game.</li>
-<li>A daily login reward system that gives you free diamonds and other items every day.</li>
-</ul>
-<p>The graphics of Dragon Trail: Hunter World are also impressive. The game has a colorful and cartoon-like style that suits its fantasy theme. The game also has high-quality animations and sound effects that enhance the immersion of the game. The game also has well-made cutscenes that show the story in a cinematic way.</p>
- <h3>The classes and the pets</h3>
-<p>Dragon <p>Dragon Trail: Hunter World has four classes that you can choose from, each with its own strengths and weaknesses. The classes are:</p>
-<p>dragon trail hunter world indir<br />
-dragon trail hunter world pc indir<br />
-dragon trail hunter world apk indir<br />
-dragon trail hunter world google play indir<br />
-dragon trail hunter world bluestacks indir<br />
-dragon trail hunter world android indir<br />
-dragon trail hunter world ios indir<br />
-dragon trail hunter world oyunu indir<br />
-dragon trail hunter world ücretsiz indir<br />
-dragon trail hunter world hileli indir<br />
-dragon trail beta indir<br />
-dragon trail beta apk indir<br />
-dragon trail beta google play indir<br />
-dragon trail beta android indir<br />
-dragon trail beta ios indir<br />
-dragon trail beta oyunu indir<br />
-dragon trail beta ücretsiz indir<br />
-dragon trail beta hileli indir<br />
-dragon trail oyunu indir<br />
-dragon trail oyunu apk indir<br />
-dragon trail oyunu google play indir<br />
-dragon trail oyunu bluestacks indir<br />
-dragon trail oyunu android indir<br />
-dragon trail oyunu ios indir<br />
-dragon trail oyunu ücretsiz indir<br />
-dragon trail oyunu hileli indir<br />
-dragon trail rol yapma oyunu indir<br />
-dragon trail rol yapma oyunu apk indir<br />
-dragon trail rol yapma oyunu google play indir<br />
-dragon trail rol yapma oyunu bluestacks indir<br />
-dragon trail rol yapma oyunu android indir<br />
-dragon trail rol yapma oyunu ios indir<br />
-dragon trail rol yapma oyunu ücretsiz indir<br />
-dragon trail rol yapma oyunu hileli indir<br />
-dragon trail island adventure game indir<br />
-dragon trail island adventure game apk indir<br />
-dragon trail island adventure game google play indir<br />
-dragon trail island adventure game bluestacks indir<br />
-dragon trail island adventure game android indir<br />
-dragon trail island adventure game ios indir<br />
-dragon trail island adventure game ücretsiz indir<br />
-dragon trail island adventure game hileli indir<br />
-tthmobi dragon trail indir<br />
-tthmobi dragon trail apk indir<br />
-tthmobi dragon trail google play indir<br />
-tthmobi dragon trail bluestacks indir<br />
-tthmobi dragon trail android indir<br />
-tthmobi dragon trail ios indir</p>
-<ul>
-<li>Warrior: A melee fighter who specializes in physical attacks and defense. He or she can use swords, axes, and shields to deal damage and protect himself or herself.</li>
-<li>Mage: A ranged caster who specializes in magic attacks and support. He or she can use staffs, wands, and books to cast spells and buff allies.</li>
-<li>Ranger: A ranged shooter who specializes in speed and accuracy. He or she can use bows, crossbows, and guns to shoot arrows and bullets at enemies.</li>
-<li>Assassin: A melee rogue who specializes in stealth and critical hits. He or she can use daggers, claws, and whips to sneak up and stab enemies.</li>
-</ul>
-<p>Dragon Trail: Hunter World also has a pet system that allows you to collect and raise various pets that will accompany you in your adventure. Pets can help you in combat by attacking enemies, healing you, or providing buffs. Pets can also be upgraded and evolved to increase their power and appearance. Some of the pets that you can find in the game are:</p>
-<ul>
-<li>Dragon: A majestic creature that has the power of fire, ice, thunder, or wind. It can breathe fireballs, ice shards, lightning bolts, or wind blades at enemies.</li>
-<li>Fox: A cute animal that has the power of illusion, charm, or luck. It can create clones, charm enemies, or increase your drop rate.</li>
-<li>Bear: A strong animal that has the power of earth, rock, or metal. It can smash enemies with its claws, throw rocks at them, or create a metal shield.</li>
-<li>Bird: A swift animal that has the power of light, sound, or speed. It can blind enemies with its feathers, stun them with its chirp, or dash at them with its wings.</li>
-</ul>
- <h2>How to download and play Dragon Trail: Hunter World on PC?</h2>
-<p>If you are interested in playing Dragon Trail: Hunter World on your PC, you might be wondering how to do it. After all, the game is only available for mobile devices on Google Play and App Store. However, there is a way to play it on your PC using an Android emulator. An Android emulator is a software that allows you to run Android apps and games on your PC. One of the best Android emulators that you can use is BlueStacks, which is free, fast, and easy to use.</p>
- <h3>The benefits of playing on PC</h3>
-<p>Playing Dragon Trail: Hunter World on PC has many benefits that you might not get on your mobile device. Some of these benefits are:</p>
-<ul>
-<li>A bigger screen that gives you a better view of the game's graphics and details.</li>
-<li>A smoother performance that reduces lag and crashes.</li>
-<li>A more comfortable control scheme that lets you use your keyboard and mouse instead of your touch screen.</li>
-<li>A longer battery life that lets you play for hours without worrying about charging your device.</li>
-<li>A more secure environment that protects your account and data from hackers and viruses.</li>
-</ul>
- <h3>The steps to install BlueStacks and Dragon Trail: Hunter World</h3>
-<p>To play Dragon Trail: Hunter World on PC using BlueStacks, you need to follow these simple steps:</p>
-<ol>
-<li>Download and install BlueStacks from its official website <a href="">here</a>.</li>
-<li>Launch BlueStacks and sign in with your Google account.</li>
-<li>Search for Dragon Trail: Hunter World in the search bar or go to the Google Play Store icon on the home screen.</li>
-<li>Click on the game icon and install it.</li>
-<li>Once the installation is complete, click on the game icon again to launch it.</li>
-</ol>
- <h3>The tips and tricks to enjoy the game on PC</h3>
-<p>To make the most out of playing Dragon Trail: Hunter World on PC using BlueStacks, you might want to try these tips and tricks:</p>
-<ul>
-<li>Customize your keyboard and mouse settings to suit your preferences. You can do this by clicking on the keyboard icon on the bottom right corner of the screen. You can also use the default settings provided by BlueStacks.</li>
-<li>Enable high frame rate mode to improve the game's smoothness. You can do this by clicking on the gear icon on the top right corner of the screen and going to the engine tab. You can also adjust other settings such as resolution, graphics quality, and memory allocation.</li>
-<li>Use the multi-instance feature to play multiple accounts or games at the same time. You can do this by You can do this by clicking on the multi-instance icon on the bottom right corner of the screen and creating a new instance. You can also clone an existing instance or sync multiple instances to perform the same actions.</li>
-<li>Use the macro feature to automate repetitive tasks or create custom commands. You can do this by clicking on the macro icon on the right side of the screen and recording your actions. You can also edit, delete, or assign hotkeys to your macros.</li>
-<li>Use the screenshot and video capture feature to record your gameplay or share your achievements. You can do this by clicking on the camera icon on the right side of the screen and choosing your desired option. You can also access your media files from the BlueStacks folder on your PC.</li>
-</ul>
- <h2>Conclusion</h2>
-<p>Dragon Trail: Hunter World is a fun and immersive role-playing game that will take you to a magical island full of dragons, pets, and adventures. You will enjoy the game's story, gameplay, features, and graphics, as well as the benefits of playing it on PC using BlueStacks. If you are looking for a new and exciting game to play, you should definitely give Dragon Trail: Hunter World a try.</p>
- <h3>Why you should try Dragon Trail: Hunter World</h3>
-<p>Here are some of the reasons why you should try Dragon Trail: Hunter World:</p>
-<ul>
-<li>It is a free-to-play game that you can download and play anytime, anywhere.</li>
-<li>It is a unique game that combines fantasy, adventure, and tribal culture in a captivating way.</li>
-<li>It is a challenging game that tests your skills, strategy, and creativity in various aspects.</li>
-<li>It is a social game that lets you interact with other players and make new friends.</li>
-<li>It is a rewarding game that gives you plenty of incentives and rewards for playing.</li>
-</ul>
- <h3>Where to find more information and updates about the game</h3>
-<p>If you want to find more information and updates about Dragon Trail: Hunter World, you can visit these sources:</p>
-<ul>
-<li>The official website of the game <a href="">here</a>, where you can find the latest news, events, guides, and support.</li>
-<li>The official Facebook page of the game <a href="">here</a>, where you can follow the posts, comments, videos, and live streams.</li>
-<li>The official YouTube channel of the game <a href="">here</a>, where you can watch the trailers, gameplay, reviews, and tips.</li>
-<li>The official Discord server of the game <a href="">here</a>, where you can chat with other players, developers, and moderators.</li>
-<li>The official Reddit community of the game <a href="">here</a>, where you can join the discussions, questions, suggestions, and feedback.</li>
-</ul>
- <h3>FAQs</h3>
-<p>Here are some of the frequently asked questions about Dragon Trail: Hunter World:</p>
-<ol>
-<li>Q: How can I change my class in the game?</li>
-<li>A: You can change your class in the game by going to the class hall in Star City and talking to the class master. You can change your class once for free, but after that you will need to pay diamonds or coupons.</li>
-<li>Q: How can I get more pets in the game?</li>
-<li>A: You can get more pets in the game by completing quests, participating in events, opening chests, or buying them from the shop. You can also breed your pets to get new ones with different attributes.</li>
-<li>Q: How can I upgrade my pets in the game?</li>
-<li>A: You can upgrade your pets in the game by feeding them with pet food or pet essence. You can also evolve them by using pet stones or pet crystals. You can also awaken them by using pet souls or pet runes.</li>
-<li>Q: How can I join or create a guild in the game?</li>
-<li>A: You can join or create a guild in the game by going to the guild hall in Star City and talking to the guild manager. You will need to be at least level 20 to join or create a guild. You will also need to pay some gold or diamonds to create a guild.</li>
-<li>Q: How can I contact the customer service in the game?</li>
-<li>A: You can contact the customer service in the game by going to the settings menu and tapping on the customer service button. You can also send an email to <a href="mailto:[email protected]">[email protected]</a> or fill out an online form <a href="">here</a>.</li>
-</ol></p> 401be4b1e0<br />
-<br />
-<br />

spaces/52Hz/CMFNet_deraindrop/model/block.py

@@ -1,146 +0,0 @@
-import torch
-import torch.nn as nn
-##########################################################################
-def conv(in_channels, out_channels, kernel_size, bias=False, stride=1):
-    layer = nn.Conv2d(in_channels, out_channels, kernel_size, padding=(kernel_size // 2), bias=bias, stride=stride)
-    return layer
-
-
-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_down(in_chn, out_chn, bias=False):
-    layer = nn.Conv2d(in_chn, out_chn, kernel_size=4, stride=2, padding=1, bias=bias)
-    return layer
-
-##########################################################################
-## Supervised Attention Module (RAM)
-class SAM(nn.Module):
-    def __init__(self, n_feat, kernel_size, bias):
-        super(SAM, self).__init__()
-        self.conv1 = conv(n_feat, n_feat, kernel_size, bias=bias)
-        self.conv2 = conv(n_feat, 3, kernel_size, bias=bias)
-        self.conv3 = conv(3, n_feat, kernel_size, bias=bias)
-
-    def forward(self, x, x_img):
-        x1 = self.conv1(x)
-        img = self.conv2(x) + x_img
-        x2 = torch.sigmoid(self.conv3(img))
-        x1 = x1 * x2
-        x1 = x1 + x
-        return x1, img
-
-##########################################################################
-## Spatial Attention
-class SALayer(nn.Module):
-    def __init__(self, kernel_size=7):
-        super(SALayer, self).__init__()
-        self.conv1 = nn.Conv2d(2, 1, kernel_size, padding=kernel_size // 2, bias=False)
-        self.sigmoid = nn.Sigmoid()
-
-    def forward(self, x):
-        avg_out = torch.mean(x, dim=1, keepdim=True)
-        max_out, _ = torch.max(x, dim=1, keepdim=True)
-        y = torch.cat([avg_out, max_out], dim=1)
-        y = self.conv1(y)
-        y = self.sigmoid(y)
-        return x * y
-
-# Spatial Attention Block (SAB)
-class SAB(nn.Module):
-    def __init__(self, n_feat, kernel_size, reduction, bias, act):
-        super(SAB, self).__init__()
-        modules_body = [conv(n_feat, n_feat, kernel_size, bias=bias), act, conv(n_feat, n_feat, kernel_size, bias=bias)]
-        self.body = nn.Sequential(*modules_body)
-        self.SA = SALayer(kernel_size=7)
-
-    def forward(self, x):
-        res = self.body(x)
-        res = self.SA(res)
-        res += x
-        return res
-
-##########################################################################
-## Pixel Attention
-class PALayer(nn.Module):
-    def __init__(self, channel, reduction=16, bias=False):
-        super(PALayer, self).__init__()
-        self.pa = nn.Sequential(
-            nn.Conv2d(channel, channel // reduction, 1, padding=0, bias=bias),
-            nn.ReLU(inplace=True),
-            nn.Conv2d(channel // reduction, channel, 1, padding=0, bias=bias), # channel <-> 1
-            nn.Sigmoid()
-        )
-
-    def forward(self, x):
-        y = self.pa(x)
-        return x * y
-
-## Pixel Attention Block (PAB)
-class PAB(nn.Module):
-    def __init__(self, n_feat, kernel_size, reduction, bias, act):
-        super(PAB, self).__init__()
-        modules_body = [conv(n_feat, n_feat, kernel_size, bias=bias), act, conv(n_feat, n_feat, kernel_size, bias=bias)]
-        self.PA = PALayer(n_feat, reduction, bias=bias)
-        self.body = nn.Sequential(*modules_body)
-
-    def forward(self, x):
-        res = self.body(x)
-        res = self.PA(res)
-        res += x
-        return res
-
-##########################################################################
-## Channel Attention Layer
-class CALayer(nn.Module):
-    def __init__(self, channel, reduction=16, bias=False):
-        super(CALayer, self).__init__()
-        # global average pooling: feature --> point
-        self.avg_pool = nn.AdaptiveAvgPool2d(1)
-        # feature channel downscale and upscale --> channel weight
-        self.conv_du = nn.Sequential(
-            nn.Conv2d(channel, channel // reduction, 1, padding=0, bias=bias),
-            nn.ReLU(inplace=True),
-            nn.Conv2d(channel // reduction, channel, 1, padding=0, bias=bias),
-            nn.Sigmoid()
-        )
-
-    def forward(self, x):
-        y = self.avg_pool(x)
-        y = self.conv_du(y)
-        return x * y
-
-## Channel Attention Block (CAB)
-class CAB(nn.Module):
-    def __init__(self, n_feat, kernel_size, reduction, bias, act):
-        super(CAB, self).__init__()
-        modules_body = [conv(n_feat, n_feat, kernel_size, bias=bias), act, conv(n_feat, n_feat, kernel_size, bias=bias)]
-
-        self.CA = CALayer(n_feat, reduction, bias=bias)
-        self.body = nn.Sequential(*modules_body)
-
-    def forward(self, x):
-        res = self.body(x)
-        res = self.CA(res)
-        res += x
-        return res
-
-
-if __name__ == "__main__":
-    import time
-    from thop import profile
-    # layer = CAB(64, 3, 4, False, nn.PReLU())
-    layer = PAB(64, 3, 4, False, nn.PReLU())
-    # layer = SAB(64, 3, 4, False, nn.PReLU())
-    for idx, m in enumerate(layer.modules()):
-        print(idx, "-", m)
-    s = time.time()
-
-    rgb = torch.ones(1, 64, 256, 256, dtype=torch.float, requires_grad=False)
-    out = layer(rgb)
-    flops, params = profile(layer, inputs=(rgb,))
-    print('parameters:', params)
-    print('flops', flops)
-    print('time: {:.4f}ms'.format((time.time()-s)*10))

spaces/A00001/bingothoo/postcss.config.js

@@ -1,6 +0,0 @@
-module.exports = {
-  plugins: {
-    tailwindcss: {},
-    autoprefixer: {},
-  },
-}

spaces/AI-Hobbyist/Hoyo-RVC/train/utils.py

@@ -1,486 +0,0 @@
-import os, traceback
-import glob
-import sys
-import argparse
-import logging
-import json
-import subprocess
-import numpy as np
-from scipy.io.wavfile import read
-import torch
-
-MATPLOTLIB_FLAG = False
-
-logging.basicConfig(stream=sys.stdout, level=logging.DEBUG)
-logger = logging
-
-
-def load_checkpoint_d(checkpoint_path, combd, sbd, optimizer=None, load_opt=1):
-    assert os.path.isfile(checkpoint_path)
-    checkpoint_dict = torch.load(checkpoint_path, map_location="cpu")
-
-    ##################
-    def go(model, bkey):
-        saved_state_dict = checkpoint_dict[bkey]
-        if hasattr(model, "module"):
-            state_dict = model.module.state_dict()
-        else:
-            state_dict = model.state_dict()
-        new_state_dict = {}
-        for k, v in state_dict.items():  # 模型需要的shape
-            try:
-                new_state_dict[k] = saved_state_dict[k]
-                if saved_state_dict[k].shape != state_dict[k].shape:
-                    print(
-                        "shape-%s-mismatch|need-%s|get-%s"
-                        % (k, state_dict[k].shape, saved_state_dict[k].shape)
-                    )  #
-                    raise KeyError
-            except:
-                # logger.info(traceback.format_exc())
-                logger.info("%s is not in the checkpoint" % k)  # pretrain缺失的
-                new_state_dict[k] = v  # 模型自带的随机值
-        if hasattr(model, "module"):
-            model.module.load_state_dict(new_state_dict, strict=False)
-        else:
-            model.load_state_dict(new_state_dict, strict=False)
-
-    go(combd, "combd")
-    go(sbd, "sbd")
-    #############
-    logger.info("Loaded model weights")
-
-    iteration = checkpoint_dict["iteration"]
-    learning_rate = checkpoint_dict["learning_rate"]
-    if (
-        optimizer is not None and load_opt == 1
-    ):  ###加载不了，如果是空的的话，重新初始化，可能还会影响lr时间表的更新，因此在train文件最外围catch
-        #   try:
-        optimizer.load_state_dict(checkpoint_dict["optimizer"])
-    #   except:
-    #     traceback.print_exc()
-    logger.info("Loaded checkpoint '{}' (epoch {})".format(checkpoint_path, iteration))
-    return model, optimizer, learning_rate, iteration
-
-
-# def load_checkpoint(checkpoint_path, model, optimizer=None):
-#   assert os.path.isfile(checkpoint_path)
-#   checkpoint_dict = torch.load(checkpoint_path, map_location='cpu')
-#   iteration = checkpoint_dict['iteration']
-#   learning_rate = checkpoint_dict['learning_rate']
-#   if optimizer is not None:
-#     optimizer.load_state_dict(checkpoint_dict['optimizer'])
-#   # print(1111)
-#   saved_state_dict = checkpoint_dict['model']
-#   # print(1111)
-#
-#   if hasattr(model, 'module'):
-#     state_dict = model.module.state_dict()
-#   else:
-#     state_dict = model.state_dict()
-#   new_state_dict= {}
-#   for k, v in state_dict.items():
-#     try:
-#       new_state_dict[k] = saved_state_dict[k]
-#     except:
-#       logger.info("%s is not in the checkpoint" % k)
-#       new_state_dict[k] = v
-#   if hasattr(model, 'module'):
-#     model.module.load_state_dict(new_state_dict)
-#   else:
-#     model.load_state_dict(new_state_dict)
-#   logger.info("Loaded checkpoint '{}' (epoch {})" .format(
-#     checkpoint_path, iteration))
-#   return model, optimizer, learning_rate, iteration
-def load_checkpoint(checkpoint_path, model, optimizer=None, load_opt=1):
-    assert os.path.isfile(checkpoint_path)
-    checkpoint_dict = torch.load(checkpoint_path, map_location="cpu")
-
-    saved_state_dict = checkpoint_dict["model"]
-    if hasattr(model, "module"):
-        state_dict = model.module.state_dict()
-    else:
-        state_dict = model.state_dict()
-    new_state_dict = {}
-    for k, v in state_dict.items():  # 模型需要的shape
-        try:
-            new_state_dict[k] = saved_state_dict[k]
-            if saved_state_dict[k].shape != state_dict[k].shape:
-                print(
-                    "shape-%s-mismatch|need-%s|get-%s"
-                    % (k, state_dict[k].shape, saved_state_dict[k].shape)
-                )  #
-                raise KeyError
-        except:
-            # logger.info(traceback.format_exc())
-            logger.info("%s is not in the checkpoint" % k)  # pretrain缺失的
-            new_state_dict[k] = v  # 模型自带的随机值
-    if hasattr(model, "module"):
-        model.module.load_state_dict(new_state_dict, strict=False)
-    else:
-        model.load_state_dict(new_state_dict, strict=False)
-    logger.info("Loaded model weights")
-
-    iteration = checkpoint_dict["iteration"]
-    learning_rate = checkpoint_dict["learning_rate"]
-    if (
-        optimizer is not None and load_opt == 1
-    ):  ###加载不了，如果是空的的话，重新初始化，可能还会影响lr时间表的更新，因此在train文件最外围catch
-        #   try:
-        optimizer.load_state_dict(checkpoint_dict["optimizer"])
-    #   except:
-    #     traceback.print_exc()
-    logger.info("Loaded checkpoint '{}' (epoch {})".format(checkpoint_path, iteration))
-    return model, optimizer, learning_rate, iteration
-
-
-def save_checkpoint(model, optimizer, learning_rate, iteration, checkpoint_path):
-    logger.info(
-        "Saving model and optimizer state at epoch {} to {}".format(
-            iteration, checkpoint_path
-        )
-    )
-    if hasattr(model, "module"):
-        state_dict = model.module.state_dict()
-    else:
-        state_dict = model.state_dict()
-    torch.save(
-        {
-            "model": state_dict,
-            "iteration": iteration,
-            "optimizer": optimizer.state_dict(),
-            "learning_rate": learning_rate,
-        },
-        checkpoint_path,
-    )
-
-
-def save_checkpoint_d(combd, sbd, optimizer, learning_rate, iteration, checkpoint_path):
-    logger.info(
-        "Saving model and optimizer state at epoch {} to {}".format(
-            iteration, checkpoint_path
-        )
-    )
-    if hasattr(combd, "module"):
-        state_dict_combd = combd.module.state_dict()
-    else:
-        state_dict_combd = combd.state_dict()
-    if hasattr(sbd, "module"):
-        state_dict_sbd = sbd.module.state_dict()
-    else:
-        state_dict_sbd = sbd.state_dict()
-    torch.save(
-        {
-            "combd": state_dict_combd,
-            "sbd": state_dict_sbd,
-            "iteration": iteration,
-            "optimizer": optimizer.state_dict(),
-            "learning_rate": learning_rate,
-        },
-        checkpoint_path,
-    )
-
-
-def summarize(
-    writer,
-    global_step,
-    scalars={},
-    histograms={},
-    images={},
-    audios={},
-    audio_sampling_rate=22050,
-):
-    for k, v in scalars.items():
-        writer.add_scalar(k, v, global_step)
-    for k, v in histograms.items():
-        writer.add_histogram(k, v, global_step)
-    for k, v in images.items():
-        writer.add_image(k, v, global_step, dataformats="HWC")
-    for k, v in audios.items():
-        writer.add_audio(k, v, global_step, audio_sampling_rate)
-
-
-def latest_checkpoint_path(dir_path, regex="G_*.pth"):
-    f_list = glob.glob(os.path.join(dir_path, regex))
-    f_list.sort(key=lambda f: int("".join(filter(str.isdigit, f))))
-    x = f_list[-1]
-    print(x)
-    return x
-
-
-def plot_spectrogram_to_numpy(spectrogram):
-    global MATPLOTLIB_FLAG
-    if not MATPLOTLIB_FLAG:
-        import matplotlib
-
-        matplotlib.use("Agg")
-        MATPLOTLIB_FLAG = True
-        mpl_logger = logging.getLogger("matplotlib")
-        mpl_logger.setLevel(logging.WARNING)
-    import matplotlib.pylab as plt
-    import numpy as np
-
-    fig, ax = plt.subplots(figsize=(10, 2))
-    im = ax.imshow(spectrogram, aspect="auto", origin="lower", interpolation="none")
-    plt.colorbar(im, ax=ax)
-    plt.xlabel("Frames")
-    plt.ylabel("Channels")
-    plt.tight_layout()
-
-    fig.canvas.draw()
-    data = np.fromstring(fig.canvas.tostring_rgb(), dtype=np.uint8, sep="")
-    data = data.reshape(fig.canvas.get_width_height()[::-1] + (3,))
-    plt.close()
-    return data
-
-
-def plot_alignment_to_numpy(alignment, info=None):
-    global MATPLOTLIB_FLAG
-    if not MATPLOTLIB_FLAG:
-        import matplotlib
-
-        matplotlib.use("Agg")
-        MATPLOTLIB_FLAG = True
-        mpl_logger = logging.getLogger("matplotlib")
-        mpl_logger.setLevel(logging.WARNING)
-    import matplotlib.pylab as plt
-    import numpy as np
-
-    fig, ax = plt.subplots(figsize=(6, 4))
-    im = ax.imshow(
-        alignment.transpose(), aspect="auto", origin="lower", interpolation="none"
-    )
-    fig.colorbar(im, ax=ax)
-    xlabel = "Decoder timestep"
-    if info is not None:
-        xlabel += "\n\n" + info
-    plt.xlabel(xlabel)
-    plt.ylabel("Encoder timestep")
-    plt.tight_layout()
-
-    fig.canvas.draw()
-    data = np.fromstring(fig.canvas.tostring_rgb(), dtype=np.uint8, sep="")
-    data = data.reshape(fig.canvas.get_width_height()[::-1] + (3,))
-    plt.close()
-    return data
-
-
-def load_wav_to_torch(full_path):
-    sampling_rate, data = read(full_path)
-    return torch.FloatTensor(data.astype(np.float32)), sampling_rate
-
-
-def load_filepaths_and_text(filename, split="|"):
-    with open(filename, encoding="utf-8") as f:
-        filepaths_and_text = [line.strip().split(split) for line in f]
-    return filepaths_and_text
-
-
-def get_hparams(init=True):
-    """
-    todo:
-      结尾七人组：
-        保存频率、总epoch                     done
-        bs                                    done
-        pretrainG、pretrainD                  done
-        卡号：os.en["CUDA_VISIBLE_DEVICES"]   done
-        if_latest                             done
-      模型：if_f0                             done
-      采样率：自动选择config                  done
-      是否缓存数据集进GPU:if_cache_data_in_gpu done
-
-      -m:
-        自动决定training_files路径,改掉train_nsf_load_pretrain.py里的hps.data.training_files    done
-      -c不要了
-    """
-    parser = argparse.ArgumentParser()
-    # parser.add_argument('-c', '--config', type=str, default="configs/40k.json",help='JSON file for configuration')
-    parser.add_argument(
-        "-se",
-        "--save_every_epoch",
-        type=int,
-        required=True,
-        help="checkpoint save frequency (epoch)",
-    )
-    parser.add_argument(
-        "-te", "--total_epoch", type=int, required=True, help="total_epoch"
-    )
-    parser.add_argument(
-        "-pg", "--pretrainG", type=str, default="", help="Pretrained Discriminator path"
-    )
-    parser.add_argument(
-        "-pd", "--pretrainD", type=str, default="", help="Pretrained Generator path"
-    )
-    parser.add_argument("-g", "--gpus", type=str, default="0", help="split by -")
-    parser.add_argument(
-        "-bs", "--batch_size", type=int, required=True, help="batch size"
-    )
-    parser.add_argument(
-        "-e", "--experiment_dir", type=str, required=True, help="experiment dir"
-    )  # -m
-    parser.add_argument(
-        "-sr", "--sample_rate", type=str, required=True, help="sample rate, 32k/40k/48k"
-    )
-    parser.add_argument(
-        "-sw",
-        "--save_every_weights",
-        type=str,
-        default="0",
-        help="save the extracted model in weights directory when saving checkpoints",
-    )
-    parser.add_argument(
-        "-v", "--version", type=str, required=True, help="model version"
-    )
-    parser.add_argument(
-        "-f0",
-        "--if_f0",
-        type=int,
-        required=True,
-        help="use f0 as one of the inputs of the model, 1 or 0",
-    )
-    parser.add_argument(
-        "-l",
-        "--if_latest",
-        type=int,
-        required=True,
-        help="if only save the latest G/D pth file, 1 or 0",
-    )
-    parser.add_argument(
-        "-c",
-        "--if_cache_data_in_gpu",
-        type=int,
-        required=True,
-        help="if caching the dataset in GPU memory, 1 or 0",
-    )
-
-    args = parser.parse_args()
-    name = args.experiment_dir
-    experiment_dir = os.path.join("./logs", args.experiment_dir)
-
-    if not os.path.exists(experiment_dir):
-        os.makedirs(experiment_dir)
-
-    if args.version == "v1" or args.sample_rate == "40k":
-        config_path = "configs/%s.json" % args.sample_rate
-    else:
-        config_path = "configs/%s_v2.json" % args.sample_rate
-    config_save_path = os.path.join(experiment_dir, "config.json")
-    if init:
-        with open(config_path, "r") as f:
-            data = f.read()
-        with open(config_save_path, "w") as f:
-            f.write(data)
-    else:
-        with open(config_save_path, "r") as f:
-            data = f.read()
-    config = json.loads(data)
-
-    hparams = HParams(**config)
-    hparams.model_dir = hparams.experiment_dir = experiment_dir
-    hparams.save_every_epoch = args.save_every_epoch
-    hparams.name = name
-    hparams.total_epoch = args.total_epoch
-    hparams.pretrainG = args.pretrainG
-    hparams.pretrainD = args.pretrainD
-    hparams.version = args.version
-    hparams.gpus = args.gpus
-    hparams.train.batch_size = args.batch_size
-    hparams.sample_rate = args.sample_rate
-    hparams.if_f0 = args.if_f0
-    hparams.if_latest = args.if_latest
-    hparams.save_every_weights = args.save_every_weights
-    hparams.if_cache_data_in_gpu = args.if_cache_data_in_gpu
-    hparams.data.training_files = "%s/filelist.txt" % experiment_dir
-    return hparams
-
-
-def get_hparams_from_dir(model_dir):
-    config_save_path = os.path.join(model_dir, "config.json")
-    with open(config_save_path, "r") as f:
-        data = f.read()
-    config = json.loads(data)
-
-    hparams = HParams(**config)
-    hparams.model_dir = model_dir
-    return hparams
-
-
-def get_hparams_from_file(config_path):
-    with open(config_path, "r") as f:
-        data = f.read()
-    config = json.loads(data)
-
-    hparams = HParams(**config)
-    return hparams
-
-
-def check_git_hash(model_dir):
-    source_dir = os.path.dirname(os.path.realpath(__file__))
-    if not os.path.exists(os.path.join(source_dir, ".git")):
-        logger.warn(
-            "{} is not a git repository, therefore hash value comparison will be ignored.".format(
-                source_dir
-            )
-        )
-        return
-
-    cur_hash = subprocess.getoutput("git rev-parse HEAD")
-
-    path = os.path.join(model_dir, "githash")
-    if os.path.exists(path):
-        saved_hash = open(path).read()
-        if saved_hash != cur_hash:
-            logger.warn(
-                "git hash values are different. {}(saved) != {}(current)".format(
-                    saved_hash[:8], cur_hash[:8]
-                )
-            )
-    else:
-        open(path, "w").write(cur_hash)
-
-
-def get_logger(model_dir, filename="train.log"):
-    global logger
-    logger = logging.getLogger(os.path.basename(model_dir))
-    logger.setLevel(logging.DEBUG)
-
-    formatter = logging.Formatter("%(asctime)s\t%(name)s\t%(levelname)s\t%(message)s")
-    if not os.path.exists(model_dir):
-        os.makedirs(model_dir)
-    h = logging.FileHandler(os.path.join(model_dir, filename))
-    h.setLevel(logging.DEBUG)
-    h.setFormatter(formatter)
-    logger.addHandler(h)
-    return logger
-
-
-class HParams:
-    def __init__(self, **kwargs):
-        for k, v in kwargs.items():
-            if type(v) == dict:
-                v = HParams(**v)
-            self[k] = v
-
-    def keys(self):
-        return self.__dict__.keys()
-
-    def items(self):
-        return self.__dict__.items()
-
-    def values(self):
-        return self.__dict__.values()
-
-    def __len__(self):
-        return len(self.__dict__)
-
-    def __getitem__(self, key):
-        return getattr(self, key)
-
-    def __setitem__(self, key, value):
-        return setattr(self, key, value)
-
-    def __contains__(self, key):
-        return key in self.__dict__
-
-    def __repr__(self):
-        return self.__dict__.__repr__()

spaces/AICODER009/Food101_Detection/app.py

@@ -1,81 +0,0 @@
-### 1. Imports and class names setup ### 
-import gradio as gr
-import os
-import torch
-
-from model import create_effnetb2_model
-from timeit import default_timer as timer
-from typing import Tuple, Dict
-
-# Setup class names
-with open("class_names.txt", "r") as f: # reading them in from class_names.txt
-    class_names = [food_name.strip() for food_name in  f.readlines()]
-    
-### 2. Model and transforms preparation ###    
-
-# Create model
-effnetb2, effnetb2_transforms = create_effnetb2_model(
-    num_classes=101, # could also use len(class_names)
-)
-
-# Load saved weights
-effnetb2.load_state_dict(
-    torch.load(
-        f="09_pretrained_effnetb2_feature_extractor_food101_20_percent.pth",
-        map_location=torch.device("cpu"),  # load to CPU
-    )
-)
-
-### 3. Predict function ###
-
-# Create predict function
-def predict(img) -> Tuple[Dict, float]:
-    """Transforms and performs a prediction on img and returns prediction and time taken.
-    """
-    # Start the timer
-    start_time = timer()
-    
-    # Transform the target image and add a batch dimension
-    img = effnetb2_transforms(img).unsqueeze(0)
-    
-    # Put model into evaluation mode and turn on inference mode
-    effnetb2.eval()
-    with torch.inference_mode():
-        # Pass the transformed image through the model and turn the prediction logits into prediction probabilities
-        pred_probs = torch.softmax(effnetb2(img), dim=1)
-    
-    # Create a prediction label and prediction probability dictionary for each prediction class (this is the required format for Gradio's output parameter)
-    pred_labels_and_probs = {class_names[i]: float(pred_probs[0][i]) for i in range(len(class_names))}
-    
-    # Calculate the prediction time
-    pred_time = round(timer() - start_time, 5)
-    
-    # Return the prediction dictionary and prediction time 
-    return pred_labels_and_probs, pred_time
-
-### 4. Gradio app ###
-
-# Create title, description and article strings
-title = "FoodVision Big 🍔👁"
-description = "An EfficientNetB2 feature extractor computer vision model to classify images of food into [101 different classes](https://github.com/mrdbourke/pytorch-deep-learning/blob/main/extras/food101_class_names.txt)."
-article = "Created by Subhan Aliyev."
-
-# Create examples list from "examples/" directory
-example_list = [["examples/" + example] for example in os.listdir("examples")]
-
-# Create Gradio interface 
-demo = gr.Interface(
-    fn=predict,
-    inputs=gr.Image(type="pil"),
-    outputs=[
-        gr.Label(num_top_classes=5, label="Predictions"),
-        gr.Number(label="Prediction time (s)"),
-    ],
-    examples=example_list,
-    title=title,
-    description=description,
-    article=article,
-)
-
-# Launch the app!
-demo.launch()

spaces/AIGC-Audio/Make_An_Audio_inpaint/ldm/models/diffusion/ddpm_audio.py

@@ -1,1262 +0,0 @@
-"""
-wild mixture of
-https://github.com/lucidrains/denoising-diffusion-pytorch/blob/7706bdfc6f527f58d33f84b7b522e61e6e3164b3/denoising_diffusion_pytorch/denoising_diffusion_pytorch.py
-https://github.com/openai/improved-diffusion/blob/e94489283bb876ac1477d5dd7709bbbd2d9902ce/improved_diffusion/gaussian_diffusion.py
-https://github.com/CompVis/taming-transformers
--- merci
-"""
-import os
-import torch
-import torch.nn as nn
-import numpy as np
-import pytorch_lightning as pl
-from torch.optim.lr_scheduler import LambdaLR
-from einops import rearrange, repeat
-from contextlib import contextmanager
-from functools import partial
-from tqdm import tqdm
-from torchvision.utils import make_grid
-from pytorch_lightning.utilities.distributed import rank_zero_only
-
-from ldm.util import log_txt_as_img, exists, default, ismap, isimage, mean_flat, count_params, instantiate_from_config
-from ldm.modules.ema import LitEma
-from ldm.modules.distributions.distributions import normal_kl, DiagonalGaussianDistribution
-from ldm.models.autoencoder import VQModelInterface, IdentityFirstStage, AutoencoderKL
-from ldm.modules.diffusionmodules.util import make_beta_schedule, extract_into_tensor, noise_like
-from ldm.models.diffusion.ddim import DDIMSampler
-from ldm.models.diffusion.ddpm import DDPM, disabled_train
-from omegaconf import ListConfig
-
-__conditioning_keys__ = {'concat': 'c_concat',
-                         'crossattn': 'c_crossattn',
-                         'adm': 'y'}
-
-
-class LatentDiffusion_audio(DDPM):
-    """main class"""
-    def __init__(self,
-                 first_stage_config,
-                 cond_stage_config,
-                 num_timesteps_cond=None,
-                 mel_dim=80,
-                 mel_length=848,
-                 cond_stage_key="image",
-                 cond_stage_trainable=False,
-                 concat_mode=True,
-                 cond_stage_forward=None,
-                 conditioning_key=None,
-                 scale_factor=1.0,
-                 scale_by_std=False,
-                 *args, **kwargs):
-        self.num_timesteps_cond = default(num_timesteps_cond, 1)
-        self.scale_by_std = scale_by_std
-        assert self.num_timesteps_cond <= kwargs['timesteps']
-        # for backwards compatibility after implementation of DiffusionWrapper
-        if conditioning_key is None:
-            conditioning_key = 'concat' if concat_mode else 'crossattn'
-        if cond_stage_config == '__is_unconditional__':
-            conditioning_key = None
-        ckpt_path = kwargs.pop("ckpt_path", None)
-        ignore_keys = kwargs.pop("ignore_keys", [])
-        super().__init__(conditioning_key=conditioning_key, *args, **kwargs)
-        self.concat_mode = concat_mode
-        self.mel_dim = mel_dim
-        self.mel_length = mel_length
-        self.cond_stage_trainable = cond_stage_trainable
-        self.cond_stage_key = cond_stage_key
-        try:
-            self.num_downs = len(first_stage_config.params.ddconfig.ch_mult) - 1
-        except:
-            self.num_downs = 0
-        if not scale_by_std:
-            self.scale_factor = scale_factor
-        else:
-            self.register_buffer('scale_factor', torch.tensor(scale_factor))
-        self.instantiate_first_stage(first_stage_config)
-        self.instantiate_cond_stage(cond_stage_config)
-        self.cond_stage_forward = cond_stage_forward
-        self.clip_denoised = False
-        self.bbox_tokenizer = None  
-
-        self.restarted_from_ckpt = False
-        if ckpt_path is not None:
-            self.init_from_ckpt(ckpt_path, ignore_keys)
-            self.restarted_from_ckpt = True
-
-    def make_cond_schedule(self, ):
-        self.cond_ids = torch.full(size=(self.num_timesteps,), fill_value=self.num_timesteps - 1, dtype=torch.long)
-        ids = torch.round(torch.linspace(0, self.num_timesteps - 1, self.num_timesteps_cond)).long()
-        self.cond_ids[:self.num_timesteps_cond] = ids
-
-    @rank_zero_only
-    @torch.no_grad()
-    def on_train_batch_start(self, batch, batch_idx, dataloader_idx):
-        # only for very first batch
-        if self.scale_by_std and self.current_epoch == 0 and self.global_step == 0 and batch_idx == 0 and not self.restarted_from_ckpt:
-            assert self.scale_factor == 1., 'rather not use custom rescaling and std-rescaling simultaneously'
-            # set rescale weight to 1./std of encodings
-            print("### USING STD-RESCALING ###")
-            x = super().get_input(batch, self.first_stage_key)
-            x = x.to(self.device)
-            encoder_posterior = self.encode_first_stage(x)
-            z = self.get_first_stage_encoding(encoder_posterior).detach()
-            del self.scale_factor
-            self.register_buffer('scale_factor', 1. / z.flatten().std())
-            print(f"setting self.scale_factor to {self.scale_factor}")
-            print("### USING STD-RESCALING ###")
-
-    def register_schedule(self,
-                          given_betas=None, beta_schedule="linear", timesteps=1000,
-                          linear_start=1e-4, linear_end=2e-2, cosine_s=8e-3):
-        super().register_schedule(given_betas, beta_schedule, timesteps, linear_start, linear_end, cosine_s)
-
-        self.shorten_cond_schedule = self.num_timesteps_cond > 1
-        if self.shorten_cond_schedule:
-            self.make_cond_schedule()
-
-    def instantiate_first_stage(self, config):
-        model = instantiate_from_config(config)
-        self.first_stage_model = model.eval()
-        self.first_stage_model.train = disabled_train
-        for param in self.first_stage_model.parameters():
-            param.requires_grad = False
-
-    def instantiate_cond_stage(self, config):
-        if not self.cond_stage_trainable:
-            if config == "__is_first_stage__":
-                print("Using first stage also as cond stage.")
-                self.cond_stage_model = self.first_stage_model
-            elif config == "__is_unconditional__":
-                print(f"Training {self.__class__.__name__} as an unconditional model.")
-                self.cond_stage_model = None
-                # self.be_unconditional = True
-            else:
-                model = instantiate_from_config(config)
-                self.cond_stage_model = model.eval()
-                self.cond_stage_model.train = disabled_train
-                for param in self.cond_stage_model.parameters():
-                    param.requires_grad = False
-        else:
-            assert config != '__is_first_stage__'
-            assert config != '__is_unconditional__'
-            model = instantiate_from_config(config)
-            self.cond_stage_model = model
-
-    def _get_denoise_row_from_list(self, samples, desc='', force_no_decoder_quantization=False):
-        denoise_row = []
-        for zd in tqdm(samples, desc=desc):
-            denoise_row.append(self.decode_first_stage(zd.to(self.device),
-                                                            force_not_quantize=force_no_decoder_quantization))
-        n_imgs_per_row = len(denoise_row)
-        denoise_row = torch.stack(denoise_row)  # n_log_step, n_row, C, H, W
-        denoise_grid = rearrange(denoise_row, 'n b c h w -> b n c h w')
-        denoise_grid = rearrange(denoise_grid, 'b n c h w -> (b n) c h w')
-        denoise_grid = make_grid(denoise_grid, nrow=n_imgs_per_row)
-        return denoise_grid
-
-    def get_first_stage_encoding(self, encoder_posterior):
-        if isinstance(encoder_posterior, DiagonalGaussianDistribution):
-            z = encoder_posterior.sample()
-        elif isinstance(encoder_posterior, torch.Tensor):
-            z = encoder_posterior
-        else:
-            raise NotImplementedError(f"encoder_posterior of type '{type(encoder_posterior)}' not yet implemented")
-        return self.scale_factor * z
-
-    def get_learned_conditioning(self, c):
-        if self.cond_stage_forward is None:
-            if hasattr(self.cond_stage_model, 'encode') and callable(self.cond_stage_model.encode):
-                c = self.cond_stage_model.encode(c)
-                if isinstance(c, DiagonalGaussianDistribution):
-                    c = c.mode()
-            else:
-                c = self.cond_stage_model(c)
-        else:
-            assert hasattr(self.cond_stage_model, self.cond_stage_forward)
-            c = getattr(self.cond_stage_model, self.cond_stage_forward)(c)
-        return c
-
-
-    @torch.no_grad()
-    def get_unconditional_conditioning(self, batch_size, null_label=None):
-        if null_label is not None:
-            xc = null_label
-            if isinstance(xc, ListConfig):
-                xc = list(xc)
-            if isinstance(xc, dict) or isinstance(xc, list):
-                c = self.get_learned_conditioning(xc)
-            else:
-                if hasattr(xc, "to"):
-                    xc = xc.to(self.device)
-                c = self.get_learned_conditioning(xc)
-        else:
-            if self.cond_stage_key in ["class_label", "cls"]:
-                xc = self.cond_stage_model.get_unconditional_conditioning(batch_size, device=self.device)
-                return self.get_learned_conditioning(xc)
-            else:
-                raise NotImplementedError("todo")
-        if isinstance(c, list):  # in case the encoder gives us a list
-            for i in range(len(c)):
-                c[i] = repeat(c[i], '1 ... -> b ...', b=batch_size).to(self.device)
-        else:
-            c = repeat(c, '1 ... -> b ...', b=batch_size).to(self.device)
-        return c
-
-    def meshgrid(self, h, w):
-        y = torch.arange(0, h).view(h, 1, 1).repeat(1, w, 1)
-        x = torch.arange(0, w).view(1, w, 1).repeat(h, 1, 1)
-
-        arr = torch.cat([y, x], dim=-1)
-        return arr
-
-    def delta_border(self, h, w):
-        """
-        :param h: height
-        :param w: width
-        :return: normalized distance to image border,
-         wtith min distance = 0 at border and max dist = 0.5 at image center
-        """
-        lower_right_corner = torch.tensor([h - 1, w - 1]).view(1, 1, 2)
-        arr = self.meshgrid(h, w) / lower_right_corner
-        dist_left_up = torch.min(arr, dim=-1, keepdims=True)[0]
-        dist_right_down = torch.min(1 - arr, dim=-1, keepdims=True)[0]
-        edge_dist = torch.min(torch.cat([dist_left_up, dist_right_down], dim=-1), dim=-1)[0]
-        return edge_dist
-
-    def get_weighting(self, h, w, Ly, Lx, device):
-        weighting = self.delta_border(h, w)
-        weighting = torch.clip(weighting, self.split_input_params["clip_min_weight"],
-                               self.split_input_params["clip_max_weight"], )
-        weighting = weighting.view(1, h * w, 1).repeat(1, 1, Ly * Lx).to(device)
-
-        if self.split_input_params["tie_braker"]:
-            L_weighting = self.delta_border(Ly, Lx)
-            L_weighting = torch.clip(L_weighting,
-                                     self.split_input_params["clip_min_tie_weight"],
-                                     self.split_input_params["clip_max_tie_weight"])
-
-            L_weighting = L_weighting.view(1, 1, Ly * Lx).to(device)
-            weighting = weighting * L_weighting
-        return weighting
-
-    def get_fold_unfold(self, x, kernel_size, stride, uf=1, df=1):  # todo load once not every time, shorten code
-        """
-        :param x: img of size (bs, c, h, w)
-        :return: n img crops of size (n, bs, c, kernel_size[0], kernel_size[1])
-        """
-        bs, nc, h, w = x.shape
-
-        # number of crops in image
-        Ly = (h - kernel_size[0]) // stride[0] + 1
-        Lx = (w - kernel_size[1]) // stride[1] + 1
-
-        if uf == 1 and df == 1:
-            fold_params = dict(kernel_size=kernel_size, dilation=1, padding=0, stride=stride)
-            unfold = torch.nn.Unfold(**fold_params)
-
-            fold = torch.nn.Fold(output_size=x.shape[2:], **fold_params)
-
-            weighting = self.get_weighting(kernel_size[0], kernel_size[1], Ly, Lx, x.device).to(x.dtype)
-            normalization = fold(weighting).view(1, 1, h, w)  # normalizes the overlap
-            weighting = weighting.view((1, 1, kernel_size[0], kernel_size[1], Ly * Lx))
-
-        elif uf > 1 and df == 1:
-            fold_params = dict(kernel_size=kernel_size, dilation=1, padding=0, stride=stride)
-            unfold = torch.nn.Unfold(**fold_params)
-
-            fold_params2 = dict(kernel_size=(kernel_size[0] * uf, kernel_size[0] * uf),
-                                dilation=1, padding=0,
-                                stride=(stride[0] * uf, stride[1] * uf))
-            fold = torch.nn.Fold(output_size=(x.shape[2] * uf, x.shape[3] * uf), **fold_params2)
-
-            weighting = self.get_weighting(kernel_size[0] * uf, kernel_size[1] * uf, Ly, Lx, x.device).to(x.dtype)
-            normalization = fold(weighting).view(1, 1, h * uf, w * uf)  # normalizes the overlap
-            weighting = weighting.view((1, 1, kernel_size[0] * uf, kernel_size[1] * uf, Ly * Lx))
-
-        elif df > 1 and uf == 1:
-            fold_params = dict(kernel_size=kernel_size, dilation=1, padding=0, stride=stride)
-            unfold = torch.nn.Unfold(**fold_params)
-
-            fold_params2 = dict(kernel_size=(kernel_size[0] // df, kernel_size[0] // df),
-                                dilation=1, padding=0,
-                                stride=(stride[0] // df, stride[1] // df))
-            fold = torch.nn.Fold(output_size=(x.shape[2] // df, x.shape[3] // df), **fold_params2)
-
-            weighting = self.get_weighting(kernel_size[0] // df, kernel_size[1] // df, Ly, Lx, x.device).to(x.dtype)
-            normalization = fold(weighting).view(1, 1, h // df, w // df)  # normalizes the overlap
-            weighting = weighting.view((1, 1, kernel_size[0] // df, kernel_size[1] // df, Ly * Lx))
-
-        else:
-            raise NotImplementedError
-
-        return fold, unfold, normalization, weighting
-
-    @torch.no_grad()
-    def get_input(self, batch, k, return_first_stage_outputs=False, force_c_encode=False,
-                  cond_key=None, return_original_cond=False, bs=None):
-        x = super().get_input(batch, k)
-        if bs is not None:
-            x = x[:bs]
-        x = x.to(self.device)
-        encoder_posterior = self.encode_first_stage(x)
-        z = self.get_first_stage_encoding(encoder_posterior).detach()
-
-        if self.model.conditioning_key is not None:
-            if cond_key is None:
-                cond_key = self.cond_stage_key
-            if cond_key != self.first_stage_key:
-                if cond_key in ['caption', 'coordinates_bbox']:
-                    xc = batch[cond_key]
-                elif cond_key == 'class_label':
-                    xc = batch
-                else:
-                    xc = super().get_input(batch, cond_key).to(self.device)
-            else:
-                xc = x
-            if not self.cond_stage_trainable or force_c_encode:
-                if isinstance(xc, dict) or isinstance(xc, list):
-                    # import pudb; pudb.set_trace()
-                    c = self.get_learned_conditioning(xc)
-                else:
-                    c = self.get_learned_conditioning(xc.to(self.device))
-            else:
-                c = xc
-            if bs is not None:
-                c = c[:bs]
-            # Testing #
-            if cond_key == 'masked_image':
-                mask = super().get_input(batch, "mask")
-                cc = torch.nn.functional.interpolate(mask, size=c.shape[-2:]) # [B, 1, 10, 106]
-                c = torch.cat((c, cc), dim=1) # [B, 5, 10, 106]
-            # Testing #
-            if self.use_positional_encodings:
-                pos_x, pos_y = self.compute_latent_shifts(batch)
-                ckey = __conditioning_keys__[self.model.conditioning_key]
-                c = {ckey: c, 'pos_x': pos_x, 'pos_y': pos_y}
-
-        else:
-            c = None
-            xc = None
-            if self.use_positional_encodings:
-                pos_x, pos_y = self.compute_latent_shifts(batch)
-                c = {'pos_x': pos_x, 'pos_y': pos_y}
-        out = [z, c]
-        if return_first_stage_outputs:
-            xrec = self.decode_first_stage(z)
-            out.extend([x, xrec])
-        if return_original_cond:
-            out.append(xc)
-        return out
-
-    @torch.no_grad()
-    def decode_first_stage(self, z, predict_cids=False, force_not_quantize=False):
-        if predict_cids:
-            if z.dim() == 4:
-                z = torch.argmax(z.exp(), dim=1).long()
-            z = self.first_stage_model.quantize.get_codebook_entry(z, shape=None)
-            z = rearrange(z, 'b h w c -> b c h w').contiguous()
-
-        z = 1. / self.scale_factor * z
-
-        if hasattr(self, "split_input_params"):
-            if self.split_input_params["patch_distributed_vq"]:
-                ks = self.split_input_params["ks"]  # eg. (128, 128)
-                stride = self.split_input_params["stride"]  # eg. (64, 64)
-                uf = self.split_input_params["vqf"]
-                bs, nc, h, w = z.shape
-                if ks[0] > h or ks[1] > w:
-                    ks = (min(ks[0], h), min(ks[1], w))
-                    print("reducing Kernel")
-
-                if stride[0] > h or stride[1] > w:
-                    stride = (min(stride[0], h), min(stride[1], w))
-                    print("reducing stride")
-
-                fold, unfold, normalization, weighting = self.get_fold_unfold(z, ks, stride, uf=uf)
-
-                z = unfold(z)  # (bn, nc * prod(**ks), L)
-                # 1. Reshape to img shape
-                z = z.view((z.shape[0], -1, ks[0], ks[1], z.shape[-1]))  # (bn, nc, ks[0], ks[1], L )
-
-                # 2. apply model loop over last dim
-                if isinstance(self.first_stage_model, VQModelInterface):
-                    output_list = [self.first_stage_model.decode(z[:, :, :, :, i],
-                                                                 force_not_quantize=predict_cids or force_not_quantize)
-                                   for i in range(z.shape[-1])]
-                else:
-
-                    output_list = [self.first_stage_model.decode(z[:, :, :, :, i])
-                                   for i in range(z.shape[-1])]
-
-                o = torch.stack(output_list, axis=-1)  # # (bn, nc, ks[0], ks[1], L)
-                o = o * weighting
-                # Reverse 1. reshape to img shape
-                o = o.view((o.shape[0], -1, o.shape[-1]))  # (bn, nc * ks[0] * ks[1], L)
-                # stitch crops together
-                decoded = fold(o)
-                decoded = decoded / normalization  # norm is shape (1, 1, h, w)
-                return decoded
-            else:
-                if isinstance(self.first_stage_model, VQModelInterface):
-                    return self.first_stage_model.decode(z, force_not_quantize=predict_cids or force_not_quantize)
-                else:
-                    return self.first_stage_model.decode(z)
-
-        else:
-            if isinstance(self.first_stage_model, VQModelInterface):
-                return self.first_stage_model.decode(z, force_not_quantize=predict_cids or force_not_quantize)
-            else:
-                return self.first_stage_model.decode(z)
-
-    # same as above but without decorator
-    def differentiable_decode_first_stage(self, z, predict_cids=False, force_not_quantize=False):
-        if predict_cids:
-            if z.dim() == 4:
-                z = torch.argmax(z.exp(), dim=1).long()
-            z = self.first_stage_model.quantize.get_codebook_entry(z, shape=None)
-            z = rearrange(z, 'b h w c -> b c h w').contiguous()
-
-        z = 1. / self.scale_factor * z
-
-        if hasattr(self, "split_input_params"):
-            if self.split_input_params["patch_distributed_vq"]:
-                ks = self.split_input_params["ks"]  # eg. (128, 128)
-                stride = self.split_input_params["stride"]  # eg. (64, 64)
-                uf = self.split_input_params["vqf"]
-                bs, nc, h, w = z.shape
-                if ks[0] > h or ks[1] > w:
-                    ks = (min(ks[0], h), min(ks[1], w))
-                    print("reducing Kernel")
-
-                if stride[0] > h or stride[1] > w:
-                    stride = (min(stride[0], h), min(stride[1], w))
-                    print("reducing stride")
-
-                fold, unfold, normalization, weighting = self.get_fold_unfold(z, ks, stride, uf=uf)
-
-                z = unfold(z)  # (bn, nc * prod(**ks), L)
-                # 1. Reshape to img shape
-                z = z.view((z.shape[0], -1, ks[0], ks[1], z.shape[-1]))  # (bn, nc, ks[0], ks[1], L )
-
-                # 2. apply model loop over last dim
-                if isinstance(self.first_stage_model, VQModelInterface):  
-                    output_list = [self.first_stage_model.decode(z[:, :, :, :, i],
-                                                                 force_not_quantize=predict_cids or force_not_quantize)
-                                   for i in range(z.shape[-1])]
-                else:
-
-                    output_list = [self.first_stage_model.decode(z[:, :, :, :, i])
-                                   for i in range(z.shape[-1])]
-
-                o = torch.stack(output_list, axis=-1)  # # (bn, nc, ks[0], ks[1], L)
-                o = o * weighting
-                # Reverse 1. reshape to img shape
-                o = o.view((o.shape[0], -1, o.shape[-1]))  # (bn, nc * ks[0] * ks[1], L)
-                # stitch crops together
-                decoded = fold(o)
-                decoded = decoded / normalization  # norm is shape (1, 1, h, w)
-                return decoded
-            else:
-                if isinstance(self.first_stage_model, VQModelInterface):
-                    return self.first_stage_model.decode(z, force_not_quantize=predict_cids or force_not_quantize)
-                else:
-                    return self.first_stage_model.decode(z)
-
-        else:
-            if isinstance(self.first_stage_model, VQModelInterface):
-                return self.first_stage_model.decode(z, force_not_quantize=predict_cids or force_not_quantize)
-            else:
-                return self.first_stage_model.decode(z)
-
-    @torch.no_grad()
-    def encode_first_stage(self, x):
-        if hasattr(self, "split_input_params"):
-            if self.split_input_params["patch_distributed_vq"]:
-                ks = self.split_input_params["ks"]  # eg. (128, 128)
-                stride = self.split_input_params["stride"]  # eg. (64, 64)
-                df = self.split_input_params["vqf"]
-                self.split_input_params['original_image_size'] = x.shape[-2:]
-                bs, nc, h, w = x.shape
-                if ks[0] > h or ks[1] > w:
-                    ks = (min(ks[0], h), min(ks[1], w))
-                    print("reducing Kernel")
-
-                if stride[0] > h or stride[1] > w:
-                    stride = (min(stride[0], h), min(stride[1], w))
-                    print("reducing stride")
-
-                fold, unfold, normalization, weighting = self.get_fold_unfold(x, ks, stride, df=df)
-                z = unfold(x)  # (bn, nc * prod(**ks), L)
-                # Reshape to img shape
-                z = z.view((z.shape[0], -1, ks[0], ks[1], z.shape[-1]))  # (bn, nc, ks[0], ks[1], L )
-
-                output_list = [self.first_stage_model.encode(z[:, :, :, :, i])
-                               for i in range(z.shape[-1])]
-
-                o = torch.stack(output_list, axis=-1)
-                o = o * weighting
-
-                # Reverse reshape to img shape
-                o = o.view((o.shape[0], -1, o.shape[-1]))  # (bn, nc * ks[0] * ks[1], L)
-                # stitch crops together
-                decoded = fold(o)
-                decoded = decoded / normalization
-                return decoded
-
-            else:
-                return self.first_stage_model.encode(x)
-        else:
-            return self.first_stage_model.encode(x)
-
-    def shared_step(self, batch, **kwargs):
-        x, c = self.get_input(batch, self.first_stage_key)
-        loss = self(x, c)
-        return loss
-
-    def test_step(self,batch,batch_idx):
-        cond = batch[self.cond_stage_key] * self.test_repeat
-        cond = self.get_learned_conditioning(cond) # c: string -> [B, T, Context_dim]
-        batch_size = len(cond)
-        enc_emb = self.sample(cond,batch_size,timesteps=self.test_numsteps)# shape = [batch_size,self.channels,self.mel_dim,self.mel_length]
-        xrec = self.decode_first_stage(enc_emb)
-        reconstructions = (xrec + 1)/2 # to mel scale
-        test_ckpt_path = os.path.basename(self.trainer.tested_ckpt_path)
-        savedir = os.path.join(self.trainer.log_dir,f'output_imgs_{test_ckpt_path}','fake_class')
-        if not os.path.exists(savedir):
-            os.makedirs(savedir)
-
-        file_names = batch['f_name']
-        nfiles = len(file_names)
-        reconstructions = reconstructions.cpu().numpy().squeeze(1) # squuze channel dim
-        for k in range(reconstructions.shape[0]):
-            b,repeat = k % nfiles, k // nfiles
-            vname_num_split_index = file_names[b].rfind('_')# file_names[b]:video_name+'_'+num
-            v_n,num = file_names[b][:vname_num_split_index],file_names[b][vname_num_split_index+1:]
-            save_img_path = os.path.join(savedir,f'{v_n}_sample_{num}_{repeat}.npy')# the num_th caption, the repeat_th repitition
-            np.save(save_img_path,reconstructions[b])
-        
-        return None
-
-    def forward(self, x, c, *args, **kwargs):
-        t = torch.randint(0, self.num_timesteps, (x.shape[0],), device=self.device).long()
-        if self.model.conditioning_key is not None:
-            assert c is not None
-            if self.cond_stage_trainable:
-                c = self.get_learned_conditioning(c) # c: string -> [B, T, Context_dim]
-            if self.shorten_cond_schedule:  # TODO: drop this option
-                tc = self.cond_ids[t].to(self.device)
-                c = self.q_sample(x_start=c, t=tc, noise=torch.randn_like(c.float()))
-        return self.p_losses(x, c, t, *args, **kwargs)
-
-    def _rescale_annotations(self, bboxes, crop_coordinates):  # TODO: move to dataset
-        def rescale_bbox(bbox):
-            x0 = clamp((bbox[0] - crop_coordinates[0]) / crop_coordinates[2])
-            y0 = clamp((bbox[1] - crop_coordinates[1]) / crop_coordinates[3])
-            w = min(bbox[2] / crop_coordinates[2], 1 - x0)
-            h = min(bbox[3] / crop_coordinates[3], 1 - y0)
-            return x0, y0, w, h
-
-        return [rescale_bbox(b) for b in bboxes]
-
-    def apply_model(self, x_noisy, t, cond, return_ids=False):
-
-        if isinstance(cond, dict):
-            # hybrid case, cond is exptected to be a dict
-            pass
-        else:
-            if not isinstance(cond, list):
-                cond = [cond]
-            key = 'c_concat' if self.model.conditioning_key == 'concat' else 'c_crossattn'
-            cond = {key: cond}
-
-        if hasattr(self, "split_input_params"):
-            assert len(cond) == 1  # todo can only deal with one conditioning atm
-            assert not return_ids  
-            ks = self.split_input_params["ks"]  # eg. (128, 128)
-            stride = self.split_input_params["stride"]  # eg. (64, 64)
-
-            h, w = x_noisy.shape[-2:]
-
-            fold, unfold, normalization, weighting = self.get_fold_unfold(x_noisy, ks, stride)
-
-            z = unfold(x_noisy)  # (bn, nc * prod(**ks), L)
-            # Reshape to img shape
-            z = z.view((z.shape[0], -1, ks[0], ks[1], z.shape[-1]))  # (bn, nc, ks[0], ks[1], L )
-            z_list = [z[:, :, :, :, i] for i in range(z.shape[-1])]
-
-            if self.cond_stage_key in ["image", "LR_image", "segmentation",
-                                       'bbox_img'] and self.model.conditioning_key:  # todo check for completeness
-                c_key = next(iter(cond.keys()))  # get key
-                c = next(iter(cond.values()))  # get value
-                assert (len(c) == 1)  # todo extend to list with more than one elem
-                c = c[0]  # get element
-
-                c = unfold(c)
-                c = c.view((c.shape[0], -1, ks[0], ks[1], c.shape[-1]))  # (bn, nc, ks[0], ks[1], L )
-
-                cond_list = [{c_key: [c[:, :, :, :, i]]} for i in range(c.shape[-1])]
-
-            elif self.cond_stage_key == 'coordinates_bbox':
-                assert 'original_image_size' in self.split_input_params, 'BoudingBoxRescaling is missing original_image_size'
-
-                # assuming padding of unfold is always 0 and its dilation is always 1
-                n_patches_per_row = int((w - ks[0]) / stride[0] + 1)
-                full_img_h, full_img_w = self.split_input_params['original_image_size']
-                # as we are operating on latents, we need the factor from the original image size to the
-                # spatial latent size to properly rescale the crops for regenerating the bbox annotations
-                num_downs = self.first_stage_model.encoder.num_resolutions - 1
-                rescale_latent = 2 ** (num_downs)
-
-                # get top left postions of patches as conforming for the bbbox tokenizer, therefore we
-                # need to rescale the tl patch coordinates to be in between (0,1)
-                tl_patch_coordinates = [(rescale_latent * stride[0] * (patch_nr % n_patches_per_row) / full_img_w,
-                                         rescale_latent * stride[1] * (patch_nr // n_patches_per_row) / full_img_h)
-                                        for patch_nr in range(z.shape[-1])]
-
-                # patch_limits are tl_coord, width and height coordinates as (x_tl, y_tl, h, w)
-                patch_limits = [(x_tl, y_tl,
-                                 rescale_latent * ks[0] / full_img_w,
-                                 rescale_latent * ks[1] / full_img_h) for x_tl, y_tl in tl_patch_coordinates]
-                # patch_values = [(np.arange(x_tl,min(x_tl+ks, 1.)),np.arange(y_tl,min(y_tl+ks, 1.))) for x_tl, y_tl in tl_patch_coordinates]
-
-                # tokenize crop coordinates for the bounding boxes of the respective patches
-                patch_limits_tknzd = [torch.LongTensor(self.bbox_tokenizer._crop_encoder(bbox))[None].to(self.device)
-                                      for bbox in patch_limits]  # list of length l with tensors of shape (1, 2)
-                print(patch_limits_tknzd[0].shape)
-                # cut tknzd crop position from conditioning
-                assert isinstance(cond, dict), 'cond must be dict to be fed into model'
-                cut_cond = cond['c_crossattn'][0][..., :-2].to(self.device)
-                print(cut_cond.shape)
-
-                adapted_cond = torch.stack([torch.cat([cut_cond, p], dim=1) for p in patch_limits_tknzd])
-                adapted_cond = rearrange(adapted_cond, 'l b n -> (l b) n')
-                print(adapted_cond.shape)
-                adapted_cond = self.get_learned_conditioning(adapted_cond)
-                print(adapted_cond.shape)
-                adapted_cond = rearrange(adapted_cond, '(l b) n d -> l b n d', l=z.shape[-1])
-                print(adapted_cond.shape)
-
-                cond_list = [{'c_crossattn': [e]} for e in adapted_cond]
-
-            else:
-                cond_list = [cond for i in range(z.shape[-1])]  # Todo make this more efficient
-
-            # apply model by loop over crops
-            output_list = [self.model(z_list[i], t, **cond_list[i]) for i in range(z.shape[-1])]
-            assert not isinstance(output_list[0],
-                                  tuple)  # todo cant deal with multiple model outputs check this never happens
-
-            o = torch.stack(output_list, axis=-1)
-            o = o * weighting
-            # Reverse reshape to img shape
-            o = o.view((o.shape[0], -1, o.shape[-1]))  # (bn, nc * ks[0] * ks[1], L)
-            # stitch crops together
-            x_recon = fold(o) / normalization
-
-        else:
-            x_recon = self.model(x_noisy, t, **cond)
-
-        if isinstance(x_recon, tuple) and not return_ids:
-            return x_recon[0]
-        else:
-            return x_recon
-
-    def _predict_eps_from_xstart(self, x_t, t, pred_xstart):
-        return (extract_into_tensor(self.sqrt_recip_alphas_cumprod, t, x_t.shape) * x_t - pred_xstart) / \
-               extract_into_tensor(self.sqrt_recipm1_alphas_cumprod, t, x_t.shape)
-
-    def _prior_bpd(self, x_start):
-        """
-        Get the prior KL term for the variational lower-bound, measured in
-        bits-per-dim.
-        This term can't be optimized, as it only depends on the encoder.
-        :param x_start: the [N x C x ...] tensor of inputs.
-        :return: a batch of [N] KL values (in bits), one per batch element.
-        """
-        batch_size = x_start.shape[0]
-        t = torch.tensor([self.num_timesteps - 1] * batch_size, device=x_start.device)
-        qt_mean, _, qt_log_variance = self.q_mean_variance(x_start, t)
-        kl_prior = normal_kl(mean1=qt_mean, logvar1=qt_log_variance, mean2=0.0, logvar2=0.0)
-        return mean_flat(kl_prior) / np.log(2.0)
-
-    def p_losses(self, x_start, cond, t, noise=None):
-        noise = default(noise, lambda: torch.randn_like(x_start))
-        x_noisy = self.q_sample(x_start=x_start, t=t, noise=noise)
-        model_output = self.apply_model(x_noisy, t, cond)
-
-        loss_dict = {}
-        prefix = 'train' if self.training else 'val'
-
-        if self.parameterization == "x0":
-            target = x_start
-        elif self.parameterization == "eps":
-            target = noise
-        else:
-            raise NotImplementedError()
-
-        loss_simple = self.get_loss(model_output, target, mean=False).mean([1, 2, 3])
-        loss_dict.update({f'{prefix}/loss_simple': loss_simple.mean()})
-
-        logvar_t = self.logvar[t].to(self.device)
-        loss = loss_simple / torch.exp(logvar_t) + logvar_t
-        # loss = loss_simple / torch.exp(self.logvar) + self.logvar
-        if self.learn_logvar:
-            loss_dict.update({f'{prefix}/loss_gamma': loss.mean()})
-            loss_dict.update({'logvar': self.logvar.data.mean()})
-
-        loss = self.l_simple_weight * loss.mean()
-
-        loss_vlb = self.get_loss(model_output, target, mean=False).mean(dim=(1, 2, 3))
-        loss_vlb = (self.lvlb_weights[t] * loss_vlb).mean()
-        loss_dict.update({f'{prefix}/loss_vlb': loss_vlb})
-        loss += (self.original_elbo_weight * loss_vlb)
-        loss_dict.update({f'{prefix}/loss': loss})
-
-        return loss, loss_dict
-
-    def p_mean_variance(self, x, c, t, clip_denoised: bool, return_codebook_ids=False, quantize_denoised=False,
-                        return_x0=False, score_corrector=None, corrector_kwargs=None):
-        t_in = t
-        model_out = self.apply_model(x, t_in, c, return_ids=return_codebook_ids)
-
-        if score_corrector is not None:
-            assert self.parameterization == "eps"
-            model_out = score_corrector.modify_score(self, model_out, x, t, c, **corrector_kwargs)
-
-        if return_codebook_ids:
-            model_out, logits = model_out
-
-        if self.parameterization == "eps":
-            x_recon = self.predict_start_from_noise(x, t=t, noise=model_out)
-        elif self.parameterization == "x0":
-            x_recon = model_out
-        else:
-            raise NotImplementedError()
-
-        if clip_denoised:
-            x_recon.clamp_(-1., 1.)
-        if quantize_denoised:
-            x_recon, _, [_, _, indices] = self.first_stage_model.quantize(x_recon)
-        model_mean, posterior_variance, posterior_log_variance = self.q_posterior(x_start=x_recon, x_t=x, t=t)
-        if return_codebook_ids:
-            return model_mean, posterior_variance, posterior_log_variance, logits
-        elif return_x0:
-            return model_mean, posterior_variance, posterior_log_variance, x_recon
-        else:
-            return model_mean, posterior_variance, posterior_log_variance
-
-    @torch.no_grad()
-    def p_sample(self, x, c, t, clip_denoised=False, repeat_noise=False,
-                 return_codebook_ids=False, quantize_denoised=False, return_x0=False,
-                 temperature=1., noise_dropout=0., score_corrector=None, corrector_kwargs=None):
-        b, *_, device = *x.shape, x.device
-        outputs = self.p_mean_variance(x=x, c=c, t=t, clip_denoised=clip_denoised,
-                                       return_codebook_ids=return_codebook_ids,
-                                       quantize_denoised=quantize_denoised,
-                                       return_x0=return_x0,
-                                       score_corrector=score_corrector, corrector_kwargs=corrector_kwargs)
-        if return_codebook_ids:
-            raise DeprecationWarning("Support dropped.")
-            model_mean, _, model_log_variance, logits = outputs
-        elif return_x0:
-            model_mean, _, model_log_variance, x0 = outputs
-        else:
-            model_mean, _, model_log_variance = outputs
-
-        noise = noise_like(x.shape, device, repeat_noise) * temperature
-        if noise_dropout > 0.:
-            noise = torch.nn.functional.dropout(noise, p=noise_dropout)
-        # no noise when t == 0
-        nonzero_mask = (1 - (t == 0).float()).reshape(b, *((1,) * (len(x.shape) - 1)))
-
-        if return_codebook_ids:
-            return model_mean + nonzero_mask * (0.5 * model_log_variance).exp() * noise, logits.argmax(dim=1)
-        if return_x0:
-            return model_mean + nonzero_mask * (0.5 * model_log_variance).exp() * noise, x0
-        else:
-            return model_mean + nonzero_mask * (0.5 * model_log_variance).exp() * noise
-
-    @torch.no_grad()
-    def progressive_denoising(self, cond, shape, verbose=True, callback=None, quantize_denoised=False,
-                              img_callback=None, mask=None, x0=None, temperature=1., noise_dropout=0.,
-                              score_corrector=None, corrector_kwargs=None, batch_size=None, x_T=None, start_T=None,
-                              log_every_t=None):
-        if not log_every_t:
-            log_every_t = self.log_every_t
-        timesteps = self.num_timesteps
-        if batch_size is not None:
-            b = batch_size if batch_size is not None else shape[0]
-            shape = [batch_size] + list(shape)
-        else:
-            b = batch_size = shape[0]
-        if x_T is None:
-            img = torch.randn(shape, device=self.device)
-        else:
-            img = x_T
-        intermediates = []
-        if cond is not None:
-            if isinstance(cond, dict):
-                cond = {key: cond[key][:batch_size] if not isinstance(cond[key], list) else
-                list(map(lambda x: x[:batch_size], cond[key])) for key in cond}
-            else:
-                cond = [c[:batch_size] for c in cond] if isinstance(cond, list) else cond[:batch_size]
-
-        if start_T is not None:
-            timesteps = min(timesteps, start_T)
-        iterator = tqdm(reversed(range(0, timesteps)), desc='Progressive Generation',
-                        total=timesteps) if verbose else reversed(
-            range(0, timesteps))
-        if type(temperature) == float:
-            temperature = [temperature] * timesteps
-
-        for i in iterator:
-            ts = torch.full((b,), i, device=self.device, dtype=torch.long)
-            if self.shorten_cond_schedule:
-                assert self.model.conditioning_key != 'hybrid'
-                tc = self.cond_ids[ts].to(cond.device)
-                cond = self.q_sample(x_start=cond, t=tc, noise=torch.randn_like(cond))
-
-            img, x0_partial = self.p_sample(img, cond, ts,
-                                            clip_denoised=self.clip_denoised,
-                                            quantize_denoised=quantize_denoised, return_x0=True,
-                                            temperature=temperature[i], noise_dropout=noise_dropout,
-                                            score_corrector=score_corrector, corrector_kwargs=corrector_kwargs)
-            if mask is not None:
-                assert x0 is not None
-                img_orig = self.q_sample(x0, ts)
-                img = img_orig * mask + (1. - mask) * img
-
-            if i % log_every_t == 0 or i == timesteps - 1:
-                intermediates.append(x0_partial)
-            if callback: callback(i)
-            if img_callback: img_callback(img, i)
-        return img, intermediates
-
-    @torch.no_grad()
-    def p_sample_loop(self, cond, shape, return_intermediates=False,
-                      x_T=None, verbose=True, callback=None, timesteps=None, quantize_denoised=False,
-                      mask=None, x0=None, img_callback=None, start_T=None,
-                      log_every_t=None):
-
-        if not log_every_t:
-            log_every_t = self.log_every_t
-        device = self.betas.device
-        b = shape[0]
-        if x_T is None:
-            img = torch.randn(shape, device=device)
-        else:
-            img = x_T
-
-        intermediates = [img]
-        if timesteps is None:
-            timesteps = self.num_timesteps
-
-        if start_T is not None:
-            timesteps = min(timesteps, start_T)
-        iterator = tqdm(reversed(range(0, timesteps)), desc='Sampling t', total=timesteps) if verbose else reversed(
-            range(0, timesteps))
-
-        if mask is not None:
-            assert x0 is not None
-            assert x0.shape[2:3] == mask.shape[2:3]  # spatial size has to match
-
-        for i in iterator:
-            ts = torch.full((b,), i, device=device, dtype=torch.long)
-            if self.shorten_cond_schedule:
-                assert self.model.conditioning_key != 'hybrid'
-                tc = self.cond_ids[ts].to(cond.device)
-                cond = self.q_sample(x_start=cond, t=tc, noise=torch.randn_like(cond))
-
-            img = self.p_sample(img, cond, ts,
-                                clip_denoised=self.clip_denoised,
-                                quantize_denoised=quantize_denoised)
-            if mask is not None:
-                img_orig = self.q_sample(x0, ts)
-                img = img_orig * mask + (1. - mask) * img
-
-            if i % log_every_t == 0 or i == timesteps - 1:
-                intermediates.append(img)
-            if callback: callback(i)
-            if img_callback: img_callback(img, i)
-
-        if return_intermediates:
-            return img, intermediates
-        return img
-
-    @torch.no_grad()
-    def sample(self, cond, batch_size=16, return_intermediates=False, x_T=None,
-               verbose=True, timesteps=None, quantize_denoised=False,
-               mask=None, x0=None, shape=None,**kwargs):
-        if shape is None:
-            shape = (batch_size, self.channels, self.mel_dim, self.mel_length)
-        if cond is not None:
-            if isinstance(cond, dict):
-                cond = {key: cond[key][:batch_size] if not isinstance(cond[key], list) else
-                list(map(lambda x: x[:batch_size], cond[key])) for key in cond}
-            else:
-                cond = [c[:batch_size] for c in cond] if isinstance(cond, list) else cond[:batch_size]
-        return self.p_sample_loop(cond,
-                                  shape,
-                                  return_intermediates=return_intermediates, x_T=x_T,
-                                  verbose=verbose, timesteps=timesteps, quantize_denoised=quantize_denoised,
-                                  mask=mask, x0=x0)
-
-    @torch.no_grad()
-    def sample_log(self,cond,batch_size,ddim, ddim_steps,**kwargs):
-
-        if ddim:
-            ddim_sampler = DDIMSampler(self)
-            shape = (self.channels, self.mel_dim, self.mel_length)
-            samples, intermediates =ddim_sampler.sample(ddim_steps,batch_size,
-                                                        shape,cond,verbose=False,**kwargs)
-
-        else:
-            samples, intermediates = self.sample(cond=cond, batch_size=batch_size,
-                                                 return_intermediates=True,**kwargs)
-
-        return samples, intermediates
-
-
-    @torch.no_grad()
-    def log_images(self, batch, N=8, n_row=4, sample=True, ddim_steps=200, ddim_eta=1., return_keys=None,
-                   quantize_denoised=True, inpaint=True, plot_denoise_rows=False, plot_progressive_rows=True,
-                   plot_diffusion_rows=True, **kwargs):
-
-        use_ddim = ddim_steps is not None
-
-        log = dict()
-        z, c, x, xrec, xc = self.get_input(batch, self.first_stage_key,
-                                           return_first_stage_outputs=True,
-                                           force_c_encode=True,
-                                           return_original_cond=True,
-                                           bs=N)
-        N = min(x.shape[0], N)
-        n_row = min(x.shape[0], n_row)
-        log["inputs"] = x
-        log["reconstruction"] = xrec
-        if self.model.conditioning_key is not None:
-            if hasattr(self.cond_stage_model, "decode") and self.cond_stage_key != "masked_image":
-                xc = self.cond_stage_model.decode(c)
-                log["conditioning"] = xc
-            elif self.cond_stage_key == "masked_image":
-                log["mask"] = c[:, -1, :, :][:, None, :, :]
-                xc = self.cond_stage_model.decode(c[:, :self.cond_stage_model.embed_dim, :, :])
-                log["conditioning"] = xc
-            elif self.cond_stage_key in ["caption"]:
-                xc = log_txt_as_img((256, 256), batch["caption"])
-                log["conditioning"] = xc
-            elif self.cond_stage_key == 'class_label':
-                xc = log_txt_as_img((x.shape[2], x.shape[3]), batch["human_label"])
-                log['conditioning'] = xc
-            elif isimage(xc):
-                log["conditioning"] = xc
-            if ismap(xc):
-                log["original_conditioning"] = self.to_rgb(xc)
-
-        if plot_diffusion_rows:
-            # get diffusion row
-            diffusion_row = list()
-            z_start = z[:n_row]
-            for t in range(self.num_timesteps):
-                if t % self.log_every_t == 0 or t == self.num_timesteps - 1:
-                    t = repeat(torch.tensor([t]), '1 -> b', b=n_row)
-                    t = t.to(self.device).long()
-                    noise = torch.randn_like(z_start)
-                    z_noisy = self.q_sample(x_start=z_start, t=t, noise=noise)
-                    diffusion_row.append(self.decode_first_stage(z_noisy))
-
-            diffusion_row = torch.stack(diffusion_row)  # n_log_step, n_row, C, H, W
-            diffusion_grid = rearrange(diffusion_row, 'n b c h w -> b n c h w')
-            diffusion_grid = rearrange(diffusion_grid, 'b n c h w -> (b n) c h w')
-            diffusion_grid = make_grid(diffusion_grid, nrow=diffusion_row.shape[0])
-            log["diffusion_row"] = diffusion_grid
-
-        if sample:
-            # get denoise row
-            with self.ema_scope("Plotting"):
-                samples, z_denoise_row = self.sample_log(cond=c,batch_size=N,ddim=use_ddim,
-                                                         ddim_steps=ddim_steps,eta=ddim_eta)
-                # samples, z_denoise_row = self.sample(cond=c, batch_size=N, return_intermediates=True)
-            x_samples = self.decode_first_stage(samples)
-            log["samples"] = x_samples
-            if plot_denoise_rows:
-                denoise_grid = self._get_denoise_row_from_list(z_denoise_row)
-                log["denoise_row"] = denoise_grid
-
-            if quantize_denoised and not isinstance(self.first_stage_model, AutoencoderKL) and not isinstance(
-                    self.first_stage_model, IdentityFirstStage):
-                # also display when quantizing x0 while sampling
-                with self.ema_scope("Plotting Quantized Denoised"):
-                    samples, z_denoise_row = self.sample_log(cond=c,batch_size=N,ddim=use_ddim,
-                                                             ddim_steps=ddim_steps,eta=ddim_eta,
-                                                             quantize_denoised=True)
-                    # samples, z_denoise_row = self.sample(cond=c, batch_size=N, return_intermediates=True,
-                    #                                      quantize_denoised=True)
-                x_samples = self.decode_first_stage(samples.to(self.device))
-                log["samples_x0_quantized"] = x_samples
-
-            if inpaint:
-                # make a simple center square
-                b, h, w = z.shape[0], z.shape[2], z.shape[3]
-                mask = torch.ones(N, h, w).to(self.device)
-                # zeros will be filled in
-                mask[:, h // 4:3 * h // 4, w // 4:3 * w // 4] = 0.
-                mask = mask[:, None, ...]
-                with self.ema_scope("Plotting Inpaint"):
-
-                    samples, _ = self.sample_log(cond=c,batch_size=N,ddim=use_ddim, eta=ddim_eta,
-                                                ddim_steps=ddim_steps, x0=z[:N], mask=mask)
-                x_samples = self.decode_first_stage(samples.to(self.device))
-                log["samples_inpainting"] = x_samples
-                log["mask_inpainting"] = mask
-
-                # outpaint
-                mask = 1 - mask
-                with self.ema_scope("Plotting Outpaint"):
-                    samples, _ = self.sample_log(cond=c, batch_size=N, ddim=use_ddim,eta=ddim_eta,
-                                                ddim_steps=ddim_steps, x0=z[:N], mask=mask)
-                x_samples = self.decode_first_stage(samples.to(self.device))
-                log["samples_outpainting"] = x_samples
-                log["mask_outpainting"] = mask
-
-        if plot_progressive_rows:
-            with self.ema_scope("Plotting Progressives"):
-                img, progressives = self.progressive_denoising(c,
-                                                               shape=(self.channels, self.mel_dim, self.mel_length),
-                                                               batch_size=N)
-            prog_row = self._get_denoise_row_from_list(progressives, desc="Progressive Generation")
-            log["progressive_row"] = prog_row
-
-        if return_keys:
-            if np.intersect1d(list(log.keys()), return_keys).shape[0] == 0:
-                return log
-            else:
-                return {key: log[key] for key in return_keys}
-        return log
-
-    def configure_optimizers(self):
-        lr = self.learning_rate
-        params = list(self.model.parameters())
-        if self.cond_stage_trainable:
-            print(f"{self.__class__.__name__}: Also optimizing conditioner params!")
-            params = params + list(self.cond_stage_model.parameters())
-        if self.learn_logvar:
-            print('Diffusion model optimizing logvar')
-            params.append(self.logvar)
-        opt = torch.optim.AdamW(params, lr=lr)
-        if self.use_scheduler:
-            assert 'target' in self.scheduler_config
-            scheduler = instantiate_from_config(self.scheduler_config)
-
-            print("Setting up LambdaLR scheduler...")
-            scheduler = [
-                {
-                    'scheduler': LambdaLR(opt, lr_lambda=scheduler.schedule),
-                    'interval': 'step',
-                    'frequency': 1
-                }]
-            return [opt], scheduler
-        return opt
-
-    @torch.no_grad()
-    def to_rgb(self, x):
-        x = x.float()
-        if not hasattr(self, "colorize"):
-            self.colorize = torch.randn(3, x.shape[1], 1, 1).to(x)
-        x = nn.functional.conv2d(x, weight=self.colorize)
-        x = 2. * (x - x.min()) / (x.max() - x.min()) - 1.
-        return x
-
-
-class LatentFinetuneDiffusion(LatentDiffusion_audio):
-    """
-         Basis for different finetunas, such as inpainting or depth2image
-         To disable finetuning mode, set finetune_keys to None
-    """
-
-    def __init__(self,
-                 concat_keys: tuple,
-                 finetune_keys=("model.diffusion_model.input_blocks.0.0.weight",
-                                "model_ema.diffusion_modelinput_blocks00weight"
-                                ),
-                 keep_finetune_dims=4,
-                 # if model was trained without concat mode before and we would like to keep these channels
-                 c_concat_log_start=None,  # to log reconstruction of c_concat codes
-                 c_concat_log_end=None,
-                 *args, **kwargs
-                 ):
-        ckpt_path = kwargs.pop("ckpt_path", None)
-        ignore_keys = kwargs.pop("ignore_keys", list())
-        super().__init__(*args, **kwargs)
-        self.finetune_keys = finetune_keys
-        self.concat_keys = concat_keys
-        self.keep_dims = keep_finetune_dims
-        self.c_concat_log_start = c_concat_log_start
-        self.c_concat_log_end = c_concat_log_end
-
-        if exists(self.finetune_keys): assert exists(ckpt_path), 'can only finetune from a given checkpoint'
-        if exists(ckpt_path):
-            self.init_from_ckpt(ckpt_path, ignore_keys)
-
-    def init_from_ckpt(self, path, ignore_keys=list(), only_model=False):
-        sd = torch.load(path, map_location="cpu")
-        if "state_dict" in list(sd.keys()):
-            sd = sd["state_dict"]
-        keys = list(sd.keys())
-
-        for k in keys:
-            for ik in ignore_keys:
-                if k.startswith(ik):
-                    print("Deleting key {} from state_dict.".format(k))
-                    del sd[k]
-
-            # make it explicit, finetune by including extra input channels
-            if exists(self.finetune_keys) and k in self.finetune_keys:
-                new_entry = None
-                for name, param in self.named_parameters():
-                    if name in self.finetune_keys:
-                        print(
-                            f"modifying key '{name}' and keeping its original {self.keep_dims} (channels) dimensions only")
-                        new_entry = torch.zeros_like(param)  # zero init
-                assert exists(new_entry), 'did not find matching parameter to modify'
-                new_entry[:, :self.keep_dims, ...] = sd[k]
-                sd[k] = new_entry
-
-        missing, unexpected = self.load_state_dict(sd, strict=False) if not only_model else self.model.load_state_dict(sd, strict=False)
-        print(f"Restored from {path} with {len(missing)} missing and {len(unexpected)} unexpected keys")
-        if len(missing) > 0:
-            print(f"Missing Keys: {missing}")
-        if len(unexpected) > 0:
-            print(f"Unexpected Keys: {unexpected}")
-
-    @torch.no_grad()
-    def log_images(self, batch, N=8, n_row=4, sample=True, ddim_steps=200, ddim_eta=1., return_keys=None,
-                   quantize_denoised=True, inpaint=True, plot_denoise_rows=False, plot_progressive_rows=True,
-                   plot_diffusion_rows=True, unconditional_guidance_scale=1., unconditional_guidance_label=None,
-                   use_ema_scope=True,
-                   **kwargs):
-        use_ddim = ddim_steps is not None
-
-        log = dict()
-        z, c, x, xrec, xc = self.get_input(batch, self.first_stage_key, bs=N, return_first_stage_outputs=True)
-        c_cat, c = c["c_concat"][0], c["c_crossattn"][0]
-        N = min(x.shape[0], N)
-        n_row = min(x.shape[0], n_row)
-        log["inputs"] = x
-        log["reconstruction"] = xrec
-        if self.model.conditioning_key is not None:
-            if hasattr(self.cond_stage_model, "decode"):
-                xc = self.cond_stage_model.decode(c)
-                log["conditioning"] = xc
-            elif self.cond_stage_key in ["caption"]:
-                xc = log_txt_as_img((x.shape[2], x.shape[3]), batch["caption"])
-                log["conditioning"] = xc
-            elif self.cond_stage_key == 'class_label':
-                xc = log_txt_as_img((x.shape[2], x.shape[3]), batch["human_label"])
-                log['conditioning'] = xc
-            elif isimage(xc):
-                log["conditioning"] = xc
-            if ismap(xc):
-                log["original_conditioning"] = self.to_rgb(xc)
-
-        if not (self.c_concat_log_start is None and self.c_concat_log_end is None):
-            log["c_concat_decoded"] = self.decode_first_stage(c_cat[:, self.c_concat_log_start:self.c_concat_log_end])
-
-        if plot_diffusion_rows:
-            # get diffusion row
-            diffusion_row = list()
-            z_start = z[:n_row]
-            for t in range(self.num_timesteps):
-                if t % self.log_every_t == 0 or t == self.num_timesteps - 1:
-                    t = repeat(torch.tensor([t]), '1 -> b', b=n_row)
-                    t = t.to(self.device).long()
-                    noise = torch.randn_like(z_start)
-                    z_noisy = self.q_sample(x_start=z_start, t=t, noise=noise)
-                    diffusion_row.append(self.decode_first_stage(z_noisy))
-
-            diffusion_row = torch.stack(diffusion_row)  # n_log_step, n_row, C, H, W
-            diffusion_grid = rearrange(diffusion_row, 'n b c h w -> b n c h w')
-            diffusion_grid = rearrange(diffusion_grid, 'b n c h w -> (b n) c h w')
-            diffusion_grid = make_grid(diffusion_grid, nrow=diffusion_row.shape[0])
-            log["diffusion_row"] = diffusion_grid
-
-        if sample:
-            # get denoise row
-            with self.ema_scope("Sampling"):
-                samples, z_denoise_row = self.sample_log(cond={"c_concat": [c_cat], "c_crossattn": [c]},
-                                                         batch_size=N, ddim=use_ddim,
-                                                         ddim_steps=ddim_steps, eta=ddim_eta)
-                # samples, z_denoise_row = self.sample(cond=c, batch_size=N, return_intermediates=True)
-            x_samples = self.decode_first_stage(samples)
-            log["samples"] = x_samples
-            if plot_denoise_rows:
-                denoise_grid = self._get_denoise_row_from_list(z_denoise_row)
-                log["denoise_row"] = denoise_grid
-
-        if unconditional_guidance_scale > 1.0:
-            uc_cross = self.get_unconditional_conditioning(N, unconditional_guidance_label)
-            uc_cat = c_cat
-            uc_full = {"c_concat": [uc_cat], "c_crossattn": [uc_cross]}
-            with self.ema_scope("Sampling with classifier-free guidance"):
-                samples_cfg, _ = self.sample_log(cond={"c_concat": [c_cat], "c_crossattn": [c]},
-                                                 batch_size=N, ddim=use_ddim,
-                                                 ddim_steps=ddim_steps, eta=ddim_eta,
-                                                 unconditional_guidance_scale=unconditional_guidance_scale,
-                                                 unconditional_conditioning=uc_full,
-                                                 )
-                x_samples_cfg = self.decode_first_stage(samples_cfg)
-                log[f"samples_cfg_scale_{unconditional_guidance_scale:.2f}"] = x_samples_cfg
-
-        return log
-
-
-class LatentInpaintDiffusion(LatentFinetuneDiffusion):
-    """
-    can either run as pure inpainting model (only concat mode) or with mixed conditionings,
-    e.g. mask as concat and text via cross-attn.
-    To disable finetuning mode, set finetune_keys to None
-     """
-
-    def __init__(self,
-                 concat_keys=("mask", "masked_image"),
-                 masked_image_key="masked_image",
-                 *args, **kwargs
-                 ):
-        super().__init__(concat_keys, *args, **kwargs)
-        self.masked_image_key = masked_image_key
-        assert self.masked_image_key in concat_keys
-
-    @torch.no_grad()
-    def get_input(self, batch, k, cond_key=None, bs=None, return_first_stage_outputs=False):
-        # note: restricted to non-trainable encoders currently
-        assert not self.cond_stage_trainable, 'trainable cond stages not yet supported for inpainting'
-        z, c, x, xrec, xc = super().get_input(batch, self.first_stage_key, return_first_stage_outputs=True,
-                                              force_c_encode=True, return_original_cond=True, bs=bs)
-
-        assert exists(self.concat_keys)
-        c_cat = list()
-        for ck in self.concat_keys:
-            if len(batch[ck].shape) == 3:
-                batch[ck] = batch[ck][..., None]
-            cc = rearrange(batch[ck], 'b h w c -> b c h w').to(memory_format=torch.contiguous_format).float()
-            if bs is not None:
-                cc = cc[:bs]
-                cc = cc.to(self.device)
-            bchw = z.shape
-            if ck != self.masked_image_key:
-                cc = torch.nn.functional.interpolate(cc, size=bchw[-2:])
-            else:
-                cc = self.get_first_stage_encoding(self.encode_first_stage(cc))
-            c_cat.append(cc)
-        c_cat = torch.cat(c_cat, dim=1)
-        all_conds = {"c_concat": [c_cat], "c_crossattn": [c]}
-        if return_first_stage_outputs:
-            return z, all_conds, x, xrec, xc
-        return z, all_conds
-
-    @torch.no_grad()
-    def log_images(self, *args, **kwargs):
-        log = super(LatentInpaintDiffusion, self).log_images(*args, **kwargs)
-        log["masked_image"] = rearrange(args[0]["masked_image"],
-                                        'b h w c -> b c h w').to(memory_format=torch.contiguous_format).float()
-        return log

spaces/AIGE/A_B/README.md

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

spaces/AIZeroToHero/04-Image2OCR/app.py

@@ -1,54 +0,0 @@
-import pandas as pd
-import PIL
-from PIL import Image
-from PIL import ImageDraw
-import gradio as gr
-import torch
-import easyocr
-
-torch.hub.download_url_to_file('https://github.com/JaidedAI/EasyOCR/raw/master/examples/english.png', 'english.png')
-torch.hub.download_url_to_file('https://github.com/JaidedAI/EasyOCR/raw/master/examples/chinese.jpg', 'chinese.jpg')
-torch.hub.download_url_to_file('https://github.com/JaidedAI/EasyOCR/raw/master/examples/japanese.jpg', 'japanese.jpg')
-torch.hub.download_url_to_file('https://i.imgur.com/mwQFd7G.jpeg', 'Hindi.jpeg')
-
-def draw_boxes(image, bounds, color='yellow', width=2):
-    draw = ImageDraw.Draw(image)
-    for bound in bounds:
-        p0, p1, p2, p3 = bound[0]
-        draw.line([*p0, *p1, *p2, *p3, *p0], fill=color, width=width)
-    return image
-
-def inference(img, lang):
-    reader = easyocr.Reader(lang)
-    bounds = reader.readtext(img.name)
-    im = PIL.Image.open(img.name)
-    draw_boxes(im, bounds)
-    im.save('result.jpg')
-    return ['result.jpg', pd.DataFrame(bounds).iloc[: , 1:]]
-
-title = 'Image To Optical Character Recognition'
-description = 'Multilingual OCR which works conveniently on all devices in multiple languages.'
-article = "<p style='text-align: center'></p>"
-examples = [['english.png',['en']],['chinese.jpg',['ch_sim', 'en']],['japanese.jpg',['ja', 'en']],['Hindi.jpeg',['hi', 'en']]]
-css = ".output_image, .input_image {height: 40rem !important; width: 100% !important;}"
-choices = [
-    "ch_sim",
-    "ch_tra",
-    "de",
-    "en",
-    "es",
-    "ja",
-    "hi",
-    "ru"
-]
-gr.Interface(
-    inference,
-    [gr.inputs.Image(type='file', label='Input'),gr.inputs.CheckboxGroup(choices, type="value", default=['en'], label='language')],
-    [gr.outputs.Image(type='file', label='Output'), gr.outputs.Dataframe(headers=['text', 'confidence'])],
-    title=title,
-    description=description,
-    article=article,
-    examples=examples,
-    css=css,
-    enable_queue=True
-    ).launch(debug=True)

spaces/AP123/dreamgaussian/process.py

@@ -1,92 +0,0 @@
-import os
-import glob
-import sys
-import cv2
-import argparse
-import numpy as np
-import matplotlib.pyplot as plt
-
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-from torchvision import transforms
-from PIL import Image
-import rembg
-
-class BLIP2():
-    def __init__(self, device='cuda'):
-        self.device = device
-        from transformers import AutoProcessor, Blip2ForConditionalGeneration
-        self.processor = AutoProcessor.from_pretrained("Salesforce/blip2-opt-2.7b")
-        self.model = Blip2ForConditionalGeneration.from_pretrained("Salesforce/blip2-opt-2.7b", torch_dtype=torch.float16).to(device)
-
-    @torch.no_grad()
-    def __call__(self, image):
-        image = Image.fromarray(image)
-        inputs = self.processor(image, return_tensors="pt").to(self.device, torch.float16)
-
-        generated_ids = self.model.generate(**inputs, max_new_tokens=20)
-        generated_text = self.processor.batch_decode(generated_ids, skip_special_tokens=True)[0].strip()
-
-        return generated_text
-
-
-if __name__ == '__main__':
-
-    parser = argparse.ArgumentParser()
-    parser.add_argument('path', type=str, help="path to image (png, jpeg, etc.)")
-    parser.add_argument('--model', default='u2net', type=str, help="rembg model, see https://github.com/danielgatis/rembg#models")
-    parser.add_argument('--size', default=256, type=int, help="output resolution")
-    parser.add_argument('--border_ratio', default=0.2, type=float, help="output border ratio")
-    parser.add_argument('--recenter', type=bool, default=True, help="recenter, potentially not helpful for multiview zero123")    
-    opt = parser.parse_args()
-
-    session = rembg.new_session(model_name=opt.model)
-
-    if os.path.isdir(opt.path):
-        print(f'[INFO] processing directory {opt.path}...')
-        files = glob.glob(f'{opt.path}/*')
-        out_dir = opt.path
-    else: # isfile
-        files = [opt.path]
-        out_dir = os.path.dirname(opt.path)
-    
-    for file in files:
-
-        out_base = os.path.basename(file).split('.')[0]
-        out_rgba = os.path.join(out_dir, out_base + '_rgba.png')
-
-        # load image
-        print(f'[INFO] loading image {file}...')
-        image = cv2.imread(file, cv2.IMREAD_UNCHANGED)
-        
-        # carve background
-        print(f'[INFO] background removal...')
-        carved_image = rembg.remove(image, session=session) # [H, W, 4]
-        mask = carved_image[..., -1] > 0
-
-        # recenter
-        if opt.recenter:
-            print(f'[INFO] recenter...')
-            final_rgba = np.zeros((opt.size, opt.size, 4), dtype=np.uint8)
-            
-            coords = np.nonzero(mask)
-            x_min, x_max = coords[0].min(), coords[0].max()
-            y_min, y_max = coords[1].min(), coords[1].max()
-            h = x_max - x_min
-            w = y_max - y_min
-            desired_size = int(opt.size * (1 - opt.border_ratio))
-            scale = desired_size / max(h, w)
-            h2 = int(h * scale)
-            w2 = int(w * scale)
-            x2_min = (opt.size - h2) // 2
-            x2_max = x2_min + h2
-            y2_min = (opt.size - w2) // 2
-            y2_max = y2_min + w2
-            final_rgba[x2_min:x2_max, y2_min:y2_max] = cv2.resize(carved_image[x_min:x_max, y_min:y_max], (w2, h2), interpolation=cv2.INTER_AREA)
-            
-        else:
-            final_rgba = carved_image
-        
-        # write image
-        cv2.imwrite(out_rgba, final_rgba)

spaces/AchyuthGamer/OpenGPT/g4f/Provider/deprecated/Lockchat.py

@@ -1,64 +0,0 @@
-from __future__ import annotations
-
-import json
-
-import requests
-
-from ...typing import Any, CreateResult
-from ..base_provider import BaseProvider
-
-
-class Lockchat(BaseProvider):
-    url: str              = "http://supertest.lockchat.app"
-    supports_stream       = True
-    supports_gpt_35_turbo = True
-    supports_gpt_4        = True
-
-    @staticmethod
-    def create_completion(
-        model: str,
-        messages: list[dict[str, str]],
-        stream: bool, **kwargs: Any) -> CreateResult:
-
-        temperature = float(kwargs.get("temperature", 0.7))
-        payload = {
-            "temperature": temperature,
-            "messages"   : messages,
-            "model"      : model,
-            "stream"     : True,
-        }
-
-        headers = {
-            "user-agent": "ChatX/39 CFNetwork/1408.0.4 Darwin/22.5.0",
-        }
-        response = requests.post("http://supertest.lockchat.app/v1/chat/completions",
-                                 json=payload, headers=headers, stream=True)
-        
-        response.raise_for_status()
-        for token in response.iter_lines():
-            if b"The model: `gpt-4` does not exist" in token:
-                print("error, retrying...")
-                Lockchat.create_completion(
-                    model       = model,
-                    messages    = messages,
-                    stream      = stream,
-                    temperature = temperature,
-                    **kwargs)
-            
-            if b"content" in token:
-                token = json.loads(token.decode("utf-8").split("data: ")[1])
-                token = token["choices"][0]["delta"].get("content")
-                if token:
-                    yield (token)
-
-    @classmethod
-    @property
-    def params(cls):
-        params = [
-            ("model", "str"),
-            ("messages", "list[dict[str, str]]"),
-            ("stream", "bool"),
-            ("temperature", "float"),
-        ]
-        param = ", ".join([": ".join(p) for p in params])
-        return f"g4f.provider.{cls.__name__} supports: ({param})"

spaces/AiMimicry/sovits-models/inference_main.py

@@ -1,130 +0,0 @@
-import io
-import logging
-import time
-from pathlib import Path
-
-import librosa
-import matplotlib.pyplot as plt
-import numpy as np
-import soundfile
-
-from inference import infer_tool
-from inference import slicer
-from inference.infer_tool import Svc
-
-logging.getLogger('numba').setLevel(logging.WARNING)
-chunks_dict = infer_tool.read_temp("inference/chunks_temp.json")
-
-
-
-def main():
-    import argparse
-
-    parser = argparse.ArgumentParser(description='sovits4 inference')
-
-    # 一定要设置的部分
-    parser.add_argument('-m', '--model_path', type=str, default="logs/44k/G_0.pth", help='模型路径')
-    parser.add_argument('-c', '--config_path', type=str, default="configs/config.json", help='配置文件路径')
-    parser.add_argument('-cl', '--clip', type=float, default=0, help='音频强制切片，默认0为自动切片，单位为秒/s')
-    parser.add_argument('-n', '--clean_names', type=str, nargs='+', default=["君の知らない物語-src.wav"], help='wav文件名列表，放在raw文件夹下')
-    parser.add_argument('-t', '--trans', type=int, nargs='+', default=[0], help='音高调整，支持正负（半音）')
-    parser.add_argument('-s', '--spk_list', type=str, nargs='+', default=['nen'], help='合成目标说话人名称')
-
-    # 可选项部分
-    parser.add_argument('-a', '--auto_predict_f0', action='store_true', default=False,help='语音转换自动预测音高，转换歌声时不要打开这个会严重跑调')
-    parser.add_argument('-cm', '--cluster_model_path', type=str, default="logs/44k/kmeans_10000.pt", help='聚类模型路径，如果没有训练聚类则随便填')
-    parser.add_argument('-cr', '--cluster_infer_ratio', type=float, default=0, help='聚类方案占比，范围0-1，若没有训练聚类模型则默认0即可')
-    parser.add_argument('-lg', '--linear_gradient', type=float, default=0, help='两段音频切片的交叉淡入长度，如果强制切片后出现人声不连贯可调整该数值，如果连贯建议采用默认值0，单位为秒')
-    parser.add_argument('-fmp', '--f0_mean_pooling', type=bool, default=False, help='是否对F0使用均值滤波器(池化)，对部分哑音有改善。注意，启动该选项会导致推理速度下降，默认关闭')
-
-    # 不用动的部分
-    parser.add_argument('-sd', '--slice_db', type=int, default=-40, help='默认-40，嘈杂的音频可以-30，干声保留呼吸可以-50')
-    parser.add_argument('-d', '--device', type=str, default=None, help='推理设备，None则为自动选择cpu和gpu')
-    parser.add_argument('-ns', '--noice_scale', type=float, default=0.4, help='噪音级别，会影响咬字和音质，较为玄学')
-    parser.add_argument('-p', '--pad_seconds', type=float, default=0.5, help='推理音频pad秒数，由于未知原因开头结尾会有异响，pad一小段静音段后就不会出现')
-    parser.add_argument('-wf', '--wav_format', type=str, default='flac', help='音频输出格式')
-    parser.add_argument('-lgr', '--linear_gradient_retain', type=float, default=0.75, help='自动音频切片后，需要舍弃每段切片的头尾。该参数设置交叉长度保留的比例，范围0-1,左开右闭')
-
-    args = parser.parse_args()
-
-    svc_model = Svc(args.model_path, args.config_path, args.device, args.cluster_model_path)
-    infer_tool.mkdir(["raw", "results"])
-    clean_names = args.clean_names
-    trans = args.trans
-    spk_list = args.spk_list
-    slice_db = args.slice_db
-    wav_format = args.wav_format
-    auto_predict_f0 = args.auto_predict_f0
-    cluster_infer_ratio = args.cluster_infer_ratio
-    noice_scale = args.noice_scale
-    pad_seconds = args.pad_seconds
-    clip = args.clip
-    lg = args.linear_gradient
-    lgr = args.linear_gradient_retain
-    F0_mean_pooling = args.f0_mean_pooling
-
-    infer_tool.fill_a_to_b(trans, clean_names)
-    for clean_name, tran in zip(clean_names, trans):
-        raw_audio_path = f"raw/{clean_name}"
-        if "." not in raw_audio_path:
-            raw_audio_path += ".wav"
-        infer_tool.format_wav(raw_audio_path)
-        wav_path = Path(raw_audio_path).with_suffix('.wav')
-        chunks = slicer.cut(wav_path, db_thresh=slice_db)
-        audio_data, audio_sr = slicer.chunks2audio(wav_path, chunks)
-        per_size = int(clip*audio_sr)
-        lg_size = int(lg*audio_sr)
-        lg_size_r = int(lg_size*lgr)
-        lg_size_c_l = (lg_size-lg_size_r)//2
-        lg_size_c_r = lg_size-lg_size_r-lg_size_c_l
-        lg = np.linspace(0,1,lg_size_r) if lg_size!=0 else 0
-
-        for spk in spk_list:
-            audio = []
-            for (slice_tag, data) in audio_data:
-                print(f'#=====segment start, {round(len(data) / audio_sr, 3)}s======')
-                
-                length = int(np.ceil(len(data) / audio_sr * svc_model.target_sample))
-                if slice_tag:
-                    print('jump empty segment')
-                    _audio = np.zeros(length)
-                    audio.extend(list(infer_tool.pad_array(_audio, length)))
-                    continue
-                if per_size != 0:
-                    datas = infer_tool.split_list_by_n(data, per_size,lg_size)
-                else:
-                    datas = [data]
-                for k,dat in enumerate(datas):
-                    per_length = int(np.ceil(len(dat) / audio_sr * svc_model.target_sample)) if clip!=0 else length
-                    if clip!=0: print(f'###=====segment clip start, {round(len(dat) / audio_sr, 3)}s======')
-                    # padd
-                    pad_len = int(audio_sr * pad_seconds)
-                    dat = np.concatenate([np.zeros([pad_len]), dat, np.zeros([pad_len])])
-                    raw_path = io.BytesIO()
-                    soundfile.write(raw_path, dat, audio_sr, format="wav")
-                    raw_path.seek(0)
-                    out_audio, out_sr = svc_model.infer(spk, tran, raw_path,
-                                                        cluster_infer_ratio=cluster_infer_ratio,
-                                                        auto_predict_f0=auto_predict_f0,
-                                                        noice_scale=noice_scale,
-                                                        F0_mean_pooling = F0_mean_pooling
-                                                        )
-                    _audio = out_audio.cpu().numpy()
-                    pad_len = int(svc_model.target_sample * pad_seconds)
-                    _audio = _audio[pad_len:-pad_len]
-                    _audio = infer_tool.pad_array(_audio, per_length)
-                    if lg_size!=0 and k!=0:
-                        lg1 = audio[-(lg_size_r+lg_size_c_r):-lg_size_c_r] if lgr != 1 else audio[-lg_size:]
-                        lg2 = _audio[lg_size_c_l:lg_size_c_l+lg_size_r]  if lgr != 1 else _audio[0:lg_size]
-                        lg_pre = lg1*(1-lg)+lg2*lg
-                        audio = audio[0:-(lg_size_r+lg_size_c_r)] if lgr != 1 else audio[0:-lg_size]
-                        audio.extend(lg_pre)
-                        _audio = _audio[lg_size_c_l+lg_size_r:] if lgr != 1 else _audio[lg_size:]
-                    audio.extend(list(_audio))
-            key = "auto" if auto_predict_f0 else f"{tran}key"
-            cluster_name = "" if cluster_infer_ratio == 0 else f"_{cluster_infer_ratio}"
-            res_path = f'./results/{clean_name}_{key}_{spk}{cluster_name}.{wav_format}'
-            soundfile.write(res_path, audio, svc_model.target_sample, format=wav_format)
-
-if __name__ == '__main__':
-    main()

spaces/Akshay-Vs/GPT-Based-Generator/README.md

@@ -1,13 +0,0 @@
----
-title: GPT Based Generator
-emoji: 🦀
-colorFrom: blue
-colorTo: gray
-sdk: streamlit
-sdk_version: 1.10.0
-app_file: app.py
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/Alealejandrooo/deathCertReader/README.md

@@ -1,13 +0,0 @@
----
-title: DeathCertifReader
-emoji: 🔥
-colorFrom: pink
-colorTo: blue
-sdk: gradio
-sdk_version: 3.28.0
-app_file: app.py
-pinned: false
-duplicated_from: LumeraDS/deathCertReader
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/Alpaca233/SadTalker/src/face3d/models/arcface_torch/configs/glint360k_r18.py

@@ -1,26 +0,0 @@
-from easydict import EasyDict as edict
-
-# make training faster
-# our RAM is 256G
-# mount -t tmpfs -o size=140G  tmpfs /train_tmp
-
-config = edict()
-config.loss = "cosface"
-config.network = "r18"
-config.resume = False
-config.output = None
-config.embedding_size = 512
-config.sample_rate = 1.0
-config.fp16 = True
-config.momentum = 0.9
-config.weight_decay = 5e-4
-config.batch_size = 128
-config.lr = 0.1  # batch size is 512
-
-config.rec = "/train_tmp/glint360k"
-config.num_classes = 360232
-config.num_image = 17091657
-config.num_epoch = 20
-config.warmup_epoch = -1
-config.decay_epoch = [8, 12, 15, 18]
-config.val_targets = ["lfw", "cfp_fp", "agedb_30"]

spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/tests/pipelines/controlnet/test_controlnet_sdxl.py

@@ -1,260 +0,0 @@
-# coding=utf-8
-# Copyright 2023 HuggingFace Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import unittest
-
-import numpy as np
-import torch
-from transformers import CLIPTextConfig, CLIPTextModel, CLIPTextModelWithProjection, CLIPTokenizer
-
-from diffusers import (
-    AutoencoderKL,
-    ControlNetModel,
-    EulerDiscreteScheduler,
-    StableDiffusionXLControlNetPipeline,
-    UNet2DConditionModel,
-)
-from diffusers.utils import randn_tensor, torch_device
-from diffusers.utils.import_utils import is_xformers_available
-from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu
-
-from ..pipeline_params import (
-    IMAGE_TO_IMAGE_IMAGE_PARAMS,
-    TEXT_TO_IMAGE_BATCH_PARAMS,
-    TEXT_TO_IMAGE_IMAGE_PARAMS,
-    TEXT_TO_IMAGE_PARAMS,
-)
-from ..test_pipelines_common import (
-    PipelineKarrasSchedulerTesterMixin,
-    PipelineLatentTesterMixin,
-    PipelineTesterMixin,
-)
-
-
-enable_full_determinism()
-
-
-class ControlNetPipelineSDXLFastTests(
-    PipelineLatentTesterMixin, PipelineKarrasSchedulerTesterMixin, PipelineTesterMixin, unittest.TestCase
-):
-    pipeline_class = StableDiffusionXLControlNetPipeline
-    params = TEXT_TO_IMAGE_PARAMS
-    batch_params = TEXT_TO_IMAGE_BATCH_PARAMS
-    image_params = IMAGE_TO_IMAGE_IMAGE_PARAMS
-    image_latents_params = TEXT_TO_IMAGE_IMAGE_PARAMS
-
-    def get_dummy_components(self):
-        torch.manual_seed(0)
-        unet = UNet2DConditionModel(
-            block_out_channels=(32, 64),
-            layers_per_block=2,
-            sample_size=32,
-            in_channels=4,
-            out_channels=4,
-            down_block_types=("DownBlock2D", "CrossAttnDownBlock2D"),
-            up_block_types=("CrossAttnUpBlock2D", "UpBlock2D"),
-            # SD2-specific config below
-            attention_head_dim=(2, 4),
-            use_linear_projection=True,
-            addition_embed_type="text_time",
-            addition_time_embed_dim=8,
-            transformer_layers_per_block=(1, 2),
-            projection_class_embeddings_input_dim=80,  # 6 * 8 + 32
-            cross_attention_dim=64,
-        )
-        torch.manual_seed(0)
-        controlnet = ControlNetModel(
-            block_out_channels=(32, 64),
-            layers_per_block=2,
-            in_channels=4,
-            down_block_types=("DownBlock2D", "CrossAttnDownBlock2D"),
-            conditioning_embedding_out_channels=(16, 32),
-            # SD2-specific config below
-            attention_head_dim=(2, 4),
-            use_linear_projection=True,
-            addition_embed_type="text_time",
-            addition_time_embed_dim=8,
-            transformer_layers_per_block=(1, 2),
-            projection_class_embeddings_input_dim=80,  # 6 * 8 + 32
-            cross_attention_dim=64,
-        )
-        torch.manual_seed(0)
-        scheduler = EulerDiscreteScheduler(
-            beta_start=0.00085,
-            beta_end=0.012,
-            steps_offset=1,
-            beta_schedule="scaled_linear",
-            timestep_spacing="leading",
-        )
-        torch.manual_seed(0)
-        vae = AutoencoderKL(
-            block_out_channels=[32, 64],
-            in_channels=3,
-            out_channels=3,
-            down_block_types=["DownEncoderBlock2D", "DownEncoderBlock2D"],
-            up_block_types=["UpDecoderBlock2D", "UpDecoderBlock2D"],
-            latent_channels=4,
-        )
-        torch.manual_seed(0)
-        text_encoder_config = CLIPTextConfig(
-            bos_token_id=0,
-            eos_token_id=2,
-            hidden_size=32,
-            intermediate_size=37,
-            layer_norm_eps=1e-05,
-            num_attention_heads=4,
-            num_hidden_layers=5,
-            pad_token_id=1,
-            vocab_size=1000,
-            # SD2-specific config below
-            hidden_act="gelu",
-            projection_dim=32,
-        )
-        text_encoder = CLIPTextModel(text_encoder_config)
-        tokenizer = CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip")
-
-        text_encoder_2 = CLIPTextModelWithProjection(text_encoder_config)
-        tokenizer_2 = CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip")
-
-        components = {
-            "unet": unet,
-            "controlnet": controlnet,
-            "scheduler": scheduler,
-            "vae": vae,
-            "text_encoder": text_encoder,
-            "tokenizer": tokenizer,
-            "text_encoder_2": text_encoder_2,
-            "tokenizer_2": tokenizer_2,
-        }
-        return components
-
-    def get_dummy_inputs(self, device, seed=0):
-        if str(device).startswith("mps"):
-            generator = torch.manual_seed(seed)
-        else:
-            generator = torch.Generator(device=device).manual_seed(seed)
-
-        controlnet_embedder_scale_factor = 2
-        image = randn_tensor(
-            (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor),
-            generator=generator,
-            device=torch.device(device),
-        )
-
-        inputs = {
-            "prompt": "A painting of a squirrel eating a burger",
-            "generator": generator,
-            "num_inference_steps": 2,
-            "guidance_scale": 6.0,
-            "output_type": "numpy",
-            "image": image,
-        }
-
-        return inputs
-
-    def test_attention_slicing_forward_pass(self):
-        return self._test_attention_slicing_forward_pass(expected_max_diff=2e-3)
-
-    @unittest.skipIf(
-        torch_device != "cuda" or not is_xformers_available(),
-        reason="XFormers attention is only available with CUDA and `xformers` installed",
-    )
-    def test_xformers_attention_forwardGenerator_pass(self):
-        self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2e-3)
-
-    def test_inference_batch_single_identical(self):
-        self._test_inference_batch_single_identical(expected_max_diff=2e-3)
-
-    @require_torch_gpu
-    def test_stable_diffusion_xl_offloads(self):
-        pipes = []
-        components = self.get_dummy_components()
-        sd_pipe = self.pipeline_class(**components).to(torch_device)
-        pipes.append(sd_pipe)
-
-        components = self.get_dummy_components()
-        sd_pipe = self.pipeline_class(**components)
-        sd_pipe.enable_model_cpu_offload()
-        pipes.append(sd_pipe)
-
-        components = self.get_dummy_components()
-        sd_pipe = self.pipeline_class(**components)
-        sd_pipe.enable_sequential_cpu_offload()
-        pipes.append(sd_pipe)
-
-        image_slices = []
-        for pipe in pipes:
-            pipe.unet.set_default_attn_processor()
-
-            inputs = self.get_dummy_inputs(torch_device)
-            image = pipe(**inputs).images
-
-            image_slices.append(image[0, -3:, -3:, -1].flatten())
-
-        assert np.abs(image_slices[0] - image_slices[1]).max() < 1e-3
-        assert np.abs(image_slices[0] - image_slices[2]).max() < 1e-3
-
-    def test_stable_diffusion_xl_multi_prompts(self):
-        components = self.get_dummy_components()
-        sd_pipe = self.pipeline_class(**components).to(torch_device)
-
-        # forward with single prompt
-        inputs = self.get_dummy_inputs(torch_device)
-        output = sd_pipe(**inputs)
-        image_slice_1 = output.images[0, -3:, -3:, -1]
-
-        # forward with same prompt duplicated
-        inputs = self.get_dummy_inputs(torch_device)
-        inputs["prompt_2"] = inputs["prompt"]
-        output = sd_pipe(**inputs)
-        image_slice_2 = output.images[0, -3:, -3:, -1]
-
-        # ensure the results are equal
-        assert np.abs(image_slice_1.flatten() - image_slice_2.flatten()).max() < 1e-4
-
-        # forward with different prompt
-        inputs = self.get_dummy_inputs(torch_device)
-        inputs["prompt_2"] = "different prompt"
-        output = sd_pipe(**inputs)
-        image_slice_3 = output.images[0, -3:, -3:, -1]
-
-        # ensure the results are not equal
-        assert np.abs(image_slice_1.flatten() - image_slice_3.flatten()).max() > 1e-4
-
-        # manually set a negative_prompt
-        inputs = self.get_dummy_inputs(torch_device)
-        inputs["negative_prompt"] = "negative prompt"
-        output = sd_pipe(**inputs)
-        image_slice_1 = output.images[0, -3:, -3:, -1]
-
-        # forward with same negative_prompt duplicated
-        inputs = self.get_dummy_inputs(torch_device)
-        inputs["negative_prompt"] = "negative prompt"
-        inputs["negative_prompt_2"] = inputs["negative_prompt"]
-        output = sd_pipe(**inputs)
-        image_slice_2 = output.images[0, -3:, -3:, -1]
-
-        # ensure the results are equal
-        assert np.abs(image_slice_1.flatten() - image_slice_2.flatten()).max() < 1e-4
-
-        # forward with different negative_prompt
-        inputs = self.get_dummy_inputs(torch_device)
-        inputs["negative_prompt"] = "negative prompt"
-        inputs["negative_prompt_2"] = "different negative prompt"
-        output = sd_pipe(**inputs)
-        image_slice_3 = output.images[0, -3:, -3:, -1]
-
-        # ensure the results are not equal
-        assert np.abs(image_slice_1.flatten() - image_slice_3.flatten()).max() > 1e-4

spaces/Andy1621/uniformer_image_detection/mmdet/core/bbox/coder/yolo_bbox_coder.py

@@ -1,89 +0,0 @@
-import mmcv
-import torch
-
-from ..builder import BBOX_CODERS
-from .base_bbox_coder import BaseBBoxCoder
-
-
-@BBOX_CODERS.register_module()
-class YOLOBBoxCoder(BaseBBoxCoder):
-    """YOLO BBox coder.
-
-    Following `YOLO <https://arxiv.org/abs/1506.02640>`_, this coder divide
-    image into grids, and encode bbox (x1, y1, x2, y2) into (cx, cy, dw, dh).
-    cx, cy in [0., 1.], denotes relative center position w.r.t the center of
-    bboxes. dw, dh are the same as :obj:`DeltaXYWHBBoxCoder`.
-
-    Args:
-        eps (float): Min value of cx, cy when encoding.
-    """
-
-    def __init__(self, eps=1e-6):
-        super(BaseBBoxCoder, self).__init__()
-        self.eps = eps
-
-    @mmcv.jit(coderize=True)
-    def encode(self, bboxes, gt_bboxes, stride):
-        """Get box regression transformation deltas that can be used to
-        transform the ``bboxes`` into the ``gt_bboxes``.
-
-        Args:
-            bboxes (torch.Tensor): Source boxes, e.g., anchors.
-            gt_bboxes (torch.Tensor): Target of the transformation, e.g.,
-                ground-truth boxes.
-            stride (torch.Tensor | int): Stride of bboxes.
-
-        Returns:
-            torch.Tensor: Box transformation deltas
-        """
-
-        assert bboxes.size(0) == gt_bboxes.size(0)
-        assert bboxes.size(-1) == gt_bboxes.size(-1) == 4
-        x_center_gt = (gt_bboxes[..., 0] + gt_bboxes[..., 2]) * 0.5
-        y_center_gt = (gt_bboxes[..., 1] + gt_bboxes[..., 3]) * 0.5
-        w_gt = gt_bboxes[..., 2] - gt_bboxes[..., 0]
-        h_gt = gt_bboxes[..., 3] - gt_bboxes[..., 1]
-        x_center = (bboxes[..., 0] + bboxes[..., 2]) * 0.5
-        y_center = (bboxes[..., 1] + bboxes[..., 3]) * 0.5
-        w = bboxes[..., 2] - bboxes[..., 0]
-        h = bboxes[..., 3] - bboxes[..., 1]
-        w_target = torch.log((w_gt / w).clamp(min=self.eps))
-        h_target = torch.log((h_gt / h).clamp(min=self.eps))
-        x_center_target = ((x_center_gt - x_center) / stride + 0.5).clamp(
-            self.eps, 1 - self.eps)
-        y_center_target = ((y_center_gt - y_center) / stride + 0.5).clamp(
-            self.eps, 1 - self.eps)
-        encoded_bboxes = torch.stack(
-            [x_center_target, y_center_target, w_target, h_target], dim=-1)
-        return encoded_bboxes
-
-    @mmcv.jit(coderize=True)
-    def decode(self, bboxes, pred_bboxes, stride):
-        """Apply transformation `pred_bboxes` to `boxes`.
-
-        Args:
-            boxes (torch.Tensor): Basic boxes, e.g. anchors.
-            pred_bboxes (torch.Tensor): Encoded boxes with shape
-            stride (torch.Tensor | int): Strides of bboxes.
-
-        Returns:
-            torch.Tensor: Decoded boxes.
-        """
-        assert pred_bboxes.size(0) == bboxes.size(0)
-        assert pred_bboxes.size(-1) == bboxes.size(-1) == 4
-        x_center = (bboxes[..., 0] + bboxes[..., 2]) * 0.5
-        y_center = (bboxes[..., 1] + bboxes[..., 3]) * 0.5
-        w = bboxes[..., 2] - bboxes[..., 0]
-        h = bboxes[..., 3] - bboxes[..., 1]
-        # Get outputs x, y
-        x_center_pred = (pred_bboxes[..., 0] - 0.5) * stride + x_center
-        y_center_pred = (pred_bboxes[..., 1] - 0.5) * stride + y_center
-        w_pred = torch.exp(pred_bboxes[..., 2]) * w
-        h_pred = torch.exp(pred_bboxes[..., 3]) * h
-
-        decoded_bboxes = torch.stack(
-            (x_center_pred - w_pred / 2, y_center_pred - h_pred / 2,
-             x_center_pred + w_pred / 2, y_center_pred + h_pred / 2),
-            dim=-1)
-
-        return decoded_bboxes

spaces/Andy1621/uniformer_image_detection/mmdet/datasets/pipelines/compose.py

@@ -1,51 +0,0 @@
-import collections
-
-from mmcv.utils import build_from_cfg
-
-from ..builder import PIPELINES
-
-
-@PIPELINES.register_module()
-class Compose(object):
-    """Compose multiple transforms sequentially.
-
-    Args:
-        transforms (Sequence[dict | callable]): Sequence of transform object or
-            config dict to be composed.
-    """
-
-    def __init__(self, transforms):
-        assert isinstance(transforms, collections.abc.Sequence)
-        self.transforms = []
-        for transform in transforms:
-            if isinstance(transform, dict):
-                transform = build_from_cfg(transform, PIPELINES)
-                self.transforms.append(transform)
-            elif callable(transform):
-                self.transforms.append(transform)
-            else:
-                raise TypeError('transform must be callable or a dict')
-
-    def __call__(self, data):
-        """Call function to apply transforms sequentially.
-
-        Args:
-            data (dict): A result dict contains the data to transform.
-
-        Returns:
-           dict: Transformed data.
-        """
-
-        for t in self.transforms:
-            data = t(data)
-            if data is None:
-                return None
-        return data
-
-    def __repr__(self):
-        format_string = self.__class__.__name__ + '('
-        for t in self.transforms:
-            format_string += '\n'
-            format_string += f'    {t}'
-        format_string += '\n)'
-        return format_string

spaces/Andy1621/uniformer_image_detection/mmdet/models/backbones/uniformer.py

@@ -1,422 +0,0 @@
-# --------------------------------------------------------
-# UniFormer
-# Copyright (c) 2022 SenseTime X-Lab
-# Licensed under The MIT License [see LICENSE for details]
-# Written by Kunchang Li
-# --------------------------------------------------------
-
-from collections import OrderedDict
-import math
-
-from functools import partial
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-import torch.utils.checkpoint as checkpoint
-import numpy as np
-from timm.models.layers import DropPath, to_2tuple, trunc_normal_
-
-from mmcv_custom import load_checkpoint
-from mmdet.utils import get_root_logger
-from ..builder import BACKBONES
-
-
-class Mlp(nn.Module):
-    def __init__(self, in_features, hidden_features=None, out_features=None, act_layer=nn.GELU, drop=0.):
-        super().__init__()
-        out_features = out_features or in_features
-        hidden_features = hidden_features or in_features
-        self.fc1 = nn.Linear(in_features, hidden_features)
-        self.act = act_layer()
-        self.fc2 = nn.Linear(hidden_features, out_features)
-        self.drop = nn.Dropout(drop)
-
-    def forward(self, x):
-        x = self.fc1(x)
-        x = self.act(x)
-        x = self.drop(x)
-        x = self.fc2(x)
-        x = self.drop(x)
-        return x
-
-
-class CMlp(nn.Module):
-    def __init__(self, in_features, hidden_features=None, out_features=None, act_layer=nn.GELU, drop=0.):
-        super().__init__()
-        out_features = out_features or in_features
-        hidden_features = hidden_features or in_features
-        self.fc1 = nn.Conv2d(in_features, hidden_features, 1)
-        self.act = act_layer()
-        self.fc2 = nn.Conv2d(hidden_features, out_features, 1)
-        self.drop = nn.Dropout(drop)
-
-    def forward(self, x):
-        x = self.fc1(x)
-        x = self.act(x)
-        x = self.drop(x)
-        x = self.fc2(x)
-        x = self.drop(x)
-        return x
-
-
-class CBlock(nn.Module):
-    def __init__(self, dim, num_heads, mlp_ratio=4., qkv_bias=False, qk_scale=None, drop=0., attn_drop=0.,
-                 drop_path=0., act_layer=nn.GELU, norm_layer=nn.LayerNorm):
-        super().__init__()
-        self.pos_embed = nn.Conv2d(dim, dim, 3, padding=1, groups=dim)
-        self.norm1 = nn.BatchNorm2d(dim)
-        self.conv1 = nn.Conv2d(dim, dim, 1)
-        self.conv2 = nn.Conv2d(dim, dim, 1)
-        self.attn = nn.Conv2d(dim, dim, 5, padding=2, groups=dim)
-        # NOTE: drop path for stochastic depth, we shall see if this is better than dropout here
-        self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity()
-        self.norm2 = nn.BatchNorm2d(dim)
-        mlp_hidden_dim = int(dim * mlp_ratio)
-        self.mlp = CMlp(in_features=dim, hidden_features=mlp_hidden_dim, act_layer=act_layer, drop=drop)
-
-    def forward(self, x):
-        x = x + self.pos_embed(x)
-        x = x + self.drop_path(self.conv2(self.attn(self.conv1(self.norm1(x)))))
-        x = x + self.drop_path(self.mlp(self.norm2(x)))
-        return x
-
-
-class Attention(nn.Module):
-    def __init__(self, dim, num_heads=8, qkv_bias=False, qk_scale=None, attn_drop=0., proj_drop=0.):
-        super().__init__()
-        self.num_heads = num_heads
-        head_dim = dim // num_heads
-        # NOTE scale factor was wrong in my original version, can set manually to be compat with prev weights
-        self.scale = qk_scale or head_dim ** -0.5
-
-        self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias)
-        self.attn_drop = nn.Dropout(attn_drop)
-        self.proj = nn.Linear(dim, dim)
-        self.proj_drop = nn.Dropout(proj_drop)
-
-    def forward(self, x):
-        B, N, C = x.shape
-        qkv = self.qkv(x).reshape(B, N, 3, self.num_heads, C // self.num_heads).permute(2, 0, 3, 1, 4)
-        q, k, v = qkv[0], qkv[1], qkv[2]   # make torchscript happy (cannot use tensor as tuple)
-
-        attn = (q @ k.transpose(-2, -1)) * self.scale
-        attn = attn.softmax(dim=-1)
-        attn = self.attn_drop(attn)
-
-        x = (attn @ v).transpose(1, 2).reshape(B, N, C)
-        x = self.proj(x)
-        x = self.proj_drop(x)
-        return x
-
-
-class SABlock(nn.Module):
-    def __init__(self, dim, num_heads, mlp_ratio=4., qkv_bias=False, qk_scale=None, drop=0., attn_drop=0.,
-                 drop_path=0., act_layer=nn.GELU, norm_layer=nn.LayerNorm):
-        super().__init__()
-        self.pos_embed = nn.Conv2d(dim, dim, 3, padding=1, groups=dim)
-        self.norm1 = norm_layer(dim)
-        self.attn = Attention(
-            dim,
-            num_heads=num_heads, qkv_bias=qkv_bias, qk_scale=qk_scale,
-            attn_drop=attn_drop, proj_drop=drop)
-        # NOTE: drop path for stochastic depth, we shall see if this is better than dropout here
-        self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity()
-        self.norm2 = norm_layer(dim)
-        mlp_hidden_dim = int(dim * mlp_ratio)
-        self.mlp = Mlp(in_features=dim, hidden_features=mlp_hidden_dim, act_layer=act_layer, drop=drop)
-
-    def forward(self, x):
-        x = x + self.pos_embed(x)
-        B, N, H, W = x.shape
-        x = x.flatten(2).transpose(1, 2)
-        x = x + self.drop_path(self.attn(self.norm1(x)))
-        x = x + self.drop_path(self.mlp(self.norm2(x)))
-        x = x.transpose(1, 2).reshape(B, N, H, W)
-        return x   
-
-
-def window_partition(x, window_size):
-    """
-    Args:
-        x: (B, H, W, C)
-        window_size (int): window size
-    Returns:
-        windows: (num_windows*B, window_size, window_size, C)
-    """
-    B, H, W, C = x.shape
-    x = x.view(B, H // window_size, window_size, W // window_size, window_size, C)
-    windows = x.permute(0, 1, 3, 2, 4, 5).contiguous().view(-1, window_size, window_size, C)
-    return windows
-
-
-def window_reverse(windows, window_size, H, W):
-    """
-    Args:
-        windows: (num_windows*B, window_size, window_size, C)
-        window_size (int): Window size
-        H (int): Height of image
-        W (int): Width of image
-    Returns:
-        x: (B, H, W, C)
-    """
-    B = int(windows.shape[0] / (H * W / window_size / window_size))
-    x = windows.view(B, H // window_size, W // window_size, window_size, window_size, -1)
-    x = x.permute(0, 1, 3, 2, 4, 5).contiguous().view(B, H, W, -1)
-    return x
-
-
-class SABlock_Windows(nn.Module):
-    def __init__(self, dim, num_heads, window_size=14, mlp_ratio=4., qkv_bias=False, qk_scale=None, drop=0., attn_drop=0.,
-                 drop_path=0., act_layer=nn.GELU, norm_layer=nn.LayerNorm):
-        super().__init__()
-        self.window_size=window_size
-        self.pos_embed = nn.Conv2d(dim, dim, 3, padding=1, groups=dim)
-        self.norm1 = norm_layer(dim)
-        self.attn = Attention(
-            dim,
-            num_heads=num_heads, qkv_bias=qkv_bias, qk_scale=qk_scale,
-            attn_drop=attn_drop, proj_drop=drop)
-        # NOTE: drop path for stochastic depth, we shall see if this is better than dropout here
-        self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity()
-        self.norm2 = norm_layer(dim)
-        mlp_hidden_dim = int(dim * mlp_ratio)
-        self.mlp = Mlp(in_features=dim, hidden_features=mlp_hidden_dim, act_layer=act_layer, drop=drop)
-
-    def forward(self, x):
-        x = x + self.pos_embed(x)
-        x = x.permute(0, 2, 3, 1)
-        B, H, W, C = x.shape
-        shortcut = x
-        x = self.norm1(x)
-
-        pad_l = pad_t = 0
-        pad_r = (self.window_size - W % self.window_size) % self.window_size
-        pad_b = (self.window_size - H % self.window_size) % self.window_size
-        x = F.pad(x, (0, 0, pad_l, pad_r, pad_t, pad_b))
-        _, Hp, Wp, _ = x.shape
-        
-        x_windows = window_partition(x, self.window_size)  # nW*B, window_size, window_size, C
-        x_windows = x_windows.view(-1, self.window_size * self.window_size, C)  # nW*B, window_size*window_size, C
-
-        # W-MSA/SW-MSA
-        attn_windows = self.attn(x_windows)  # nW*B, window_size*window_size, C
-
-        # merge windows
-        attn_windows = attn_windows.view(-1, self.window_size, self.window_size, C)
-        x = window_reverse(attn_windows, self.window_size, Hp, Wp)  # B H' W' C
-
-        # reverse cyclic shift
-        if pad_r > 0 or pad_b > 0:
-            x = x[:, :H, :W, :].contiguous()
-
-        x = shortcut + self.drop_path(x)
-        x = x + self.drop_path(self.mlp(self.norm2(x)))
-        x = x.permute(0, 3, 1, 2).reshape(B, C, H, W)
-        return x 
-             
-
-class PatchEmbed(nn.Module):
-    """ Image to Patch Embedding
-    """
-    def __init__(self, img_size=224, patch_size=16, in_chans=3, embed_dim=768):
-        super().__init__()
-        img_size = to_2tuple(img_size)
-        patch_size = to_2tuple(patch_size)
-        num_patches = (img_size[1] // patch_size[1]) * (img_size[0] // patch_size[0])
-        self.img_size = img_size
-        self.patch_size = patch_size
-        self.num_patches = num_patches
-        self.norm = nn.LayerNorm(embed_dim)
-        self.proj = nn.Conv2d(in_chans, embed_dim, kernel_size=patch_size, stride=patch_size)
-
-    def forward(self, x):
-        B, _, H, W = x.shape
-        x = self.proj(x)
-        B, _, H, W = x.shape
-        x = x.flatten(2).transpose(1, 2)
-        x = self.norm(x)
-        x = x.reshape(B, H, W, -1).permute(0, 3, 1, 2).contiguous()
-        return x
-    
-
-@BACKBONES.register_module()   
-class UniFormer(nn.Module):
-    """ Vision Transformer
-    A PyTorch impl of : `An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale`  -
-        https://arxiv.org/abs/2010.11929
-    """
-    def __init__(self, layers=[3, 4, 8, 3], img_size=224, in_chans=3, num_classes=80, embed_dim=[64, 128, 320, 512],
-                 head_dim=64, mlp_ratio=4., qkv_bias=True, qk_scale=None, representation_size=None,
-                 drop_rate=0., attn_drop_rate=0., drop_path_rate=0., norm_layer=partial(nn.LayerNorm, eps=1e-6),
-                 pretrained_path=None, use_checkpoint=False, checkpoint_num=[0, 0, 0, 0], 
-                 windows=False, hybrid=False, window_size=14):
-        """
-        Args:
-            layer (list): number of block in each layer
-            img_size (int, tuple): input image size
-            in_chans (int): number of input channels
-            num_classes (int): number of classes for classification head
-            embed_dim (int): embedding dimension
-            head_dim (int): dimension 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
-            pretrained_path (str): path of pretrained model
-            use_checkpoint (bool): whether use checkpoint
-            checkpoint_num (list): index for using checkpoint in every stage
-            windows (bool): whether use window MHRA
-            hybrid (bool): whether use hybrid MHRA
-            window_size (int): size of window (>14)
-        """
-        super().__init__()
-        self.num_classes = num_classes
-        self.use_checkpoint = use_checkpoint
-        self.checkpoint_num = checkpoint_num
-        self.windows = windows
-        print(f'Use Checkpoint: {self.use_checkpoint}')
-        print(f'Checkpoint Number: {self.checkpoint_num}')
-        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_embed1 = PatchEmbed(
-            img_size=img_size, patch_size=4, in_chans=in_chans, embed_dim=embed_dim[0])
-        self.patch_embed2 = PatchEmbed(
-            img_size=img_size // 4, patch_size=2, in_chans=embed_dim[0], embed_dim=embed_dim[1])
-        self.patch_embed3 = PatchEmbed(
-            img_size=img_size // 8, patch_size=2, in_chans=embed_dim[1], embed_dim=embed_dim[2])
-        self.patch_embed4 = PatchEmbed(
-            img_size=img_size // 16, patch_size=2, in_chans=embed_dim[2], embed_dim=embed_dim[3])
-
-        self.pos_drop = nn.Dropout(p=drop_rate)
-        dpr = [x.item() for x in torch.linspace(0, drop_path_rate, sum(layers))]  # stochastic depth decay rule
-        num_heads = [dim // head_dim for dim in embed_dim]
-        self.blocks1 = nn.ModuleList([
-            CBlock(
-                dim=embed_dim[0], num_heads=num_heads[0], mlp_ratio=mlp_ratio, qkv_bias=qkv_bias, qk_scale=qk_scale,
-                drop=drop_rate, attn_drop=attn_drop_rate, drop_path=dpr[i], norm_layer=norm_layer)
-            for i in range(layers[0])])
-        self.norm1=norm_layer(embed_dim[0])
-        self.blocks2 = nn.ModuleList([
-            CBlock(
-                dim=embed_dim[1], num_heads=num_heads[1], mlp_ratio=mlp_ratio, qkv_bias=qkv_bias, qk_scale=qk_scale,
-                drop=drop_rate, attn_drop=attn_drop_rate, drop_path=dpr[i+layers[0]], norm_layer=norm_layer)
-            for i in range(layers[1])])
-        self.norm2 = norm_layer(embed_dim[1])
-        if self.windows:
-            print('Use local window for all blocks in stage3')
-            self.blocks3 = nn.ModuleList([
-            SABlock_Windows(
-                dim=embed_dim[2], num_heads=num_heads[2], window_size=window_size, mlp_ratio=mlp_ratio, qkv_bias=qkv_bias, qk_scale=qk_scale,
-                drop=drop_rate, attn_drop=attn_drop_rate, drop_path=dpr[i+layers[0]+layers[1]], norm_layer=norm_layer)
-            for i in range(layers[2])])
-        elif hybrid:
-            print('Use hybrid window for blocks in stage3')
-            block3 = []
-            for i in range(layers[2]):
-                if (i + 1) % 4 == 0:
-                    block3.append(SABlock(
-                    dim=embed_dim[2], num_heads=num_heads[2], mlp_ratio=mlp_ratio, qkv_bias=qkv_bias, qk_scale=qk_scale,
-                    drop=drop_rate, attn_drop=attn_drop_rate, drop_path=dpr[i+layers[0]+layers[1]], norm_layer=norm_layer))
-                else:
-                    block3.append(SABlock_Windows(
-                    dim=embed_dim[2], num_heads=num_heads[2], window_size=window_size, mlp_ratio=mlp_ratio, qkv_bias=qkv_bias, qk_scale=qk_scale,
-                    drop=drop_rate, attn_drop=attn_drop_rate, drop_path=dpr[i+layers[0]+layers[1]], norm_layer=norm_layer))
-            self.blocks3 = nn.ModuleList(block3)
-        else:
-            print('Use global window for all blocks in stage3')
-            self.blocks3 = nn.ModuleList([
-            SABlock(
-                dim=embed_dim[2], num_heads=num_heads[2], mlp_ratio=mlp_ratio, qkv_bias=qkv_bias, qk_scale=qk_scale,
-                drop=drop_rate, attn_drop=attn_drop_rate, drop_path=dpr[i+layers[0]+layers[1]], norm_layer=norm_layer)
-            for i in range(layers[2])])
-        self.norm3 = norm_layer(embed_dim[2])
-        self.blocks4 = nn.ModuleList([
-            SABlock(
-                dim=embed_dim[3], num_heads=num_heads[3], mlp_ratio=mlp_ratio, qkv_bias=qkv_bias, qk_scale=qk_scale,
-                drop=drop_rate, attn_drop=attn_drop_rate, drop_path=dpr[i+layers[0]+layers[1]+layers[2]], norm_layer=norm_layer)
-            for i in range(layers[3])])
-        self.norm4 = norm_layer(embed_dim[3])
-        
-        # Representation layer
-        if representation_size:
-            self.num_features = representation_size
-            self.pre_logits = nn.Sequential(OrderedDict([
-                ('fc', nn.Linear(embed_dim, representation_size)),
-                ('act', nn.Tanh())
-            ]))
-        else:
-            self.pre_logits = nn.Identity()
-        
-        self.apply(self._init_weights)
-        self.init_weights(pretrained=pretrained_path)
-        
-    def init_weights(self, pretrained):
-        if isinstance(pretrained, str):
-            logger = get_root_logger()
-            load_checkpoint(self, pretrained, map_location='cpu', strict=False, logger=logger)
-            print(f'Load pretrained model from {pretrained}')
-    def _init_weights(self, m):
-        if isinstance(m, nn.Linear):
-            trunc_normal_(m.weight, std=.02)
-            if isinstance(m, nn.Linear) and m.bias is not None:
-                nn.init.constant_(m.bias, 0)
-        elif isinstance(m, nn.LayerNorm):
-            nn.init.constant_(m.bias, 0)
-            nn.init.constant_(m.weight, 1.0)
-
-    @torch.jit.ignore
-    def no_weight_decay(self):
-        return {'pos_embed', 'cls_token'}
-
-    def get_classifier(self):
-        return self.head
-
-    def reset_classifier(self, num_classes, global_pool=''):
-        self.num_classes = num_classes
-        self.head = nn.Linear(self.embed_dim, num_classes) if num_classes > 0 else nn.Identity()
-
-    def forward_features(self, x):
-        out = []
-        x = self.patch_embed1(x)
-        x = self.pos_drop(x)
-        for i, blk in enumerate(self.blocks1):
-            if self.use_checkpoint and i < self.checkpoint_num[0]:
-                x = checkpoint.checkpoint(blk, x)
-            else:
-                x = blk(x)
-        x_out = self.norm1(x.permute(0, 2, 3, 1))
-        out.append(x_out.permute(0, 3, 1, 2).contiguous())
-        x = self.patch_embed2(x)
-        for i, blk in enumerate(self.blocks2):
-            if self.use_checkpoint and i < self.checkpoint_num[1]:
-                x = checkpoint.checkpoint(blk, x)
-            else:
-                x = blk(x)
-        x_out = self.norm2(x.permute(0, 2, 3, 1))
-        out.append(x_out.permute(0, 3, 1, 2).contiguous())
-        x = self.patch_embed3(x)
-        for i, blk in enumerate(self.blocks3):
-            if self.use_checkpoint and i < self.checkpoint_num[2]:
-                x = checkpoint.checkpoint(blk, x)
-            else:
-                x = blk(x)
-        x_out = self.norm3(x.permute(0, 2, 3, 1))
-        out.append(x_out.permute(0, 3, 1, 2).contiguous())
-        x = self.patch_embed4(x)
-        for i, blk in enumerate(self.blocks4):
-            if self.use_checkpoint and i < self.checkpoint_num[3]:
-                x = checkpoint.checkpoint(blk, x)
-            else:
-                x = blk(x)
-        x_out = self.norm4(x.permute(0, 2, 3, 1))
-        out.append(x_out.permute(0, 3, 1, 2).contiguous())
-        return tuple(out)
-
-    def forward(self, x):
-        x = self.forward_features(x)
-        return x

spaces/Andy1621/uniformer_image_detection/mmdet/models/dense_heads/fsaf_head.py

@@ -1,422 +0,0 @@
-import numpy as np
-import torch
-from mmcv.cnn import normal_init
-from mmcv.runner import force_fp32
-
-from mmdet.core import (anchor_inside_flags, images_to_levels, multi_apply,
-                        unmap)
-from ..builder import HEADS
-from ..losses.accuracy import accuracy
-from ..losses.utils import weight_reduce_loss
-from .retina_head import RetinaHead
-
-
-@HEADS.register_module()
-class FSAFHead(RetinaHead):
-    """Anchor-free head used in `FSAF <https://arxiv.org/abs/1903.00621>`_.
-
-    The head contains two subnetworks. The first classifies anchor boxes and
-    the second regresses deltas for the anchors (num_anchors is 1 for anchor-
-    free methods)
-
-    Args:
-        *args: Same as its base class in :class:`RetinaHead`
-        score_threshold (float, optional): The score_threshold to calculate
-            positive recall. If given, prediction scores lower than this value
-            is counted as incorrect prediction. Default to None.
-        **kwargs: Same as its base class in :class:`RetinaHead`
-
-    Example:
-        >>> import torch
-        >>> self = FSAFHead(11, 7)
-        >>> x = torch.rand(1, 7, 32, 32)
-        >>> cls_score, bbox_pred = self.forward_single(x)
-        >>> # Each anchor predicts a score for each class except background
-        >>> cls_per_anchor = cls_score.shape[1] / self.num_anchors
-        >>> box_per_anchor = bbox_pred.shape[1] / self.num_anchors
-        >>> assert cls_per_anchor == self.num_classes
-        >>> assert box_per_anchor == 4
-    """
-
-    def __init__(self, *args, score_threshold=None, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.score_threshold = score_threshold
-
-    def forward_single(self, x):
-        """Forward feature map of a single scale level.
-
-        Args:
-            x (Tensor): Feature map of a single scale level.
-
-        Returns:
-            tuple (Tensor):
-                cls_score (Tensor): Box scores for each scale level
-                    Has shape (N, num_points * num_classes, H, W).
-                bbox_pred (Tensor): Box energies / deltas for each scale
-                    level with shape (N, num_points * 4, H, W).
-        """
-        cls_score, bbox_pred = super().forward_single(x)
-        # relu: TBLR encoder only accepts positive bbox_pred
-        return cls_score, self.relu(bbox_pred)
-
-    def init_weights(self):
-        """Initialize weights of the head."""
-        super(FSAFHead, self).init_weights()
-        # The positive bias in self.retina_reg conv is to prevent predicted \
-        #  bbox with 0 area
-        normal_init(self.retina_reg, std=0.01, bias=0.25)
-
-    def _get_targets_single(self,
-                            flat_anchors,
-                            valid_flags,
-                            gt_bboxes,
-                            gt_bboxes_ignore,
-                            gt_labels,
-                            img_meta,
-                            label_channels=1,
-                            unmap_outputs=True):
-        """Compute regression and classification targets for anchors in a
-        single image.
-
-        Most of the codes are the same with the base class
-          :obj: `AnchorHead`, except that it also collects and returns
-          the matched gt index in the image (from 0 to num_gt-1). If the
-          anchor bbox is not matched to any gt, the corresponding value in
-          pos_gt_inds is -1.
-        """
-        inside_flags = anchor_inside_flags(flat_anchors, valid_flags,
-                                           img_meta['img_shape'][:2],
-                                           self.train_cfg.allowed_border)
-        if not inside_flags.any():
-            return (None, ) * 7
-        # Assign gt and sample anchors
-        anchors = flat_anchors[inside_flags.type(torch.bool), :]
-        assign_result = self.assigner.assign(
-            anchors, gt_bboxes, gt_bboxes_ignore,
-            None if self.sampling else gt_labels)
-
-        sampling_result = self.sampler.sample(assign_result, anchors,
-                                              gt_bboxes)
-
-        num_valid_anchors = anchors.shape[0]
-        bbox_targets = torch.zeros_like(anchors)
-        bbox_weights = torch.zeros_like(anchors)
-        labels = anchors.new_full((num_valid_anchors, ),
-                                  self.num_classes,
-                                  dtype=torch.long)
-        label_weights = anchors.new_zeros((num_valid_anchors, label_channels),
-                                          dtype=torch.float)
-        pos_gt_inds = anchors.new_full((num_valid_anchors, ),
-                                       -1,
-                                       dtype=torch.long)
-
-        pos_inds = sampling_result.pos_inds
-        neg_inds = sampling_result.neg_inds
-
-        if len(pos_inds) > 0:
-            if not self.reg_decoded_bbox:
-                pos_bbox_targets = self.bbox_coder.encode(
-                    sampling_result.pos_bboxes, sampling_result.pos_gt_bboxes)
-            else:
-                # When the regression loss (e.g. `IouLoss`, `GIouLoss`)
-                # is applied directly on the decoded bounding boxes, both
-                # the predicted boxes and regression targets should be with
-                # absolute coordinate format.
-                pos_bbox_targets = sampling_result.pos_gt_bboxes
-            bbox_targets[pos_inds, :] = pos_bbox_targets
-            bbox_weights[pos_inds, :] = 1.0
-            # The assigned gt_index for each anchor. (0-based)
-            pos_gt_inds[pos_inds] = sampling_result.pos_assigned_gt_inds
-            if gt_labels is None:
-                # Only rpn gives gt_labels as None
-                # Foreground is the first class
-                labels[pos_inds] = 0
-            else:
-                labels[pos_inds] = gt_labels[
-                    sampling_result.pos_assigned_gt_inds]
-            if self.train_cfg.pos_weight <= 0:
-                label_weights[pos_inds] = 1.0
-            else:
-                label_weights[pos_inds] = self.train_cfg.pos_weight
-
-        if len(neg_inds) > 0:
-            label_weights[neg_inds] = 1.0
-
-        # shadowed_labels is a tensor composed of tuples
-        #  (anchor_inds, class_label) that indicate those anchors lying in the
-        #  outer region of a gt or overlapped by another gt with a smaller
-        #  area.
-        #
-        # Therefore, only the shadowed labels are ignored for loss calculation.
-        # the key `shadowed_labels` is defined in :obj:`CenterRegionAssigner`
-        shadowed_labels = assign_result.get_extra_property('shadowed_labels')
-        if shadowed_labels is not None and shadowed_labels.numel():
-            if len(shadowed_labels.shape) == 2:
-                idx_, label_ = shadowed_labels[:, 0], shadowed_labels[:, 1]
-                assert (labels[idx_] != label_).all(), \
-                    'One label cannot be both positive and ignored'
-                label_weights[idx_, label_] = 0
-            else:
-                label_weights[shadowed_labels] = 0
-
-        # map up to original set of anchors
-        if unmap_outputs:
-            num_total_anchors = flat_anchors.size(0)
-            labels = unmap(labels, num_total_anchors, inside_flags)
-            label_weights = unmap(label_weights, num_total_anchors,
-                                  inside_flags)
-            bbox_targets = unmap(bbox_targets, num_total_anchors, inside_flags)
-            bbox_weights = unmap(bbox_weights, num_total_anchors, inside_flags)
-            pos_gt_inds = unmap(
-                pos_gt_inds, num_total_anchors, inside_flags, fill=-1)
-
-        return (labels, label_weights, bbox_targets, bbox_weights, pos_inds,
-                neg_inds, sampling_result, pos_gt_inds)
-
-    @force_fp32(apply_to=('cls_scores', 'bbox_preds'))
-    def loss(self,
-             cls_scores,
-             bbox_preds,
-             gt_bboxes,
-             gt_labels,
-             img_metas,
-             gt_bboxes_ignore=None):
-        """Compute loss of the head.
-
-        Args:
-            cls_scores (list[Tensor]): Box scores for each scale level
-                Has shape (N, num_points * num_classes, H, W).
-            bbox_preds (list[Tensor]): Box energies / deltas for each scale
-                level with shape (N, num_points * 4, H, W).
-            gt_bboxes (list[Tensor]): each item are the truth boxes for each
-                image in [tl_x, tl_y, br_x, br_y] format.
-            gt_labels (list[Tensor]): class indices corresponding to each box
-            img_metas (list[dict]): Meta information of each image, e.g.,
-                image size, scaling factor, etc.
-            gt_bboxes_ignore (None | list[Tensor]): specify which bounding
-                boxes can be ignored when computing the loss.
-
-        Returns:
-            dict[str, Tensor]: A dictionary of loss components.
-        """
-        for i in range(len(bbox_preds)):  # loop over fpn level
-            # avoid 0 area of the predicted bbox
-            bbox_preds[i] = bbox_preds[i].clamp(min=1e-4)
-        # TODO: It may directly use the base-class loss function.
-        featmap_sizes = [featmap.size()[-2:] for featmap in cls_scores]
-        assert len(featmap_sizes) == self.anchor_generator.num_levels
-        batch_size = len(gt_bboxes)
-        device = cls_scores[0].device
-        anchor_list, valid_flag_list = self.get_anchors(
-            featmap_sizes, img_metas, device=device)
-        label_channels = self.cls_out_channels if self.use_sigmoid_cls else 1
-        cls_reg_targets = self.get_targets(
-            anchor_list,
-            valid_flag_list,
-            gt_bboxes,
-            img_metas,
-            gt_bboxes_ignore_list=gt_bboxes_ignore,
-            gt_labels_list=gt_labels,
-            label_channels=label_channels)
-        if cls_reg_targets is None:
-            return None
-        (labels_list, label_weights_list, bbox_targets_list, bbox_weights_list,
-         num_total_pos, num_total_neg,
-         pos_assigned_gt_inds_list) = cls_reg_targets
-
-        num_gts = np.array(list(map(len, gt_labels)))
-        num_total_samples = (
-            num_total_pos + num_total_neg if self.sampling else num_total_pos)
-        # anchor number of multi levels
-        num_level_anchors = [anchors.size(0) for anchors in anchor_list[0]]
-        # concat all level anchors and flags to a single tensor
-        concat_anchor_list = []
-        for i in range(len(anchor_list)):
-            concat_anchor_list.append(torch.cat(anchor_list[i]))
-        all_anchor_list = images_to_levels(concat_anchor_list,
-                                           num_level_anchors)
-        losses_cls, losses_bbox = multi_apply(
-            self.loss_single,
-            cls_scores,
-            bbox_preds,
-            all_anchor_list,
-            labels_list,
-            label_weights_list,
-            bbox_targets_list,
-            bbox_weights_list,
-            num_total_samples=num_total_samples)
-
-        # `pos_assigned_gt_inds_list` (length: fpn_levels) stores the assigned
-        # gt index of each anchor bbox in each fpn level.
-        cum_num_gts = list(np.cumsum(num_gts))  # length of batch_size
-        for i, assign in enumerate(pos_assigned_gt_inds_list):
-            # loop over fpn levels
-            for j in range(1, batch_size):
-                # loop over batch size
-                # Convert gt indices in each img to those in the batch
-                assign[j][assign[j] >= 0] += int(cum_num_gts[j - 1])
-            pos_assigned_gt_inds_list[i] = assign.flatten()
-            labels_list[i] = labels_list[i].flatten()
-        num_gts = sum(map(len, gt_labels))  # total number of gt in the batch
-        # The unique label index of each gt in the batch
-        label_sequence = torch.arange(num_gts, device=device)
-        # Collect the average loss of each gt in each level
-        with torch.no_grad():
-            loss_levels, = multi_apply(
-                self.collect_loss_level_single,
-                losses_cls,
-                losses_bbox,
-                pos_assigned_gt_inds_list,
-                labels_seq=label_sequence)
-            # Shape: (fpn_levels, num_gts). Loss of each gt at each fpn level
-            loss_levels = torch.stack(loss_levels, dim=0)
-            # Locate the best fpn level for loss back-propagation
-            if loss_levels.numel() == 0:  # zero gt
-                argmin = loss_levels.new_empty((num_gts, ), dtype=torch.long)
-            else:
-                _, argmin = loss_levels.min(dim=0)
-
-        # Reweight the loss of each (anchor, label) pair, so that only those
-        #  at the best gt level are back-propagated.
-        losses_cls, losses_bbox, pos_inds = multi_apply(
-            self.reweight_loss_single,
-            losses_cls,
-            losses_bbox,
-            pos_assigned_gt_inds_list,
-            labels_list,
-            list(range(len(losses_cls))),
-            min_levels=argmin)
-        num_pos = torch.cat(pos_inds, 0).sum().float()
-        pos_recall = self.calculate_pos_recall(cls_scores, labels_list,
-                                               pos_inds)
-
-        if num_pos == 0:  # No gt
-            avg_factor = num_pos + float(num_total_neg)
-        else:
-            avg_factor = num_pos
-        for i in range(len(losses_cls)):
-            losses_cls[i] /= avg_factor
-            losses_bbox[i] /= avg_factor
-        return dict(
-            loss_cls=losses_cls,
-            loss_bbox=losses_bbox,
-            num_pos=num_pos / batch_size,
-            pos_recall=pos_recall)
-
-    def calculate_pos_recall(self, cls_scores, labels_list, pos_inds):
-        """Calculate positive recall with score threshold.
-
-        Args:
-            cls_scores (list[Tensor]): Classification scores at all fpn levels.
-                Each tensor is in shape (N, num_classes * num_anchors, H, W)
-            labels_list (list[Tensor]): The label that each anchor is assigned
-                to. Shape (N * H * W * num_anchors, )
-            pos_inds (list[Tensor]): List of bool tensors indicating whether
-                the anchor is assigned to a positive label.
-                Shape (N * H * W * num_anchors, )
-
-        Returns:
-            Tensor: A single float number indicating the positive recall.
-        """
-        with torch.no_grad():
-            num_class = self.num_classes
-            scores = [
-                cls.permute(0, 2, 3, 1).reshape(-1, num_class)[pos]
-                for cls, pos in zip(cls_scores, pos_inds)
-            ]
-            labels = [
-                label.reshape(-1)[pos]
-                for label, pos in zip(labels_list, pos_inds)
-            ]
-            scores = torch.cat(scores, dim=0)
-            labels = torch.cat(labels, dim=0)
-            if self.use_sigmoid_cls:
-                scores = scores.sigmoid()
-            else:
-                scores = scores.softmax(dim=1)
-
-            return accuracy(scores, labels, thresh=self.score_threshold)
-
-    def collect_loss_level_single(self, cls_loss, reg_loss, assigned_gt_inds,
-                                  labels_seq):
-        """Get the average loss in each FPN level w.r.t. each gt label.
-
-        Args:
-            cls_loss (Tensor): Classification loss of each feature map pixel,
-              shape (num_anchor, num_class)
-            reg_loss (Tensor): Regression loss of each feature map pixel,
-              shape (num_anchor, 4)
-            assigned_gt_inds (Tensor): It indicates which gt the prior is
-              assigned to (0-based, -1: no assignment). shape (num_anchor),
-            labels_seq: The rank of labels. shape (num_gt)
-
-        Returns:
-            shape: (num_gt), average loss of each gt in this level
-        """
-        if len(reg_loss.shape) == 2:  # iou loss has shape (num_prior, 4)
-            reg_loss = reg_loss.sum(dim=-1)  # sum loss in tblr dims
-        if len(cls_loss.shape) == 2:
-            cls_loss = cls_loss.sum(dim=-1)  # sum loss in class dims
-        loss = cls_loss + reg_loss
-        assert loss.size(0) == assigned_gt_inds.size(0)
-        # Default loss value is 1e6 for a layer where no anchor is positive
-        #  to ensure it will not be chosen to back-propagate gradient
-        losses_ = loss.new_full(labels_seq.shape, 1e6)
-        for i, l in enumerate(labels_seq):
-            match = assigned_gt_inds == l
-            if match.any():
-                losses_[i] = loss[match].mean()
-        return losses_,
-
-    def reweight_loss_single(self, cls_loss, reg_loss, assigned_gt_inds,
-                             labels, level, min_levels):
-        """Reweight loss values at each level.
-
-        Reassign loss values at each level by masking those where the
-        pre-calculated loss is too large. Then return the reduced losses.
-
-        Args:
-            cls_loss (Tensor): Element-wise classification loss.
-              Shape: (num_anchors, num_classes)
-            reg_loss (Tensor): Element-wise regression loss.
-              Shape: (num_anchors, 4)
-            assigned_gt_inds (Tensor): The gt indices that each anchor bbox
-              is assigned to. -1 denotes a negative anchor, otherwise it is the
-              gt index (0-based). Shape: (num_anchors, ),
-            labels (Tensor): Label assigned to anchors. Shape: (num_anchors, ).
-            level (int): The current level index in the pyramid
-              (0-4 for RetinaNet)
-            min_levels (Tensor): The best-matching level for each gt.
-              Shape: (num_gts, ),
-
-        Returns:
-            tuple:
-                - cls_loss: Reduced corrected classification loss. Scalar.
-                - reg_loss: Reduced corrected regression loss. Scalar.
-                - pos_flags (Tensor): Corrected bool tensor indicating the
-                  final positive anchors. Shape: (num_anchors, ).
-        """
-        loc_weight = torch.ones_like(reg_loss)
-        cls_weight = torch.ones_like(cls_loss)
-        pos_flags = assigned_gt_inds >= 0  # positive pixel flag
-        pos_indices = torch.nonzero(pos_flags, as_tuple=False).flatten()
-
-        if pos_flags.any():  # pos pixels exist
-            pos_assigned_gt_inds = assigned_gt_inds[pos_flags]
-            zeroing_indices = (min_levels[pos_assigned_gt_inds] != level)
-            neg_indices = pos_indices[zeroing_indices]
-
-            if neg_indices.numel():
-                pos_flags[neg_indices] = 0
-                loc_weight[neg_indices] = 0
-                # Only the weight corresponding to the label is
-                #  zeroed out if not selected
-                zeroing_labels = labels[neg_indices]
-                assert (zeroing_labels >= 0).all()
-                cls_weight[neg_indices, zeroing_labels] = 0
-
-        # Weighted loss for both cls and reg loss
-        cls_loss = weight_reduce_loss(cls_loss, cls_weight, reduction='sum')
-        reg_loss = weight_reduce_loss(reg_loss, loc_weight, reduction='sum')
-
-        return cls_loss, reg_loss, pos_flags

spaces/Andy1621/uniformer_image_segmentation/configs/fastscnn/README.md

@@ -1,22 +0,0 @@
-# Fast-SCNN for Semantic Segmentation
-
-## Introduction
-
-<!-- [ALGORITHM] -->
-
-```latex
-@article{poudel2019fast,
-  title={Fast-scnn: Fast semantic segmentation network},
-  author={Poudel, Rudra PK and Liwicki, Stephan and Cipolla, Roberto},
-  journal={arXiv preprint arXiv:1902.04502},
-  year={2019}
-}
-```
-
-## Results and models
-
-### Cityscapes
-
-| Method    | Backbone  | Crop Size | Lr schd | Mem (GB) | Inf time (fps) |  mIoU | mIoU(ms+flip) | config                                                                                  | download                                                                                                                                                                                                                                                       |
-| --------- | --------- | --------- | ------: | -------- | -------------- | ----: | ------------- | --------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| Fast-SCNN | Fast-SCNN | 512x1024  |   80000 | 8.4      | 63.61          | 69.06 | -             | [config](https://github.com/open-mmlab/mmsegmentation/blob/master/configs/fast_scnn.py) | [model](https://download.openmmlab.com/mmsegmentation/v0.5/fast_scnn/fast_scnn_4x8_80k_lr0.12_cityscapes-f5096c79.pth) &#124; [log](https://download.openmmlab.com/mmsegmentation/v0.5/fast_scnn/fast_scnn_4x8_80k_lr0.12_cityscapes-20200807_165744.log.json) |

spaces/Annotation-AI/fast-segment-everything-with-text-prompt/app.py

@@ -1,17 +0,0 @@
-import os
-
-
-github_user = os.environ.get("GITHUB_USER")
-github_token = os.environ.get("GITHUB_TOKEN")
-
-repo_name = "annotation-ai/mlwiz-technical-demo"
-
-os.system(f"export GITHUB_USER={github_user}")
-os.system(f"export GITHUB_TOKEN={github_token}")
-os.system(f"git clone https://{github_user}:{github_token}@github.com/{repo_name}")
-
-cwd0 = os.getcwd()
-cwd1 = os.path.join(cwd0, "mlwiz-technical-demo/sam")
-os.chdir(cwd1)
-os.system("pip install -r requirements.txt")
-os.system("python app_everything_text.py")

spaces/Anonymous-sub/Rerender/ControlNet/annotator/uniformer/mmcv/ops/psa_mask.py

@@ -1,92 +0,0 @@
-# Modified from https://github.com/hszhao/semseg/blob/master/lib/psa
-from torch import nn
-from torch.autograd import Function
-from torch.nn.modules.utils import _pair
-
-from ..utils import ext_loader
-
-ext_module = ext_loader.load_ext('_ext',
-                                 ['psamask_forward', 'psamask_backward'])
-
-
-class PSAMaskFunction(Function):
-
-    @staticmethod
-    def symbolic(g, input, psa_type, mask_size):
-        return g.op(
-            'mmcv::MMCVPSAMask',
-            input,
-            psa_type_i=psa_type,
-            mask_size_i=mask_size)
-
-    @staticmethod
-    def forward(ctx, input, psa_type, mask_size):
-        ctx.psa_type = psa_type
-        ctx.mask_size = _pair(mask_size)
-        ctx.save_for_backward(input)
-
-        h_mask, w_mask = ctx.mask_size
-        batch_size, channels, h_feature, w_feature = input.size()
-        assert channels == h_mask * w_mask
-        output = input.new_zeros(
-            (batch_size, h_feature * w_feature, h_feature, w_feature))
-
-        ext_module.psamask_forward(
-            input,
-            output,
-            psa_type=psa_type,
-            num_=batch_size,
-            h_feature=h_feature,
-            w_feature=w_feature,
-            h_mask=h_mask,
-            w_mask=w_mask,
-            half_h_mask=(h_mask - 1) // 2,
-            half_w_mask=(w_mask - 1) // 2)
-        return output
-
-    @staticmethod
-    def backward(ctx, grad_output):
-        input = ctx.saved_tensors[0]
-        psa_type = ctx.psa_type
-        h_mask, w_mask = ctx.mask_size
-        batch_size, channels, h_feature, w_feature = input.size()
-        grad_input = grad_output.new_zeros(
-            (batch_size, channels, h_feature, w_feature))
-        ext_module.psamask_backward(
-            grad_output,
-            grad_input,
-            psa_type=psa_type,
-            num_=batch_size,
-            h_feature=h_feature,
-            w_feature=w_feature,
-            h_mask=h_mask,
-            w_mask=w_mask,
-            half_h_mask=(h_mask - 1) // 2,
-            half_w_mask=(w_mask - 1) // 2)
-        return grad_input, None, None, None
-
-
-psa_mask = PSAMaskFunction.apply
-
-
-class PSAMask(nn.Module):
-
-    def __init__(self, psa_type, mask_size=None):
-        super(PSAMask, self).__init__()
-        assert psa_type in ['collect', 'distribute']
-        if psa_type == 'collect':
-            psa_type_enum = 0
-        else:
-            psa_type_enum = 1
-        self.psa_type_enum = psa_type_enum
-        self.mask_size = mask_size
-        self.psa_type = psa_type
-
-    def forward(self, input):
-        return psa_mask(input, self.psa_type_enum, self.mask_size)
-
-    def __repr__(self):
-        s = self.__class__.__name__
-        s += f'(psa_type={self.psa_type}, '
-        s += f'mask_size={self.mask_size})'
-        return s

spaces/Anonymous-sub/Rerender/ControlNet/ldm/models/diffusion/dpm_solver/dpm_solver.py

@@ -1,1154 +0,0 @@
-import torch
-import torch.nn.functional as F
-import math
-from tqdm import tqdm
-
-
-class NoiseScheduleVP:
-    def __init__(
-            self,
-            schedule='discrete',
-            betas=None,
-            alphas_cumprod=None,
-            continuous_beta_0=0.1,
-            continuous_beta_1=20.,
-    ):
-        """Create a wrapper class for the forward SDE (VP type).
-        ***
-        Update: We support discrete-time diffusion models by implementing a picewise linear interpolation for log_alpha_t.
-                We recommend to use schedule='discrete' for the discrete-time diffusion models, especially for high-resolution images.
-        ***
-        The forward SDE ensures that the condition distribution q_{t|0}(x_t | x_0) = N ( alpha_t * x_0, sigma_t^2 * I ).
-        We further define lambda_t = log(alpha_t) - log(sigma_t), which is the half-logSNR (described in the DPM-Solver paper).
-        Therefore, we implement the functions for computing alpha_t, sigma_t and lambda_t. For t in [0, T], we have:
-            log_alpha_t = self.marginal_log_mean_coeff(t)
-            sigma_t = self.marginal_std(t)
-            lambda_t = self.marginal_lambda(t)
-        Moreover, as lambda(t) is an invertible function, we also support its inverse function:
-            t = self.inverse_lambda(lambda_t)
-        ===============================================================
-        We support both discrete-time DPMs (trained on n = 0, 1, ..., N-1) and continuous-time DPMs (trained on t in [t_0, T]).
-        1. For discrete-time DPMs:
-            For discrete-time DPMs trained on n = 0, 1, ..., N-1, we convert the discrete steps to continuous time steps by:
-                t_i = (i + 1) / N
-            e.g. for N = 1000, we have t_0 = 1e-3 and T = t_{N-1} = 1.
-            We solve the corresponding diffusion ODE from time T = 1 to time t_0 = 1e-3.
-            Args:
-                betas: A `torch.Tensor`. The beta array for the discrete-time DPM. (See the original DDPM paper for details)
-                alphas_cumprod: A `torch.Tensor`. The cumprod alphas for the discrete-time DPM. (See the original DDPM paper for details)
-            Note that we always have alphas_cumprod = cumprod(betas). Therefore, we only need to set one of `betas` and `alphas_cumprod`.
-            **Important**:  Please pay special attention for the args for `alphas_cumprod`:
-                The `alphas_cumprod` is the \hat{alpha_n} arrays in the notations of DDPM. Specifically, DDPMs assume that
-                    q_{t_n | 0}(x_{t_n} | x_0) = N ( \sqrt{\hat{alpha_n}} * x_0, (1 - \hat{alpha_n}) * I ).
-                Therefore, the notation \hat{alpha_n} is different from the notation alpha_t in DPM-Solver. In fact, we have
-                    alpha_{t_n} = \sqrt{\hat{alpha_n}},
-                and
-                    log(alpha_{t_n}) = 0.5 * log(\hat{alpha_n}).
-        2. For continuous-time DPMs:
-            We support two types of VPSDEs: linear (DDPM) and cosine (improved-DDPM). The hyperparameters for the noise
-            schedule are the default settings in DDPM and improved-DDPM:
-            Args:
-                beta_min: A `float` number. The smallest beta for the linear schedule.
-                beta_max: A `float` number. The largest beta for the linear schedule.
-                cosine_s: A `float` number. The hyperparameter in the cosine schedule.
-                cosine_beta_max: A `float` number. The hyperparameter in the cosine schedule.
-                T: A `float` number. The ending time of the forward process.
-        ===============================================================
-        Args:
-            schedule: A `str`. The noise schedule of the forward SDE. 'discrete' for discrete-time DPMs,
-                    'linear' or 'cosine' for continuous-time DPMs.
-        Returns:
-            A wrapper object of the forward SDE (VP type).
-
-        ===============================================================
-        Example:
-        # For discrete-time DPMs, given betas (the beta array for n = 0, 1, ..., N - 1):
-        >>> ns = NoiseScheduleVP('discrete', betas=betas)
-        # For discrete-time DPMs, given alphas_cumprod (the \hat{alpha_n} array for n = 0, 1, ..., N - 1):
-        >>> ns = NoiseScheduleVP('discrete', alphas_cumprod=alphas_cumprod)
-        # For continuous-time DPMs (VPSDE), linear schedule:
-        >>> ns = NoiseScheduleVP('linear', continuous_beta_0=0.1, continuous_beta_1=20.)
-        """
-
-        if schedule not in ['discrete', 'linear', 'cosine']:
-            raise ValueError(
-                "Unsupported noise schedule {}. The schedule needs to be 'discrete' or 'linear' or 'cosine'".format(
-                    schedule))
-
-        self.schedule = schedule
-        if schedule == 'discrete':
-            if betas is not None:
-                log_alphas = 0.5 * torch.log(1 - betas).cumsum(dim=0)
-            else:
-                assert alphas_cumprod is not None
-                log_alphas = 0.5 * torch.log(alphas_cumprod)
-            self.total_N = len(log_alphas)
-            self.T = 1.
-            self.t_array = torch.linspace(0., 1., self.total_N + 1)[1:].reshape((1, -1))
-            self.log_alpha_array = log_alphas.reshape((1, -1,))
-        else:
-            self.total_N = 1000
-            self.beta_0 = continuous_beta_0
-            self.beta_1 = continuous_beta_1
-            self.cosine_s = 0.008
-            self.cosine_beta_max = 999.
-            self.cosine_t_max = math.atan(self.cosine_beta_max * (1. + self.cosine_s) / math.pi) * 2. * (
-                        1. + self.cosine_s) / math.pi - self.cosine_s
-            self.cosine_log_alpha_0 = math.log(math.cos(self.cosine_s / (1. + self.cosine_s) * math.pi / 2.))
-            self.schedule = schedule
-            if schedule == 'cosine':
-                # For the cosine schedule, T = 1 will have numerical issues. So we manually set the ending time T.
-                # Note that T = 0.9946 may be not the optimal setting. However, we find it works well.
-                self.T = 0.9946
-            else:
-                self.T = 1.
-
-    def marginal_log_mean_coeff(self, t):
-        """
-        Compute log(alpha_t) of a given continuous-time label t in [0, T].
-        """
-        if self.schedule == 'discrete':
-            return interpolate_fn(t.reshape((-1, 1)), self.t_array.to(t.device),
-                                  self.log_alpha_array.to(t.device)).reshape((-1))
-        elif self.schedule == 'linear':
-            return -0.25 * t ** 2 * (self.beta_1 - self.beta_0) - 0.5 * t * self.beta_0
-        elif self.schedule == 'cosine':
-            log_alpha_fn = lambda s: torch.log(torch.cos((s + self.cosine_s) / (1. + self.cosine_s) * math.pi / 2.))
-            log_alpha_t = log_alpha_fn(t) - self.cosine_log_alpha_0
-            return log_alpha_t
-
-    def marginal_alpha(self, t):
-        """
-        Compute alpha_t of a given continuous-time label t in [0, T].
-        """
-        return torch.exp(self.marginal_log_mean_coeff(t))
-
-    def marginal_std(self, t):
-        """
-        Compute sigma_t of a given continuous-time label t in [0, T].
-        """
-        return torch.sqrt(1. - torch.exp(2. * self.marginal_log_mean_coeff(t)))
-
-    def marginal_lambda(self, t):
-        """
-        Compute lambda_t = log(alpha_t) - log(sigma_t) of a given continuous-time label t in [0, T].
-        """
-        log_mean_coeff = self.marginal_log_mean_coeff(t)
-        log_std = 0.5 * torch.log(1. - torch.exp(2. * log_mean_coeff))
-        return log_mean_coeff - log_std
-
-    def inverse_lambda(self, lamb):
-        """
-        Compute the continuous-time label t in [0, T] of a given half-logSNR lambda_t.
-        """
-        if self.schedule == 'linear':
-            tmp = 2. * (self.beta_1 - self.beta_0) * torch.logaddexp(-2. * lamb, torch.zeros((1,)).to(lamb))
-            Delta = self.beta_0 ** 2 + tmp
-            return tmp / (torch.sqrt(Delta) + self.beta_0) / (self.beta_1 - self.beta_0)
-        elif self.schedule == 'discrete':
-            log_alpha = -0.5 * torch.logaddexp(torch.zeros((1,)).to(lamb.device), -2. * lamb)
-            t = interpolate_fn(log_alpha.reshape((-1, 1)), torch.flip(self.log_alpha_array.to(lamb.device), [1]),
-                               torch.flip(self.t_array.to(lamb.device), [1]))
-            return t.reshape((-1,))
-        else:
-            log_alpha = -0.5 * torch.logaddexp(-2. * lamb, torch.zeros((1,)).to(lamb))
-            t_fn = lambda log_alpha_t: torch.arccos(torch.exp(log_alpha_t + self.cosine_log_alpha_0)) * 2. * (
-                        1. + self.cosine_s) / math.pi - self.cosine_s
-            t = t_fn(log_alpha)
-            return t
-
-
-def model_wrapper(
-        model,
-        noise_schedule,
-        model_type="noise",
-        model_kwargs={},
-        guidance_type="uncond",
-        condition=None,
-        unconditional_condition=None,
-        guidance_scale=1.,
-        classifier_fn=None,
-        classifier_kwargs={},
-):
-    """Create a wrapper function for the noise prediction model.
-    DPM-Solver needs to solve the continuous-time diffusion ODEs. For DPMs trained on discrete-time labels, we need to
-    firstly wrap the model function to a noise prediction model that accepts the continuous time as the input.
-    We support four types of the diffusion model by setting `model_type`:
-        1. "noise": noise prediction model. (Trained by predicting noise).
-        2. "x_start": data prediction model. (Trained by predicting the data x_0 at time 0).
-        3. "v": velocity prediction model. (Trained by predicting the velocity).
-            The "v" prediction is derivation detailed in Appendix D of [1], and is used in Imagen-Video [2].
-            [1] Salimans, Tim, and Jonathan Ho. "Progressive distillation for fast sampling of diffusion models."
-                arXiv preprint arXiv:2202.00512 (2022).
-            [2] Ho, Jonathan, et al. "Imagen Video: High Definition Video Generation with Diffusion Models."
-                arXiv preprint arXiv:2210.02303 (2022).
-
-        4. "score": marginal score function. (Trained by denoising score matching).
-            Note that the score function and the noise prediction model follows a simple relationship:
-            ```
-                noise(x_t, t) = -sigma_t * score(x_t, t)
-            ```
-    We support three types of guided sampling by DPMs by setting `guidance_type`:
-        1. "uncond": unconditional sampling by DPMs.
-            The input `model` has the following format:
-            ``
-                model(x, t_input, **model_kwargs) -> noise | x_start | v | score
-            ``
-        2. "classifier": classifier guidance sampling [3] by DPMs and another classifier.
-            The input `model` has the following format:
-            ``
-                model(x, t_input, **model_kwargs) -> noise | x_start | v | score
-            ``
-            The input `classifier_fn` has the following format:
-            ``
-                classifier_fn(x, t_input, cond, **classifier_kwargs) -> logits(x, t_input, cond)
-            ``
-            [3] P. Dhariwal and A. Q. Nichol, "Diffusion models beat GANs on image synthesis,"
-                in Advances in Neural Information Processing Systems, vol. 34, 2021, pp. 8780-8794.
-        3. "classifier-free": classifier-free guidance sampling by conditional DPMs.
-            The input `model` has the following format:
-            ``
-                model(x, t_input, cond, **model_kwargs) -> noise | x_start | v | score
-            ``
-            And if cond == `unconditional_condition`, the model output is the unconditional DPM output.
-            [4] Ho, Jonathan, and Tim Salimans. "Classifier-free diffusion guidance."
-                arXiv preprint arXiv:2207.12598 (2022).
-
-    The `t_input` is the time label of the model, which may be discrete-time labels (i.e. 0 to 999)
-    or continuous-time labels (i.e. epsilon to T).
-    We wrap the model function to accept only `x` and `t_continuous` as inputs, and outputs the predicted noise:
-    ``
-        def model_fn(x, t_continuous) -> noise:
-            t_input = get_model_input_time(t_continuous)
-            return noise_pred(model, x, t_input, **model_kwargs)
-    ``
-    where `t_continuous` is the continuous time labels (i.e. epsilon to T). And we use `model_fn` for DPM-Solver.
-    ===============================================================
-    Args:
-        model: A diffusion model with the corresponding format described above.
-        noise_schedule: A noise schedule object, such as NoiseScheduleVP.
-        model_type: A `str`. The parameterization type of the diffusion model.
-                    "noise" or "x_start" or "v" or "score".
-        model_kwargs: A `dict`. A dict for the other inputs of the model function.
-        guidance_type: A `str`. The type of the guidance for sampling.
-                    "uncond" or "classifier" or "classifier-free".
-        condition: A pytorch tensor. The condition for the guided sampling.
-                    Only used for "classifier" or "classifier-free" guidance type.
-        unconditional_condition: A pytorch tensor. The condition for the unconditional sampling.
-                    Only used for "classifier-free" guidance type.
-        guidance_scale: A `float`. The scale for the guided sampling.
-        classifier_fn: A classifier function. Only used for the classifier guidance.
-        classifier_kwargs: A `dict`. A dict for the other inputs of the classifier function.
-    Returns:
-        A noise prediction model that accepts the noised data and the continuous time as the inputs.
-    """
-
-    def get_model_input_time(t_continuous):
-        """
-        Convert the continuous-time `t_continuous` (in [epsilon, T]) to the model input time.
-        For discrete-time DPMs, we convert `t_continuous` in [1 / N, 1] to `t_input` in [0, 1000 * (N - 1) / N].
-        For continuous-time DPMs, we just use `t_continuous`.
-        """
-        if noise_schedule.schedule == 'discrete':
-            return (t_continuous - 1. / noise_schedule.total_N) * 1000.
-        else:
-            return t_continuous
-
-    def noise_pred_fn(x, t_continuous, cond=None):
-        if t_continuous.reshape((-1,)).shape[0] == 1:
-            t_continuous = t_continuous.expand((x.shape[0]))
-        t_input = get_model_input_time(t_continuous)
-        if cond is None:
-            output = model(x, t_input, **model_kwargs)
-        else:
-            output = model(x, t_input, cond, **model_kwargs)
-        if model_type == "noise":
-            return output
-        elif model_type == "x_start":
-            alpha_t, sigma_t = noise_schedule.marginal_alpha(t_continuous), noise_schedule.marginal_std(t_continuous)
-            dims = x.dim()
-            return (x - expand_dims(alpha_t, dims) * output) / expand_dims(sigma_t, dims)
-        elif model_type == "v":
-            alpha_t, sigma_t = noise_schedule.marginal_alpha(t_continuous), noise_schedule.marginal_std(t_continuous)
-            dims = x.dim()
-            return expand_dims(alpha_t, dims) * output + expand_dims(sigma_t, dims) * x
-        elif model_type == "score":
-            sigma_t = noise_schedule.marginal_std(t_continuous)
-            dims = x.dim()
-            return -expand_dims(sigma_t, dims) * output
-
-    def cond_grad_fn(x, t_input):
-        """
-        Compute the gradient of the classifier, i.e. nabla_{x} log p_t(cond | x_t).
-        """
-        with torch.enable_grad():
-            x_in = x.detach().requires_grad_(True)
-            log_prob = classifier_fn(x_in, t_input, condition, **classifier_kwargs)
-            return torch.autograd.grad(log_prob.sum(), x_in)[0]
-
-    def model_fn(x, t_continuous):
-        """
-        The noise predicition model function that is used for DPM-Solver.
-        """
-        if t_continuous.reshape((-1,)).shape[0] == 1:
-            t_continuous = t_continuous.expand((x.shape[0]))
-        if guidance_type == "uncond":
-            return noise_pred_fn(x, t_continuous)
-        elif guidance_type == "classifier":
-            assert classifier_fn is not None
-            t_input = get_model_input_time(t_continuous)
-            cond_grad = cond_grad_fn(x, t_input)
-            sigma_t = noise_schedule.marginal_std(t_continuous)
-            noise = noise_pred_fn(x, t_continuous)
-            return noise - guidance_scale * expand_dims(sigma_t, dims=cond_grad.dim()) * cond_grad
-        elif guidance_type == "classifier-free":
-            if guidance_scale == 1. or unconditional_condition is None:
-                return noise_pred_fn(x, t_continuous, cond=condition)
-            else:
-                x_in = torch.cat([x] * 2)
-                t_in = torch.cat([t_continuous] * 2)
-                c_in = torch.cat([unconditional_condition, condition])
-                noise_uncond, noise = noise_pred_fn(x_in, t_in, cond=c_in).chunk(2)
-                return noise_uncond + guidance_scale * (noise - noise_uncond)
-
-    assert model_type in ["noise", "x_start", "v"]
-    assert guidance_type in ["uncond", "classifier", "classifier-free"]
-    return model_fn
-
-
-class DPM_Solver:
-    def __init__(self, model_fn, noise_schedule, predict_x0=False, thresholding=False, max_val=1.):
-        """Construct a DPM-Solver.
-        We support both the noise prediction model ("predicting epsilon") and the data prediction model ("predicting x0").
-        If `predict_x0` is False, we use the solver for the noise prediction model (DPM-Solver).
-        If `predict_x0` is True, we use the solver for the data prediction model (DPM-Solver++).
-            In such case, we further support the "dynamic thresholding" in [1] when `thresholding` is True.
-            The "dynamic thresholding" can greatly improve the sample quality for pixel-space DPMs with large guidance scales.
-        Args:
-            model_fn: A noise prediction model function which accepts the continuous-time input (t in [epsilon, T]):
-                ``
-                def model_fn(x, t_continuous):
-                    return noise
-                ``
-            noise_schedule: A noise schedule object, such as NoiseScheduleVP.
-            predict_x0: A `bool`. If true, use the data prediction model; else, use the noise prediction model.
-            thresholding: A `bool`. Valid when `predict_x0` is True. Whether to use the "dynamic thresholding" in [1].
-            max_val: A `float`. Valid when both `predict_x0` and `thresholding` are True. The max value for thresholding.
-
-        [1] Chitwan Saharia, William Chan, Saurabh Saxena, Lala Li, Jay Whang, Emily Denton, Seyed Kamyar Seyed Ghasemipour, Burcu Karagol Ayan, S Sara Mahdavi, Rapha Gontijo Lopes, et al. Photorealistic text-to-image diffusion models with deep language understanding. arXiv preprint arXiv:2205.11487, 2022b.
-        """
-        self.model = model_fn
-        self.noise_schedule = noise_schedule
-        self.predict_x0 = predict_x0
-        self.thresholding = thresholding
-        self.max_val = max_val
-
-    def noise_prediction_fn(self, x, t):
-        """
-        Return the noise prediction model.
-        """
-        return self.model(x, t)
-
-    def data_prediction_fn(self, x, t):
-        """
-        Return the data prediction model (with thresholding).
-        """
-        noise = self.noise_prediction_fn(x, t)
-        dims = x.dim()
-        alpha_t, sigma_t = self.noise_schedule.marginal_alpha(t), self.noise_schedule.marginal_std(t)
-        x0 = (x - expand_dims(sigma_t, dims) * noise) / expand_dims(alpha_t, dims)
-        if self.thresholding:
-            p = 0.995  # A hyperparameter in the paper of "Imagen" [1].
-            s = torch.quantile(torch.abs(x0).reshape((x0.shape[0], -1)), p, dim=1)
-            s = expand_dims(torch.maximum(s, self.max_val * torch.ones_like(s).to(s.device)), dims)
-            x0 = torch.clamp(x0, -s, s) / s
-        return x0
-
-    def model_fn(self, x, t):
-        """
-        Convert the model to the noise prediction model or the data prediction model.
-        """
-        if self.predict_x0:
-            return self.data_prediction_fn(x, t)
-        else:
-            return self.noise_prediction_fn(x, t)
-
-    def get_time_steps(self, skip_type, t_T, t_0, N, device):
-        """Compute the intermediate time steps for sampling.
-        Args:
-            skip_type: A `str`. The type for the spacing of the time steps. We support three types:
-                - 'logSNR': uniform logSNR for the time steps.
-                - 'time_uniform': uniform time for the time steps. (**Recommended for high-resolutional data**.)
-                - 'time_quadratic': quadratic time for the time steps. (Used in DDIM for low-resolutional data.)
-            t_T: A `float`. The starting time of the sampling (default is T).
-            t_0: A `float`. The ending time of the sampling (default is epsilon).
-            N: A `int`. The total number of the spacing of the time steps.
-            device: A torch device.
-        Returns:
-            A pytorch tensor of the time steps, with the shape (N + 1,).
-        """
-        if skip_type == 'logSNR':
-            lambda_T = self.noise_schedule.marginal_lambda(torch.tensor(t_T).to(device))
-            lambda_0 = self.noise_schedule.marginal_lambda(torch.tensor(t_0).to(device))
-            logSNR_steps = torch.linspace(lambda_T.cpu().item(), lambda_0.cpu().item(), N + 1).to(device)
-            return self.noise_schedule.inverse_lambda(logSNR_steps)
-        elif skip_type == 'time_uniform':
-            return torch.linspace(t_T, t_0, N + 1).to(device)
-        elif skip_type == 'time_quadratic':
-            t_order = 2
-            t = torch.linspace(t_T ** (1. / t_order), t_0 ** (1. / t_order), N + 1).pow(t_order).to(device)
-            return t
-        else:
-            raise ValueError(
-                "Unsupported skip_type {}, need to be 'logSNR' or 'time_uniform' or 'time_quadratic'".format(skip_type))
-
-    def get_orders_and_timesteps_for_singlestep_solver(self, steps, order, skip_type, t_T, t_0, device):
-        """
-        Get the order of each step for sampling by the singlestep DPM-Solver.
-        We combine both DPM-Solver-1,2,3 to use all the function evaluations, which is named as "DPM-Solver-fast".
-        Given a fixed number of function evaluations by `steps`, the sampling procedure by DPM-Solver-fast is:
-            - If order == 1:
-                We take `steps` of DPM-Solver-1 (i.e. DDIM).
-            - If order == 2:
-                - Denote K = (steps // 2). We take K or (K + 1) intermediate time steps for sampling.
-                - If steps % 2 == 0, we use K steps of DPM-Solver-2.
-                - If steps % 2 == 1, we use K steps of DPM-Solver-2 and 1 step of DPM-Solver-1.
-            - If order == 3:
-                - Denote K = (steps // 3 + 1). We take K intermediate time steps for sampling.
-                - If steps % 3 == 0, we use (K - 2) steps of DPM-Solver-3, and 1 step of DPM-Solver-2 and 1 step of DPM-Solver-1.
-                - If steps % 3 == 1, we use (K - 1) steps of DPM-Solver-3 and 1 step of DPM-Solver-1.
-                - If steps % 3 == 2, we use (K - 1) steps of DPM-Solver-3 and 1 step of DPM-Solver-2.
-        ============================================
-        Args:
-            order: A `int`. The max order for the solver (2 or 3).
-            steps: A `int`. The total number of function evaluations (NFE).
-            skip_type: A `str`. The type for the spacing of the time steps. We support three types:
-                - 'logSNR': uniform logSNR for the time steps.
-                - 'time_uniform': uniform time for the time steps. (**Recommended for high-resolutional data**.)
-                - 'time_quadratic': quadratic time for the time steps. (Used in DDIM for low-resolutional data.)
-            t_T: A `float`. The starting time of the sampling (default is T).
-            t_0: A `float`. The ending time of the sampling (default is epsilon).
-            device: A torch device.
-        Returns:
-            orders: A list of the solver order of each step.
-        """
-        if order == 3:
-            K = steps // 3 + 1
-            if steps % 3 == 0:
-                orders = [3, ] * (K - 2) + [2, 1]
-            elif steps % 3 == 1:
-                orders = [3, ] * (K - 1) + [1]
-            else:
-                orders = [3, ] * (K - 1) + [2]
-        elif order == 2:
-            if steps % 2 == 0:
-                K = steps // 2
-                orders = [2, ] * K
-            else:
-                K = steps // 2 + 1
-                orders = [2, ] * (K - 1) + [1]
-        elif order == 1:
-            K = 1
-            orders = [1, ] * steps
-        else:
-            raise ValueError("'order' must be '1' or '2' or '3'.")
-        if skip_type == 'logSNR':
-            # To reproduce the results in DPM-Solver paper
-            timesteps_outer = self.get_time_steps(skip_type, t_T, t_0, K, device)
-        else:
-            timesteps_outer = self.get_time_steps(skip_type, t_T, t_0, steps, device)[
-                torch.cumsum(torch.tensor([0, ] + orders)).to(device)]
-        return timesteps_outer, orders
-
-    def denoise_to_zero_fn(self, x, s):
-        """
-        Denoise at the final step, which is equivalent to solve the ODE from lambda_s to infty by first-order discretization.
-        """
-        return self.data_prediction_fn(x, s)
-
-    def dpm_solver_first_update(self, x, s, t, model_s=None, return_intermediate=False):
-        """
-        DPM-Solver-1 (equivalent to DDIM) from time `s` to time `t`.
-        Args:
-            x: A pytorch tensor. The initial value at time `s`.
-            s: A pytorch tensor. The starting time, with the shape (x.shape[0],).
-            t: A pytorch tensor. The ending time, with the shape (x.shape[0],).
-            model_s: A pytorch tensor. The model function evaluated at time `s`.
-                If `model_s` is None, we evaluate the model by `x` and `s`; otherwise we directly use it.
-            return_intermediate: A `bool`. If true, also return the model value at time `s`.
-        Returns:
-            x_t: A pytorch tensor. The approximated solution at time `t`.
-        """
-        ns = self.noise_schedule
-        dims = x.dim()
-        lambda_s, lambda_t = ns.marginal_lambda(s), ns.marginal_lambda(t)
-        h = lambda_t - lambda_s
-        log_alpha_s, log_alpha_t = ns.marginal_log_mean_coeff(s), ns.marginal_log_mean_coeff(t)
-        sigma_s, sigma_t = ns.marginal_std(s), ns.marginal_std(t)
-        alpha_t = torch.exp(log_alpha_t)
-
-        if self.predict_x0:
-            phi_1 = torch.expm1(-h)
-            if model_s is None:
-                model_s = self.model_fn(x, s)
-            x_t = (
-                    expand_dims(sigma_t / sigma_s, dims) * x
-                    - expand_dims(alpha_t * phi_1, dims) * model_s
-            )
-            if return_intermediate:
-                return x_t, {'model_s': model_s}
-            else:
-                return x_t
-        else:
-            phi_1 = torch.expm1(h)
-            if model_s is None:
-                model_s = self.model_fn(x, s)
-            x_t = (
-                    expand_dims(torch.exp(log_alpha_t - log_alpha_s), dims) * x
-                    - expand_dims(sigma_t * phi_1, dims) * model_s
-            )
-            if return_intermediate:
-                return x_t, {'model_s': model_s}
-            else:
-                return x_t
-
-    def singlestep_dpm_solver_second_update(self, x, s, t, r1=0.5, model_s=None, return_intermediate=False,
-                                            solver_type='dpm_solver'):
-        """
-        Singlestep solver DPM-Solver-2 from time `s` to time `t`.
-        Args:
-            x: A pytorch tensor. The initial value at time `s`.
-            s: A pytorch tensor. The starting time, with the shape (x.shape[0],).
-            t: A pytorch tensor. The ending time, with the shape (x.shape[0],).
-            r1: A `float`. The hyperparameter of the second-order solver.
-            model_s: A pytorch tensor. The model function evaluated at time `s`.
-                If `model_s` is None, we evaluate the model by `x` and `s`; otherwise we directly use it.
-            return_intermediate: A `bool`. If true, also return the model value at time `s` and `s1` (the intermediate time).
-            solver_type: either 'dpm_solver' or 'taylor'. The type for the high-order solvers.
-                The type slightly impacts the performance. We recommend to use 'dpm_solver' type.
-        Returns:
-            x_t: A pytorch tensor. The approximated solution at time `t`.
-        """
-        if solver_type not in ['dpm_solver', 'taylor']:
-            raise ValueError("'solver_type' must be either 'dpm_solver' or 'taylor', got {}".format(solver_type))
-        if r1 is None:
-            r1 = 0.5
-        ns = self.noise_schedule
-        dims = x.dim()
-        lambda_s, lambda_t = ns.marginal_lambda(s), ns.marginal_lambda(t)
-        h = lambda_t - lambda_s
-        lambda_s1 = lambda_s + r1 * h
-        s1 = ns.inverse_lambda(lambda_s1)
-        log_alpha_s, log_alpha_s1, log_alpha_t = ns.marginal_log_mean_coeff(s), ns.marginal_log_mean_coeff(
-            s1), ns.marginal_log_mean_coeff(t)
-        sigma_s, sigma_s1, sigma_t = ns.marginal_std(s), ns.marginal_std(s1), ns.marginal_std(t)
-        alpha_s1, alpha_t = torch.exp(log_alpha_s1), torch.exp(log_alpha_t)
-
-        if self.predict_x0:
-            phi_11 = torch.expm1(-r1 * h)
-            phi_1 = torch.expm1(-h)
-
-            if model_s is None:
-                model_s = self.model_fn(x, s)
-            x_s1 = (
-                    expand_dims(sigma_s1 / sigma_s, dims) * x
-                    - expand_dims(alpha_s1 * phi_11, dims) * model_s
-            )
-            model_s1 = self.model_fn(x_s1, s1)
-            if solver_type == 'dpm_solver':
-                x_t = (
-                        expand_dims(sigma_t / sigma_s, dims) * x
-                        - expand_dims(alpha_t * phi_1, dims) * model_s
-                        - (0.5 / r1) * expand_dims(alpha_t * phi_1, dims) * (model_s1 - model_s)
-                )
-            elif solver_type == 'taylor':
-                x_t = (
-                        expand_dims(sigma_t / sigma_s, dims) * x
-                        - expand_dims(alpha_t * phi_1, dims) * model_s
-                        + (1. / r1) * expand_dims(alpha_t * ((torch.exp(-h) - 1.) / h + 1.), dims) * (
-                                    model_s1 - model_s)
-                )
-        else:
-            phi_11 = torch.expm1(r1 * h)
-            phi_1 = torch.expm1(h)
-
-            if model_s is None:
-                model_s = self.model_fn(x, s)
-            x_s1 = (
-                    expand_dims(torch.exp(log_alpha_s1 - log_alpha_s), dims) * x
-                    - expand_dims(sigma_s1 * phi_11, dims) * model_s
-            )
-            model_s1 = self.model_fn(x_s1, s1)
-            if solver_type == 'dpm_solver':
-                x_t = (
-                        expand_dims(torch.exp(log_alpha_t - log_alpha_s), dims) * x
-                        - expand_dims(sigma_t * phi_1, dims) * model_s
-                        - (0.5 / r1) * expand_dims(sigma_t * phi_1, dims) * (model_s1 - model_s)
-                )
-            elif solver_type == 'taylor':
-                x_t = (
-                        expand_dims(torch.exp(log_alpha_t - log_alpha_s), dims) * x
-                        - expand_dims(sigma_t * phi_1, dims) * model_s
-                        - (1. / r1) * expand_dims(sigma_t * ((torch.exp(h) - 1.) / h - 1.), dims) * (model_s1 - model_s)
-                )
-        if return_intermediate:
-            return x_t, {'model_s': model_s, 'model_s1': model_s1}
-        else:
-            return x_t
-
-    def singlestep_dpm_solver_third_update(self, x, s, t, r1=1. / 3., r2=2. / 3., model_s=None, model_s1=None,
-                                           return_intermediate=False, solver_type='dpm_solver'):
-        """
-        Singlestep solver DPM-Solver-3 from time `s` to time `t`.
-        Args:
-            x: A pytorch tensor. The initial value at time `s`.
-            s: A pytorch tensor. The starting time, with the shape (x.shape[0],).
-            t: A pytorch tensor. The ending time, with the shape (x.shape[0],).
-            r1: A `float`. The hyperparameter of the third-order solver.
-            r2: A `float`. The hyperparameter of the third-order solver.
-            model_s: A pytorch tensor. The model function evaluated at time `s`.
-                If `model_s` is None, we evaluate the model by `x` and `s`; otherwise we directly use it.
-            model_s1: A pytorch tensor. The model function evaluated at time `s1` (the intermediate time given by `r1`).
-                If `model_s1` is None, we evaluate the model at `s1`; otherwise we directly use it.
-            return_intermediate: A `bool`. If true, also return the model value at time `s`, `s1` and `s2` (the intermediate times).
-            solver_type: either 'dpm_solver' or 'taylor'. The type for the high-order solvers.
-                The type slightly impacts the performance. We recommend to use 'dpm_solver' type.
-        Returns:
-            x_t: A pytorch tensor. The approximated solution at time `t`.
-        """
-        if solver_type not in ['dpm_solver', 'taylor']:
-            raise ValueError("'solver_type' must be either 'dpm_solver' or 'taylor', got {}".format(solver_type))
-        if r1 is None:
-            r1 = 1. / 3.
-        if r2 is None:
-            r2 = 2. / 3.
-        ns = self.noise_schedule
-        dims = x.dim()
-        lambda_s, lambda_t = ns.marginal_lambda(s), ns.marginal_lambda(t)
-        h = lambda_t - lambda_s
-        lambda_s1 = lambda_s + r1 * h
-        lambda_s2 = lambda_s + r2 * h
-        s1 = ns.inverse_lambda(lambda_s1)
-        s2 = ns.inverse_lambda(lambda_s2)
-        log_alpha_s, log_alpha_s1, log_alpha_s2, log_alpha_t = ns.marginal_log_mean_coeff(
-            s), ns.marginal_log_mean_coeff(s1), ns.marginal_log_mean_coeff(s2), ns.marginal_log_mean_coeff(t)
-        sigma_s, sigma_s1, sigma_s2, sigma_t = ns.marginal_std(s), ns.marginal_std(s1), ns.marginal_std(
-            s2), ns.marginal_std(t)
-        alpha_s1, alpha_s2, alpha_t = torch.exp(log_alpha_s1), torch.exp(log_alpha_s2), torch.exp(log_alpha_t)
-
-        if self.predict_x0:
-            phi_11 = torch.expm1(-r1 * h)
-            phi_12 = torch.expm1(-r2 * h)
-            phi_1 = torch.expm1(-h)
-            phi_22 = torch.expm1(-r2 * h) / (r2 * h) + 1.
-            phi_2 = phi_1 / h + 1.
-            phi_3 = phi_2 / h - 0.5
-
-            if model_s is None:
-                model_s = self.model_fn(x, s)
-            if model_s1 is None:
-                x_s1 = (
-                        expand_dims(sigma_s1 / sigma_s, dims) * x
-                        - expand_dims(alpha_s1 * phi_11, dims) * model_s
-                )
-                model_s1 = self.model_fn(x_s1, s1)
-            x_s2 = (
-                    expand_dims(sigma_s2 / sigma_s, dims) * x
-                    - expand_dims(alpha_s2 * phi_12, dims) * model_s
-                    + r2 / r1 * expand_dims(alpha_s2 * phi_22, dims) * (model_s1 - model_s)
-            )
-            model_s2 = self.model_fn(x_s2, s2)
-            if solver_type == 'dpm_solver':
-                x_t = (
-                        expand_dims(sigma_t / sigma_s, dims) * x
-                        - expand_dims(alpha_t * phi_1, dims) * model_s
-                        + (1. / r2) * expand_dims(alpha_t * phi_2, dims) * (model_s2 - model_s)
-                )
-            elif solver_type == 'taylor':
-                D1_0 = (1. / r1) * (model_s1 - model_s)
-                D1_1 = (1. / r2) * (model_s2 - model_s)
-                D1 = (r2 * D1_0 - r1 * D1_1) / (r2 - r1)
-                D2 = 2. * (D1_1 - D1_0) / (r2 - r1)
-                x_t = (
-                        expand_dims(sigma_t / sigma_s, dims) * x
-                        - expand_dims(alpha_t * phi_1, dims) * model_s
-                        + expand_dims(alpha_t * phi_2, dims) * D1
-                        - expand_dims(alpha_t * phi_3, dims) * D2
-                )
-        else:
-            phi_11 = torch.expm1(r1 * h)
-            phi_12 = torch.expm1(r2 * h)
-            phi_1 = torch.expm1(h)
-            phi_22 = torch.expm1(r2 * h) / (r2 * h) - 1.
-            phi_2 = phi_1 / h - 1.
-            phi_3 = phi_2 / h - 0.5
-
-            if model_s is None:
-                model_s = self.model_fn(x, s)
-            if model_s1 is None:
-                x_s1 = (
-                        expand_dims(torch.exp(log_alpha_s1 - log_alpha_s), dims) * x
-                        - expand_dims(sigma_s1 * phi_11, dims) * model_s
-                )
-                model_s1 = self.model_fn(x_s1, s1)
-            x_s2 = (
-                    expand_dims(torch.exp(log_alpha_s2 - log_alpha_s), dims) * x
-                    - expand_dims(sigma_s2 * phi_12, dims) * model_s
-                    - r2 / r1 * expand_dims(sigma_s2 * phi_22, dims) * (model_s1 - model_s)
-            )
-            model_s2 = self.model_fn(x_s2, s2)
-            if solver_type == 'dpm_solver':
-                x_t = (
-                        expand_dims(torch.exp(log_alpha_t - log_alpha_s), dims) * x
-                        - expand_dims(sigma_t * phi_1, dims) * model_s
-                        - (1. / r2) * expand_dims(sigma_t * phi_2, dims) * (model_s2 - model_s)
-                )
-            elif solver_type == 'taylor':
-                D1_0 = (1. / r1) * (model_s1 - model_s)
-                D1_1 = (1. / r2) * (model_s2 - model_s)
-                D1 = (r2 * D1_0 - r1 * D1_1) / (r2 - r1)
-                D2 = 2. * (D1_1 - D1_0) / (r2 - r1)
-                x_t = (
-                        expand_dims(torch.exp(log_alpha_t - log_alpha_s), dims) * x
-                        - expand_dims(sigma_t * phi_1, dims) * model_s
-                        - expand_dims(sigma_t * phi_2, dims) * D1
-                        - expand_dims(sigma_t * phi_3, dims) * D2
-                )
-
-        if return_intermediate:
-            return x_t, {'model_s': model_s, 'model_s1': model_s1, 'model_s2': model_s2}
-        else:
-            return x_t
-
-    def multistep_dpm_solver_second_update(self, x, model_prev_list, t_prev_list, t, solver_type="dpm_solver"):
-        """
-        Multistep solver DPM-Solver-2 from time `t_prev_list[-1]` to time `t`.
-        Args:
-            x: A pytorch tensor. The initial value at time `s`.
-            model_prev_list: A list of pytorch tensor. The previous computed model values.
-            t_prev_list: A list of pytorch tensor. The previous times, each time has the shape (x.shape[0],)
-            t: A pytorch tensor. The ending time, with the shape (x.shape[0],).
-            solver_type: either 'dpm_solver' or 'taylor'. The type for the high-order solvers.
-                The type slightly impacts the performance. We recommend to use 'dpm_solver' type.
-        Returns:
-            x_t: A pytorch tensor. The approximated solution at time `t`.
-        """
-        if solver_type not in ['dpm_solver', 'taylor']:
-            raise ValueError("'solver_type' must be either 'dpm_solver' or 'taylor', got {}".format(solver_type))
-        ns = self.noise_schedule
-        dims = x.dim()
-        model_prev_1, model_prev_0 = model_prev_list
-        t_prev_1, t_prev_0 = t_prev_list
-        lambda_prev_1, lambda_prev_0, lambda_t = ns.marginal_lambda(t_prev_1), ns.marginal_lambda(
-            t_prev_0), ns.marginal_lambda(t)
-        log_alpha_prev_0, log_alpha_t = ns.marginal_log_mean_coeff(t_prev_0), ns.marginal_log_mean_coeff(t)
-        sigma_prev_0, sigma_t = ns.marginal_std(t_prev_0), ns.marginal_std(t)
-        alpha_t = torch.exp(log_alpha_t)
-
-        h_0 = lambda_prev_0 - lambda_prev_1
-        h = lambda_t - lambda_prev_0
-        r0 = h_0 / h
-        D1_0 = expand_dims(1. / r0, dims) * (model_prev_0 - model_prev_1)
-        if self.predict_x0:
-            if solver_type == 'dpm_solver':
-                x_t = (
-                        expand_dims(sigma_t / sigma_prev_0, dims) * x
-                        - expand_dims(alpha_t * (torch.exp(-h) - 1.), dims) * model_prev_0
-                        - 0.5 * expand_dims(alpha_t * (torch.exp(-h) - 1.), dims) * D1_0
-                )
-            elif solver_type == 'taylor':
-                x_t = (
-                        expand_dims(sigma_t / sigma_prev_0, dims) * x
-                        - expand_dims(alpha_t * (torch.exp(-h) - 1.), dims) * model_prev_0
-                        + expand_dims(alpha_t * ((torch.exp(-h) - 1.) / h + 1.), dims) * D1_0
-                )
-        else:
-            if solver_type == 'dpm_solver':
-                x_t = (
-                        expand_dims(torch.exp(log_alpha_t - log_alpha_prev_0), dims) * x
-                        - expand_dims(sigma_t * (torch.exp(h) - 1.), dims) * model_prev_0
-                        - 0.5 * expand_dims(sigma_t * (torch.exp(h) - 1.), dims) * D1_0
-                )
-            elif solver_type == 'taylor':
-                x_t = (
-                        expand_dims(torch.exp(log_alpha_t - log_alpha_prev_0), dims) * x
-                        - expand_dims(sigma_t * (torch.exp(h) - 1.), dims) * model_prev_0
-                        - expand_dims(sigma_t * ((torch.exp(h) - 1.) / h - 1.), dims) * D1_0
-                )
-        return x_t
-
-    def multistep_dpm_solver_third_update(self, x, model_prev_list, t_prev_list, t, solver_type='dpm_solver'):
-        """
-        Multistep solver DPM-Solver-3 from time `t_prev_list[-1]` to time `t`.
-        Args:
-            x: A pytorch tensor. The initial value at time `s`.
-            model_prev_list: A list of pytorch tensor. The previous computed model values.
-            t_prev_list: A list of pytorch tensor. The previous times, each time has the shape (x.shape[0],)
-            t: A pytorch tensor. The ending time, with the shape (x.shape[0],).
-            solver_type: either 'dpm_solver' or 'taylor'. The type for the high-order solvers.
-                The type slightly impacts the performance. We recommend to use 'dpm_solver' type.
-        Returns:
-            x_t: A pytorch tensor. The approximated solution at time `t`.
-        """
-        ns = self.noise_schedule
-        dims = x.dim()
-        model_prev_2, model_prev_1, model_prev_0 = model_prev_list
-        t_prev_2, t_prev_1, t_prev_0 = t_prev_list
-        lambda_prev_2, lambda_prev_1, lambda_prev_0, lambda_t = ns.marginal_lambda(t_prev_2), ns.marginal_lambda(
-            t_prev_1), ns.marginal_lambda(t_prev_0), ns.marginal_lambda(t)
-        log_alpha_prev_0, log_alpha_t = ns.marginal_log_mean_coeff(t_prev_0), ns.marginal_log_mean_coeff(t)
-        sigma_prev_0, sigma_t = ns.marginal_std(t_prev_0), ns.marginal_std(t)
-        alpha_t = torch.exp(log_alpha_t)
-
-        h_1 = lambda_prev_1 - lambda_prev_2
-        h_0 = lambda_prev_0 - lambda_prev_1
-        h = lambda_t - lambda_prev_0
-        r0, r1 = h_0 / h, h_1 / h
-        D1_0 = expand_dims(1. / r0, dims) * (model_prev_0 - model_prev_1)
-        D1_1 = expand_dims(1. / r1, dims) * (model_prev_1 - model_prev_2)
-        D1 = D1_0 + expand_dims(r0 / (r0 + r1), dims) * (D1_0 - D1_1)
-        D2 = expand_dims(1. / (r0 + r1), dims) * (D1_0 - D1_1)
-        if self.predict_x0:
-            x_t = (
-                    expand_dims(sigma_t / sigma_prev_0, dims) * x
-                    - expand_dims(alpha_t * (torch.exp(-h) - 1.), dims) * model_prev_0
-                    + expand_dims(alpha_t * ((torch.exp(-h) - 1.) / h + 1.), dims) * D1
-                    - expand_dims(alpha_t * ((torch.exp(-h) - 1. + h) / h ** 2 - 0.5), dims) * D2
-            )
-        else:
-            x_t = (
-                    expand_dims(torch.exp(log_alpha_t - log_alpha_prev_0), dims) * x
-                    - expand_dims(sigma_t * (torch.exp(h) - 1.), dims) * model_prev_0
-                    - expand_dims(sigma_t * ((torch.exp(h) - 1.) / h - 1.), dims) * D1
-                    - expand_dims(sigma_t * ((torch.exp(h) - 1. - h) / h ** 2 - 0.5), dims) * D2
-            )
-        return x_t
-
-    def singlestep_dpm_solver_update(self, x, s, t, order, return_intermediate=False, solver_type='dpm_solver', r1=None,
-                                     r2=None):
-        """
-        Singlestep DPM-Solver with the order `order` from time `s` to time `t`.
-        Args:
-            x: A pytorch tensor. The initial value at time `s`.
-            s: A pytorch tensor. The starting time, with the shape (x.shape[0],).
-            t: A pytorch tensor. The ending time, with the shape (x.shape[0],).
-            order: A `int`. The order of DPM-Solver. We only support order == 1 or 2 or 3.
-            return_intermediate: A `bool`. If true, also return the model value at time `s`, `s1` and `s2` (the intermediate times).
-            solver_type: either 'dpm_solver' or 'taylor'. The type for the high-order solvers.
-                The type slightly impacts the performance. We recommend to use 'dpm_solver' type.
-            r1: A `float`. The hyperparameter of the second-order or third-order solver.
-            r2: A `float`. The hyperparameter of the third-order solver.
-        Returns:
-            x_t: A pytorch tensor. The approximated solution at time `t`.
-        """
-        if order == 1:
-            return self.dpm_solver_first_update(x, s, t, return_intermediate=return_intermediate)
-        elif order == 2:
-            return self.singlestep_dpm_solver_second_update(x, s, t, return_intermediate=return_intermediate,
-                                                            solver_type=solver_type, r1=r1)
-        elif order == 3:
-            return self.singlestep_dpm_solver_third_update(x, s, t, return_intermediate=return_intermediate,
-                                                           solver_type=solver_type, r1=r1, r2=r2)
-        else:
-            raise ValueError("Solver order must be 1 or 2 or 3, got {}".format(order))
-
-    def multistep_dpm_solver_update(self, x, model_prev_list, t_prev_list, t, order, solver_type='dpm_solver'):
-        """
-        Multistep DPM-Solver with the order `order` from time `t_prev_list[-1]` to time `t`.
-        Args:
-            x: A pytorch tensor. The initial value at time `s`.
-            model_prev_list: A list of pytorch tensor. The previous computed model values.
-            t_prev_list: A list of pytorch tensor. The previous times, each time has the shape (x.shape[0],)
-            t: A pytorch tensor. The ending time, with the shape (x.shape[0],).
-            order: A `int`. The order of DPM-Solver. We only support order == 1 or 2 or 3.
-            solver_type: either 'dpm_solver' or 'taylor'. The type for the high-order solvers.
-                The type slightly impacts the performance. We recommend to use 'dpm_solver' type.
-        Returns:
-            x_t: A pytorch tensor. The approximated solution at time `t`.
-        """
-        if order == 1:
-            return self.dpm_solver_first_update(x, t_prev_list[-1], t, model_s=model_prev_list[-1])
-        elif order == 2:
-            return self.multistep_dpm_solver_second_update(x, model_prev_list, t_prev_list, t, solver_type=solver_type)
-        elif order == 3:
-            return self.multistep_dpm_solver_third_update(x, model_prev_list, t_prev_list, t, solver_type=solver_type)
-        else:
-            raise ValueError("Solver order must be 1 or 2 or 3, got {}".format(order))
-
-    def dpm_solver_adaptive(self, x, order, t_T, t_0, h_init=0.05, atol=0.0078, rtol=0.05, theta=0.9, t_err=1e-5,
-                            solver_type='dpm_solver'):
-        """
-        The adaptive step size solver based on singlestep DPM-Solver.
-        Args:
-            x: A pytorch tensor. The initial value at time `t_T`.
-            order: A `int`. The (higher) order of the solver. We only support order == 2 or 3.
-            t_T: A `float`. The starting time of the sampling (default is T).
-            t_0: A `float`. The ending time of the sampling (default is epsilon).
-            h_init: A `float`. The initial step size (for logSNR).
-            atol: A `float`. The absolute tolerance of the solver. For image data, the default setting is 0.0078, followed [1].
-            rtol: A `float`. The relative tolerance of the solver. The default setting is 0.05.
-            theta: A `float`. The safety hyperparameter for adapting the step size. The default setting is 0.9, followed [1].
-            t_err: A `float`. The tolerance for the time. We solve the diffusion ODE until the absolute error between the
-                current time and `t_0` is less than `t_err`. The default setting is 1e-5.
-            solver_type: either 'dpm_solver' or 'taylor'. The type for the high-order solvers.
-                The type slightly impacts the performance. We recommend to use 'dpm_solver' type.
-        Returns:
-            x_0: A pytorch tensor. The approximated solution at time `t_0`.
-        [1] A. Jolicoeur-Martineau, K. Li, R. Piché-Taillefer, T. Kachman, and I. Mitliagkas, "Gotta go fast when generating data with score-based models," arXiv preprint arXiv:2105.14080, 2021.
-        """
-        ns = self.noise_schedule
-        s = t_T * torch.ones((x.shape[0],)).to(x)
-        lambda_s = ns.marginal_lambda(s)
-        lambda_0 = ns.marginal_lambda(t_0 * torch.ones_like(s).to(x))
-        h = h_init * torch.ones_like(s).to(x)
-        x_prev = x
-        nfe = 0
-        if order == 2:
-            r1 = 0.5
-            lower_update = lambda x, s, t: self.dpm_solver_first_update(x, s, t, return_intermediate=True)
-            higher_update = lambda x, s, t, **kwargs: self.singlestep_dpm_solver_second_update(x, s, t, r1=r1,
-                                                                                               solver_type=solver_type,
-                                                                                               **kwargs)
-        elif order == 3:
-            r1, r2 = 1. / 3., 2. / 3.
-            lower_update = lambda x, s, t: self.singlestep_dpm_solver_second_update(x, s, t, r1=r1,
-                                                                                    return_intermediate=True,
-                                                                                    solver_type=solver_type)
-            higher_update = lambda x, s, t, **kwargs: self.singlestep_dpm_solver_third_update(x, s, t, r1=r1, r2=r2,
-                                                                                              solver_type=solver_type,
-                                                                                              **kwargs)
-        else:
-            raise ValueError("For adaptive step size solver, order must be 2 or 3, got {}".format(order))
-        while torch.abs((s - t_0)).mean() > t_err:
-            t = ns.inverse_lambda(lambda_s + h)
-            x_lower, lower_noise_kwargs = lower_update(x, s, t)
-            x_higher = higher_update(x, s, t, **lower_noise_kwargs)
-            delta = torch.max(torch.ones_like(x).to(x) * atol, rtol * torch.max(torch.abs(x_lower), torch.abs(x_prev)))
-            norm_fn = lambda v: torch.sqrt(torch.square(v.reshape((v.shape[0], -1))).mean(dim=-1, keepdim=True))
-            E = norm_fn((x_higher - x_lower) / delta).max()
-            if torch.all(E <= 1.):
-                x = x_higher
-                s = t
-                x_prev = x_lower
-                lambda_s = ns.marginal_lambda(s)
-            h = torch.min(theta * h * torch.float_power(E, -1. / order).float(), lambda_0 - lambda_s)
-            nfe += order
-        print('adaptive solver nfe', nfe)
-        return x
-
-    def sample(self, x, steps=20, t_start=None, t_end=None, order=3, skip_type='time_uniform',
-               method='singlestep', lower_order_final=True, denoise_to_zero=False, solver_type='dpm_solver',
-               atol=0.0078, rtol=0.05,
-               ):
-        """
-        Compute the sample at time `t_end` by DPM-Solver, given the initial `x` at time `t_start`.
-        =====================================================
-        We support the following algorithms for both noise prediction model and data prediction model:
-            - 'singlestep':
-                Singlestep DPM-Solver (i.e. "DPM-Solver-fast" in the paper), which combines different orders of singlestep DPM-Solver.
-                We combine all the singlestep solvers with order <= `order` to use up all the function evaluations (steps).
-                The total number of function evaluations (NFE) == `steps`.
-                Given a fixed NFE == `steps`, the sampling procedure is:
-                    - If `order` == 1:
-                        - Denote K = steps. We use K steps of DPM-Solver-1 (i.e. DDIM).
-                    - If `order` == 2:
-                        - Denote K = (steps // 2) + (steps % 2). We take K intermediate time steps for sampling.
-                        - If steps % 2 == 0, we use K steps of singlestep DPM-Solver-2.
-                        - If steps % 2 == 1, we use (K - 1) steps of singlestep DPM-Solver-2 and 1 step of DPM-Solver-1.
-                    - If `order` == 3:
-                        - Denote K = (steps // 3 + 1). We take K intermediate time steps for sampling.
-                        - If steps % 3 == 0, we use (K - 2) steps of singlestep DPM-Solver-3, and 1 step of singlestep DPM-Solver-2 and 1 step of DPM-Solver-1.
-                        - If steps % 3 == 1, we use (K - 1) steps of singlestep DPM-Solver-3 and 1 step of DPM-Solver-1.
-                        - If steps % 3 == 2, we use (K - 1) steps of singlestep DPM-Solver-3 and 1 step of singlestep DPM-Solver-2.
-            - 'multistep':
-                Multistep DPM-Solver with the order of `order`. The total number of function evaluations (NFE) == `steps`.
-                We initialize the first `order` values by lower order multistep solvers.
-                Given a fixed NFE == `steps`, the sampling procedure is:
-                    Denote K = steps.
-                    - If `order` == 1:
-                        - We use K steps of DPM-Solver-1 (i.e. DDIM).
-                    - If `order` == 2:
-                        - We firstly use 1 step of DPM-Solver-1, then use (K - 1) step of multistep DPM-Solver-2.
-                    - If `order` == 3:
-                        - We firstly use 1 step of DPM-Solver-1, then 1 step of multistep DPM-Solver-2, then (K - 2) step of multistep DPM-Solver-3.
-            - 'singlestep_fixed':
-                Fixed order singlestep DPM-Solver (i.e. DPM-Solver-1 or singlestep DPM-Solver-2 or singlestep DPM-Solver-3).
-                We use singlestep DPM-Solver-`order` for `order`=1 or 2 or 3, with total [`steps` // `order`] * `order` NFE.
-            - 'adaptive':
-                Adaptive step size DPM-Solver (i.e. "DPM-Solver-12" and "DPM-Solver-23" in the paper).
-                We ignore `steps` and use adaptive step size DPM-Solver with a higher order of `order`.
-                You can adjust the absolute tolerance `atol` and the relative tolerance `rtol` to balance the computatation costs
-                (NFE) and the sample quality.
-                    - If `order` == 2, we use DPM-Solver-12 which combines DPM-Solver-1 and singlestep DPM-Solver-2.
-                    - If `order` == 3, we use DPM-Solver-23 which combines singlestep DPM-Solver-2 and singlestep DPM-Solver-3.
-        =====================================================
-        Some advices for choosing the algorithm:
-            - For **unconditional sampling** or **guided sampling with small guidance scale** by DPMs:
-                Use singlestep DPM-Solver ("DPM-Solver-fast" in the paper) with `order = 3`.
-                e.g.
-                    >>> dpm_solver = DPM_Solver(model_fn, noise_schedule, predict_x0=False)
-                    >>> x_sample = dpm_solver.sample(x, steps=steps, t_start=t_start, t_end=t_end, order=3,
-                            skip_type='time_uniform', method='singlestep')
-            - For **guided sampling with large guidance scale** by DPMs:
-                Use multistep DPM-Solver with `predict_x0 = True` and `order = 2`.
-                e.g.
-                    >>> dpm_solver = DPM_Solver(model_fn, noise_schedule, predict_x0=True)
-                    >>> x_sample = dpm_solver.sample(x, steps=steps, t_start=t_start, t_end=t_end, order=2,
-                            skip_type='time_uniform', method='multistep')
-        We support three types of `skip_type`:
-            - 'logSNR': uniform logSNR for the time steps. **Recommended for low-resolutional images**
-            - 'time_uniform': uniform time for the time steps. **Recommended for high-resolutional images**.
-            - 'time_quadratic': quadratic time for the time steps.
-        =====================================================
-        Args:
-            x: A pytorch tensor. The initial value at time `t_start`
-                e.g. if `t_start` == T, then `x` is a sample from the standard normal distribution.
-            steps: A `int`. The total number of function evaluations (NFE).
-            t_start: A `float`. The starting time of the sampling.
-                If `T` is None, we use self.noise_schedule.T (default is 1.0).
-            t_end: A `float`. The ending time of the sampling.
-                If `t_end` is None, we use 1. / self.noise_schedule.total_N.
-                e.g. if total_N == 1000, we have `t_end` == 1e-3.
-                For discrete-time DPMs:
-                    - We recommend `t_end` == 1. / self.noise_schedule.total_N.
-                For continuous-time DPMs:
-                    - We recommend `t_end` == 1e-3 when `steps` <= 15; and `t_end` == 1e-4 when `steps` > 15.
-            order: A `int`. The order of DPM-Solver.
-            skip_type: A `str`. The type for the spacing of the time steps. 'time_uniform' or 'logSNR' or 'time_quadratic'.
-            method: A `str`. The method for sampling. 'singlestep' or 'multistep' or 'singlestep_fixed' or 'adaptive'.
-            denoise_to_zero: A `bool`. Whether to denoise to time 0 at the final step.
-                Default is `False`. If `denoise_to_zero` is `True`, the total NFE is (`steps` + 1).
-                This trick is firstly proposed by DDPM (https://arxiv.org/abs/2006.11239) and
-                score_sde (https://arxiv.org/abs/2011.13456). Such trick can improve the FID
-                for diffusion models sampling by diffusion SDEs for low-resolutional images
-                (such as CIFAR-10). However, we observed that such trick does not matter for
-                high-resolutional images. As it needs an additional NFE, we do not recommend
-                it for high-resolutional images.
-            lower_order_final: A `bool`. Whether to use lower order solvers at the final steps.
-                Only valid for `method=multistep` and `steps < 15`. We empirically find that
-                this trick is a key to stabilizing the sampling by DPM-Solver with very few steps
-                (especially for steps <= 10). So we recommend to set it to be `True`.
-            solver_type: A `str`. The taylor expansion type for the solver. `dpm_solver` or `taylor`. We recommend `dpm_solver`.
-            atol: A `float`. The absolute tolerance of the adaptive step size solver. Valid when `method` == 'adaptive'.
-            rtol: A `float`. The relative tolerance of the adaptive step size solver. Valid when `method` == 'adaptive'.
-        Returns:
-            x_end: A pytorch tensor. The approximated solution at time `t_end`.
-        """
-        t_0 = 1. / self.noise_schedule.total_N if t_end is None else t_end
-        t_T = self.noise_schedule.T if t_start is None else t_start
-        device = x.device
-        if method == 'adaptive':
-            with torch.no_grad():
-                x = self.dpm_solver_adaptive(x, order=order, t_T=t_T, t_0=t_0, atol=atol, rtol=rtol,
-                                             solver_type=solver_type)
-        elif method == 'multistep':
-            assert steps >= order
-            timesteps = self.get_time_steps(skip_type=skip_type, t_T=t_T, t_0=t_0, N=steps, device=device)
-            assert timesteps.shape[0] - 1 == steps
-            with torch.no_grad():
-                vec_t = timesteps[0].expand((x.shape[0]))
-                model_prev_list = [self.model_fn(x, vec_t)]
-                t_prev_list = [vec_t]
-                # Init the first `order` values by lower order multistep DPM-Solver.
-                for init_order in tqdm(range(1, order), desc="DPM init order"):
-                    vec_t = timesteps[init_order].expand(x.shape[0])
-                    x = self.multistep_dpm_solver_update(x, model_prev_list, t_prev_list, vec_t, init_order,
-                                                         solver_type=solver_type)
-                    model_prev_list.append(self.model_fn(x, vec_t))
-                    t_prev_list.append(vec_t)
-                # Compute the remaining values by `order`-th order multistep DPM-Solver.
-                for step in tqdm(range(order, steps + 1), desc="DPM multistep"):
-                    vec_t = timesteps[step].expand(x.shape[0])
-                    if lower_order_final and steps < 15:
-                        step_order = min(order, steps + 1 - step)
-                    else:
-                        step_order = order
-                    x = self.multistep_dpm_solver_update(x, model_prev_list, t_prev_list, vec_t, step_order,
-                                                         solver_type=solver_type)
-                    for i in range(order - 1):
-                        t_prev_list[i] = t_prev_list[i + 1]
-                        model_prev_list[i] = model_prev_list[i + 1]
-                    t_prev_list[-1] = vec_t
-                    # We do not need to evaluate the final model value.
-                    if step < steps:
-                        model_prev_list[-1] = self.model_fn(x, vec_t)
-        elif method in ['singlestep', 'singlestep_fixed']:
-            if method == 'singlestep':
-                timesteps_outer, orders = self.get_orders_and_timesteps_for_singlestep_solver(steps=steps, order=order,
-                                                                                              skip_type=skip_type,
-                                                                                              t_T=t_T, t_0=t_0,
-                                                                                              device=device)
-            elif method == 'singlestep_fixed':
-                K = steps // order
-                orders = [order, ] * K
-                timesteps_outer = self.get_time_steps(skip_type=skip_type, t_T=t_T, t_0=t_0, N=K, device=device)
-            for i, order in enumerate(orders):
-                t_T_inner, t_0_inner = timesteps_outer[i], timesteps_outer[i + 1]
-                timesteps_inner = self.get_time_steps(skip_type=skip_type, t_T=t_T_inner.item(), t_0=t_0_inner.item(),
-                                                      N=order, device=device)
-                lambda_inner = self.noise_schedule.marginal_lambda(timesteps_inner)
-                vec_s, vec_t = t_T_inner.tile(x.shape[0]), t_0_inner.tile(x.shape[0])
-                h = lambda_inner[-1] - lambda_inner[0]
-                r1 = None if order <= 1 else (lambda_inner[1] - lambda_inner[0]) / h
-                r2 = None if order <= 2 else (lambda_inner[2] - lambda_inner[0]) / h
-                x = self.singlestep_dpm_solver_update(x, vec_s, vec_t, order, solver_type=solver_type, r1=r1, r2=r2)
-        if denoise_to_zero:
-            x = self.denoise_to_zero_fn(x, torch.ones((x.shape[0],)).to(device) * t_0)
-        return x
-
-
-#############################################################
-# other utility functions
-#############################################################
-
-def interpolate_fn(x, xp, yp):
-    """
-    A piecewise linear function y = f(x), using xp and yp as keypoints.
-    We implement f(x) in a differentiable way (i.e. applicable for autograd).
-    The function f(x) is well-defined for all x-axis. (For x beyond the bounds of xp, we use the outmost points of xp to define the linear function.)
-    Args:
-        x: PyTorch tensor with shape [N, C], where N is the batch size, C is the number of channels (we use C = 1 for DPM-Solver).
-        xp: PyTorch tensor with shape [C, K], where K is the number of keypoints.
-        yp: PyTorch tensor with shape [C, K].
-    Returns:
-        The function values f(x), with shape [N, C].
-    """
-    N, K = x.shape[0], xp.shape[1]
-    all_x = torch.cat([x.unsqueeze(2), xp.unsqueeze(0).repeat((N, 1, 1))], dim=2)
-    sorted_all_x, x_indices = torch.sort(all_x, dim=2)
-    x_idx = torch.argmin(x_indices, dim=2)
-    cand_start_idx = x_idx - 1
-    start_idx = torch.where(
-        torch.eq(x_idx, 0),
-        torch.tensor(1, device=x.device),
-        torch.where(
-            torch.eq(x_idx, K), torch.tensor(K - 2, device=x.device), cand_start_idx,
-        ),
-    )
-    end_idx = torch.where(torch.eq(start_idx, cand_start_idx), start_idx + 2, start_idx + 1)
-    start_x = torch.gather(sorted_all_x, dim=2, index=start_idx.unsqueeze(2)).squeeze(2)
-    end_x = torch.gather(sorted_all_x, dim=2, index=end_idx.unsqueeze(2)).squeeze(2)
-    start_idx2 = torch.where(
-        torch.eq(x_idx, 0),
-        torch.tensor(0, device=x.device),
-        torch.where(
-            torch.eq(x_idx, K), torch.tensor(K - 2, device=x.device), cand_start_idx,
-        ),
-    )
-    y_positions_expanded = yp.unsqueeze(0).expand(N, -1, -1)
-    start_y = torch.gather(y_positions_expanded, dim=2, index=start_idx2.unsqueeze(2)).squeeze(2)
-    end_y = torch.gather(y_positions_expanded, dim=2, index=(start_idx2 + 1).unsqueeze(2)).squeeze(2)
-    cand = start_y + (x - start_x) * (end_y - start_y) / (end_x - start_x)
-    return cand
-
-
-def expand_dims(v, dims):
-    """
-    Expand the tensor `v` to the dim `dims`.
-    Args:
-        `v`: a PyTorch tensor with shape [N].
-        `dim`: a `int`.
-    Returns:
-        a PyTorch tensor with shape [N, 1, 1, ..., 1] and the total dimension is `dims`.
-    """
-    return v[(...,) + (None,) * (dims - 1)]

spaces/AtomdffAI/wechatgpt4atom/docker/sample-chatgpt-on-wechat/Makefile

@@ -1,26 +0,0 @@
-IMG:=`cat Name`
-MOUNT:=
-PORT_MAP:=
-DOTENV:=.env
-CONTAINER_NAME:=sample-chatgpt-on-wechat
-
-echo:
-	echo $(IMG)
-
-run_d:
-	docker rm $(CONTAINER_NAME) || echo
-	docker run -dt  --name $(CONTAINER_NAME) $(PORT_MAP) \
-			--env-file=$(DOTENV) \
-			$(MOUNT) $(IMG) 
-
-run_i:
-	docker rm $(CONTAINER_NAME) || echo
-	docker run -it  --name $(CONTAINER_NAME) $(PORT_MAP) \
-			--env-file=$(DOTENV) \
-			$(MOUNT) $(IMG) 
-
-stop:
-	docker stop $(CONTAINER_NAME)
-
-rm:     stop
-	docker rm $(CONTAINER_NAME)

spaces/Avkash/WebcamFaceProcessing/README.md

@@ -1,13 +0,0 @@
----
-title: WebcamFaceProcessing
-emoji: 📉
-colorFrom: pink
-colorTo: indigo
-sdk: gradio
-sdk_version: 3.10.1
-app_file: app.py
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/Awesimo/jojogan/e4e/options/train_options.py

@@ -1,84 +0,0 @@
-from argparse import ArgumentParser
-from configs.paths_config import model_paths
-
-
-class TrainOptions:
-
-    def __init__(self):
-        self.parser = ArgumentParser()
-        self.initialize()
-
-    def initialize(self):
-        self.parser.add_argument('--exp_dir', type=str, help='Path to experiment output directory')
-        self.parser.add_argument('--dataset_type', default='ffhq_encode', type=str,
-                                 help='Type of dataset/experiment to run')
-        self.parser.add_argument('--encoder_type', default='Encoder4Editing', type=str, help='Which encoder to use')
-
-        self.parser.add_argument('--batch_size', default=4, type=int, help='Batch size for training')
-        self.parser.add_argument('--test_batch_size', default=2, type=int, help='Batch size for testing and inference')
-        self.parser.add_argument('--workers', default=4, type=int, help='Number of train dataloader workers')
-        self.parser.add_argument('--test_workers', default=2, type=int,
-                                 help='Number of test/inference dataloader workers')
-
-        self.parser.add_argument('--learning_rate', default=0.0001, type=float, help='Optimizer learning rate')
-        self.parser.add_argument('--optim_name', default='ranger', type=str, help='Which optimizer to use')
-        self.parser.add_argument('--train_decoder', default=False, type=bool, help='Whether to train the decoder model')
-        self.parser.add_argument('--start_from_latent_avg', action='store_true',
-                                 help='Whether to add average latent vector to generate codes from encoder.')
-        self.parser.add_argument('--lpips_type', default='alex', type=str, help='LPIPS backbone')
-
-        self.parser.add_argument('--lpips_lambda', default=0.8, type=float, help='LPIPS loss multiplier factor')
-        self.parser.add_argument('--id_lambda', default=0.1, type=float, help='ID loss multiplier factor')
-        self.parser.add_argument('--l2_lambda', default=1.0, type=float, help='L2 loss multiplier factor')
-
-        self.parser.add_argument('--stylegan_weights', default=model_paths['stylegan_ffhq'], type=str,
-                                 help='Path to StyleGAN model weights')
-        self.parser.add_argument('--stylegan_size', default=1024, type=int,
-                                 help='size of pretrained StyleGAN Generator')
-        self.parser.add_argument('--checkpoint_path', default=None, type=str, help='Path to pSp model checkpoint')
-
-        self.parser.add_argument('--max_steps', default=500000, type=int, help='Maximum number of training steps')
-        self.parser.add_argument('--image_interval', default=100, type=int,
-                                 help='Interval for logging train images during training')
-        self.parser.add_argument('--board_interval', default=50, type=int,
-                                 help='Interval for logging metrics to tensorboard')
-        self.parser.add_argument('--val_interval', default=1000, type=int, help='Validation interval')
-        self.parser.add_argument('--save_interval', default=None, type=int, help='Model checkpoint interval')
-
-        # Discriminator flags
-        self.parser.add_argument('--w_discriminator_lambda', default=0, type=float, help='Dw loss multiplier')
-        self.parser.add_argument('--w_discriminator_lr', default=2e-5, type=float, help='Dw learning rate')
-        self.parser.add_argument("--r1", type=float, default=10, help="weight of the r1 regularization")
-        self.parser.add_argument("--d_reg_every", type=int, default=16,
-                                 help="interval for applying r1 regularization")
-        self.parser.add_argument('--use_w_pool', action='store_true',
-                                 help='Whether to store a latnet codes pool for the discriminator\'s training')
-        self.parser.add_argument("--w_pool_size", type=int, default=50,
-                                 help="W\'s pool size, depends on --use_w_pool")
-
-        # e4e specific
-        self.parser.add_argument('--delta_norm', type=int, default=2, help="norm type of the deltas")
-        self.parser.add_argument('--delta_norm_lambda', type=float, default=2e-4, help="lambda for delta norm loss")
-
-        # Progressive training
-        self.parser.add_argument('--progressive_steps', nargs='+', type=int, default=None,
-                                 help="The training steps of training new deltas. steps[i] starts the delta_i training")
-        self.parser.add_argument('--progressive_start', type=int, default=None,
-                                 help="The training step to start training the deltas, overrides progressive_steps")
-        self.parser.add_argument('--progressive_step_every', type=int, default=2_000,
-                                 help="Amount of training steps for each progressive step")
-
-        # Save additional training info to enable future training continuation from produced checkpoints
-        self.parser.add_argument('--save_training_data', action='store_true',
-                                 help='Save intermediate training data to resume training from the checkpoint')
-        self.parser.add_argument('--sub_exp_dir', default=None, type=str, help='Name of sub experiment directory')
-        self.parser.add_argument('--keep_optimizer', action='store_true',
-                                 help='Whether to continue from the checkpoint\'s optimizer')
-        self.parser.add_argument('--resume_training_from_ckpt', default=None, type=str,
-                                 help='Path to training checkpoint, works when --save_training_data was set to True')
-        self.parser.add_argument('--update_param_list', nargs='+', type=str, default=None,
-                                 help="Name of training parameters to update the loaded training checkpoint")
-
-    def parse(self):
-        opts = self.parser.parse_args()
-        return opts

spaces/Awiny/Image2Paragraph/models/grit_src/grit/data/transforms/custom_transform.py

@@ -1,115 +0,0 @@
-# -*- coding: utf-8 -*-
-# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
-# Part of the code is from https://github.com/rwightman/efficientdet-pytorch/blob/master/effdet/data/transforms.py 
-# Modified by Xingyi Zhou
-# The original code is under Apache-2.0 License
-import numpy as np
-import torch
-import torch.nn.functional as F
-from fvcore.transforms.transform import (
-    CropTransform,
-    HFlipTransform,
-    NoOpTransform,
-    Transform,
-    TransformList,
-)
-from PIL import Image
-
-try:
-    import cv2  # noqa
-except ImportError:
-    # OpenCV is an optional dependency at the moment
-    pass
-
-__all__ = [
-    "EfficientDetResizeCropTransform",
-]
-
-
-class EfficientDetResizeCropTransform(Transform):
-    """
-    """
-
-    def __init__(self, scaled_h, scaled_w, offset_y, offset_x, img_scale, \
-        target_size, interp=None):
-        """
-        Args:
-            h, w (int): original image size
-            new_h, new_w (int): new image size
-            interp: PIL interpolation methods, defaults to bilinear.
-        """
-        # TODO decide on PIL vs opencv
-        super().__init__()
-        if interp is None:
-            interp = Image.BILINEAR
-        self._set_attributes(locals())
-
-    def apply_image(self, img, interp=None):
-        assert len(img.shape) <= 4
-
-        if img.dtype == np.uint8:
-            pil_image = Image.fromarray(img)
-            interp_method = interp if interp is not None else self.interp
-            pil_image = pil_image.resize((self.scaled_w, self.scaled_h), interp_method)
-            ret = np.asarray(pil_image)
-            right = min(self.scaled_w, self.offset_x + self.target_size[1])
-            lower = min(self.scaled_h, self.offset_y + self.target_size[0])
-            if len(ret.shape) <= 3:
-                ret = ret[self.offset_y: lower, self.offset_x: right]
-            else:
-                ret = ret[..., self.offset_y: lower, self.offset_x: right, :]
-        else:
-            # PIL only supports uint8
-            img = torch.from_numpy(img)
-            shape = list(img.shape)
-            shape_4d = shape[:2] + [1] * (4 - len(shape)) + shape[2:]
-            img = img.view(shape_4d).permute(2, 3, 0, 1)  # hw(c) -> nchw
-            _PIL_RESIZE_TO_INTERPOLATE_MODE = {Image.BILINEAR: "bilinear", Image.BICUBIC: "bicubic"}
-            mode = _PIL_RESIZE_TO_INTERPOLATE_MODE[self.interp]
-            img = F.interpolate(img, (self.scaled_h, self.scaled_w), mode=mode, align_corners=False)
-            shape[:2] = (self.scaled_h, self.scaled_w)
-            ret = img.permute(2, 3, 0, 1).view(shape).numpy()  # nchw -> hw(c)
-            right = min(self.scaled_w, self.offset_x + self.target_size[1])
-            lower = min(self.scaled_h, self.offset_y + self.target_size[0])
-            if len(ret.shape) <= 3:
-                ret = ret[self.offset_y: lower, self.offset_x: right]
-            else:
-                ret = ret[..., self.offset_y: lower, self.offset_x: right, :]
-        return ret
-
-
-    def apply_coords(self, coords):
-        coords[:, 0] = coords[:, 0] * self.img_scale
-        coords[:, 1] = coords[:, 1] * self.img_scale
-        coords[:, 0] -= self.offset_x
-        coords[:, 1] -= self.offset_y
-        return coords
-
-
-    def apply_segmentation(self, segmentation):
-        segmentation = self.apply_image(segmentation, interp=Image.NEAREST)
-        return segmentation
-
-
-    def inverse(self):
-        raise NotImplementedError
-
-
-    def inverse_apply_coords(self, coords):
-        coords[:, 0] += self.offset_x
-        coords[:, 1] += self.offset_y
-        coords[:, 0] = coords[:, 0] / self.img_scale
-        coords[:, 1] = coords[:, 1] / self.img_scale
-        return coords
-
-
-    def inverse_apply_box(self, box: np.ndarray) -> np.ndarray:
-        """
-        """
-        idxs = np.array([(0, 1), (2, 1), (0, 3), (2, 3)]).flatten()
-        coords = np.asarray(box).reshape(-1, 4)[:, idxs].reshape(-1, 2)
-        coords = self.inverse_apply_coords(coords).reshape((-1, 4, 2))
-        minxy = coords.min(axis=1)
-        maxxy = coords.max(axis=1)
-        trans_boxes = np.concatenate((minxy, maxxy), axis=1)
-        return trans_boxes

spaces/Awiny/Image2Paragraph/models/grit_src/grit/modeling/soft_nms.py

@@ -1,177 +0,0 @@
-import torch
-
-from detectron2.structures import Boxes, RotatedBoxes, pairwise_iou, pairwise_iou_rotated
-
-
-def soft_nms(boxes, scores, method, gaussian_sigma, linear_threshold, prune_threshold):
-    """
-    Performs soft non-maximum suppression algorithm on axis aligned boxes
-
-    Args:
-        boxes (Tensor[N, 5]):
-           boxes where NMS will be performed. They
-           are expected to be in (x_ctr, y_ctr, width, height, angle_degrees) format
-        scores (Tensor[N]):
-           scores for each one of the boxes
-        method (str):
-           one of ['gaussian', 'linear', 'hard']
-           see paper for details. users encouraged not to use "hard", as this is the
-           same nms available elsewhere in detectron2
-        gaussian_sigma (float):
-           parameter for Gaussian penalty function
-        linear_threshold (float):
-           iou threshold for applying linear decay. Nt from the paper
-           re-used as threshold for standard "hard" nms
-        prune_threshold (float):
-           boxes with scores below this threshold are pruned at each iteration.
-           Dramatically reduces computation time. Authors use values in [10e-4, 10e-2]
-
-    Returns:
-        tuple(Tensor, Tensor):
-            [0]: int64 tensor with the indices of the elements that have been kept
-            by Soft NMS, sorted in decreasing order of scores
-            [1]: float tensor with the re-scored scores of the elements that were kept
-"""
-    return _soft_nms(
-        Boxes,
-        pairwise_iou,
-        boxes,
-        scores,
-        method,
-        gaussian_sigma,
-        linear_threshold,
-        prune_threshold,
-    )
-
-
-def batched_soft_nms(
-        boxes, scores, idxs, method, gaussian_sigma, linear_threshold, prune_threshold
-):
-    """
-    Performs soft non-maximum suppression in a batched fashion.
-
-    Each index value correspond to a category, and NMS
-    will not be applied between elements of different categories.
-
-    Args:
-        boxes (Tensor[N, 4]):
-           boxes where NMS will be performed. They
-           are expected to be in (x1, y1, x2, y2) format
-        scores (Tensor[N]):
-           scores for each one of the boxes
-        idxs (Tensor[N]):
-           indices of the categories for each one of the boxes.
-        method (str):
-           one of ['gaussian', 'linear', 'hard']
-           see paper for details. users encouraged not to use "hard", as this is the
-           same nms available elsewhere in detectron2
-        gaussian_sigma (float):
-           parameter for Gaussian penalty function
-        linear_threshold (float):
-           iou threshold for applying linear decay. Nt from the paper
-           re-used as threshold for standard "hard" nms
-        prune_threshold (float):
-           boxes with scores below this threshold are pruned at each iteration.
-           Dramatically reduces computation time. Authors use values in [10e-4, 10e-2]
-    Returns:
-        tuple(Tensor, Tensor):
-            [0]: int64 tensor with the indices of the elements that have been kept
-            by Soft NMS, sorted in decreasing order of scores
-            [1]: float tensor with the re-scored scores of the elements that were kept
-    """
-    if boxes.numel() == 0:
-        return (
-            torch.empty((0,), dtype=torch.int64, device=boxes.device),
-            torch.empty((0,), dtype=torch.float32, device=scores.device),
-        )
-    # strategy: in order to perform NMS independently per class.
-    # we add an offset to all the boxes. The offset is dependent
-    # only on the class idx, and is large enough so that boxes
-    # from different classes do not overlap
-    max_coordinate = boxes.max()
-    offsets = idxs.to(boxes) * (max_coordinate + 1)
-    boxes_for_nms = boxes + offsets[:, None]
-    return soft_nms(
-        boxes_for_nms, scores, method, gaussian_sigma, linear_threshold, prune_threshold
-    )
-
-
-def _soft_nms(
-        box_class,
-        pairwise_iou_func,
-        boxes,
-        scores,
-        method,
-        gaussian_sigma,
-        linear_threshold,
-        prune_threshold,
-):
-    """
-    Soft non-max suppression algorithm.
-
-    Implementation of [Soft-NMS -- Improving Object Detection With One Line of Codec]
-    (https://arxiv.org/abs/1704.04503)
-
-    Args:
-        box_class (cls): one of Box, RotatedBoxes
-        pairwise_iou_func (func): one of pairwise_iou, pairwise_iou_rotated
-        boxes (Tensor[N, ?]):
-           boxes where NMS will be performed
-           if Boxes, in (x1, y1, x2, y2) format
-           if RotatedBoxes, in (x_ctr, y_ctr, width, height, angle_degrees) format
-        scores (Tensor[N]):
-           scores for each one of the boxes
-        method (str):
-           one of ['gaussian', 'linear', 'hard']
-           see paper for details. users encouraged not to use "hard", as this is the
-           same nms available elsewhere in detectron2
-        gaussian_sigma (float):
-           parameter for Gaussian penalty function
-        linear_threshold (float):
-           iou threshold for applying linear decay. Nt from the paper
-           re-used as threshold for standard "hard" nms
-        prune_threshold (float):
-           boxes with scores below this threshold are pruned at each iteration.
-           Dramatically reduces computation time. Authors use values in [10e-4, 10e-2]
-
-    Returns:
-        tuple(Tensor, Tensor):
-            [0]: int64 tensor with the indices of the elements that have been kept
-            by Soft NMS, sorted in decreasing order of scores
-            [1]: float tensor with the re-scored scores of the elements that were kept
-    """
-    boxes = boxes.clone()
-    scores = scores.clone()
-    idxs = torch.arange(scores.size()[0])
-
-    idxs_out = []
-    scores_out = []
-
-    while scores.numel() > 0:
-        top_idx = torch.argmax(scores)
-        idxs_out.append(idxs[top_idx].item())
-        scores_out.append(scores[top_idx].item())
-
-        top_box = boxes[top_idx]
-        ious = pairwise_iou_func(box_class(top_box.unsqueeze(0)), box_class(boxes))[0]
-
-        if method == "linear":
-            decay = torch.ones_like(ious)
-            decay_mask = ious > linear_threshold
-            decay[decay_mask] = 1 - ious[decay_mask]
-        elif method == "gaussian":
-            decay = torch.exp(-torch.pow(ious, 2) / gaussian_sigma)
-        elif method == "hard":  # standard NMS
-            decay = (ious < linear_threshold).float()
-        else:
-            raise NotImplementedError("{} soft nms method not implemented.".format(method))
-
-        scores *= decay
-        keep = scores > prune_threshold
-        keep[top_idx] = False
-
-        boxes = boxes[keep]
-        scores = scores[keep]
-        idxs = idxs[keep]
-
-    return torch.tensor(idxs_out).to(boxes.device), torch.tensor(scores_out).to(scores.device)

spaces/AxelBell/EasyOCR_text_recognition/README.md

@@ -1,13 +0,0 @@
----
-title: EasyOCR
-emoji: 👁️‍🗨️
-colorFrom: blue
-colorTo: yellow
-sdk: gradio
-sdk_version: 3.42.0
-app_file: app.py
-pinned: false
-license: apache-2.0
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces#reference

spaces/Benson/text-generation/Examples/8 Reglas De La Piscina Bola Apk.md

@@ -1,66 +0,0 @@
-
-<h1>8 reglas de piscina de bolas APK: Una aplicación práctica para los amantes de la piscina</h1>
-<p>Si te gusta jugar al billar, sabes lo importante que es seguir las reglas y llevar un registro de la puntuación. Pero a veces, puede ser difícil recordar todos los detalles o encontrar un árbitro confiable. Es por eso que necesita 8 Reglas de piscina de bolas APK, una aplicación gratuita que le ayuda a jugar al billar como un profesional. En este artículo, le diremos qué es 8 Reglas del Pool de Bolas APK, cómo descargarlo e instalarlo, cómo usarlo y qué beneficios ofrece. </p>
-<h2>8 reglas de la piscina bola apk</h2><br /><p><b><b>Download Zip</b> &#10031;&#10031;&#10031; <a href="https://bltlly.com/2v6Mg8">https://bltlly.com/2v6Mg8</a></b></p><br /><br />
- <h2>¿Qué es 8 reglas de piscina de bolas APK? </h2>
-<p>8 Reglas de la piscina de bolas APK es una aplicación para Android que actúa como árbitro y un marcador para juegos de billar. Se basa en las normas oficiales de la Australian Eight Ball Federation (AEBF), que son ampliamente utilizadas en torneos y competiciones. La aplicación tiene cuatro características principales: cronómetro, reglas, marcador y ajustes. Puedes usarlo para cronometrar tus disparos, revisar las reglas, actualizar la puntuación y personalizar tus preferencias. </p>
- <h3>Características de 8 reglas de piscina de bolas APK</h3>
-<p>Estas son algunas de las características que hacen de 8 reglas de piscina de bolas APK una aplicación útil para los amantes de la piscina:</p>
- <h4>Cronómetro</h4>
-<p>La función de cronómetro le permite establecer un límite de tiempo para cada disparo. El tiempo predeterminado es de 60 segundos, con una advertencia a 30 segundos y una cuenta atrás a 5 segundos. También puede agregar una extensión de 30 segundos si es necesario. El cronómetro sonará cuando se acabe el tiempo, indicando una falta. También puede pausar o reiniciar el cronómetro en cualquier momento. </p>
-<p></p>
- <h4>Reglas</h4>
-<p>La función de reglas le da acceso a las reglas oficiales de la AEBF para el pool de 8 bolas. Puede navegar a través de diferentes categorías, tales como reglas generales, faltas, tiros, bolas y bastidores. También puedes buscar términos o palabras clave específicos. Las reglas son claras y concisas, con ejemplos e ilustraciones para ayudarte a entenderlas mejor. </p>
- <h4>Marcador</h4>
-
- <h4>Ajustes</h4>
-<p>La función de configuración le permite personalizar su aplicación de acuerdo a sus preferencias. Puede cambiar el idioma (inglés o francés), el sonido (encendido o apagado), la vibración (encendido o apagado) y el tema (claro u oscuro). También puede ponerse en contacto con el desarrollador o calificar la aplicación de esta función. </p>
- <h3> Cómo descargar e instalar 8 reglas de piscina de bolas APK? </h3>
-<p>Descargar e instalar 8 reglas de piscina de bolas APK es fácil y rápido. Estos son los pasos que debe seguir:</p>
-<ol>
-<li>Ir a [este enlace]( 1 ) y haga clic en "Descargar APK". </li>
-<li>Espere a que la descarga termine y abra el archivo. </li>
-<li>Si se le solicita, permita la instalación desde fuentes desconocidas. </li>
-<li>Siga las instrucciones en la pantalla y complete la instalación. </li>
-<li>Iniciar la aplicación y disfrutar de jugar al billar con tus amigos. </li>
-</ol>
- <h3>Cómo utilizar 8 reglas de piscina de bolas APK? </h3>
-<p>Uso de 8 reglas de piscina de bolas APK es simple e intuitivo. Aquí hay algunos consejos sobre cómo usarlo:</p>
- <h4>Iniciar un nuevo juego</h4>
-<p>Para iniciar un nuevo juego, toque en el botón "New Game" en la pantalla de inicio. Introduzca los nombres de los jugadores o equipos y elija sus colores. Toca "Iniciar juego" para comenzar. </p>
- <h4>Utilice el cronómetro</h4>
-<p>Para usar el cronómetro, toque el botón "Cronómetro" en la esquina inferior derecha de la pantalla. El cronómetro comenzará la cuenta atrás desde 60 segundos. Puede pausar o restablecer el cronómetro pulsando sobre él. También puede agregar una extensión de 30 segundos tocando el botón "Extensión". El cronómetro sonará cuando el tiempo termine, indicando una falta. </p>
- <h4>Compruebe las reglas</h4>
-
- <h4>Actualizar el marcador</h4>
-<p>Para actualizar el marcador, toque el botón "Marcador" en la esquina superior derecha de la pantalla. Verás los nombres y colores de los jugadores o equipos, y sus puntos. Para sumar o restar puntos, toca los botones "+" o "-" junto a cada jugador o equipo. La aplicación calculará automáticamente la puntuación total y mostrará el ganador al final del juego. También puede guardar o eliminar el historial de partituras tocando el botón "Historial". </p>
- <h4>Personalizar la configuración</h4>
-<p>Para personalizar la configuración, toque en el botón "Configuración" en la esquina superior izquierda de la pantalla. Verá una lista de opciones, como idioma, sonido, vibración y tema. Toque en cualquier opción para cambiarla según sus preferencias. También puede ponerse en contacto con el desarrollador o calificar la aplicación de esta función. </p>
- <h2>Los beneficios de usar 8 reglas de piscina de bolas APK</h2>
-<p>Usando 8 reglas de piscina de bolas APK tiene muchos beneficios para los amantes de la piscina. Aquí están algunos de ellos:</p>
- <h3>Conveniencia</h3>
-<p>Con 8 reglas de la piscina de bolas APK, no es necesario llevar un cronómetro físico, un libro de reglas, o un marcador de papel. Puede tener todo lo que necesita en su smartphone. También puede acceder a la aplicación en cualquier momento y en cualquier lugar, siempre y cuando tenga una conexión a Internet. </p>
- <h3>Precisión</h3>
-<p>Con 8 reglas del grupo de bolas APK, no es necesario depender de su memoria o conjeturas para seguir las reglas y realizar un seguimiento de la puntuación. La aplicación le proporciona información precisa y actualizada basada en las normas oficiales de la AEBF. También puedes evitar errores o disputas humanas usando la aplicación como árbitro y marcador. </p>
- <h3>Equidad</h3>
-<p>Con 8 reglas de billar de bolas APK, usted no tiene que preocuparse de hacer trampa o sesgo al jugar al billar con sus amigos. La aplicación asegura que todo el mundo juega con las mismas reglas y tiene las mismas posibilidades de ganar. También puede disfrutar de una competencia amistosa y justa sin ningún argumento o conflicto. </p>
- <h3>Diversión</h3>
-
- <h2>Conclusión</h2>
-<p>8 Reglas de la piscina de bolas APK es una aplicación práctica para los amantes de la piscina que quieren jugar al billar como un profesional. Se basa en las reglas oficiales de la AEBF y tiene cuatro características principales: cronómetro, reglas, marcador y ajustes. Puedes usarlo para cronometrar tus disparos, revisar las reglas, actualizar la puntuación y personalizar tus preferencias. Puedes descargarlo e instalarlo gratis desde [este enlace] y usarlo en cualquier momento y en cualquier lugar. El uso de 8 reglas de piscina de bolas APK tiene muchos beneficios, tales como la comodidad, precisión, equidad y diversión. Es una aplicación imprescindible para los amantes de la piscina que quieren jugar al billar como un profesional. </p>
- <p>Aquí hay algunas preguntas frecuentes que es posible que tenga acerca de 8 reglas de piscina de bolas APK:</p>
-<ul>
-<li>Q: Es 8 reglas de piscina de bolas APK seguro de usar? </li>
-<li>A: Sí, 8 reglas de la piscina de bolas APK es seguro de usar. No contiene ningún virus, malware o spyware. Tampoco recopila ni comparte datos personales de su dispositivo. </li>
-<li>Q: Es 8 reglas de piscina de bolas APK compatible con mi dispositivo? </li>
-<li>A: 8 reglas de la piscina de bolas APK es compatible con la mayoría de los dispositivos Android que se ejecutan en Android 4.4 o superior. Puede comprobar la compatibilidad de su dispositivo visitando [este enlace] y haciendo clic en "Comprobar compatibilidad". </li>
-<li>Q: Es 8 reglas de piscina de bolas APK disponible para dispositivos iOS? </li>
-<li>A: No, 8 reglas de la piscina de bolas APK no está disponible para dispositivos iOS. Sin embargo, puede usar una aplicación similar llamada 8 Reglas de la piscina de bolas - Herramienta de árbitro, que está disponible en la App Store.</li>
-<li>Q: ¿Puedo usar 8 reglas de piscina de bolas APK sin conexión? </li>
-<li>A: Sí, puede usar 8 reglas de piscina de bolas APK sin conexión. Sin embargo, necesitará una conexión a Internet para descargar e instalar la aplicación, y para acceder a algunas de las funciones, como las reglas y la configuración. </li>
-<li>Q: ¿Puedo compartir 8 reglas de piscina de bolas APK con mis amigos? </li>
-<li>A: Sí, puede compartir 8 reglas de piscina de bolas APK con tus amigos. Puede enviarles el enlace para descargar la aplicación, o usar el botón "Compartir" en la aplicación para enviarles el archivo APK a través de Bluetooth, correo electrónico u otras aplicaciones. </li>
-
- <p>Espero que haya disfrutado de la lectura de este artículo y aprendido algo nuevo acerca de 8 Reglas de la piscina de bolas APK. Si tiene alguna pregunta o comentario, no dude en dejar un comentario a continuación. Gracias por su tiempo y atención. </p> 64aa2da5cf<br />
-<br />
-<br />

spaces/Big-Web/MMSD/env/Lib/site-packages/pip/_vendor/rich/_ratio.py

@@ -1,160 +0,0 @@
-import sys
-from fractions import Fraction
-from math import ceil
-from typing import cast, List, Optional, Sequence
-
-if sys.version_info >= (3, 8):
-    from typing import Protocol
-else:
-    from pip._vendor.typing_extensions import Protocol  # pragma: no cover
-
-
-class Edge(Protocol):
-    """Any object that defines an edge (such as Layout)."""
-
-    size: Optional[int] = None
-    ratio: int = 1
-    minimum_size: int = 1
-
-
-def ratio_resolve(total: int, edges: Sequence[Edge]) -> List[int]:
-    """Divide total space to satisfy size, ratio, and minimum_size, constraints.
-
-    The returned list of integers should add up to total in most cases, unless it is
-    impossible to satisfy all the constraints. For instance, if there are two edges
-    with a minimum size of 20 each and `total` is 30 then the returned list will be
-    greater than total. In practice, this would mean that a Layout object would
-    clip the rows that would overflow the screen height.
-
-    Args:
-        total (int): Total number of characters.
-        edges (List[Edge]): Edges within total space.
-
-    Returns:
-        List[int]: Number of characters for each edge.
-    """
-    # Size of edge or None for yet to be determined
-    sizes = [(edge.size or None) for edge in edges]
-
-    _Fraction = Fraction
-
-    # While any edges haven't been calculated
-    while None in sizes:
-        # Get flexible edges and index to map these back on to sizes list
-        flexible_edges = [
-            (index, edge)
-            for index, (size, edge) in enumerate(zip(sizes, edges))
-            if size is None
-        ]
-        # Remaining space in total
-        remaining = total - sum(size or 0 for size in sizes)
-        if remaining <= 0:
-            # No room for flexible edges
-            return [
-                ((edge.minimum_size or 1) if size is None else size)
-                for size, edge in zip(sizes, edges)
-            ]
-        # Calculate number of characters in a ratio portion
-        portion = _Fraction(
-            remaining, sum((edge.ratio or 1) for _, edge in flexible_edges)
-        )
-
-        # If any edges will be less than their minimum, replace size with the minimum
-        for index, edge in flexible_edges:
-            if portion * edge.ratio <= edge.minimum_size:
-                sizes[index] = edge.minimum_size
-                # New fixed size will invalidate calculations, so we need to repeat the process
-                break
-        else:
-            # Distribute flexible space and compensate for rounding error
-            # Since edge sizes can only be integers we need to add the remainder
-            # to the following line
-            remainder = _Fraction(0)
-            for index, edge in flexible_edges:
-                size, remainder = divmod(portion * edge.ratio + remainder, 1)
-                sizes[index] = size
-            break
-    # Sizes now contains integers only
-    return cast(List[int], sizes)
-
-
-def ratio_reduce(
-    total: int, ratios: List[int], maximums: List[int], values: List[int]
-) -> List[int]:
-    """Divide an integer total in to parts based on ratios.
-
-    Args:
-        total (int): The total to divide.
-        ratios (List[int]): A list of integer ratios.
-        maximums (List[int]): List of maximums values for each slot.
-        values (List[int]): List of values
-
-    Returns:
-        List[int]: A list of integers guaranteed to sum to total.
-    """
-    ratios = [ratio if _max else 0 for ratio, _max in zip(ratios, maximums)]
-    total_ratio = sum(ratios)
-    if not total_ratio:
-        return values[:]
-    total_remaining = total
-    result: List[int] = []
-    append = result.append
-    for ratio, maximum, value in zip(ratios, maximums, values):
-        if ratio and total_ratio > 0:
-            distributed = min(maximum, round(ratio * total_remaining / total_ratio))
-            append(value - distributed)
-            total_remaining -= distributed
-            total_ratio -= ratio
-        else:
-            append(value)
-    return result
-
-
-def ratio_distribute(
-    total: int, ratios: List[int], minimums: Optional[List[int]] = None
-) -> List[int]:
-    """Distribute an integer total in to parts based on ratios.
-
-    Args:
-        total (int): The total to divide.
-        ratios (List[int]): A list of integer ratios.
-        minimums (List[int]): List of minimum values for each slot.
-
-    Returns:
-        List[int]: A list of integers guaranteed to sum to total.
-    """
-    if minimums:
-        ratios = [ratio if _min else 0 for ratio, _min in zip(ratios, minimums)]
-    total_ratio = sum(ratios)
-    assert total_ratio > 0, "Sum of ratios must be > 0"
-
-    total_remaining = total
-    distributed_total: List[int] = []
-    append = distributed_total.append
-    if minimums is None:
-        _minimums = [0] * len(ratios)
-    else:
-        _minimums = minimums
-    for ratio, minimum in zip(ratios, _minimums):
-        if total_ratio > 0:
-            distributed = max(minimum, ceil(ratio * total_remaining / total_ratio))
-        else:
-            distributed = total_remaining
-        append(distributed)
-        total_ratio -= ratio
-        total_remaining -= distributed
-    return distributed_total
-
-
-if __name__ == "__main__":
-    from dataclasses import dataclass
-
-    @dataclass
-    class E:
-
-        size: Optional[int] = None
-        ratio: int = 1
-        minimum_size: int = 1
-
-    resolved = ratio_resolve(110, [E(None, 1, 1), E(None, 1, 1), E(None, 1, 1)])
-    print(sum(resolved))

spaces/Big-Web/MMSD/env/Lib/site-packages/setuptools/_distutils/_collections.py

@@ -1,56 +0,0 @@
-import collections
-import itertools
-
-
-# from jaraco.collections 3.5.1
-class DictStack(list, collections.abc.Mapping):
-    """
-    A stack of dictionaries that behaves as a view on those dictionaries,
-    giving preference to the last.
-
-    >>> stack = DictStack([dict(a=1, c=2), dict(b=2, a=2)])
-    >>> stack['a']
-    2
-    >>> stack['b']
-    2
-    >>> stack['c']
-    2
-    >>> len(stack)
-    3
-    >>> stack.push(dict(a=3))
-    >>> stack['a']
-    3
-    >>> set(stack.keys()) == set(['a', 'b', 'c'])
-    True
-    >>> set(stack.items()) == set([('a', 3), ('b', 2), ('c', 2)])
-    True
-    >>> dict(**stack) == dict(stack) == dict(a=3, c=2, b=2)
-    True
-    >>> d = stack.pop()
-    >>> stack['a']
-    2
-    >>> d = stack.pop()
-    >>> stack['a']
-    1
-    >>> stack.get('b', None)
-    >>> 'c' in stack
-    True
-    """
-
-    def __iter__(self):
-        dicts = list.__iter__(self)
-        return iter(set(itertools.chain.from_iterable(c.keys() for c in dicts)))
-
-    def __getitem__(self, key):
-        for scope in reversed(tuple(list.__iter__(self))):
-            if key in scope:
-                return scope[key]
-        raise KeyError(key)
-
-    push = list.append
-
-    def __contains__(self, other):
-        return collections.abc.Mapping.__contains__(self, other)
-
-    def __len__(self):
-        return len(list(iter(self)))

spaces/Binettebob22/fast_diffusion2/index.html

@@ -1,16 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-  <head>
-    <meta charset="utf-8" />
-    <meta name="twitter:card" content="player"/>
-    <meta name="twitter:site" content=""/>
-    <meta name="twitter:player" content="https://omnibus-maximum-multiplier-places.hf.space"/>
-    <meta name="twitter:player:stream" content="https://omnibus-maximum-multiplier-places.hf.space"/>
-    <meta name="twitter:player:width" content="100%"/>
-    <meta name="twitter:player:height" content="600"/>    
-    <meta property="og:title" content="Embedded Live Viewer"/>
-    <meta property="og:description" content="Tweet Genie - A Huggingface Space"/>
-    <meta property="og:image" content="https://cdn.glitch.global/80dbe92e-ce75-44af-84d5-74a2e21e9e55/omnicard.png?v=1676772531627"/>
-    <!--<meta http-equiv="refresh" content="0; url=https://huggingface.co/spaces/corbt/tweet-genie">-->
-  </head>
-</html>

spaces/CVPR/Dual-Key_Backdoor_Attacks/app.py

@@ -1,2 +0,0 @@
-from demo import *
-launch_demo()

spaces/CVPR/Dual-Key_Backdoor_Attacks/datagen/detectron2/detectron2/evaluation/testing.py

@@ -1,78 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
-import logging
-import numpy as np
-import pprint
-import sys
-from collections import OrderedDict
-from collections.abc import Mapping
-
-
-def print_csv_format(results):
-    """
-    Print main metrics in a format similar to Detectron,
-    so that they are easy to copypaste into a spreadsheet.
-
-    Args:
-        results (OrderedDict[dict]): task_name -> {metric -> score}
-    """
-    assert isinstance(results, OrderedDict), results  # unordered results cannot be properly printed
-    logger = logging.getLogger(__name__)
-    for task, res in results.items():
-        # Don't print "AP-category" metrics since they are usually not tracked.
-        important_res = [(k, v) for k, v in res.items() if "-" not in k]
-        logger.info("copypaste: Task: {}".format(task))
-        logger.info("copypaste: " + ",".join([k[0] for k in important_res]))
-        logger.info("copypaste: " + ",".join(["{0:.4f}".format(k[1]) for k in important_res]))
-
-
-def verify_results(cfg, results):
-    """
-    Args:
-        results (OrderedDict[dict]): task_name -> {metric -> score}
-
-    Returns:
-        bool: whether the verification succeeds or not
-    """
-    expected_results = cfg.TEST.EXPECTED_RESULTS
-    if not len(expected_results):
-        return True
-
-    ok = True
-    for task, metric, expected, tolerance in expected_results:
-        actual = results[task][metric]
-        if not np.isfinite(actual):
-            ok = False
-        diff = abs(actual - expected)
-        if diff > tolerance:
-            ok = False
-
-    logger = logging.getLogger(__name__)
-    if not ok:
-        logger.error("Result verification failed!")
-        logger.error("Expected Results: " + str(expected_results))
-        logger.error("Actual Results: " + pprint.pformat(results))
-
-        sys.exit(1)
-    else:
-        logger.info("Results verification passed.")
-    return ok
-
-
-def flatten_results_dict(results):
-    """
-    Expand a hierarchical dict of scalars into a flat dict of scalars.
-    If results[k1][k2][k3] = v, the returned dict will have the entry
-    {"k1/k2/k3": v}.
-
-    Args:
-        results (dict):
-    """
-    r = {}
-    for k, v in results.items():
-        if isinstance(v, Mapping):
-            v = flatten_results_dict(v)
-            for kk, vv in v.items():
-                r[k + "/" + kk] = vv
-        else:
-            r[k] = v
-    return r

spaces/CVPR/LIVE/thrust/thrust/detail/allocator/tagged_allocator.h

@@ -1,101 +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>
-#include <thrust/detail/type_traits/pointer_traits.h>
-#include <thrust/iterator/iterator_traits.h>
-
-namespace thrust
-{
-namespace detail
-{
-
-template<typename T, typename Tag, typename Pointer> class tagged_allocator;
-
-template<typename Tag, typename Pointer>
-  class tagged_allocator<void, Tag, Pointer>
-{
-  public:
-    typedef void                                                                                 value_type;
-    typedef typename thrust::detail::pointer_traits<Pointer>::template rebind<void>::other       pointer;
-    typedef typename thrust::detail::pointer_traits<Pointer>::template rebind<const void>::other const_pointer;
-    typedef std::size_t                                                                          size_type;
-    typedef typename thrust::detail::pointer_traits<Pointer>::difference_type                    difference_type;
-    typedef Tag                                                                                  system_type;
-
-    template<typename U>
-      struct rebind
-    {
-      typedef tagged_allocator<U,Tag,Pointer> other;
-    }; // end rebind
-};
-
-template<typename T, typename Tag, typename Pointer>
-  class tagged_allocator
-{
-  public:
-    typedef T                                                                                 value_type;
-    typedef typename thrust::detail::pointer_traits<Pointer>::template rebind<T>::other       pointer;
-    typedef typename thrust::detail::pointer_traits<Pointer>::template rebind<const T>::other const_pointer;
-    typedef typename thrust::iterator_reference<pointer>::type                                reference;
-    typedef typename thrust::iterator_reference<const_pointer>::type                          const_reference;
-    typedef std::size_t                                                                       size_type;
-    typedef typename thrust::detail::pointer_traits<pointer>::difference_type                 difference_type;
-    typedef Tag                                                                               system_type;
-
-    template<typename U>
-      struct rebind
-    {
-      typedef tagged_allocator<U,Tag,Pointer> other;
-    }; // end rebind
-
-    __host__ __device__
-    inline tagged_allocator();
-
-    __host__ __device__
-    inline tagged_allocator(const tagged_allocator &);
-
-    template<typename U, typename OtherPointer>
-    __host__ __device__
-    inline tagged_allocator(const tagged_allocator<U, Tag, OtherPointer> &);
-
-    __host__ __device__
-    inline ~tagged_allocator();
-
-    __host__ __device__
-    pointer address(reference x) const;
-
-    __host__ __device__
-    const_pointer address(const_reference x) const;
-
-    size_type max_size() const;
-};
-
-template<typename T1, typename Pointer1, typename T2, typename Pointer2, typename Tag>
-__host__ __device__
-bool operator==(const tagged_allocator<T1,Pointer1,Tag> &, const tagged_allocator<T2,Pointer2,Tag> &);
-
-template<typename T1, typename Pointer1, typename T2, typename Pointer2, typename Tag>
-__host__ __device__
-bool operator!=(const tagged_allocator<T1,Pointer1,Tag> &, const tagged_allocator<T2,Pointer2,Tag> &);
-
-} // end detail
-} // end thrust
-
-#include <thrust/detail/allocator/tagged_allocator.inl>
-

spaces/CVPR/LIVE/thrust/thrust/system/cpp/detail/copy.h

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

spaces/CVPR/WALT/mmdet/models/necks/fpn_carafe.py

@@ -1,267 +0,0 @@
-import torch.nn as nn
-from mmcv.cnn import ConvModule, build_upsample_layer, xavier_init
-from mmcv.ops.carafe import CARAFEPack
-
-from ..builder import NECKS
-
-
-@NECKS.register_module()
-class FPN_CARAFE(nn.Module):
-    """FPN_CARAFE is a more flexible implementation of FPN. It allows more
-    choice for upsample methods during the top-down pathway.
-
-    It can reproduce the performance of ICCV 2019 paper
-    CARAFE: Content-Aware ReAssembly of FEatures
-    Please refer to https://arxiv.org/abs/1905.02188 for more details.
-
-    Args:
-        in_channels (list[int]): Number of channels for each input feature map.
-        out_channels (int): Output channels of feature pyramids.
-        num_outs (int): Number of output stages.
-        start_level (int): Start level of feature pyramids.
-            (Default: 0)
-        end_level (int): End level of feature pyramids.
-            (Default: -1 indicates the last level).
-        norm_cfg (dict): Dictionary to construct and config norm layer.
-        activate (str): Type of activation function in ConvModule
-            (Default: None indicates w/o activation).
-        order (dict): Order of components in ConvModule.
-        upsample (str): Type of upsample layer.
-        upsample_cfg (dict): Dictionary to construct and config upsample layer.
-    """
-
-    def __init__(self,
-                 in_channels,
-                 out_channels,
-                 num_outs,
-                 start_level=0,
-                 end_level=-1,
-                 norm_cfg=None,
-                 act_cfg=None,
-                 order=('conv', 'norm', 'act'),
-                 upsample_cfg=dict(
-                     type='carafe',
-                     up_kernel=5,
-                     up_group=1,
-                     encoder_kernel=3,
-                     encoder_dilation=1)):
-        super(FPN_CARAFE, self).__init__()
-        assert isinstance(in_channels, list)
-        self.in_channels = in_channels
-        self.out_channels = out_channels
-        self.num_ins = len(in_channels)
-        self.num_outs = num_outs
-        self.norm_cfg = norm_cfg
-        self.act_cfg = act_cfg
-        self.with_bias = norm_cfg is None
-        self.upsample_cfg = upsample_cfg.copy()
-        self.upsample = self.upsample_cfg.get('type')
-        self.relu = nn.ReLU(inplace=False)
-
-        self.order = order
-        assert order in [('conv', 'norm', 'act'), ('act', 'conv', 'norm')]
-
-        assert self.upsample in [
-            'nearest', 'bilinear', 'deconv', 'pixel_shuffle', 'carafe', None
-        ]
-        if self.upsample in ['deconv', 'pixel_shuffle']:
-            assert hasattr(
-                self.upsample_cfg,
-                'upsample_kernel') and self.upsample_cfg.upsample_kernel > 0
-            self.upsample_kernel = self.upsample_cfg.pop('upsample_kernel')
-
-        if end_level == -1:
-            self.backbone_end_level = self.num_ins
-            assert num_outs >= self.num_ins - start_level
-        else:
-            # if end_level < inputs, no extra level is allowed
-            self.backbone_end_level = end_level
-            assert end_level <= len(in_channels)
-            assert num_outs == end_level - start_level
-        self.start_level = start_level
-        self.end_level = end_level
-
-        self.lateral_convs = nn.ModuleList()
-        self.fpn_convs = nn.ModuleList()
-        self.upsample_modules = nn.ModuleList()
-
-        for i in range(self.start_level, self.backbone_end_level):
-            l_conv = ConvModule(
-                in_channels[i],
-                out_channels,
-                1,
-                norm_cfg=norm_cfg,
-                bias=self.with_bias,
-                act_cfg=act_cfg,
-                inplace=False,
-                order=self.order)
-            fpn_conv = ConvModule(
-                out_channels,
-                out_channels,
-                3,
-                padding=1,
-                norm_cfg=self.norm_cfg,
-                bias=self.with_bias,
-                act_cfg=act_cfg,
-                inplace=False,
-                order=self.order)
-            if i != self.backbone_end_level - 1:
-                upsample_cfg_ = self.upsample_cfg.copy()
-                if self.upsample == 'deconv':
-                    upsample_cfg_.update(
-                        in_channels=out_channels,
-                        out_channels=out_channels,
-                        kernel_size=self.upsample_kernel,
-                        stride=2,
-                        padding=(self.upsample_kernel - 1) // 2,
-                        output_padding=(self.upsample_kernel - 1) // 2)
-                elif self.upsample == 'pixel_shuffle':
-                    upsample_cfg_.update(
-                        in_channels=out_channels,
-                        out_channels=out_channels,
-                        scale_factor=2,
-                        upsample_kernel=self.upsample_kernel)
-                elif self.upsample == 'carafe':
-                    upsample_cfg_.update(channels=out_channels, scale_factor=2)
-                else:
-                    # suppress warnings
-                    align_corners = (None
-                                     if self.upsample == 'nearest' else False)
-                    upsample_cfg_.update(
-                        scale_factor=2,
-                        mode=self.upsample,
-                        align_corners=align_corners)
-                upsample_module = build_upsample_layer(upsample_cfg_)
-                self.upsample_modules.append(upsample_module)
-            self.lateral_convs.append(l_conv)
-            self.fpn_convs.append(fpn_conv)
-
-        # add extra conv layers (e.g., RetinaNet)
-        extra_out_levels = (
-            num_outs - self.backbone_end_level + self.start_level)
-        if extra_out_levels >= 1:
-            for i in range(extra_out_levels):
-                in_channels = (
-                    self.in_channels[self.backbone_end_level -
-                                     1] if i == 0 else out_channels)
-                extra_l_conv = ConvModule(
-                    in_channels,
-                    out_channels,
-                    3,
-                    stride=2,
-                    padding=1,
-                    norm_cfg=norm_cfg,
-                    bias=self.with_bias,
-                    act_cfg=act_cfg,
-                    inplace=False,
-                    order=self.order)
-                if self.upsample == 'deconv':
-                    upsampler_cfg_ = dict(
-                        in_channels=out_channels,
-                        out_channels=out_channels,
-                        kernel_size=self.upsample_kernel,
-                        stride=2,
-                        padding=(self.upsample_kernel - 1) // 2,
-                        output_padding=(self.upsample_kernel - 1) // 2)
-                elif self.upsample == 'pixel_shuffle':
-                    upsampler_cfg_ = dict(
-                        in_channels=out_channels,
-                        out_channels=out_channels,
-                        scale_factor=2,
-                        upsample_kernel=self.upsample_kernel)
-                elif self.upsample == 'carafe':
-                    upsampler_cfg_ = dict(
-                        channels=out_channels,
-                        scale_factor=2,
-                        **self.upsample_cfg)
-                else:
-                    # suppress warnings
-                    align_corners = (None
-                                     if self.upsample == 'nearest' else False)
-                    upsampler_cfg_ = dict(
-                        scale_factor=2,
-                        mode=self.upsample,
-                        align_corners=align_corners)
-                upsampler_cfg_['type'] = self.upsample
-                upsample_module = build_upsample_layer(upsampler_cfg_)
-                extra_fpn_conv = ConvModule(
-                    out_channels,
-                    out_channels,
-                    3,
-                    padding=1,
-                    norm_cfg=self.norm_cfg,
-                    bias=self.with_bias,
-                    act_cfg=act_cfg,
-                    inplace=False,
-                    order=self.order)
-                self.upsample_modules.append(upsample_module)
-                self.fpn_convs.append(extra_fpn_conv)
-                self.lateral_convs.append(extra_l_conv)
-
-    # default init_weights for conv(msra) and norm in ConvModule
-    def init_weights(self):
-        """Initialize the weights of module."""
-        for m in self.modules():
-            if isinstance(m, (nn.Conv2d, nn.ConvTranspose2d)):
-                xavier_init(m, distribution='uniform')
-        for m in self.modules():
-            if isinstance(m, CARAFEPack):
-                m.init_weights()
-
-    def slice_as(self, src, dst):
-        """Slice ``src`` as ``dst``
-
-        Note:
-            ``src`` should have the same or larger size than ``dst``.
-
-        Args:
-            src (torch.Tensor): Tensors to be sliced.
-            dst (torch.Tensor): ``src`` will be sliced to have the same
-                size as ``dst``.
-
-        Returns:
-            torch.Tensor: Sliced tensor.
-        """
-        assert (src.size(2) >= dst.size(2)) and (src.size(3) >= dst.size(3))
-        if src.size(2) == dst.size(2) and src.size(3) == dst.size(3):
-            return src
-        else:
-            return src[:, :, :dst.size(2), :dst.size(3)]
-
-    def tensor_add(self, a, b):
-        """Add tensors ``a`` and ``b`` that might have different sizes."""
-        if a.size() == b.size():
-            c = a + b
-        else:
-            c = a + self.slice_as(b, a)
-        return c
-
-    def forward(self, inputs):
-        """Forward function."""
-        assert len(inputs) == len(self.in_channels)
-
-        # build laterals
-        laterals = []
-        for i, lateral_conv in enumerate(self.lateral_convs):
-            if i <= self.backbone_end_level - self.start_level:
-                input = inputs[min(i + self.start_level, len(inputs) - 1)]
-            else:
-                input = laterals[-1]
-            lateral = lateral_conv(input)
-            laterals.append(lateral)
-
-        # build top-down path
-        for i in range(len(laterals) - 1, 0, -1):
-            if self.upsample is not None:
-                upsample_feat = self.upsample_modules[i - 1](laterals[i])
-            else:
-                upsample_feat = laterals[i]
-            laterals[i - 1] = self.tensor_add(laterals[i - 1], upsample_feat)
-
-        # build outputs
-        num_conv_outs = len(self.fpn_convs)
-        outs = []
-        for i in range(num_conv_outs):
-            out = self.fpn_convs[i](laterals[i])
-            outs.append(out)
-        return tuple(outs)