- 
-
-[Pokemon](https://huggingface.co/datasets/huggan/pokemon) 데이터셋을 사용할 경우:
-
-```bash
-accelerate launch train_unconditional.py \
- --dataset_name="huggan/pokemon" \
- --resolution=64 \
- --output_dir="ddpm-ema-pokemon-64" \
- --train_batch_size=16 \
- --num_epochs=100 \
- --gradient_accumulation_steps=1 \
- --learning_rate=1e-4 \
- --lr_warmup_steps=500 \
- --mixed_precision=no \
- --push_to_hub
-```
-
-
-
- 
-
-
-### 여러개의 GPU로 훈련하기
-
-`accelerate`을 사용하면 원활한 다중 GPU 훈련이 가능합니다. `accelerate`을 사용하여 분산 훈련을 실행하려면 [여기](https://huggingface.co/docs/accelerate/basic_tutorials/launch) 지침을 따르세요. 다음은 명령어 예제입니다.
-
-```bash
-accelerate launch --mixed_precision="fp16" --multi_gpu train_unconditional.py \
- --dataset_name="huggan/pokemon" \
- --resolution=64 --center_crop --random_flip \
- --output_dir="ddpm-ema-pokemon-64" \
- --train_batch_size=16 \
- --num_epochs=100 \
- --gradient_accumulation_steps=1 \
- --use_ema \
- --learning_rate=1e-4 \
- --lr_warmup_steps=500 \
- --mixed_precision="fp16" \
- --logger="wandb" \
- --push_to_hub
-```
diff --git a/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/src/diffusers/pipelines/repaint/pipeline_repaint.py b/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/src/diffusers/pipelines/repaint/pipeline_repaint.py
deleted file mode 100644
index 8200b9db630dc862fc9e3e2e1e5aa2fd3281cec7..0000000000000000000000000000000000000000
--- a/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/src/diffusers/pipelines/repaint/pipeline_repaint.py
+++ /dev/null
@@ -1,232 +0,0 @@
-# Copyright 2023 ETH Zurich Computer Vision Lab and The HuggingFace Team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-
-import warnings
-from typing import List, Optional, Tuple, Union
-
-import numpy as np
-import PIL
-import torch
-
-from ...models import UNet2DModel
-from ...schedulers import RePaintScheduler
-from ...utils import PIL_INTERPOLATION, logging, randn_tensor
-from ..pipeline_utils import DiffusionPipeline, ImagePipelineOutput
-
-
-logger = logging.get_logger(__name__) # pylint: disable=invalid-name
-
-
-# Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion_img2img.preprocess
-def _preprocess_image(image: Union[List, PIL.Image.Image, torch.Tensor]):
- warnings.warn(
- "The preprocess method is deprecated and will be removed in a future version. Please"
- " use VaeImageProcessor.preprocess instead",
- FutureWarning,
- )
- if isinstance(image, torch.Tensor):
- return image
- elif isinstance(image, PIL.Image.Image):
- image = [image]
-
- if isinstance(image[0], PIL.Image.Image):
- w, h = image[0].size
- w, h = (x - x % 8 for x in (w, h)) # resize to integer multiple of 8
-
- image = [np.array(i.resize((w, h), resample=PIL_INTERPOLATION["lanczos"]))[None, :] for i in image]
- image = np.concatenate(image, axis=0)
- image = np.array(image).astype(np.float32) / 255.0
- image = image.transpose(0, 3, 1, 2)
- image = 2.0 * image - 1.0
- image = torch.from_numpy(image)
- elif isinstance(image[0], torch.Tensor):
- image = torch.cat(image, dim=0)
- return image
-
-
-def _preprocess_mask(mask: Union[List, PIL.Image.Image, torch.Tensor]):
- if isinstance(mask, torch.Tensor):
- return mask
- elif isinstance(mask, PIL.Image.Image):
- mask = [mask]
-
- if isinstance(mask[0], PIL.Image.Image):
- w, h = mask[0].size
- w, h = (x - x % 32 for x in (w, h)) # resize to integer multiple of 32
- mask = [np.array(m.convert("L").resize((w, h), resample=PIL_INTERPOLATION["nearest"]))[None, :] for m in mask]
- mask = np.concatenate(mask, axis=0)
- mask = mask.astype(np.float32) / 255.0
- mask[mask < 0.5] = 0
- mask[mask >= 0.5] = 1
- mask = torch.from_numpy(mask)
- elif isinstance(mask[0], torch.Tensor):
- mask = torch.cat(mask, dim=0)
- return mask
-
-
-class RePaintPipeline(DiffusionPipeline):
- r"""
- Pipeline for image inpainting using RePaint.
-
- This model inherits from [`DiffusionPipeline`]. Check the superclass documentation for the generic methods
- implemented for all pipelines (downloading, saving, running on a particular device, etc.).
-
- Parameters:
- unet ([`UNet2DModel`]):
- A `UNet2DModel` to denoise the encoded image latents.
- scheduler ([`RePaintScheduler`]):
- A `RePaintScheduler` to be used in combination with `unet` to denoise the encoded image.
- """
-
- unet: UNet2DModel
- scheduler: RePaintScheduler
-
- def __init__(self, unet, scheduler):
- super().__init__()
- self.register_modules(unet=unet, scheduler=scheduler)
-
- @torch.no_grad()
- def __call__(
- self,
- image: Union[torch.Tensor, PIL.Image.Image],
- mask_image: Union[torch.Tensor, PIL.Image.Image],
- num_inference_steps: int = 250,
- eta: float = 0.0,
- jump_length: int = 10,
- jump_n_sample: int = 10,
- generator: Optional[Union[torch.Generator, List[torch.Generator]]] = None,
- output_type: Optional[str] = "pil",
- return_dict: bool = True,
- ) -> Union[ImagePipelineOutput, Tuple]:
- r"""
- The call function to the pipeline for generation.
-
- Args:
- image (`torch.FloatTensor` or `PIL.Image.Image`):
- The original image to inpaint on.
- mask_image (`torch.FloatTensor` or `PIL.Image.Image`):
- The mask_image where 0.0 define which part of the original image to inpaint.
- num_inference_steps (`int`, *optional*, defaults to 1000):
- The number of denoising steps. More denoising steps usually lead to a higher quality image at the
- expense of slower inference.
- eta (`float`):
- The weight of the added noise in a diffusion step. Its value is between 0.0 and 1.0; 0.0 corresponds to
- DDIM and 1.0 is the DDPM scheduler.
- jump_length (`int`, *optional*, defaults to 10):
- The number of steps taken forward in time before going backward in time for a single jump ("j" in
- RePaint paper). Take a look at Figure 9 and 10 in the [paper](https://arxiv.org/pdf/2201.09865.pdf).
- jump_n_sample (`int`, *optional*, defaults to 10):
- The number of times to make a forward time jump for a given chosen time sample. Take a look at Figure 9
- and 10 in the [paper](https://arxiv.org/pdf/2201.09865.pdf).
- generator (`torch.Generator`, *optional*):
- A [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) to make
- generation deterministic.
- output_type (`str`, `optional`, defaults to `"pil"`):
- The output format of the generated image. Choose between `PIL.Image` or `np.array`.
- return_dict (`bool`, *optional*, defaults to `True`):
- Whether or not to return a [`ImagePipelineOutput`] instead of a plain tuple.
-
- Example:
-
- ```py
- >>> from io import BytesIO
- >>> import torch
- >>> import PIL
- >>> import requests
- >>> from diffusers import RePaintPipeline, RePaintScheduler
-
-
- >>> def download_image(url):
- ... response = requests.get(url)
- ... return PIL.Image.open(BytesIO(response.content)).convert("RGB")
-
-
- >>> img_url = "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/repaint/celeba_hq_256.png"
- >>> mask_url = "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/repaint/mask_256.png"
-
- >>> # Load the original image and the mask as PIL images
- >>> original_image = download_image(img_url).resize((256, 256))
- >>> mask_image = download_image(mask_url).resize((256, 256))
-
- >>> # Load the RePaint scheduler and pipeline based on a pretrained DDPM model
- >>> scheduler = RePaintScheduler.from_pretrained("google/ddpm-ema-celebahq-256")
- >>> pipe = RePaintPipeline.from_pretrained("google/ddpm-ema-celebahq-256", scheduler=scheduler)
- >>> pipe = pipe.to("cuda")
-
- >>> generator = torch.Generator(device="cuda").manual_seed(0)
- >>> output = pipe(
- ... image=original_image,
- ... mask_image=mask_image,
- ... num_inference_steps=250,
- ... eta=0.0,
- ... jump_length=10,
- ... jump_n_sample=10,
- ... generator=generator,
- ... )
- >>> inpainted_image = output.images[0]
- ```
-
- Returns:
- [`~pipelines.ImagePipelineOutput`] or `tuple`:
- If `return_dict` is `True`, [`~pipelines.ImagePipelineOutput`] is returned, otherwise a `tuple` is
- returned where the first element is a list with the generated images.
- """
-
- original_image = image
-
- original_image = _preprocess_image(original_image)
- original_image = original_image.to(device=self._execution_device, dtype=self.unet.dtype)
- mask_image = _preprocess_mask(mask_image)
- mask_image = mask_image.to(device=self._execution_device, dtype=self.unet.dtype)
-
- batch_size = original_image.shape[0]
-
- # sample gaussian noise to begin the loop
- if isinstance(generator, list) and len(generator) != batch_size:
- raise ValueError(
- f"You have passed a list of generators of length {len(generator)}, but requested an effective batch"
- f" size of {batch_size}. Make sure the batch size matches the length of the generators."
- )
-
- image_shape = original_image.shape
- image = randn_tensor(image_shape, generator=generator, device=self._execution_device, dtype=self.unet.dtype)
-
- # set step values
- self.scheduler.set_timesteps(num_inference_steps, jump_length, jump_n_sample, self._execution_device)
- self.scheduler.eta = eta
-
- t_last = self.scheduler.timesteps[0] + 1
- generator = generator[0] if isinstance(generator, list) else generator
- for i, t in enumerate(self.progress_bar(self.scheduler.timesteps)):
- if t < t_last:
- # predict the noise residual
- model_output = self.unet(image, t).sample
- # compute previous image: x_t -> x_t-1
- image = self.scheduler.step(model_output, t, image, original_image, mask_image, generator).prev_sample
-
- else:
- # compute the reverse: x_t-1 -> x_t
- image = self.scheduler.undo_step(image, t_last, generator)
- t_last = t
-
- image = (image / 2 + 0.5).clamp(0, 1)
- image = image.cpu().permute(0, 2, 3, 1).numpy()
- if output_type == "pil":
- image = self.numpy_to_pil(image)
-
- if not return_dict:
- return (image,)
-
- return ImagePipelineOutput(images=image)
diff --git a/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/src/diffusers/utils/doc_utils.py b/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/src/diffusers/utils/doc_utils.py
deleted file mode 100644
index f1f87743f99802931334bd51bf99985775116d59..0000000000000000000000000000000000000000
--- a/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/src/diffusers/utils/doc_utils.py
+++ /dev/null
@@ -1,38 +0,0 @@
-# Copyright 2023 The HuggingFace Team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""
-Doc utilities: Utilities related to documentation
-"""
-import re
-
-
-def replace_example_docstring(example_docstring):
- def docstring_decorator(fn):
- func_doc = fn.__doc__
- lines = func_doc.split("\n")
- i = 0
- while i < len(lines) and re.search(r"^\s*Examples?:\s*$", lines[i]) is None:
- i += 1
- if i < len(lines):
- lines[i] = example_docstring
- func_doc = "\n".join(lines)
- else:
- raise ValueError(
- f"The function {fn} should have an empty 'Examples:' in its docstring as placeholder, "
- f"current docstring is:\n{func_doc}"
- )
- fn.__doc__ = func_doc
- return fn
-
- return docstring_decorator
diff --git a/spaces/Andy1621/uniformer_image_detection/configs/scnet/scnet_r50_fpn_1x_coco.py b/spaces/Andy1621/uniformer_image_detection/configs/scnet/scnet_r50_fpn_1x_coco.py
deleted file mode 100644
index e4215a6d2d0b90f8ccd9c1291f6ca222c0ff554f..0000000000000000000000000000000000000000
--- a/spaces/Andy1621/uniformer_image_detection/configs/scnet/scnet_r50_fpn_1x_coco.py
+++ /dev/null
@@ -1,136 +0,0 @@
-_base_ = '../htc/htc_r50_fpn_1x_coco.py'
-# model settings
-model = dict(
- type='SCNet',
- roi_head=dict(
- _delete_=True,
- type='SCNetRoIHead',
- num_stages=3,
- stage_loss_weights=[1, 0.5, 0.25],
- bbox_roi_extractor=dict(
- type='SingleRoIExtractor',
- roi_layer=dict(type='RoIAlign', output_size=7, sampling_ratio=0),
- out_channels=256,
- featmap_strides=[4, 8, 16, 32]),
- bbox_head=[
- dict(
- type='SCNetBBoxHead',
- num_shared_fcs=2,
- in_channels=256,
- fc_out_channels=1024,
- roi_feat_size=7,
- num_classes=80,
- bbox_coder=dict(
- type='DeltaXYWHBBoxCoder',
- target_means=[0., 0., 0., 0.],
- target_stds=[0.1, 0.1, 0.2, 0.2]),
- reg_class_agnostic=True,
- loss_cls=dict(
- type='CrossEntropyLoss',
- use_sigmoid=False,
- loss_weight=1.0),
- loss_bbox=dict(type='SmoothL1Loss', beta=1.0,
- loss_weight=1.0)),
- dict(
- type='SCNetBBoxHead',
- num_shared_fcs=2,
- in_channels=256,
- fc_out_channels=1024,
- roi_feat_size=7,
- num_classes=80,
- bbox_coder=dict(
- type='DeltaXYWHBBoxCoder',
- target_means=[0., 0., 0., 0.],
- target_stds=[0.05, 0.05, 0.1, 0.1]),
- reg_class_agnostic=True,
- loss_cls=dict(
- type='CrossEntropyLoss',
- use_sigmoid=False,
- loss_weight=1.0),
- loss_bbox=dict(type='SmoothL1Loss', beta=1.0,
- loss_weight=1.0)),
- dict(
- type='SCNetBBoxHead',
- num_shared_fcs=2,
- in_channels=256,
- fc_out_channels=1024,
- roi_feat_size=7,
- num_classes=80,
- bbox_coder=dict(
- type='DeltaXYWHBBoxCoder',
- target_means=[0., 0., 0., 0.],
- target_stds=[0.033, 0.033, 0.067, 0.067]),
- reg_class_agnostic=True,
- loss_cls=dict(
- type='CrossEntropyLoss',
- use_sigmoid=False,
- loss_weight=1.0),
- loss_bbox=dict(type='SmoothL1Loss', beta=1.0, loss_weight=1.0))
- ],
- mask_roi_extractor=dict(
- type='SingleRoIExtractor',
- roi_layer=dict(type='RoIAlign', output_size=14, sampling_ratio=0),
- out_channels=256,
- featmap_strides=[4, 8, 16, 32]),
- mask_head=dict(
- type='SCNetMaskHead',
- num_convs=12,
- in_channels=256,
- conv_out_channels=256,
- num_classes=80,
- conv_to_res=True,
- loss_mask=dict(
- type='CrossEntropyLoss', use_mask=True, loss_weight=1.0)),
- semantic_roi_extractor=dict(
- type='SingleRoIExtractor',
- roi_layer=dict(type='RoIAlign', output_size=14, sampling_ratio=0),
- out_channels=256,
- featmap_strides=[8]),
- semantic_head=dict(
- type='SCNetSemanticHead',
- num_ins=5,
- fusion_level=1,
- num_convs=4,
- in_channels=256,
- conv_out_channels=256,
- num_classes=183,
- ignore_label=255,
- loss_weight=0.2,
- conv_to_res=True),
- glbctx_head=dict(
- type='GlobalContextHead',
- num_convs=4,
- in_channels=256,
- conv_out_channels=256,
- num_classes=80,
- loss_weight=3.0,
- conv_to_res=True),
- feat_relay_head=dict(
- type='FeatureRelayHead',
- in_channels=1024,
- out_conv_channels=256,
- roi_feat_size=7,
- scale_factor=2)))
-
-# uncomment below code to enable test time augmentations
-# img_norm_cfg = dict(
-# mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)
-# test_pipeline = [
-# dict(type='LoadImageFromFile'),
-# dict(
-# type='MultiScaleFlipAug',
-# img_scale=[(600, 900), (800, 1200), (1000, 1500), (1200, 1800),
-# (1400, 2100)],
-# flip=True,
-# transforms=[
-# dict(type='Resize', keep_ratio=True),
-# dict(type='RandomFlip', flip_ratio=0.5),
-# dict(type='Normalize', **img_norm_cfg),
-# dict(type='Pad', size_divisor=32),
-# dict(type='ImageToTensor', keys=['img']),
-# dict(type='Collect', keys=['img']),
-# ])
-# ]
-# data = dict(
-# val=dict(pipeline=test_pipeline),
-# test=dict(pipeline=test_pipeline))
diff --git a/spaces/Andy1621/uniformer_image_detection/mmdet/core/utils/dist_utils.py b/spaces/Andy1621/uniformer_image_detection/mmdet/core/utils/dist_utils.py
deleted file mode 100644
index 5fe77753313783f95bd7111038ef8b58ee4e4bc5..0000000000000000000000000000000000000000
--- a/spaces/Andy1621/uniformer_image_detection/mmdet/core/utils/dist_utils.py
+++ /dev/null
@@ -1,69 +0,0 @@
-import warnings
-from collections import OrderedDict
-
-import torch.distributed as dist
-from mmcv.runner import OptimizerHook
-from torch._utils import (_flatten_dense_tensors, _take_tensors,
- _unflatten_dense_tensors)
-
-
-def _allreduce_coalesced(tensors, world_size, bucket_size_mb=-1):
- if bucket_size_mb > 0:
- bucket_size_bytes = bucket_size_mb * 1024 * 1024
- buckets = _take_tensors(tensors, bucket_size_bytes)
- else:
- buckets = OrderedDict()
- for tensor in tensors:
- tp = tensor.type()
- if tp not in buckets:
- buckets[tp] = []
- buckets[tp].append(tensor)
- buckets = buckets.values()
-
- for bucket in buckets:
- flat_tensors = _flatten_dense_tensors(bucket)
- dist.all_reduce(flat_tensors)
- flat_tensors.div_(world_size)
- for tensor, synced in zip(
- bucket, _unflatten_dense_tensors(flat_tensors, bucket)):
- tensor.copy_(synced)
-
-
-def allreduce_grads(params, coalesce=True, bucket_size_mb=-1):
- """Allreduce gradients.
-
- Args:
- params (list[torch.Parameters]): List of parameters of a model
- coalesce (bool, optional): Whether allreduce parameters as a whole.
- Defaults to True.
- bucket_size_mb (int, optional): Size of bucket, the unit is MB.
- Defaults to -1.
- """
- grads = [
- param.grad.data for param in params
- if param.requires_grad and param.grad is not None
- ]
- world_size = dist.get_world_size()
- if coalesce:
- _allreduce_coalesced(grads, world_size, bucket_size_mb)
- else:
- for tensor in grads:
- dist.all_reduce(tensor.div_(world_size))
-
-
-class DistOptimizerHook(OptimizerHook):
- """Deprecated optimizer hook for distributed training."""
-
- def __init__(self, *args, **kwargs):
- warnings.warn('"DistOptimizerHook" is deprecated, please switch to'
- '"mmcv.runner.OptimizerHook".')
- super().__init__(*args, **kwargs)
-
-
-def reduce_mean(tensor):
- """"Obtain the mean of tensor on different GPUs."""
- if not (dist.is_available() and dist.is_initialized()):
- return tensor
- tensor = tensor.clone()
- dist.all_reduce(tensor.div_(dist.get_world_size()), op=dist.ReduceOp.SUM)
- return tensor
diff --git a/spaces/Aniemore/Russian-Emotion-Recognition/app.py b/spaces/Aniemore/Russian-Emotion-Recognition/app.py
deleted file mode 100644
index 38e440b960524c11227aede0578afc573eb5e1f9..0000000000000000000000000000000000000000
--- a/spaces/Aniemore/Russian-Emotion-Recognition/app.py
+++ /dev/null
@@ -1,74 +0,0 @@
-from transformers import pipeline
-import gradio as gr
-from pyctcdecode import BeamSearchDecoderCTC
-import os
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-import torchaudio
-from transformers import AutoConfig, AutoModel, Wav2Vec2FeatureExtractor
-import librosa
-import numpy as np
-import subprocess
-import time
-
-TRUST = True
-SR = 16000
-
-
-def resample(speech_array, sampling_rate):
- speech = torch.from_numpy(speech_array)
- print(speech, speech.shape, sampling_rate)
- resampler = torchaudio.transforms.Resample(sampling_rate)
- speech = resampler(speech).squeeze().numpy()
- return speech
-
-
-def predict(speech_array, sampling_rate):
- speech = resample(speech_array, sampling_rate)
- print(speech, speech.shape)
- inputs = feature_extractor(speech, sampling_rate=SR, return_tensors="pt", padding=True)
- inputs = {key: inputs[key].to(device) for key in inputs}
-
- with torch.no_grad():
- logits = model.to(device)(**inputs).logits
-
- scores = F.softmax(logits, dim=1).detach().cpu().numpy()[0]
- outputs = {config.id2label[i]: round(float(score), 3) for i, score in enumerate(scores)}
- return outputs
-
-
-config = AutoConfig.from_pretrained('Aniemore/wav2vec2-xlsr-53-russian-emotion-recognition', trust_remote_code=TRUST)
-model = AutoModel.from_pretrained("Aniemore/wav2vec2-xlsr-53-russian-emotion-recognition", trust_remote_code=TRUST)
-feature_extractor = Wav2Vec2FeatureExtractor.from_pretrained("Aniemore/wav2vec2-xlsr-53-russian-emotion-recognition")
-
-device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-print(device)
-
-
-def recognize(audio):
- sr, audio_array = audio
- audio_array = audio_array.astype(np.float32)
- state = predict(audio_array, sr)
- return state
-
-
-def test_some(audio):
- sr, audio_array = audio
- audio_array = audio_array.astype(np.float32)
-
- return (sr, audio_array)
-
-
-interface = gr.Interface(
- fn=recognize,
- inputs=[
- gr.Audio(source="microphone", label="Скажите что-нибудь...")
- ],
- outputs=[
- gr.Label(num_top_classes=7)
- ],
- live=False
- )
-
-gr.TabbedInterface([interface], ["Russian Emotion Recognition"]).launch(debug=True)
\ No newline at end of file
diff --git a/spaces/AnishKumbhar/ChatBot/text-generation-webui-main/modules/ui_default.py b/spaces/AnishKumbhar/ChatBot/text-generation-webui-main/modules/ui_default.py
deleted file mode 100644
index 7db6f0d93abcc36354b0d687d83c865b8f5dd406..0000000000000000000000000000000000000000
--- a/spaces/AnishKumbhar/ChatBot/text-generation-webui-main/modules/ui_default.py
+++ /dev/null
@@ -1,104 +0,0 @@
-import gradio as gr
-
-from modules import logits, shared, ui, utils
-from modules.prompts import count_tokens, load_prompt
-from modules.text_generation import (
- generate_reply_wrapper,
- get_token_ids,
- stop_everything_event
-)
-from modules.utils import gradio
-
-inputs = ('textbox-default', 'interface_state')
-outputs = ('output_textbox', 'html-default')
-
-
-def create_ui():
- mu = shared.args.multi_user
- with gr.Tab('Default', elem_id='default-tab'):
- shared.gradio['last_input-default'] = gr.State('')
- with gr.Row():
- with gr.Column():
- with gr.Row():
- shared.gradio['textbox-default'] = gr.Textbox(value='', lines=27, label='Input', elem_classes=['textbox_default', 'add_scrollbar'])
- shared.gradio['token-counter-default'] = gr.HTML(value="0", elem_classes=["token-counter", "default-token-counter"])
-
- with gr.Row():
- shared.gradio['Generate-default'] = gr.Button('Generate', variant='primary')
- shared.gradio['Stop-default'] = gr.Button('Stop', elem_id='stop')
- shared.gradio['Continue-default'] = gr.Button('Continue')
-
- with gr.Row():
- shared.gradio['prompt_menu-default'] = gr.Dropdown(choices=utils.get_available_prompts(), value='None', label='Prompt', elem_classes='slim-dropdown')
- ui.create_refresh_button(shared.gradio['prompt_menu-default'], lambda: None, lambda: {'choices': utils.get_available_prompts()}, 'refresh-button', interactive=not mu)
- shared.gradio['save_prompt-default'] = gr.Button('💾', elem_classes='refresh-button', interactive=not mu)
- shared.gradio['delete_prompt-default'] = gr.Button('🗑️', elem_classes='refresh-button', interactive=not mu)
-
- with gr.Column():
- with gr.Tab('Raw'):
- shared.gradio['output_textbox'] = gr.Textbox(lines=27, label='Output', elem_id='textbox-default', elem_classes=['textbox_default_output', 'add_scrollbar'])
-
- with gr.Tab('Markdown'):
- shared.gradio['markdown_render-default'] = gr.Button('Render')
- shared.gradio['markdown-default'] = gr.Markdown()
-
- with gr.Tab('HTML'):
- shared.gradio['html-default'] = gr.HTML()
-
- with gr.Tab('Logits'):
- with gr.Row():
- with gr.Column(scale=10):
- shared.gradio['get_logits-default'] = gr.Button('Get next token probabilities')
- with gr.Column(scale=1):
- shared.gradio['use_samplers-default'] = gr.Checkbox(label='Use samplers', value=True, elem_classes=['no-background'])
-
- with gr.Row():
- shared.gradio['logits-default'] = gr.Textbox(lines=23, label='Output', elem_classes=['textbox_logits', 'add_scrollbar'])
- shared.gradio['logits-default-previous'] = gr.Textbox(lines=23, label='Previous output', elem_classes=['textbox_logits', 'add_scrollbar'])
-
- with gr.Tab('Tokens'):
- shared.gradio['get_tokens-default'] = gr.Button('Get token IDs for the input')
- shared.gradio['tokens-default'] = gr.Textbox(lines=23, label='Tokens', elem_classes=['textbox_logits', 'add_scrollbar', 'monospace'])
-
-
-def create_event_handlers():
- shared.gradio['Generate-default'].click(
- lambda x: x, gradio('textbox-default'), gradio('last_input-default')).then(
- ui.gather_interface_values, gradio(shared.input_elements), gradio('interface_state')).then(
- generate_reply_wrapper, gradio(inputs), gradio(outputs), show_progress=False).then(
- ui.gather_interface_values, gradio(shared.input_elements), gradio('interface_state')).then(
- lambda: None, None, None, _js=f'() => {{{ui.audio_notification_js}}}')
-
- shared.gradio['textbox-default'].submit(
- lambda x: x, gradio('textbox-default'), gradio('last_input-default')).then(
- ui.gather_interface_values, gradio(shared.input_elements), gradio('interface_state')).then(
- generate_reply_wrapper, gradio(inputs), gradio(outputs), show_progress=False).then(
- ui.gather_interface_values, gradio(shared.input_elements), gradio('interface_state')).then(
- lambda: None, None, None, _js=f'() => {{{ui.audio_notification_js}}}')
-
- shared.gradio['markdown_render-default'].click(lambda x: x, gradio('output_textbox'), gradio('markdown-default'), queue=False)
- shared.gradio['Continue-default'].click(
- ui.gather_interface_values, gradio(shared.input_elements), gradio('interface_state')).then(
- generate_reply_wrapper, [shared.gradio['output_textbox']] + gradio(inputs)[1:], gradio(outputs), show_progress=False).then(
- ui.gather_interface_values, gradio(shared.input_elements), gradio('interface_state')).then(
- lambda: None, None, None, _js=f'() => {{{ui.audio_notification_js}}}')
-
- shared.gradio['Stop-default'].click(stop_everything_event, None, None, queue=False)
- shared.gradio['prompt_menu-default'].change(load_prompt, gradio('prompt_menu-default'), gradio('textbox-default'), show_progress=False)
- shared.gradio['save_prompt-default'].click(
- lambda x: x, gradio('textbox-default'), gradio('save_contents')).then(
- lambda: 'prompts/', None, gradio('save_root')).then(
- lambda: utils.current_time() + '.txt', None, gradio('save_filename')).then(
- lambda: gr.update(visible=True), None, gradio('file_saver'))
-
- shared.gradio['delete_prompt-default'].click(
- lambda: 'prompts/', None, gradio('delete_root')).then(
- lambda x: x + '.txt', gradio('prompt_menu-default'), gradio('delete_filename')).then(
- lambda: gr.update(visible=True), None, gradio('file_deleter'))
-
- shared.gradio['textbox-default'].change(lambda x: f"{count_tokens(x)}", gradio('textbox-default'), gradio('token-counter-default'), show_progress=False)
- shared.gradio['get_logits-default'].click(
- ui.gather_interface_values, gradio(shared.input_elements), gradio('interface_state')).then(
- logits.get_next_logits, gradio('textbox-default', 'interface_state', 'use_samplers-default', 'logits-default'), gradio('logits-default', 'logits-default-previous'), show_progress=False)
-
- shared.gradio['get_tokens-default'].click(get_token_ids, gradio('textbox-default'), gradio('tokens-default'), show_progress=False)
diff --git a/spaces/Anonymous-sub/Rerender/ControlNet/ldm/modules/midas/api.py b/spaces/Anonymous-sub/Rerender/ControlNet/ldm/modules/midas/api.py
deleted file mode 100644
index b58ebbffd942a2fc22264f0ab47e400c26b9f41c..0000000000000000000000000000000000000000
--- a/spaces/Anonymous-sub/Rerender/ControlNet/ldm/modules/midas/api.py
+++ /dev/null
@@ -1,170 +0,0 @@
-# based on https://github.com/isl-org/MiDaS
-
-import cv2
-import torch
-import torch.nn as nn
-from torchvision.transforms import Compose
-
-from ldm.modules.midas.midas.dpt_depth import DPTDepthModel
-from ldm.modules.midas.midas.midas_net import MidasNet
-from ldm.modules.midas.midas.midas_net_custom import MidasNet_small
-from ldm.modules.midas.midas.transforms import Resize, NormalizeImage, PrepareForNet
-
-
-ISL_PATHS = {
- "dpt_large": "midas_models/dpt_large-midas-2f21e586.pt",
- "dpt_hybrid": "midas_models/dpt_hybrid-midas-501f0c75.pt",
- "midas_v21": "",
- "midas_v21_small": "",
-}
-
-
-def disabled_train(self, mode=True):
- """Overwrite model.train with this function to make sure train/eval mode
- does not change anymore."""
- return self
-
-
-def load_midas_transform(model_type):
- # https://github.com/isl-org/MiDaS/blob/master/run.py
- # load transform only
- if model_type == "dpt_large": # DPT-Large
- net_w, net_h = 384, 384
- resize_mode = "minimal"
- normalization = NormalizeImage(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
-
- elif model_type == "dpt_hybrid": # DPT-Hybrid
- net_w, net_h = 384, 384
- resize_mode = "minimal"
- normalization = NormalizeImage(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
-
- elif model_type == "midas_v21":
- net_w, net_h = 384, 384
- resize_mode = "upper_bound"
- normalization = NormalizeImage(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
-
- elif model_type == "midas_v21_small":
- net_w, net_h = 256, 256
- resize_mode = "upper_bound"
- normalization = NormalizeImage(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
-
- else:
- assert False, f"model_type '{model_type}' not implemented, use: --model_type large"
-
- transform = Compose(
- [
- Resize(
- net_w,
- net_h,
- resize_target=None,
- keep_aspect_ratio=True,
- ensure_multiple_of=32,
- resize_method=resize_mode,
- image_interpolation_method=cv2.INTER_CUBIC,
- ),
- normalization,
- PrepareForNet(),
- ]
- )
-
- return transform
-
-
-def load_model(model_type):
- # https://github.com/isl-org/MiDaS/blob/master/run.py
- # load network
- model_path = ISL_PATHS[model_type]
- if model_type == "dpt_large": # DPT-Large
- model = DPTDepthModel(
- path=model_path,
- backbone="vitl16_384",
- non_negative=True,
- )
- net_w, net_h = 384, 384
- resize_mode = "minimal"
- normalization = NormalizeImage(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
-
- elif model_type == "dpt_hybrid": # DPT-Hybrid
- model = DPTDepthModel(
- path=model_path,
- backbone="vitb_rn50_384",
- non_negative=True,
- )
- net_w, net_h = 384, 384
- resize_mode = "minimal"
- normalization = NormalizeImage(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
-
- elif model_type == "midas_v21":
- model = MidasNet(model_path, non_negative=True)
- net_w, net_h = 384, 384
- resize_mode = "upper_bound"
- normalization = NormalizeImage(
- mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]
- )
-
- elif model_type == "midas_v21_small":
- model = MidasNet_small(model_path, features=64, backbone="efficientnet_lite3", exportable=True,
- non_negative=True, blocks={'expand': True})
- net_w, net_h = 256, 256
- resize_mode = "upper_bound"
- normalization = NormalizeImage(
- mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]
- )
-
- else:
- print(f"model_type '{model_type}' not implemented, use: --model_type large")
- assert False
-
- transform = Compose(
- [
- Resize(
- net_w,
- net_h,
- resize_target=None,
- keep_aspect_ratio=True,
- ensure_multiple_of=32,
- resize_method=resize_mode,
- image_interpolation_method=cv2.INTER_CUBIC,
- ),
- normalization,
- PrepareForNet(),
- ]
- )
-
- return model.eval(), transform
-
-
-class MiDaSInference(nn.Module):
- MODEL_TYPES_TORCH_HUB = [
- "DPT_Large",
- "DPT_Hybrid",
- "MiDaS_small"
- ]
- MODEL_TYPES_ISL = [
- "dpt_large",
- "dpt_hybrid",
- "midas_v21",
- "midas_v21_small",
- ]
-
- def __init__(self, model_type):
- super().__init__()
- assert (model_type in self.MODEL_TYPES_ISL)
- model, _ = load_model(model_type)
- self.model = model
- self.model.train = disabled_train
-
- def forward(self, x):
- # x in 0..1 as produced by calling self.transform on a 0..1 float64 numpy array
- # NOTE: we expect that the correct transform has been called during dataloading.
- with torch.no_grad():
- prediction = self.model(x)
- prediction = torch.nn.functional.interpolate(
- prediction.unsqueeze(1),
- size=x.shape[2:],
- mode="bicubic",
- align_corners=False,
- )
- assert prediction.shape == (x.shape[0], 1, x.shape[2], x.shape[3])
- return prediction
-
diff --git a/spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/pip/_vendor/platformdirs/macos.py b/spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/pip/_vendor/platformdirs/macos.py
deleted file mode 100644
index ec9751129c16018d3ef6e8bd2b5812f049348b77..0000000000000000000000000000000000000000
--- a/spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/pip/_vendor/platformdirs/macos.py
+++ /dev/null
@@ -1,70 +0,0 @@
-from __future__ import annotations
-
-import os
-
-from .api import PlatformDirsABC
-
-
-class MacOS(PlatformDirsABC):
- """
- Platform directories for the macOS operating system. Follows the guidance from `Apple documentation
-
--
Blockman Go APK Mediafıre: Cómo descargar y jugar el juego Ultimate Sandbox
-¿Te encantan los juegos de sandbox donde puedes dar rienda suelta a tu creatividad y divertirte con tus amigos? Si es así, entonces deberías probar Blockman Go, un juego gratuito que te permite jugar, crear y compartir tus experiencias con millones de jugadores de todo el mundo. Pero lo que si quieres jugar Blockman Ir en su dispositivo Android sin usar Google Play Store? No te preocupes, hay una manera de hacer eso. En este artículo, le mostraremos cómo descargar y jugar Blockman Go APK de Mediafıre, una popular plataforma para compartir archivos. También le diremos por qué usted debe jugar Blockman Go APK Mediafıre, cómo jugar, y algunos consejos y trucos para hacer su experiencia de juego más agradable.
-¿Qué es Blockman Go?
-Blockman Go es un juego sandbox desarrollado por Garena, un desarrollador y editor de juegos en línea líder. Fue lanzado en 2018 y desde entonces ha ganado una gran base de fans de más de 100 millones de descargas en Google Play Store. Blockman Go es un juego que te permite crear tu propio mundo, explorar diferentes modos de juego e interactuar con otros jugadores en tiempo real. Puedes elegir entre varios minijuegos como Bed Wars, Sky Wars, Murder Mystery, Parkour, Survival Games y más. También puedes personalizar tu avatar con cientos de atuendos, accesorios, peinados y pieles. Puedes chatear con otros jugadores usando mensajes de voz o de texto, unirte a clanes, hacer amigos e incluso casarte. Blockman Go es un juego que ofrece infinitas posibilidades de diversión y creatividad.
-blockman go apk mediafıre
Download Zip ✓✓✓ https://bltlly.com/2v6IS7
-
Características de Blockman Go
-Algunas de las características que hacen que Blockman Go se destaque de otros juegos de sandbox son:
--
-
- Tiene gráficos impresionantes y una jugabilidad suave que funcionan bien en la mayoría de los dispositivos Android. -
- Tiene una interfaz fácil de usar y controles fáciles que lo hacen adecuado para jugadores de todas las edades. -
- Tiene una variedad de modos de juego que se adaptan a diferentes gustos y preferencias. - -
- Tiene un sistema de recompensa que le da oro y gemas para jugar, iniciar sesión diariamente, completar tareas y más. -
- Tiene una tienda en línea que le permite comprar artículos con oro o gemas o dinero real. -
- Tiene actualizaciones regulares que agregan nuevas características, correcciones de errores y mejoras. -
Cómo descargar Blockman Go APK de Mediafıre
-Si desea jugar Blockman Ir en su dispositivo Android sin usar Google Play Store, puede descargar el archivo APK de Mediafıre. Mediafıre es una plataforma de intercambio de archivos que le permite cargar y descargar archivos de forma gratuita. Aquí están los pasos para descargar Blockman Go APK de Mediafıre:
--
-
- Ir a este enlace en su navegador. Esto le llevará a la página Mediafıre donde se encuentra el archivo APK de Blockman Go. -
- Haga clic en el botón verde "Descargar". Esto comenzará a descargar el archivo APK a su dispositivo. -
- Una vez que la descarga se ha completado, localizar el archivo APK en el gestor de archivos del dispositivo o carpeta de descarga. -
- Toque en el archivo APK para instalarlo. Es posible que deba habilitar "Fuentes desconocidas" o "Permitir desde esta fuente" en la configuración de su dispositivo para permitir la instalación de aplicaciones desde fuera de Google Play Store. -
- Espere a que termine la instalación. Puede ver un mensaje de confirmación que dice "App instalado". -
- Toque en "Abrir" para iniciar la aplicación Blockman Go. También puede encontrar el icono de la aplicación en la pantalla de inicio del dispositivo o cajón de aplicaciones. -
Felicidades, que ha descargado e instalado con éxito Blockman Go APK de Mediafıre. Ahora puedes disfrutar jugando el último juego de sandbox en tu dispositivo Android.
-¿Por qué jugar Blockman Go APK Mediafıre?
- -Ventajas de jugar Blockman Go APK Mediafıre
--
-
- Puedes jugar Blockman Go sin usar Google Play Store, que puede estar bloqueado o restringido en algunas regiones o dispositivos. -
- Puede jugar Blockman Go sin iniciar sesión con su cuenta de Google, que puede proteger su privacidad y seguridad. -
- Puede jugar Blockman Go sin actualizar la aplicación cada vez que hay una nueva versión, que puede ahorrar sus datos y espacio de almacenamiento. -
- Puede jugar Blockman Go con versiones anteriores de la aplicación, que puede ser compatible con su dispositivo o características preferidas. -
Desventajas de jugar Blockman Go APK Mediafıre
--
-
- Es posible que no pueda acceder a algunas funciones o servicios que requieren una cuenta de Google, como almacenamiento en la nube, logros, tablas de clasificación y más. -
- Es posible que no pueda recibir las últimas actualizaciones, correcciones de errores y mejoras que están disponibles en la versión oficial. -
- Puede encontrar algunos errores o fallos que se fijan en la versión oficial. -
- Puede arriesgarse a descargar un archivo APK falso o modificado que contiene malware o virus que pueden dañar su dispositivo o robar su información. -
Como se puede ver, jugando Blockman Go APK Mediafıre tiene sus pros y contras. Usted debe sopesar cuidadosamente y decidir lo que es mejor para usted. Si decide jugar Blockman Go APK Mediafıre, asegúrese de descargarlo desde una fuente de confianza como Mediafıre y escanear con una aplicación antivirus antes de instalarlo.
-Cómo jugar Blockman Go APK Mediafıre
-Ahora que ha descargado e instalado Blockman Go APK Mediafıre, usted está listo para jugar. Pero ¿cómo se juega? No te preocupes, le guiará a través de los fundamentos de la reproducción de Blockman Go APK Mediafıre. Estos son algunos pasos a seguir:
-Cómo crear una cuenta e iniciar sesión
- --
-
- Abra la aplicación Blockman Go en su dispositivo. Verá una pantalla de bienvenida con dos opciones: "Invitado" y "Iniciar sesión". -
- Si quieres jugar como invitado, toca "Invitado". Esto te permitirá jugar sin crear una cuenta, pero no podrás guardar tu progreso o acceder a algunas funciones. -
- Si desea crear una cuenta, toque en "Iniciar sesión". Esto te llevará a una pantalla de inicio de sesión con cuatro opciones: "Facebook", "Google", "Twitter" y "Blockman". -
- Si desea utilizar su cuenta de Facebook, Google o Twitter para iniciar sesión, toque en el icono correspondiente y siga las instrucciones. Esto vinculará su cuenta de redes sociales a su cuenta de Blockman Go. -
- Si desea utilizar una cuenta de Blockman para iniciar sesión, toque en "Blockman". Esto lo llevará a una pantalla de registro donde necesita ingresar su nombre de usuario, contraseña, dirección de correo electrónico y código de verificación. A continuación, toque en "Registrarse". Esto creará su cuenta de Blockman e iniciar sesión. -
Felicidades, has creado una cuenta y has iniciado sesión en Blockman Go. Ahora puedes empezar a jugar el juego.
-Cómo elegir un modo de juego y unirse a un servidor
-Lo siguiente que tienes que hacer es elegir un modo de juego y unirte a un servidor. Esto te permitirá jugar con otros jugadores en diferentes minijuegos. Hay muchos modos de juego para elegir, como Bed Wars, Sky Wars, Murder Mystery, Parkour, Survival Games y más. Cada modo de juego tiene sus propias reglas, objetivos y desafíos. Estos son los pasos para elegir un modo de juego y unirse a un servidor:
- --
-
- En la pantalla principal de Blockman Go, toque en el "Juego" icono en la parte inferior. Esto te llevará a una pantalla de selección de juegos donde puedes ver los diferentes modos de juego disponibles. -
- Deslice hacia la izquierda o hacia la derecha para navegar por los modos de juego. También puede usar la barra de búsqueda en la parte superior para encontrar un modo de juego específico por nombre o palabra clave. - -
- Desliza hacia arriba o hacia abajo para navegar a través de los servidores. También puede usar el botón de filtro en la parte superior para ordenar los servidores por región, idioma, reproductores y más. -
- Toque en el servidor al que desea unirse. Esto lo llevará a una pantalla del lobby donde puede ver los detalles del servidor, como el nombre, la descripción, las reglas, el mapa y los jugadores. -
- Toque en el botón "Unirse" en la parte inferior. Esto comenzará a cargar el juego y lo conectará al servidor. -
Felicidades, has elegido un modo de juego y te has unido a un servidor. Ahora puedes jugar con otros jugadores en ese modo de juego.
-Cómo crear, construir y compartir tus creaciones
-Lo último que necesitas hacer es crear, construir y compartir tus creaciones. Esta es la característica principal de Blockman Go que le permite expresar su creatividad e imaginación. Puedes usar varios bloques, elementos, herramientas y accesorios para crear lo que quieras. También puedes compartir tus creaciones con otros jugadores y obtener comentarios y valoraciones. Estos son los pasos para crear, construir y compartir tus creaciones:
--
-
- En la pantalla principal de Blockman Go, toque en el "Crear" icono en la parte inferior. Esto lo llevará a una pantalla de creación donde puede ver su inventario y opciones. -
- Toque en el botón "Nuevo" en la parte superior. Esto le permitirá crear un nuevo mundo donde puede construir su creación. -
- Introduzca un nombre para su mundo y elija una plantilla de la lista. También puede personalizar la configuración de su mundo, como dificultad, clima, tiempo y más. -
- Toque en el botón "Crear" en la parte inferior. Esto comenzará a crear su mundo y cargarlo por usted. -
- Una vez que tu mundo está cargado, puedes empezar a crear y construir tu creación. Puede usar los botones en la parte inferior para cambiar entre diferentes modos, como mover, rotar, escalar, borrar, copiar, pegar, deshacer, rehacer y más. -
- También puede usar los botones de la parte superior para acceder a su inventario, caja de herramientas, biblioteca de objetos, cuadro de chat, menú y más. - -
- Para colocar un artículo o bloque en su mundo, toque en él en su inventario y luego toque en un espacio vacío en su mundo. También puede arrastrarlo o usar los botones de la parte inferior para ajustar su posición, rotación y escala. -
- Para construir una estructura o una escena, repita los pasos anteriores hasta que esté satisfecho con su creación. También puede usar el botón de la caja de herramientas en la parte superior para acceder a algunas herramientas útiles como relleno, reemplazo, hueco y más. -
- Para compartir tu creación con otros jugadores, toca el botón de menú en la parte superior y selecciona "Compartir". Esto te permitirá subir tu mundo al servidor Blockman Go y obtener un enlace que puedes compartir con otros. -
- Para ver las creaciones de otros jugadores, toque en el icono "Explorar" en la parte inferior. Esto te llevará a una pantalla de exploración donde puedes ver las creaciones destacadas, populares y recientes de otros jugadores. -
- Para unirse a una creación de otro reproductor, toque en él y seleccione "Unirse". Esto comenzará a cargar el mundo y lo conectará a él. -
Felicidades, has creado, construido y compartido tu creación. Ahora puedes disfrutar viendo tu obra maestra y las creaciones de otros jugadores en Blockman Go.
-Consejos y trucos para jugar Blockman Go APK Mediafıre
-Jugar Blockman Go APK Mediafıre puede ser divertido y gratificante, pero también puede ser desafiante y frustrante a veces. Para ayudarte a tener una mejor experiencia de juego, aquí hay algunos consejos y trucos que puedes usar:
-Cómo ganar oro y gemas
-El oro y las gemas son las principales monedas en Blockman Go que puedes usar para comprar artículos, trajes, pieles y más. Puedes ganar oro y gemas jugando, iniciando sesión diariamente, completando tareas, viendo anuncios, invitando a amigos y más. Aquí hay algunas maneras de ganar más oro y gemas:
--
-
- Jugar juegos que tienen altas recompensas o bonos. Algunos juegos ofrecen más oro o gemas que otros dependiendo de la dificultad, duración o popularidad del juego. - -
- Completar tareas y logros. Puede obtener oro, gemas, artículos, o incluso cupones completando varias tareas y logros en el juego. -
- Ver anuncios y vídeos. Puede obtener oro o gemas viendo anuncios o videos en el juego. También puedes obtener artículos o cupones gratis viendo videos patrocinados. -
- Invita a amigos y únete a clanes. Puedes conseguir oro o gemas invitando a tus amigos a jugar a Blockman Go usando tu código de referencia. También puedes conseguir oro o gemas uniéndote a clanes y participando en actividades del clan. -
Cómo personalizar tu avatar y chatear con otros jugadores
-Personalizar tu avatar y chatear con otros jugadores son algunos de los aspectos divertidos de jugar Blockman Go. Puedes hacer que tu avatar se vea único y expresar tu personalidad cambiando su apariencia y atuendo. También puede comunicarse y socializar con otros jugadores mediante el uso de mensajes de voz o de texto. Aquí hay algunas maneras de personalizar tu avatar y chatear con otros jugadores:
--
-
- Cambia la apariencia de tu avatar. Puedes cambiar el género de tu avatar, la forma de la cara, el color de los ojos, el estilo de cabello, el color del cabello, el tono de la piel y más tocando el icono "Avatar" en la parte inferior de la pantalla principal. -Cambia el atuendo de tu avatar. Puedes cambiar la ropa de tu avatar, zapatos, sombreros, gafas, máscaras, mochilas, alas, colas, mascotas y más tocando el ícono "Closet" en la parte inferior de la pantalla principal. Puedes comprar nuevos atuendos usando oro o gemas o dinero real en la tienda online. - -
Cómo usar trucos y hacks
-Trucos y hacks son métodos que algunos jugadores utilizan para obtener una ventaja injusta o eludir algunas restricciones en Blockman Go. Pueden incluir la modificación de los archivos del juego, el uso de aplicaciones o herramientas de terceros, la explotación de fallos o errores, o el uso de códigos o comandos. Algunos ejemplos de trucos y hacks son oro o gemas ilimitadas, modo dios, speed hack, fly hack, invisibilidad, teletransportación y más. Aquí hay algunas maneras de usar trucos y hacks en Blockman Go:
--
-
- Modifica los archivos del juego. Puedes modificar los archivos del juego usando una aplicación de administrador de archivos o una aplicación de explorador raíz en tu dispositivo. Puede cambiar algunos valores o parámetros en los archivos del juego para alterar el comportamiento o la apariencia del juego. Por ejemplo, puede cambiar la cantidad de oro o gemas que tiene editando el archivo de datos. Sin embargo, este método es arriesgado y puede causar que tu juego falle o falle. -
- Usa aplicaciones o herramientas de terceros. Puedes usar aplicaciones o herramientas de terceros diseñadas para hackear o engañar a Blockman Go. Estas aplicaciones o herramientas pueden requerir que las instales en tu dispositivo o que conectes tu dispositivo a un ordenador. También pueden requerir que les concedas algunos permisos o acceso al sistema de tu dispositivo. Por ejemplo, puede utilizar una aplicación de hacker juego o un archivo APK modificado para hackear Blockman Go. Sin embargo, este método es peligroso y puede exponer su dispositivo a malware o virus. -
- Explotar fallos o errores. Puede explotar fallos o errores que están presentes en Blockman Go. Estos fallos o errores son errores o fallas en el juego que hacen que se comporte de una manera no deseada. Por ejemplo, puedes aprovechar un fallo que te permite volar o caminar a través de las paredes en algunos modos de juego. Sin embargo, este método no es confiable y puede ser corregido o parcheado por los desarrolladores. - -
Como puedes ver, usar trucos y hacks en Blockman Go puede ser tentador pero también arriesgado y poco ético. Debes ser cuidadoso y responsable al usarlos y respetar las reglas y los derechos de otros jugadores. También debe tener en cuenta que el uso de trucos y hacks puede resultar en que su cuenta sea prohibida, suspendida o eliminada por los desarrolladores.
-Conclusión
-Blockman Go es un juego sandbox que te permite jugar, crear y compartir tus experiencias con millones de jugadores de todo el mundo. Puede descargar y jugar Blockman Go APK de Mediafıre, una plataforma de intercambio de archivos que le permite jugar Blockman Go sin usar Google Play Store. Sin embargo, también debe considerar las ventajas y desventajas de jugar Blockman Go APK Mediafıre y decidir lo que es mejor para usted. También debe aprender a jugar Blockman Go APK Mediafıre y utilizar algunos consejos y trucos para hacer su experiencia de juego más agradable. Esperamos que este artículo le ha ayudado a entender más acerca de Blockman Go APK Mediafıre y cómo descargar y jugar.
-Preguntas frecuentes
-Aquí hay algunas preguntas frecuentes sobre Blockman Go APK Mediafıre:
--
-
- ¿Es seguro Blockman Go APK Mediafıre? -
- ¿Es Blockman Go APK Mediafıre libre? -
- ¿Puedo jugar Blockman Go APK Mediafıre con mis amigos? - -
- ¿Puedo jugar Blockman Go APK Mediafıre fuera de línea? -
- ¿Puedo transferir mi progreso de Blockman Go APK Mediafıre a la versión oficial? -
- Primero, necesitas desinstalar la versión original de Rope Hero de tu dispositivo si lo tienes instalado. -
- En segundo lugar, debe habilitar fuentes desconocidas en su dispositivo. Para hacer esto, vaya a Configuración > Seguridad > Fuentes desconocidas y active. -
- En tercer lugar, es necesario descargar el archivo apk mod de una fuente confiable. Puede encontrar muchos sitios web que ofrecen el archivo apk mod de forma gratuita. Asegúrate de descargarlo desde un sitio de confianza que no contenga virus o malware. -
- Cuarto, es necesario localizar el archivo descargado en el dispositivo y toque en él para iniciar el proceso de instalación. Siga las instrucciones en la pantalla y espere a que termine. -
- Quinto, necesitas lanzar el juego y disfrutar jugando con diamantes y dinero ilimitados. -
- ¿Es Rope Hero ilimitado diamantes Mod APK gratis? -
- ¿Es seguro Rope Hero Unlimited Diamonds Mod APK? -
- ¿Es Rope Hero ilimitado diamantes Mod APK compatible con mi dispositivo? -
- ¿Puedo jugar Rope Hero ilimitado diamantes Mod APK en línea? -
- ¿Puedo actualizar Rope Hero ilimitado diamantes Mod APK? -
Blockman Go APK Mediafıre es seguro, siempre y cuando se descarga desde una fuente de confianza como Mediafıre y escanear con una aplicación antivirus antes de instalarlo. Sin embargo, también debe tener cuidado con los archivos APK falsos o modificados que pueden contener malware o virus que pueden dañar su dispositivo o robar su información.
-Blockman Go APK Mediafıre es gratis para descargar y jugar. Sin embargo, algunas características o artículos pueden requerir oro, gemas o dinero real para desbloquear o comprar.
-No, no se puede jugar Blockman Go APK Mediafıre fuera de línea. Necesita una conexión a Internet para jugar Blockman Go APK Mediafıre ya que es un juego en línea que requiere transmisión de datos y sincronización.
-No, no puede transferir su progreso de Blockman Go APK Mediafıre a la versión oficial. Necesitas crear una nueva cuenta y empezar desde cero si quieres jugar la versión oficial de Google Play Store.
64aa2da5cf-
-
\ No newline at end of file diff --git a/spaces/Benson/text-generation/Examples/Cuerda Hroe Ilimitado Diamantes Mod Apk.md b/spaces/Benson/text-generation/Examples/Cuerda Hroe Ilimitado Diamantes Mod Apk.md deleted file mode 100644 index 5bcda5c43fc5752a4cf0e6ec2c04a8952666c618..0000000000000000000000000000000000000000 --- a/spaces/Benson/text-generation/Examples/Cuerda Hroe Ilimitado Diamantes Mod Apk.md +++ /dev/null @@ -1,65 +0,0 @@ - -
Cuerda héroe ilimitado diamantes Mod APK: Una guía para los fans de superhéroes
-Si eres un fan de los juegos de superhéroes, es posible que hayas oído hablar de Rope Hero, un popular juego de acción en tercera persona con un toque de ciencia ficción. En este juego, se puede jugar como un héroe con estilo en un traje de protección, que puede utilizar superpoderes y armas para luchar contra el crimen y los gángsters en una gran ciudad. Pero lo que si quieres disfrutar del juego sin limitaciones? Ahí es donde Rope Hero Unlimited Diamonds Mod APK entra en juego. En este artículo, te contaremos todo lo que necesitas saber sobre esta versión modificada del juego, incluyendo sus características, beneficios y cómo descargarlo e instalarlo. Sigue leyendo para saber más.
-cuerda héroe ilimitado diamantes mod apk
Download File ⚡ https://bltlly.com/2v6Mky
-
¿Qué es el héroe de cuerda?
-Rope Hero es un juego desarrollado por Naxeex Action & RPG Games, que tiene más de 10 millones de descargas en Google Play Store. Es un juego de acción en tercera persona que te permite jugar como un superhéroe en un traje de ciencia ficción, que puede usar superpoderes y armas para luchar contra el crimen y los gángsters en una gran ciudad. El juego tiene gráficos increíbles, física realista y muchas características divertidas.
-Un juego de acción en tercera persona con un superhéroe de ciencia ficción
-En Rope Hero, puedes controlar a tu héroe con simples controles táctiles. Puedes moverte por la ciudad, saltar, correr, subir, balancearte y volar con tu súper cuerda. También puedes usar tus brazos y piernas para golpear, patear y lanzar enemigos. También puede utilizar varias armas, armas cuerpo a cuerpo y súper armas para hacer frente a diferentes situaciones. Incluso puede conducir cualquier coche que desee en la ciudad.
-Características del juego
-Rope Hero tiene muchas características que lo convierten en un juego emocionante y adictivo. Algunas de ellas son:
- -Superpoderes y armas
- -Mundo abierto y misiones
-El juego tiene un mundo abierto que se puede explorar libremente. La ciudad está llena de aventuras peligrosas y emocionantes. Usted puede encontrar varios secretos y mini-juegos en diferentes lugares. También puedes completar misiones que te darán recompensas y progresarán en la historia de tu héroe. Puedes luchar contra pandillas callejeras, ladrones de autos, policías corruptos, fuerzas militares, alienígenas, zombis, robots, monstruos y más.
-Personalización y skins
-Puedes personalizar a tu héroe con diferentes atuendos y accesorios. Puedes encontrar varias pieles para tu héroe en la tienda de juegos o completando misiones. Cada piel tiene su propio conjunto de potenciadores que mejorarán las habilidades de tu héroe. También puede crear su propia piel única mediante la combinación de piezas de otros trajes.
-¿Qué es la cuerda héroe ilimitado diamantes Mod APK?
-Héroe de cuerda ilimitada diamantes Mod APK
Héroe de cuerda ilimitada diamantes Mod APK es una versión modificada del juego que le da recursos ilimitados y acceso a todo en el juego. Es un archivo que puedes descargar e instalar en tu dispositivo Android, y disfrutar del juego con más diversión y libertad.
-Una versión modificada del juego con recursos ilimitados
-El apk mod es un archivo que ha sido alterado por algunos desarrolladores para cambiar algunos aspectos del juego. En este caso, el apk mod le da diamantes ilimitados y dinero, que son las principales monedas en el juego. Puedes usarlos para comprar lo que quieras en la tienda de juegos, como armas, pieles, coches y más. También puedes mejorar las habilidades y habilidades de tu héroe con ellos. También puedes usarlas para saltar anuncios y acelerar el juego.
-Beneficios de usar el mod apk
-Hay muchos beneficios de usar el apk mod para Rope Hero. Algunos de ellos son:
-Desbloquear todo en el juego
- -Disfruta de diamantes y dinero ilimitados
-Con el apk mod, se puede disfrutar de diamantes ilimitados y dinero, que son las principales monedas en el juego. Puedes usarlos para comprar lo que quieras en la tienda de juegos, como armas, pieles, coches y más. También puedes mejorar las habilidades y habilidades de tu héroe con ellos. También puedes usarlas para saltar anuncios y acelerar el juego.
-No se requieren anuncios ni root
-Con el apk mod, puede jugar el juego sin ningún anuncio molesto que interrumpen su juego. También puede jugar el juego sin rootear su dispositivo, lo que significa que no tiene que arriesgarse a dañar su dispositivo o perder su garantía. El mod apk es seguro y fácil de usar.
-¿Cómo descargar e instalar Rope Hero ilimitado diamantes Mod APK?
-Si desea descargar e instalar Rope Hero ilimitado diamantes Mod APK en su dispositivo Android, es necesario seguir estos sencillos pasos:
-Pasos para descargar e instalar el mod apk
--
-
Consejos y trucos para jugar el juego con el apk mod
- -Usa tus superpoderes sabiamente
-Tu héroe tiene superpoderes que le permiten hacer cosas increíbles. Puedes usar tu súper cuerda para balancearte de edificio en edificio, o para agarrar enemigos y objetos. También puede utilizar su salto de rana para saltar alto en el aire. También puede utilizar su súper visión para ver a través de paredes y objetos. Sin embargo, estas superpotencias tienen un tiempo de reutilización, lo que significa que no puedes usarlas continuamente. Debe esperar a que se recarguen antes de volver a usarlas. Por lo tanto, debe usarlas sabiamente y estratégicamente, dependiendo de la situación.
-Explora la ciudad y encuentra secretos
-El juego tiene un mundo abierto que se puede explorar libremente. La ciudad está llena de aventuras peligrosas y emocionantes. Puedes encontrar varios secretos y minijuegos en diferentes lugares. Por ejemplo, puedes encontrar cofres ocultos que contienen diamantes o dinero. También puedes encontrar botones ocultos que activan trampas o eventos. También puedes encontrar portales ocultos que te transportan a otros mundos o dimensiones. También puedes encontrar huevos de Pascua ocultos que hacen referencia a otros juegos o películas. Explorar la ciudad no solo te dará recompensas, sino que también hará que tu juego sea más divertido e interesante.
-Completar misiones y desafíos
-El juego tiene muchas misiones y
El juego tiene muchas misiones y desafíos que le dará recompensas y el progreso de la historia de su héroe. Puedes encontrarlos en el mapa o hablando con los PNJ. Algunas de las misiones son misiones principales relacionadas con la trama del juego. Algunos de ellos son misiones secundarias que son opcionales, pero todavía divertido y gratificante. Algunas de ellas son misiones diarias que se reinician todos los días y te dan diamantes o dinero. Algunas de ellas son misiones especiales que solo están disponibles por un tiempo limitado o durante eventos. Completar misiones y desafíos no solo te dará recursos sino que también mejorará la reputación y las habilidades de tu héroe.
-Conclusión
- -Preguntas frecuentes
-Aquí hay algunas preguntas frecuentes sobre Rope Hero Unlimited Diamonds Mod APK:
--
-
Sí, Rope Hero Unlimited Diamonds Mod APK es gratis para descargar y jugar. No tienes que pagar nada para disfrutar del juego con recursos ilimitados.
-Sí, Rope Hero Unlimited Diamonds Mod APK es seguro de usar. No contiene ningún virus o malware que pueda dañar su dispositivo o datos. Sin embargo, siempre debe descargarlo de una fuente confiable y escanearlo con un antivirus antes de instalarlo.
-Cuerda héroe ilimitado diamantes Mod APK es compatible con la mayoría de los dispositivos Android que tienen Android 4.4 o superior. Sin embargo, algunos dispositivos pueden no soportar el juego o el apk mod debido a diferentes especificaciones o ajustes. Usted debe comprobar la compatibilidad de su dispositivo antes de descargar e instalar el apk mod.
-No, Cuerda héroe ilimitado diamantes Mod APK es un juego fuera de línea que no requiere una conexión a Internet para jugar. Puede reproducirlo en cualquier lugar y en cualquier momento sin preocuparse por el uso de datos o problemas de conexión.
-No, Rope Hero Unlimited Diamonds Mod APK no es una versión oficial del juego, por lo que no recibe actualizaciones regulares de los desarrolladores. Si desea actualizar el juego, usted tiene que desinstalar el apk mod e instalar la versión original de Google Play Store. Sin embargo, puede perder su progreso y recursos si lo hace.
--
-
\ No newline at end of file diff --git a/spaces/Big-Web/MMSD/env/Lib/site-packages/pip/_vendor/urllib3/packages/__init__.py b/spaces/Big-Web/MMSD/env/Lib/site-packages/pip/_vendor/urllib3/packages/__init__.py deleted file mode 100644 index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000 diff --git a/spaces/BigSalmon/GPT2Mask/README.md b/spaces/BigSalmon/GPT2Mask/README.md deleted file mode 100644 index 87b7720e8e4c32ae8c140efabcf6da52587e2a2f..0000000000000000000000000000000000000000 --- a/spaces/BigSalmon/GPT2Mask/README.md +++ /dev/null @@ -1,12 +0,0 @@ ---- -title: GPT2Mask -emoji: 🐢 -colorFrom: red -colorTo: yellow -sdk: streamlit -sdk_version: 1.2.0 -app_file: app.py -pinned: false ---- - -Check out the configuration reference at https://huggingface.co/docs/hub/spaces#reference diff --git a/spaces/CVPR/Dual-Key_Backdoor_Attacks/datagen/detectron2/tools/visualize_data.py b/spaces/CVPR/Dual-Key_Backdoor_Attacks/datagen/detectron2/tools/visualize_data.py deleted file mode 100644 index 8e7e4ad4031985259e5adde48cda928a3f26a64d..0000000000000000000000000000000000000000 --- a/spaces/CVPR/Dual-Key_Backdoor_Attacks/datagen/detectron2/tools/visualize_data.py +++ /dev/null @@ -1,98 +0,0 @@ -#!/usr/bin/env python -# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved -import argparse -import numpy as np -import os -from itertools import chain -import cv2 -import tqdm -from PIL import Image - -from detectron2.config import get_cfg -from detectron2.data import DatasetCatalog, MetadataCatalog, build_detection_train_loader -from detectron2.data import detection_utils as utils -from detectron2.data.build import filter_images_with_few_keypoints -from detectron2.utils.logger import setup_logger -from detectron2.utils.visualizer import Visualizer - - -def setup(args): - cfg = get_cfg() - if args.config_file: - cfg.merge_from_file(args.config_file) - cfg.merge_from_list(args.opts) - cfg.freeze() - return cfg - - -def parse_args(in_args=None): - parser = argparse.ArgumentParser(description="Visualize ground-truth data") - parser.add_argument( - "--source", - choices=["annotation", "dataloader"], - required=True, - help="visualize the annotations or the data loader (with pre-processing)", - ) - parser.add_argument("--config-file", default="", metavar="FILE", help="path to config file") - parser.add_argument("--output-dir", default="./", help="path to output directory") - parser.add_argument("--show", action="store_true", help="show output in a window") - parser.add_argument( - "opts", - help="Modify config options using the command-line", - default=None, - nargs=argparse.REMAINDER, - ) - return parser.parse_args(in_args) - - -if __name__ == "__main__": - args = parse_args() - logger = setup_logger() - logger.info("Arguments: " + str(args)) - cfg = setup(args) - - dirname = args.output_dir - os.makedirs(dirname, exist_ok=True) - metadata = MetadataCatalog.get(cfg.DATASETS.TRAIN[0]) - - def output(vis, fname): - if args.show: - print(fname) - cv2.imshow("window", vis.get_image()[:, :, ::-1]) - cv2.waitKey() - else: - filepath = os.path.join(dirname, fname) - print("Saving to {} ...".format(filepath)) - vis.save(filepath) - - scale = 2.0 if args.show else 1.0 - if args.source == "dataloader": - train_data_loader = build_detection_train_loader(cfg) - for batch in train_data_loader: - for per_image in batch: - # Pytorch tensor is in (C, H, W) format - img = per_image["image"].permute(1, 2, 0) - if cfg.INPUT.FORMAT == "BGR": - img = img[:, :, [2, 1, 0]] - else: - img = np.asarray(Image.fromarray(img, mode=cfg.INPUT.FORMAT).convert("RGB")) - - visualizer = Visualizer(img, metadata=metadata, scale=scale) - target_fields = per_image["instances"].get_fields() - labels = [metadata.thing_classes[i] for i in target_fields["gt_classes"]] - vis = visualizer.overlay_instances( - labels=labels, - boxes=target_fields.get("gt_boxes", None), - masks=target_fields.get("gt_masks", None), - keypoints=target_fields.get("gt_keypoints", None), - ) - output(vis, str(per_image["image_id"]) + ".jpg") - else: - dicts = list(chain.from_iterable([DatasetCatalog.get(k) for k in cfg.DATASETS.TRAIN])) - if cfg.MODEL.KEYPOINT_ON: - dicts = filter_images_with_few_keypoints(dicts, 1) - for dic in tqdm.tqdm(dicts): - img = utils.read_image(dic["file_name"], "RGB") - visualizer = Visualizer(img, metadata=metadata, scale=scale) - vis = visualizer.draw_dataset_dict(dic) - output(vis, os.path.basename(dic["file_name"])) diff --git a/spaces/CVPR/LIVE/pybind11/tests/env.py b/spaces/CVPR/LIVE/pybind11/tests/env.py deleted file mode 100644 index 5cded441271c61af72fc0be0de79332dc6279d72..0000000000000000000000000000000000000000 --- a/spaces/CVPR/LIVE/pybind11/tests/env.py +++ /dev/null @@ -1,14 +0,0 @@ -# -*- coding: utf-8 -*- -import platform -import sys - -LINUX = sys.platform.startswith("linux") -MACOS = sys.platform.startswith("darwin") -WIN = sys.platform.startswith("win32") or sys.platform.startswith("cygwin") - -CPYTHON = platform.python_implementation() == "CPython" -PYPY = platform.python_implementation() == "PyPy" - -PY2 = sys.version_info.major == 2 - -PY = sys.version_info diff --git a/spaces/CVPR/LIVE/thrust/dependencies/cub/cmake/AppendOptionIfAvailable.cmake b/spaces/CVPR/LIVE/thrust/dependencies/cub/cmake/AppendOptionIfAvailable.cmake deleted file mode 100644 index 478321ec8787ec34b2d4fc5dd6067e9239103a07..0000000000000000000000000000000000000000 --- a/spaces/CVPR/LIVE/thrust/dependencies/cub/cmake/AppendOptionIfAvailable.cmake +++ /dev/null @@ -1,13 +0,0 @@ -include_guard(GLOBAL) -include(CheckCXXCompilerFlag) - -macro (APPEND_OPTION_IF_AVAILABLE _FLAG _LIST) - -string(MAKE_C_IDENTIFIER "CXX_FLAG_${_FLAG}" _VAR) -check_cxx_compiler_flag(${_FLAG} ${_VAR}) - -if (${${_VAR}}) - list(APPEND ${_LIST} ${_FLAG}) -endif () - -endmacro () diff --git a/spaces/CVPR/LIVE/thrust/thrust/system/cpp/detail/merge.h b/spaces/CVPR/LIVE/thrust/thrust/system/cpp/detail/merge.h deleted file mode 100644 index 20e17f2d40dd218d2e7b22a7744321f75ea6ab0c..0000000000000000000000000000000000000000 --- a/spaces/CVPR/LIVE/thrust/thrust/system/cpp/detail/merge.h +++ /dev/null @@ -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
-
-This UI gives access to some pretrained language models from [*HuggingFace*](https://github.com/huggingface/) that are distributed via GT4SD.
-
-For **examples** and **documentation** of the model parameters, please see below.
-Moreover, we provide a **model card** ([Mitchell et al. (2019)](https://dl.acm.org/doi/abs/10.1145/3287560.3287596?casa_token=XD4eHiE2cRUAAAAA:NL11gMa1hGPOUKTAbtXnbVQBDBbjxwcjGECF_i-WC_3g1aBgU1Hbz_f2b4kI_m1in-w__1ztGeHnwHs)) at the bottom of this page.
diff --git a/spaces/Geonmo/socratic-models-image-captioning-with-BLOOM/prompts/extract_text_features.py b/spaces/Geonmo/socratic-models-image-captioning-with-BLOOM/prompts/extract_text_features.py
deleted file mode 100644
index 2e536c845c960a6de2577619e2dc49343627bd82..0000000000000000000000000000000000000000
--- a/spaces/Geonmo/socratic-models-image-captioning-with-BLOOM/prompts/extract_text_features.py
+++ /dev/null
@@ -1,154 +0,0 @@
-import os
-import numpy as np
-import torch
-import clip
-import csv
-import tqdm
-from profanity_filter import ProfanityFilter
-
-
-templates = [
- lambda c: f'a bad photo of a {c}.',
- lambda c: f'a photo of many {c}.',
- lambda c: f'a sculpture of a {c}.',
- lambda c: f'a photo of the hard to see {c}.',
- lambda c: f'a low resolution photo of the {c}.',
- lambda c: f'a rendering of a {c}.',
- lambda c: f'graffiti of a {c}.',
- lambda c: f'a bad photo of the {c}.',
- lambda c: f'a cropped photo of the {c}.',
- lambda c: f'a tattoo of a {c}.',
- lambda c: f'the embroidered {c}.',
- lambda c: f'a photo of a hard to see {c}.',
- lambda c: f'a bright photo of a {c}.',
- lambda c: f'a photo of a clean {c}.',
- lambda c: f'a photo of a dirty {c}.',
- lambda c: f'a dark photo of the {c}.',
- lambda c: f'a drawing of a {c}.',
- lambda c: f'a photo of my {c}.',
- lambda c: f'the plastic {c}.',
- lambda c: f'a photo of the cool {c}.',
- lambda c: f'a close-up photo of a {c}.',
- lambda c: f'a black and white photo of the {c}.',
- lambda c: f'a painting of the {c}.',
- lambda c: f'a painting of a {c}.',
- lambda c: f'a pixelated photo of the {c}.',
- lambda c: f'a sculpture of the {c}.',
- lambda c: f'a bright photo of the {c}.',
- lambda c: f'a cropped photo of a {c}.',
- lambda c: f'a plastic {c}.',
- lambda c: f'a photo of the dirty {c}.',
- lambda c: f'a jpeg corrupted photo of a {c}.',
- lambda c: f'a blurry photo of the {c}.',
- lambda c: f'a photo of the {c}.',
- lambda c: f'a good photo of the {c}.',
- lambda c: f'a rendering of the {c}.',
- lambda c: f'a {c} in a video game.',
- lambda c: f'a photo of one {c}.',
- lambda c: f'a doodle of a {c}.',
- lambda c: f'a close-up photo of the {c}.',
- lambda c: f'a photo of a {c}.',
- lambda c: f'the origami {c}.',
- lambda c: f'the {c} in a video game.',
- lambda c: f'a sketch of a {c}.',
- lambda c: f'a doodle of the {c}.',
- lambda c: f'a origami {c}.',
- lambda c: f'a low resolution photo of a {c}.',
- lambda c: f'the toy {c}.',
- lambda c: f'a rendition of the {c}.',
- lambda c: f'a photo of the clean {c}.',
- lambda c: f'a photo of a large {c}.',
- lambda c: f'a rendition of a {c}.',
- lambda c: f'a photo of a nice {c}.',
- lambda c: f'a photo of a weird {c}.',
- lambda c: f'a blurry photo of a {c}.',
- lambda c: f'a cartoon {c}.',
- lambda c: f'art of a {c}.',
- lambda c: f'a sketch of the {c}.',
- lambda c: f'a embroidered {c}.',
- lambda c: f'a pixelated photo of a {c}.',
- lambda c: f'itap of the {c}.',
- lambda c: f'a jpeg corrupted photo of the {c}.',
- lambda c: f'a good photo of a {c}.',
- lambda c: f'a plushie {c}.',
- lambda c: f'a photo of the nice {c}.',
- lambda c: f'a photo of the small {c}.',
- lambda c: f'a photo of the weird {c}.',
- lambda c: f'the cartoon {c}.',
- lambda c: f'art of the {c}.',
- lambda c: f'a drawing of the {c}.',
- lambda c: f'a photo of the large {c}.',
- lambda c: f'a black and white photo of a {c}.',
- lambda c: f'the plushie {c}.',
- lambda c: f'a dark photo of a {c}.',
- lambda c: f'itap of a {c}.',
- lambda c: f'graffiti of the {c}.',
- lambda c: f'a toy {c}.',
- lambda c: f'itap of my {c}.',
- lambda c: f'a photo of a cool {c}.',
- lambda c: f'a photo of a small {c}.',
- lambda c: f'a tattoo of the {c}.',
-]
-
-os.environ['CUDA_VISIBLE_DEVICES'] = '0'
-device = "cuda" if torch.cuda.is_available() else "cpu"
-clip_model, clip_preprocess = clip.load("ViT-L/14", device=device)
-
-'''
-csv_data = open('openimage-classnames.csv')
-csv_reader = csv.reader(csv_data)
-class_names = []
-for row in csv_reader:
- class_names.append(row[-1])
-'''
-'''
-txt_data = open('tencent-ml-images.txt')
-pf = ProfanityFilter()
-lines = txt_data.readlines()
-class_names = []
-for line in lines[4:]:
- class_name_precook = line.strip().split('\t')[-1]
- safe_list = ''
- for class_name in class_name_precook.split(', '):
- if pf.is_clean(class_name):
- safe_list += '%s, ' % class_name
- safe_list = safe_list[:-2]
- if len(safe_list) > 0:
- class_names.append(safe_list)
-f_w = open('tencent-ml-classnames.txt', 'w')
-for cln in class_names:
- f_w.write('%s\n' % cln)
-f_w.close()
-'''
-place_categories = np.loadtxt('categories_places365.txt', dtype=str)
-place_texts = []
-for place in place_categories[:, 0]:
- place = place.split('/')[2:]
- if len(place) > 1:
- place = place[1] + ' ' + place[0]
- else:
- place = place[0]
- place = place.replace('_', ' ')
- place_texts.append(place)
-class_names = place_texts
-f_w = open('place365-classnames.txt', 'w')
-for cln in class_names:
- f_w.write('%s\n' % cln)
-f_w.close()
-print(class_names)
-
-class_weights = []
-with torch.no_grad():
- for classname in tqdm.tqdm(class_names, desc='encoding text'):
- texts = [template(classname) for template in templates]
- text_inputs = clip.tokenize(texts).to(device)
- text_features = clip_model.encode_text(text_inputs)
- text_features /= text_features.norm(dim=-1, keepdim=True)
- text_features = text_features.mean(dim=0)
- text_features /= text_features.norm()
- class_weights.append(text_features)
-
-class_weights = torch.stack(class_weights)
-print(class_weights.shape)
-#torch.save(class_weights, 'clip_ViTL14_openimage_classifier_weights.pt')
-torch.save(class_weights, 'clip_ViTL14_place365_classifier_weights.pt')
diff --git a/spaces/Gradio-Blocks/beat-interpolator/examples/models/celeba256/model.py b/spaces/Gradio-Blocks/beat-interpolator/examples/models/celeba256/model.py
deleted file mode 100644
index eb34339a77dc9c6076965897556a727a299b8fdd..0000000000000000000000000000000000000000
--- a/spaces/Gradio-Blocks/beat-interpolator/examples/models/celeba256/model.py
+++ /dev/null
@@ -1,37 +0,0 @@
-import torch
-import numpy as np
-
-
-def create_celeba256_inference():
- device = 'cuda' if torch.cuda.is_available() else 'cpu'
- use_gpu = True if torch.cuda.is_available() else False
- celeba256 = torch.hub.load(
- 'facebookresearch/pytorch_GAN_zoo:hub',
- 'PGAN',
- model_name='celebAHQ-256',
- pretrained=True,
- useGPU=use_gpu
- )
- celeba256_noise, _ = celeba256.buildNoiseData(1)
- @torch.inference_mode()
- def celeba256_generator(latents):
- latents = [torch.from_numpy(latent).float().to(device) for latent in latents]
- latents = torch.stack(latents)
- out = celeba256.test(latents)
- outs = []
- for out_i in out:
- out_i = ((out_i.permute(1,2,0) + 1) * 127.5).clamp(0,255).cpu().numpy()
- out_i = np.uint8(out_i)
- outs.append(out_i)
- return outs
-
- return {
- 'name': 'Celeba256',
- 'generator': celeba256_generator,
- 'latent_dim': celeba256_noise.shape[1],
- 'fps': 5,
- 'batch_size': 1,
- 'strength': 0.6,
- 'max_duration': 20,
- 'use_peak': True
- }
diff --git a/spaces/Gradio-Blocks/uniformer_image_detection/configs/reppoints/README.md b/spaces/Gradio-Blocks/uniformer_image_detection/configs/reppoints/README.md
deleted file mode 100644
index 2ab22cd8e83151b5f028df96641fea5bfe6caa7a..0000000000000000000000000000000000000000
--- a/spaces/Gradio-Blocks/uniformer_image_detection/configs/reppoints/README.md
+++ /dev/null
@@ -1,54 +0,0 @@
-# RepPoints: Point Set Representation for Object Detection
-
-By [Ze Yang](https://yangze.tech/), [Shaohui Liu](http://b1ueber2y.me/), and [Han Hu](https://ancientmooner.github.io/).
-
-We provide code support and configuration files to reproduce the results in the paper for
-["RepPoints: Point Set Representation for Object Detection"](https://arxiv.org/abs/1904.11490) on COCO object detection.
-
-## Introduction
-
-[ALGORITHM]
-
-**RepPoints**, initially described in [arXiv](https://arxiv.org/abs/1904.11490), is a new representation method for visual objects, on which visual understanding tasks are typically centered. Visual object representation, aiming at both geometric description and appearance feature extraction, is conventionally achieved by `bounding box + RoIPool (RoIAlign)`. The bounding box representation is convenient to use; however, it provides only a rectangular localization of objects that lacks geometric precision and may consequently degrade feature quality. Our new representation, RepPoints, models objects by a `point set` instead of a `bounding box`, which learns to adaptively position themselves over an object in a manner that circumscribes the object’s `spatial extent` and enables `semantically aligned feature extraction`. This richer and more flexible representation maintains the convenience of bounding boxes while facilitating various visual understanding applications. This repo demonstrated the effectiveness of RepPoints for COCO object detection.
-
-Another feature of this repo is the demonstration of an `anchor-free detector`, which can be as effective as state-of-the-art anchor-based detection methods. The anchor-free detector can utilize either `bounding box` or `RepPoints` as the basic object representation.
-
-
- 
-
-
-## Citing RepPoints
-
-```
-@inproceedings{yang2019reppoints,
- title={RepPoints: Point Set Representation for Object Detection},
- author={Yang, Ze and Liu, Shaohui and Hu, Han and Wang, Liwei and Lin, Stephen},
- booktitle={The IEEE International Conference on Computer Vision (ICCV)},
- month={Oct},
- year={2019}
-}
-```
-
-## Results and models
-
-The results on COCO 2017val are shown in the table below.
-
-| Method | Backbone | GN | Anchor | convert func | Lr schd | Mem (GB) | Inf time (fps) | box AP | Config | Download |
-|:---------:|:-------------:|:---:|:------:|:------------:|:-------:|:--------:|:--------------:|:------:|:------:|:--------:|
-| BBox | R-50-FPN | Y | single | - | 1x | 3.9 | 15.9 | 36.4 | [config](https://github.com/open-mmlab/mmdetection/tree/master/configs/reppoints/bbox_r50_grid_fpn_gn-neck+head_1x_coco.py) | [model](http://download.openmmlab.com/mmdetection/v2.0/reppoints/bbox_r50_grid_fpn_gn-neck%2Bhead_1x_coco/bbox_r50_grid_fpn_gn-neck%2Bhead_1x_coco_20200329-c98bfa96.pth) | [log](http://download.openmmlab.com/mmdetection/v2.0/reppoints/bbox_r50_grid_fpn_gn-neck%2Bhead_1x_coco/bbox_r50_grid_fpn_gn-neck%2Bhead_1x_coco_20200329_145916.log.json) |
-| BBox | R-50-FPN | Y | none | - | 1x | 3.9 | 15.4 | 37.4 | [config](https://github.com/open-mmlab/mmdetection/tree/master/configs/reppoints/bbox_r50_grid_center_fpn_gn-neck+Bhead_1x_coco.py) | [model](http://download.openmmlab.com/mmdetection/v2.0/reppoints/bbox_r50_grid_center_fpn_gn-neck%2Bhead_1x_coco/bbox_r50_grid_center_fpn_gn-neck%2Bhead_1x_coco_20200330-00f73d58.pth) | [log](http://download.openmmlab.com/mmdetection/v2.0/reppoints/bbox_r50_grid_center_fpn_gn-neck%2Bhead_1x_coco/bbox_r50_grid_center_fpn_gn-neck%2Bhead_1x_coco_20200330_233609.log.json) |
-| RepPoints | R-50-FPN | N | none | moment | 1x | 3.3 | 18.5 | 37.0 | [config](https://github.com/open-mmlab/mmdetection/tree/master/configs/reppoints/reppoints_moment_r50_fpn_1x_coco.py) | [model](http://download.openmmlab.com/mmdetection/v2.0/reppoints/reppoints_moment_r50_fpn_1x_coco/reppoints_moment_r50_fpn_1x_coco_20200330-b73db8d1.pth) | [log](http://download.openmmlab.com/mmdetection/v2.0/reppoints/reppoints_moment_r50_fpn_1x_coco/reppoints_moment_r50_fpn_1x_coco_20200330_233609.log.json) |
-| RepPoints | R-50-FPN | Y | none | moment | 1x | 3.9 | 17.5 | 38.1 | [config](https://github.com/open-mmlab/mmdetection/tree/master/configs/reppoints/reppoints_moment_r50_fpn_gn-neck%2Bhead_1x_coco.py) | [model](http://download.openmmlab.com/mmdetection/v2.0/reppoints/reppoints_moment_r50_fpn_gn-neck%2Bhead_1x_coco/reppoints_moment_r50_fpn_gn-neck%2Bhead_1x_coco_20200329-4b38409a.pth) | [log](http://download.openmmlab.com/mmdetection/v2.0/reppoints/reppoints_moment_r50_fpn_gn-neck%2Bhead_1x_coco/reppoints_moment_r50_fpn_gn-neck%2Bhead_1x_coco_20200329_145952.log.json) |
-| RepPoints | R-50-FPN | Y | none | moment | 2x | 3.9 | - | 38.6 | [config](https://github.com/open-mmlab/mmdetection/tree/master/configs/reppoints/reppoints_moment_r50_fpn_gn-neck+head_2x_coco.py) | [model](http://download.openmmlab.com/mmdetection/v2.0/reppoints/reppoints_moment_r50_fpn_gn-neck%2Bhead_2x_coco/reppoints_moment_r50_fpn_gn-neck%2Bhead_2x_coco_20200329-91babaa2.pth) | [log](http://download.openmmlab.com/mmdetection/v2.0/reppoints/reppoints_moment_r50_fpn_gn-neck%2Bhead_2x_coco/reppoints_moment_r50_fpn_gn-neck%2Bhead_2x_coco_20200329_150020.log.json) |
-| RepPoints | R-101-FPN | Y | none | moment | 2x | 5.8 | 13.7 | 40.5 | [config](https://github.com/open-mmlab/mmdetection/tree/master/configs/reppoints/reppoints_moment_r101_fpn_gn-neck+head_2x_coco.py) | [model](http://download.openmmlab.com/mmdetection/v2.0/reppoints/reppoints_moment_r101_fpn_gn-neck%2Bhead_2x_coco/reppoints_moment_r101_fpn_gn-neck%2Bhead_2x_coco_20200329-4fbc7310.pth) | [log](http://download.openmmlab.com/mmdetection/v2.0/reppoints/reppoints_moment_r101_fpn_gn-neck%2Bhead_2x_coco/reppoints_moment_r101_fpn_gn-neck%2Bhead_2x_coco_20200329_132205.log.json) |
-| RepPoints | R-101-FPN-DCN | Y | none | moment | 2x | 5.9 | 12.1 | 42.9 | [config](https://github.com/open-mmlab/mmdetection/tree/master/configs/reppoints/reppoints_moment_r101_fpn_dconv_c3-c5_gn-neck+head_2x_coco.py) | [model](http://download.openmmlab.com/mmdetection/v2.0/reppoints/reppoints_moment_r101_fpn_dconv_c3-c5_gn-neck%2Bhead_2x_coco/reppoints_moment_r101_fpn_dconv_c3-c5_gn-neck%2Bhead_2x_coco_20200329-3309fbf2.pth) | [log](http://download.openmmlab.com/mmdetection/v2.0/reppoints/reppoints_moment_r101_fpn_dconv_c3-c5_gn-neck%2Bhead_2x_coco/reppoints_moment_r101_fpn_dconv_c3-c5_gn-neck%2Bhead_2x_coco_20200329_132134.log.json) |
-| RepPoints | X-101-FPN-DCN | Y | none | moment | 2x | 7.1 | 9.3 | 44.2 | [config](https://github.com/open-mmlab/mmdetection/tree/master/configs/reppoints/reppoints_moment_x101_fpn_dconv_c3-c5_gn-neck+head_2x_coco.py) | [model](http://download.openmmlab.com/mmdetection/v2.0/reppoints/reppoints_moment_x101_fpn_dconv_c3-c5_gn-neck%2Bhead_2x_coco/reppoints_moment_x101_fpn_dconv_c3-c5_gn-neck%2Bhead_2x_coco_20200329-f87da1ea.pth) | [log](http://download.openmmlab.com/mmdetection/v2.0/reppoints/reppoints_moment_x101_fpn_dconv_c3-c5_gn-neck%2Bhead_2x_coco/reppoints_moment_x101_fpn_dconv_c3-c5_gn-neck%2Bhead_2x_coco_20200329_132201.log.json) |
-
-**Notes:**
-
-- `R-xx`, `X-xx` denote the ResNet and ResNeXt architectures, respectively.
-- `DCN` denotes replacing 3x3 conv with the 3x3 deformable convolution in `c3-c5` stages of backbone.
-- `none` in the `anchor` column means 2-d `center point` (x,y) is used to represent the initial object hypothesis. `single` denotes one 4-d anchor box (x,y,w,h) with IoU based label assign criterion is adopted.
-- `moment`, `partial MinMax`, `MinMax` in the `convert func` column are three functions to convert a point set to a pseudo box.
-- Note the results here are slightly different from those reported in the paper, due to framework change. While the original paper uses an [MXNet](https://mxnet.apache.org/) implementation, we re-implement the method in [PyTorch](https://pytorch.org/) based on mmdetection.
diff --git a/spaces/HESOAYM/ElviraMulti/modules/llama_func.py b/spaces/HESOAYM/ElviraMulti/modules/llama_func.py
deleted file mode 100644
index aec202a851c8ec51d1a96ce23320919af0d22a95..0000000000000000000000000000000000000000
--- a/spaces/HESOAYM/ElviraMulti/modules/llama_func.py
+++ /dev/null
@@ -1,166 +0,0 @@
-import os
-import logging
-
-from llama_index import download_loader
-from llama_index import (
- Document,
- LLMPredictor,
- PromptHelper,
- QuestionAnswerPrompt,
- RefinePrompt,
-)
-import colorama
-import PyPDF2
-from tqdm import tqdm
-
-from modules.presets import *
-from modules.utils import *
-from modules.config import local_embedding
-
-
-def get_index_name(file_src):
- file_paths = [x.name for x in file_src]
- file_paths.sort(key=lambda x: os.path.basename(x))
-
- md5_hash = hashlib.md5()
- for file_path in file_paths:
- with open(file_path, "rb") as f:
- while chunk := f.read(8192):
- md5_hash.update(chunk)
-
- return md5_hash.hexdigest()
-
-
-def block_split(text):
- blocks = []
- while len(text) > 0:
- blocks.append(Document(text[:1000]))
- text = text[1000:]
- return blocks
-
-
-def get_documents(file_src):
- documents = []
- logging.debug("Loading documents...")
- logging.debug(f"file_src: {file_src}")
- for file in file_src:
- filepath = file.name
- filename = os.path.basename(filepath)
- file_type = os.path.splitext(filepath)[1]
- logging.info(f"loading file: {filename}")
- try:
- if file_type == ".pdf":
- logging.debug("Loading PDF...")
- try:
- from modules.pdf_func import parse_pdf
- from modules.config import advance_docs
-
- two_column = advance_docs["pdf"].get("two_column", False)
- pdftext = parse_pdf(filepath, two_column).text
- except:
- pdftext = ""
- with open(filepath, "rb") as pdfFileObj:
- pdfReader = PyPDF2.PdfReader(pdfFileObj)
- for page in tqdm(pdfReader.pages):
- pdftext += page.extract_text()
- text_raw = pdftext
- elif file_type == ".docx":
- logging.debug("Loading Word...")
- DocxReader = download_loader("DocxReader")
- loader = DocxReader()
- text_raw = loader.load_data(file=filepath)[0].text
- elif file_type == ".epub":
- logging.debug("Loading EPUB...")
- EpubReader = download_loader("EpubReader")
- loader = EpubReader()
- text_raw = loader.load_data(file=filepath)[0].text
- elif file_type == ".xlsx":
- logging.debug("Loading Excel...")
- text_list = excel_to_string(filepath)
- for elem in text_list:
- documents.append(Document(elem))
- continue
- else:
- logging.debug("Loading text file...")
- with open(filepath, "r", encoding="utf-8") as f:
- text_raw = f.read()
- except Exception as e:
- logging.error(f"Error loading file: {filename}")
- pass
- text = add_space(text_raw)
- # text = block_split(text)
- # documents += text
- documents += [Document(text)]
- logging.debug("Documents loaded.")
- return documents
-
-
-def construct_index(
- api_key,
- file_src,
- max_input_size=4096,
- num_outputs=5,
- max_chunk_overlap=20,
- chunk_size_limit=600,
- embedding_limit=None,
- separator=" ",
-):
- from langchain.chat_models import ChatOpenAI
- from langchain.embeddings.huggingface import HuggingFaceEmbeddings
- from llama_index import GPTSimpleVectorIndex, ServiceContext, LangchainEmbedding, OpenAIEmbedding
-
- if api_key:
- os.environ["OPENAI_API_KEY"] = api_key
- else:
- # 由于一个依赖的愚蠢的设计，这里必须要有一个API KEY
- os.environ["OPENAI_API_KEY"] = "sk-xxxxxxx"
- chunk_size_limit = None if chunk_size_limit == 0 else chunk_size_limit
- embedding_limit = None if embedding_limit == 0 else embedding_limit
- separator = " " if separator == "" else separator
-
- prompt_helper = PromptHelper(
- max_input_size=max_input_size,
- num_output=num_outputs,
- max_chunk_overlap=max_chunk_overlap,
- embedding_limit=embedding_limit,
- chunk_size_limit=600,
- separator=separator,
- )
- index_name = get_index_name(file_src)
- if os.path.exists(f"./index/{index_name}.json"):
- logging.info("找到了缓存的索引文件，加载中……")
- return GPTSimpleVectorIndex.load_from_disk(f"./index/{index_name}.json")
- else:
- try:
- documents = get_documents(file_src)
- if local_embedding:
- embed_model = LangchainEmbedding(HuggingFaceEmbeddings())
- else:
- embed_model = OpenAIEmbedding()
- logging.info("构建索引中……")
- with retrieve_proxy():
- service_context = ServiceContext.from_defaults(
- prompt_helper=prompt_helper,
- chunk_size_limit=chunk_size_limit,
- embed_model=embed_model,
- )
- index = GPTSimpleVectorIndex.from_documents(
- documents, service_context=service_context
- )
- logging.debug("索引构建完成！")
- os.makedirs("./index", exist_ok=True)
- index.save_to_disk(f"./index/{index_name}.json")
- logging.debug("索引已保存至本地!")
- return index
-
- except Exception as e:
- logging.error("索引构建失败！", e)
- print(e)
- return None
-
-
-def add_space(text):
- punctuations = {"，": "， ", "。": "。 ", "？": "？ ", "！": "！ ", "：": "： ", "；": "； "}
- for cn_punc, en_punc in punctuations.items():
- text = text.replace(cn_punc, en_punc)
- return text
diff --git a/spaces/HarryLee/eCommerceImageCaptioning/fairseq/examples/laser/laser_src/laser_transformer.py b/spaces/HarryLee/eCommerceImageCaptioning/fairseq/examples/laser/laser_src/laser_transformer.py
deleted file mode 100644
index 0be030994ff87334ca0392302374693f7f2c61b3..0000000000000000000000000000000000000000
--- a/spaces/HarryLee/eCommerceImageCaptioning/fairseq/examples/laser/laser_src/laser_transformer.py
+++ /dev/null
@@ -1,354 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-import logging
-
-from typing import Any, Dict, List, Optional
-from torch import Tensor
-
-import torch
-import torch.nn as nn
-
-from fairseq.models import (
- FairseqEncoderDecoderModel,
- register_model,
- register_model_architecture,
-)
-from fairseq.models.transformer import (
- base_architecture,
- Embedding,
- TransformerModel,
- TransformerEncoder,
- TransformerDecoder,
-)
-from fairseq.modules import (
- TransformerDecoderLayer,
-)
-
-logger = logging.getLogger(__name__)
-
-
-@register_model("laser_transformer")
-class LaserTransformerModel(FairseqEncoderDecoderModel):
- """Train Transformer for LASER task
-
- Requires --task laser
- """
-
- def __init__(self, encoder, decoder):
- super().__init__(encoder, decoder)
-
- def forward(
- self,
- src_tokens,
- src_lengths,
- prev_output_tokens=None,
- tgt_tokens=None,
- tgt_lengths=None,
- target_language_id=-1,
- dataset_name="",
- ):
- laser_encoder_out = self.encoder(src_tokens, src_lengths)
- return self.decoder(
- prev_output_tokens, laser_encoder_out, lang_id=target_language_id
- )
-
- @staticmethod
- def add_args(parser):
- """Add model-specific arguments to the parser."""
- TransformerModel.add_args(parser)
- parser.add_argument(
- "--decoder-lang-embed-dim",
- type=int,
- metavar="N",
- help="decoder language embedding dimension",
- )
-
- @classmethod
- def build_model(cls, args, task):
- base_laser_transformer_architecture(args)
-
- num_langs = task.num_tasks if hasattr(task, "num_tasks") else 0
-
- def load_embed_tokens(dictionary, embed_dim):
- num_embeddings = len(dictionary)
- padding_idx = dictionary.pad()
-
- return Embedding(num_embeddings, embed_dim, padding_idx)
-
- encoder_embed_tokens = load_embed_tokens(
- task.source_dictionary, args.encoder_embed_dim
- )
- decoder_embed_tokens = load_embed_tokens(
- task.target_dictionary, args.decoder_embed_dim
- )
- num_langs = task.num_tasks if hasattr(task, "num_tasks") else 0
-
- encoder = LaserTransformerEncoder(
- args, task.source_dictionary, encoder_embed_tokens
- )
-
- decoder = LaserTransformerDecoder(
- args,
- task.target_dictionary,
- decoder_embed_tokens,
- num_langs=num_langs,
- lang_embed_dim=args.decoder_lang_embed_dim,
- )
-
- return cls(encoder, decoder)
-
-
-class LaserTransformerEncoder(TransformerEncoder):
- def __init__(self, *args, **kwargs):
- super().__init__(*args, **kwargs)
-
- def forward(self, src_tokens, *args, **kwargs):
- encoder_out = super().forward(src_tokens, *args, **kwargs)
-
- x = encoder_out["encoder_out"][0] # T x B x C
- padding_mask = src_tokens.eq(self.padding_idx).t().unsqueeze(-1)
-
- if padding_mask.any():
- x = x.float().masked_fill_(padding_mask, float("-inf")).type_as(x)
-
- # Build the sentence embedding by max-pooling over the encoder outputs
- sentemb = x.max(dim=0)[0]
-
- # The Pytorch Mobile lite interpreter does not supports returning NamedTuple in
- # `foward` so we use a dictionary instead.
- # TorchScript does not support mixed values so the values are all lists.
- # The empty list is equivalent to None.
- return {"sentemb": [sentemb]} # B x C
-
- @torch.jit.export
- def reorder_encoder_out(self, encoder_out: Dict[str, List[Tensor]], new_order):
- """
- Same as the one in transformer.py, with new_sentemb
- """
- if len(encoder_out["sentemb"]) == 0:
- new_sentemb = []
- else:
- new_sentemb = [encoder_out["sentemb"][0].index_select(0, new_order)]
-
- return {
- "sentemb": new_sentemb, # B x C
- }
-
-
-class LaserTransformerDecoder(TransformerDecoder):
- def __init__(self, args, dictionary, *kargs, **kwargs):
- self.num_langs = kwargs.get("num_langs", 1)
- self.lang_embed_dim = kwargs.get("lang_embed_dim", 0)
- kwargs.pop("num_langs", None)
- kwargs.pop("lang_embed_dim", None)
-
- super().__init__(args, dictionary, *kargs, **kwargs, no_encoder_attn=True)
-
- if self.lang_embed_dim == 0:
- self.embed_lang = None
- else:
- self.embed_lang = nn.Embedding(self.num_langs, self.lang_embed_dim)
- nn.init.uniform_(self.embed_lang.weight, -0.1, 0.1)
-
- if self.output_projection is not None:
- laser_output_embed_dim = (
- self.output_embed_dim + self.lang_embed_dim + args.encoder_embed_dim
- )
- self.output_projection = nn.Linear(
- laser_output_embed_dim, len(dictionary), bias=False
- )
- nn.init.normal_(
- self.output_projection.weight,
- mean=0,
- std=laser_output_embed_dim ** -0.5,
- )
-
- def build_decoder_layer(self, args, no_encoder_attn=False):
- decoder_embed_dim = args.decoder_embed_dim
- args.decoder_embed_dim = (
- decoder_embed_dim + self.lang_embed_dim + args.encoder_embed_dim
- )
- res = TransformerDecoderLayer(args, no_encoder_attn=True)
- args.decoder_embed_dim = decoder_embed_dim
-
- return res
-
- def extract_features(
- self,
- prev_output_tokens,
- encoder_out: Optional[Dict[str, List[Tensor]]],
- incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]] = None,
- full_context_alignment: bool = False,
- alignment_layer: Optional[int] = None,
- alignment_heads: Optional[int] = None,
- lang_id: Optional[int] = None,
- ):
- """
- Similar to *forward* but only return features.
-
- Includes several features from "Jointly Learning to Align and
- Translate with Transformer Models" (Garg et al., EMNLP 2019).
-
- Args:
- full_context_alignment (bool, optional): don't apply
- auto-regressive mask to self-attention (default: False).
- alignment_layer (int, optional): return mean alignment over
- heads at this layer (default: last layer).
- alignment_heads (int, optional): only average alignment over
- this many heads (default: all heads).
-
- Returns:
- tuple:
- - the decoder's features of shape `(batch, tgt_len, embed_dim)`
- - a dictionary with any model-specific outputs
- """
- if alignment_layer is None:
- alignment_layer = self.num_layers - 1
-
- # embed positions
- positions = (
- self.embed_positions(
- prev_output_tokens, incremental_state=incremental_state
- )
- if self.embed_positions is not None
- else None
- )
-
- if incremental_state is not None:
- prev_output_tokens = prev_output_tokens[:, -1:]
- if positions is not None:
- positions = positions[:, -1:]
-
- bsz, seqlen = prev_output_tokens.size()
-
- # embed tokens and positions
- x = self.embed_scale * self.embed_tokens(prev_output_tokens)
-
- if self.quant_noise is not None:
- x = self.quant_noise(x)
-
- if self.project_in_dim is not None:
- x = self.project_in_dim(x)
-
- if positions is not None:
- x += positions
-
- if self.layernorm_embedding is not None:
- x = self.layernorm_embedding(x)
-
- x = self.dropout_module(x)
-
- # B x T x C -> T x B x C
- x = x.transpose(0, 1)
-
- if self.embed_lang is not None:
- lang_ids = prev_output_tokens.data.new_full((bsz,), lang_id)
- langemb = self.embed_lang(lang_ids)
- langemb = langemb.unsqueeze(0)
- repeat_vals = [x.shape[0] // langemb.shape[0]] + [-1] * (
- len(langemb.shape) - 1
- )
- x = torch.cat((x, langemb.expand(*repeat_vals)), dim=-1)
-
- sentemb = encoder_out["sentemb"][0]
- sentemb = sentemb.unsqueeze(0)
-
- repeat_vals = [x.shape[0] // sentemb.shape[0]] + [-1] * (len(sentemb.shape) - 1)
- x = torch.cat((x, sentemb.expand(*repeat_vals)), dim=-1)
-
- self_attn_padding_mask: Optional[Tensor] = None
- if self.cross_self_attention or prev_output_tokens.eq(self.padding_idx).any():
- self_attn_padding_mask = prev_output_tokens.eq(self.padding_idx)
-
- # decoder layers
- attn: Optional[Tensor] = None
- inner_states: List[Optional[Tensor]] = [x]
- for idx, layer in enumerate(self.layers):
- if incremental_state is None and not full_context_alignment:
- self_attn_mask = self.buffered_future_mask(x)
- else:
- self_attn_mask = None
-
- x, layer_attn, _ = layer(
- x,
- None,
- None,
- incremental_state,
- self_attn_mask=self_attn_mask,
- self_attn_padding_mask=self_attn_padding_mask,
- need_attn=bool((idx == alignment_layer)),
- need_head_weights=bool((idx == alignment_layer)),
- )
- inner_states.append(x)
- if layer_attn is not None and idx == alignment_layer:
- attn = layer_attn.float().to(x)
-
- if attn is not None:
- if alignment_heads is not None:
- attn = attn[:alignment_heads]
-
- # average probabilities over heads
- attn = attn.mean(dim=0)
-
- if self.layer_norm is not None:
- x = self.layer_norm(x)
-
- # T x B x C -> B x T x C
- x = x.transpose(0, 1)
-
- if self.project_out_dim is not None:
- x = self.project_out_dim(x)
-
- return x, {"attn": [attn], "inner_states": inner_states}
-
- def forward(
- self,
- prev_output_tokens,
- encoder_out: Optional[Dict[str, List[Tensor]]] = None,
- incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]] = None,
- features_only: bool = False,
- alignment_layer: Optional[int] = None,
- alignment_heads: Optional[int] = None,
- src_lengths: Optional[Any] = None,
- return_all_hiddens: bool = False,
- lang_id: Optional[int] = None,
- ):
- """
- Args:
- prev_output_tokens (LongTensor): previous decoder outputs of shape
- `(batch, tgt_len)`, for teacher forcing
- encoder_out (optional): output from the encoder, used for
- encoder-side attention
- incremental_state (dict): dictionary used for storing state during
- :ref:`Incremental decoding`
- features_only (bool, optional): only return features without
- applying output layer (default: False).
-
- Returns:
- tuple:
- - the decoder's output of shape `(batch, tgt_len, vocab)`
- - a dictionary with any model-specific outputs
- """
-
- assert lang_id is not None
-
- x, extra = self.extract_features(
- prev_output_tokens,
- encoder_out=encoder_out,
- incremental_state=incremental_state,
- alignment_layer=alignment_layer,
- alignment_heads=alignment_heads,
- lang_id=lang_id,
- )
- if not features_only:
- x = self.output_layer(x)
- return x, extra
-
-
-@register_model_architecture("laser_transformer", "laser_transformer")
-def base_laser_transformer_architecture(args):
- base_architecture(args)
- args.decoder_lang_embed_dim = getattr(args, "decoder_lang_embed_dim", 0)
diff --git a/spaces/HarryLee/eCommerceImageCaptioning/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/decode_word_step2.sh b/spaces/HarryLee/eCommerceImageCaptioning/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/decode_word_step2.sh
deleted file mode 100644
index 59a6cbb12539cf62658f8344f7be7cecf2e3380f..0000000000000000000000000000000000000000
--- a/spaces/HarryLee/eCommerceImageCaptioning/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/decode_word_step2.sh
+++ /dev/null
@@ -1,30 +0,0 @@
-#!/bin/bash
-
-# prepare a new data directory of HMM word output
-
-. ./path.sh
-
-set -eu
-
-out_dir= # same as in train.sh
-dec_lmparam= # LM hyperparameters (e.g., 7.0.0)
-
-dec_exp=tri3b # what HMM stage to decode (e.g., tri3b)
-dec_suffix=word
-dec_splits="train valid"
-dec_data_dir=$out_dir/dec_data_word # where to write HMM output
-
-data_dir=$out_dir/data
-wrd_data_dir=$out_dir/data_word
-
-for x in $dec_splits; do
- mkdir -p $dec_data_dir/$x
- cp $data_dir/$x/{feats.scp,cmvn.scp,utt2spk,spk2utt} $dec_data_dir/$x/
-
- tra=$out_dir/exp/$dec_exp/decode${dec_suffix}_${x}/scoring/${dec_lmparam}.tra
- cat $tra | utils/int2sym.pl -f 2- $data_dir/lang_word/words.txt | \
- sed 's:
- Learning RepPoints in Object Detection.
-{title}
Get your Open AI API key here
') - openAI_key=gr.Textbox(label='Enter your OpenAI API key here') - url = gr.Textbox(label='Enter PDF URL here') - gr.Markdown("OR
{title}
or
川虎 Chat 🐯 Chuanhu Chat
-
-
- 
-
-
-
-
-## Usage Tips
-
-- To better control the ChatGPT, use System Prompt.
-- To use a Prompt Template, select the Prompt Template Collection file first, and then choose certain prompt from the drop-down menu.
-- To try again if the response is unsatisfactory, use `🔄 Regenerate` button.
-- To start a new line in the input box, press Shift + Enter keys.
-- To quickly switch between input history, press ↑ and ↓ key in the input box.
-- To deploy the program onto a server, change the last line of the program to `demo.launch(server_name="0.0.0.0", server_port=
-
-
--
Lightweight and User-friendly Web-UI for LLMs including ChatGPT/ChatGLM/LLaMA
-
- 
- 
-
- Streaming / Unlimited conversations / Save history / Preset prompts / Chat with files / Web search
- LaTeX rendering / Table rendering / Code highlighting
- Auto dark mode / Adaptive web interface / WeChat-like theme
- Multi-parameters tuning / Multi-API-Key support / Multi-user support
- Compatible with GPT-4 / Local deployment for LLMs
-
- 
-
-
-
diff --git a/spaces/JLD/docker-hello-world/main.py b/spaces/JLD/docker-hello-world/main.py
deleted file mode 100644
index 563beac73e4a34e98ab6e60c07bcb2a4862b3174..0000000000000000000000000000000000000000
--- a/spaces/JLD/docker-hello-world/main.py
+++ /dev/null
@@ -1,7 +0,0 @@
-from fastapi import FastAPI
-
-app = FastAPI()
-
-@app.get("/")
-def read_root():
- return {"Hello": "World!"}
\ No newline at end of file
diff --git a/spaces/JohnSmith9982/ChuanhuChatGPT_Beta/readme/README_ja.md b/spaces/JohnSmith9982/ChuanhuChatGPT_Beta/readme/README_ja.md
deleted file mode 100644
index 1e0771070e0c9852f02a1024c65176f5a1ac46ba..0000000000000000000000000000000000000000
--- a/spaces/JohnSmith9982/ChuanhuChatGPT_Beta/readme/README_ja.md
+++ /dev/null
@@ -1,139 +0,0 @@
-
-
-川虎 Chat 🐯 Chuanhu Chat
-
-
- 
-
-
-
-
-## サポートされている大規模言語モデル
-
-**APIを通じてアクセス可能な大規模言語モデル**：
-
-- [ChatGPT](https://chat.openai.com) ([GPT-4](https://openai.com/product/gpt-4))
-- [Google PaLM](https://developers.generativeai.google/products/palm)
-- [Inspur Yuan 1.0](https://air.inspur.com/home)
-- [MiniMax](https://api.minimax.chat/)
-- [XMChat](https://github.com/MILVLG/xmchat)
-
-**ローカルに展開された大規模言語モデル**：
-
-- [ChatGLM](https://github.com/THUDM/ChatGLM-6B) ([ChatGLM2](https://github.com/THUDM/ChatGLM2-6B))
-- [LLaMA](https://github.com/facebookresearch/llama)
-- [StableLM](https://github.com/Stability-AI/StableLM)
-- [MOSS](https://github.com/OpenLMLab/MOSS)
-
-## 使う上でのTips
-
-- ChatGPTをより適切に制御するために、システムプロンプトを使用できます。
-- プロンプトテンプレートを使用するには、プロンプトテンプレートコレクションを選択し、ドロップダウンメニューから特定のプロンプトを選択。回答が不十分な場合は、`🔄再生成`ボタンを使って再試行します。
-- 入力ボックスで改行するには、Shift + Enterキーを押してください。
-- 入力履歴を素早く切り替えるには、入力ボックスで ↑と↓キーを押す。
-- プログラムをサーバーに展開するには、`config.json` 内の `"server_name": "0.0.0.0", "server_port": <ポート番号>`を設定してください。
-- 共有リンクを取得するには、 `config.json` 内の `"share": true` を設定してください。なお、公開リンクでアクセスするためには、プログラムが実行されている必要があることに注意してください。
-- Hugging Face Spacesで使用する場合： より速く、より安全に利用するために、**Duplicate Space**を使用し、自分のスペースでプログラムを実行することをお勧めします。
-
-## クイックスタート
-
-```shell
-git clone https://github.com/GaiZhenbiao/ChuanhuChatGPT.git
-cd ChuanhuChatGPT
-pip install -r requirements.txt
-```
-
-次に `config_example.json`をコピーして `config.json`にリネームし、そのファイルにAPI-Keyなどの設定を記入する。
-
-```shell
-python ChuanhuChatbot.py
-```
-
-ブラウザのウィンドウが開き、ChatGPTとチャットできるようになります。
-
-> **Note**
->
-> 詳しい手順は[wikiページ](https://github.com/GaiZhenbiao/ChuanhuChatGPT/wiki/使用教程)をご確認ください。
-
-## トラブルシューティング
-
-問題が発生した場合は、まずこのプロジェクトの最新の変更点を手動で引っ張ってみるのがよいでしょう。その手順は以下の通りです：
-
-1. ウェブページの `Download ZIP` をクリックして最新のコードアーカイブをダウンロードするか、または
- ```shell
- git pull https://github.com/GaiZhenbiao/ChuanhuChatGPT.git main -f
- ```
-2. 新しい依存関係が導入されている可能性があるため、依存関係を再度インストールしてみてください。
- ```
- pip install -r requirements.txt
- ```
-
-一般的に、以下の手順でほとんどの問題を解決することができます。
-
-それでも問題が解決しない場合は、こちらのページをご参照ください： [よくある質問（FAQ）](https://github.com/GaiZhenbiao/ChuanhuChatGPT/wiki/常见问题)
-
-このページでは、考えられるほぼすべての問題点と解決策を掲載しています。よくお読みください。
-
-## More Information
-
-より詳細な情報は、[wiki](https://github.com/GaiZhenbiao/ChuanhuChatGPT/wiki) をご覧ください。:
-
-- [How to contribute a translation](https://github.com/GaiZhenbiao/ChuanhuChatGPT/wiki/Localization)
-- [How to make a contribution](https://github.com/GaiZhenbiao/ChuanhuChatGPT/wiki/贡献指南)
-- [How to cite the project](https://github.com/GaiZhenbiao/ChuanhuChatGPT/wiki/使用许可#如何引用该项目)
-- [Project changelog](https://github.com/GaiZhenbiao/ChuanhuChatGPT/wiki/更新日志)
-- [Project license](https://github.com/GaiZhenbiao/ChuanhuChatGPT/wiki/使用许可)
-
-## Starchart
-
-[](https://star-history.com/#GaiZhenbiao/ChuanhuChatGPT&Date)
-
-## Contributors
-
-
- -
ChatGPT/ChatGLM/LLaMAなどのLLMのための軽量でユーザーフレンドリーなWeb-UI
-
- ストリーム出力／会話回数無制限／履歴保存／プリセットプロンプト／ファイルへの質問チャット
- ウェブ検索／LaTeXレンダリング／表レンダリング／コードハイライト
- オートダークモード／アダプティブ・ウェブ・インターフェイス／WeChatライク・テーマ
- マルチパラメーターチューニング／マルチAPI-Key対応／マルチユーザー対応
- GPT-4対応／LLMのローカルデプロイ可能。
-
-
-
-
-
diff --git a/spaces/JosePezantes/Violencia-politica-genero/style.css b/spaces/JosePezantes/Violencia-politica-genero/style.css
deleted file mode 100644
index b4cfaad1ccba34b4029d6ac325b692f9f2e19cc6..0000000000000000000000000000000000000000
--- a/spaces/JosePezantes/Violencia-politica-genero/style.css
+++ /dev/null
@@ -1,64 +0,0 @@
-.stButton > button{
- color: #FFFFFF;
- background-color: #C60C35;
- font-size: 18px;
- height: 35px;
- width: 40%;
- margin: 0%;
- position: relative;
- top: 50%;
- left: 50%;
- -ms-transform: translate(-50%, -50%);
- transform: translate(-50%, -50%);
-}
-
-.stButton> button:hover{
- color: #FFFFFF;
- background-color: #920000;
- border-color: #920000;
- font-size: 20px;
- height: 35px;
- width: 40%;
-
-}
-thead tr {
- background-color: #009879;
- text-align: left;
-}
-thead tr th {
- color:#FFFFFF !important;
-}
-th, td {
- padding: 12px 15px;
-}
-
-table {
- border-collapse: collapse;
- margin: 25px 0;
- font-size: 0.9em;
- font-family: sans-serif;
- min-width: 400px;
- box-shadow: 0 0 20px rgba(0, 0, 0, 0.15);
-}
-
-tbody tr {
- border-bottom: 1px solid #dddddd;
-}
-
-tbody tr:nth-of-type(even) {
- background-color: #f3f3f3;
-}
-
-tbody tr:last-of-type {
- border-bottom: 2px solid #009879;
-}
-
-tbody tr.active-row {
- font-weight: bold;
- color: #009879;
-}
-
-.stAlert {
- justify-content:baseline;
- display: flex;
-}
\ No newline at end of file
diff --git a/spaces/KANATA980122/bingo/README.md b/spaces/KANATA980122/bingo/README.md
deleted file mode 100644
index 5d6936218874c647b5d22e13ad4be7edb8936f92..0000000000000000000000000000000000000000
--- a/spaces/KANATA980122/bingo/README.md
+++ /dev/null
@@ -1,28 +0,0 @@
----
-title: bingo
-emoji: 😊
-colorFrom: red
-colorTo: red
-sdk: docker
-license: mit
-duplicated_from: hf4all/bingo
----
-
-
-
-# Bingo
-
-Bingo，一个让你呼吸顺畅 New Bing。
-
-高度还原 New Bing 网页版的主要操作，国内可用，兼容绝大多数微软 Bing AI 的功能，可自行部署使用。
-
-
-
-[](https://hub.docker.com/repository/docker/weaigc/bingo/)
-[](https://hub.docker.com/repository/docker/weaigc/bingo/)
-[](https://github.com/weaigc/bingo/blob/main/license)
-
-问题反馈请前往 https://github.com/weaigc/bingo/issues
-
-
-
diff --git a/spaces/KPCGD/bingo/src/components/chat-attachments.tsx b/spaces/KPCGD/bingo/src/components/chat-attachments.tsx
deleted file mode 100644
index ef43d4e262935d263b6099138c56f7daade5299d..0000000000000000000000000000000000000000
--- a/spaces/KPCGD/bingo/src/components/chat-attachments.tsx
+++ /dev/null
@@ -1,37 +0,0 @@
-import Image from 'next/image'
-import ClearIcon from '@/assets/images/clear.svg'
-import RefreshIcon from '@/assets/images/refresh.svg'
-import { FileItem } from '@/lib/bots/bing/types'
-import { cn } from '@/lib/utils'
-import { useBing } from '@/lib/hooks/use-bing'
-
-type ChatAttachmentsProps = Pick
- {attachmentList.map(file => (
-
- ) : null
-}
diff --git a/spaces/Kangarroar/ApplioRVC-Inference/infer/lib/infer_pack/attentions.py b/spaces/Kangarroar/ApplioRVC-Inference/infer/lib/infer_pack/attentions.py
deleted file mode 100644
index 19a0a670021aacb9ae1c7f8f54ca1bff8e065375..0000000000000000000000000000000000000000
--- a/spaces/Kangarroar/ApplioRVC-Inference/infer/lib/infer_pack/attentions.py
+++ /dev/null
@@ -1,417 +0,0 @@
-import copy
-import math
-
-import numpy as np
-import torch
-from torch import nn
-from torch.nn import functional as F
-
-from infer.lib.infer_pack import commons, modules
-from infer.lib.infer_pack.modules import LayerNorm
-
-
-class Encoder(nn.Module):
- def __init__(
- self,
- hidden_channels,
- filter_channels,
- n_heads,
- n_layers,
- kernel_size=1,
- p_dropout=0.0,
- window_size=10,
- **kwargs
- ):
- super().__init__()
- self.hidden_channels = hidden_channels
- self.filter_channels = filter_channels
- self.n_heads = n_heads
- self.n_layers = n_layers
- self.kernel_size = kernel_size
- self.p_dropout = p_dropout
- self.window_size = window_size
-
- self.drop = nn.Dropout(p_dropout)
- self.attn_layers = nn.ModuleList()
- self.norm_layers_1 = nn.ModuleList()
- self.ffn_layers = nn.ModuleList()
- self.norm_layers_2 = nn.ModuleList()
- for i in range(self.n_layers):
- self.attn_layers.append(
- MultiHeadAttention(
- hidden_channels,
- hidden_channels,
- n_heads,
- p_dropout=p_dropout,
- window_size=window_size,
- )
- )
- self.norm_layers_1.append(LayerNorm(hidden_channels))
- self.ffn_layers.append(
- FFN(
- hidden_channels,
- hidden_channels,
- filter_channels,
- kernel_size,
- p_dropout=p_dropout,
- )
- )
- self.norm_layers_2.append(LayerNorm(hidden_channels))
-
- def forward(self, x, x_mask):
- attn_mask = x_mask.unsqueeze(2) * x_mask.unsqueeze(-1)
- x = x * x_mask
- for i in range(self.n_layers):
- y = self.attn_layers[i](x, x, attn_mask)
- y = self.drop(y)
- x = self.norm_layers_1[i](x + y)
-
- y = self.ffn_layers[i](x, x_mask)
- y = self.drop(y)
- x = self.norm_layers_2[i](x + y)
- x = x * x_mask
- return x
-
-
-class Decoder(nn.Module):
- def __init__(
- self,
- hidden_channels,
- filter_channels,
- n_heads,
- n_layers,
- kernel_size=1,
- p_dropout=0.0,
- proximal_bias=False,
- proximal_init=True,
- **kwargs
- ):
- super().__init__()
- self.hidden_channels = hidden_channels
- self.filter_channels = filter_channels
- self.n_heads = n_heads
- self.n_layers = n_layers
- self.kernel_size = kernel_size
- self.p_dropout = p_dropout
- self.proximal_bias = proximal_bias
- self.proximal_init = proximal_init
-
- self.drop = nn.Dropout(p_dropout)
- self.self_attn_layers = nn.ModuleList()
- self.norm_layers_0 = nn.ModuleList()
- self.encdec_attn_layers = nn.ModuleList()
- self.norm_layers_1 = nn.ModuleList()
- self.ffn_layers = nn.ModuleList()
- self.norm_layers_2 = nn.ModuleList()
- for i in range(self.n_layers):
- self.self_attn_layers.append(
- MultiHeadAttention(
- hidden_channels,
- hidden_channels,
- n_heads,
- p_dropout=p_dropout,
- proximal_bias=proximal_bias,
- proximal_init=proximal_init,
- )
- )
- self.norm_layers_0.append(LayerNorm(hidden_channels))
- self.encdec_attn_layers.append(
- MultiHeadAttention(
- hidden_channels, hidden_channels, n_heads, p_dropout=p_dropout
- )
- )
- self.norm_layers_1.append(LayerNorm(hidden_channels))
- self.ffn_layers.append(
- FFN(
- hidden_channels,
- hidden_channels,
- filter_channels,
- kernel_size,
- p_dropout=p_dropout,
- causal=True,
- )
- )
- self.norm_layers_2.append(LayerNorm(hidden_channels))
-
- def forward(self, x, x_mask, h, h_mask):
- """
- x: decoder input
- h: encoder output
- """
- self_attn_mask = commons.subsequent_mask(x_mask.size(2)).to(
- device=x.device, dtype=x.dtype
- )
- encdec_attn_mask = h_mask.unsqueeze(2) * x_mask.unsqueeze(-1)
- x = x * x_mask
- for i in range(self.n_layers):
- y = self.self_attn_layers[i](x, x, self_attn_mask)
- y = self.drop(y)
- x = self.norm_layers_0[i](x + y)
-
- y = self.encdec_attn_layers[i](x, h, encdec_attn_mask)
- y = self.drop(y)
- x = self.norm_layers_1[i](x + y)
-
- y = self.ffn_layers[i](x, x_mask)
- y = self.drop(y)
- x = self.norm_layers_2[i](x + y)
- x = x * x_mask
- return x
-
-
-class MultiHeadAttention(nn.Module):
- def __init__(
- self,
- channels,
- out_channels,
- n_heads,
- p_dropout=0.0,
- window_size=None,
- heads_share=True,
- block_length=None,
- proximal_bias=False,
- proximal_init=False,
- ):
- super().__init__()
- assert channels % n_heads == 0
-
- self.channels = channels
- self.out_channels = out_channels
- self.n_heads = n_heads
- self.p_dropout = p_dropout
- self.window_size = window_size
- self.heads_share = heads_share
- self.block_length = block_length
- self.proximal_bias = proximal_bias
- self.proximal_init = proximal_init
- self.attn = None
-
- self.k_channels = channels // n_heads
- self.conv_q = nn.Conv1d(channels, channels, 1)
- self.conv_k = nn.Conv1d(channels, channels, 1)
- self.conv_v = nn.Conv1d(channels, channels, 1)
- self.conv_o = nn.Conv1d(channels, out_channels, 1)
- self.drop = nn.Dropout(p_dropout)
-
- if window_size is not None:
- n_heads_rel = 1 if heads_share else n_heads
- rel_stddev = self.k_channels**-0.5
- self.emb_rel_k = nn.Parameter(
- torch.randn(n_heads_rel, window_size * 2 + 1, self.k_channels)
- * rel_stddev
- )
- self.emb_rel_v = nn.Parameter(
- torch.randn(n_heads_rel, window_size * 2 + 1, self.k_channels)
- * rel_stddev
- )
-
- nn.init.xavier_uniform_(self.conv_q.weight)
- nn.init.xavier_uniform_(self.conv_k.weight)
- nn.init.xavier_uniform_(self.conv_v.weight)
- if proximal_init:
- with torch.no_grad():
- self.conv_k.weight.copy_(self.conv_q.weight)
- self.conv_k.bias.copy_(self.conv_q.bias)
-
- def forward(self, x, c, attn_mask=None):
- q = self.conv_q(x)
- k = self.conv_k(c)
- v = self.conv_v(c)
-
- x, self.attn = self.attention(q, k, v, mask=attn_mask)
-
- x = self.conv_o(x)
- return x
-
- def attention(self, query, key, value, mask=None):
- # reshape [b, d, t] -> [b, n_h, t, d_k]
- b, d, t_s, t_t = (*key.size(), query.size(2))
- query = query.view(b, self.n_heads, self.k_channels, t_t).transpose(2, 3)
- key = key.view(b, self.n_heads, self.k_channels, t_s).transpose(2, 3)
- value = value.view(b, self.n_heads, self.k_channels, t_s).transpose(2, 3)
-
- scores = torch.matmul(query / math.sqrt(self.k_channels), key.transpose(-2, -1))
- if self.window_size is not None:
- assert (
- t_s == t_t
- ), "Relative attention is only available for self-attention."
- key_relative_embeddings = self._get_relative_embeddings(self.emb_rel_k, t_s)
- rel_logits = self._matmul_with_relative_keys(
- query / math.sqrt(self.k_channels), key_relative_embeddings
- )
- scores_local = self._relative_position_to_absolute_position(rel_logits)
- scores = scores + scores_local
- if self.proximal_bias:
- assert t_s == t_t, "Proximal bias is only available for self-attention."
- scores = scores + self._attention_bias_proximal(t_s).to(
- device=scores.device, dtype=scores.dtype
- )
- if mask is not None:
- scores = scores.masked_fill(mask == 0, -1e4)
- if self.block_length is not None:
- assert (
- t_s == t_t
- ), "Local attention is only available for self-attention."
- block_mask = (
- torch.ones_like(scores)
- .triu(-self.block_length)
- .tril(self.block_length)
- )
- scores = scores.masked_fill(block_mask == 0, -1e4)
- p_attn = F.softmax(scores, dim=-1) # [b, n_h, t_t, t_s]
- p_attn = self.drop(p_attn)
- output = torch.matmul(p_attn, value)
- if self.window_size is not None:
- relative_weights = self._absolute_position_to_relative_position(p_attn)
- value_relative_embeddings = self._get_relative_embeddings(
- self.emb_rel_v, t_s
- )
- output = output + self._matmul_with_relative_values(
- relative_weights, value_relative_embeddings
- )
- output = (
- output.transpose(2, 3).contiguous().view(b, d, t_t)
- ) # [b, n_h, t_t, d_k] -> [b, d, t_t]
- return output, p_attn
-
- def _matmul_with_relative_values(self, x, y):
- """
- x: [b, h, l, m]
- y: [h or 1, m, d]
- ret: [b, h, l, d]
- """
- ret = torch.matmul(x, y.unsqueeze(0))
- return ret
-
- def _matmul_with_relative_keys(self, x, y):
- """
- x: [b, h, l, d]
- y: [h or 1, m, d]
- ret: [b, h, l, m]
- """
- ret = torch.matmul(x, y.unsqueeze(0).transpose(-2, -1))
- return ret
-
- def _get_relative_embeddings(self, relative_embeddings, length):
- max_relative_position = 2 * self.window_size + 1
- # Pad first before slice to avoid using cond ops.
- pad_length = max(length - (self.window_size + 1), 0)
- slice_start_position = max((self.window_size + 1) - length, 0)
- slice_end_position = slice_start_position + 2 * length - 1
- if pad_length > 0:
- padded_relative_embeddings = F.pad(
- relative_embeddings,
- commons.convert_pad_shape([[0, 0], [pad_length, pad_length], [0, 0]]),
- )
- else:
- padded_relative_embeddings = relative_embeddings
- used_relative_embeddings = padded_relative_embeddings[
- :, slice_start_position:slice_end_position
- ]
- return used_relative_embeddings
-
- def _relative_position_to_absolute_position(self, x):
- """
- x: [b, h, l, 2*l-1]
- ret: [b, h, l, l]
- """
- batch, heads, length, _ = x.size()
- # Concat columns of pad to shift from relative to absolute indexing.
- x = F.pad(x, commons.convert_pad_shape([[0, 0], [0, 0], [0, 0], [0, 1]]))
-
- # Concat extra elements so to add up to shape (len+1, 2*len-1).
- x_flat = x.view([batch, heads, length * 2 * length])
- x_flat = F.pad(
- x_flat, commons.convert_pad_shape([[0, 0], [0, 0], [0, length - 1]])
- )
-
- # Reshape and slice out the padded elements.
- x_final = x_flat.view([batch, heads, length + 1, 2 * length - 1])[
- :, :, :length, length - 1 :
- ]
- return x_final
-
- def _absolute_position_to_relative_position(self, x):
- """
- x: [b, h, l, l]
- ret: [b, h, l, 2*l-1]
- """
- batch, heads, length, _ = x.size()
- # padd along column
- x = F.pad(
- x, commons.convert_pad_shape([[0, 0], [0, 0], [0, 0], [0, length - 1]])
- )
- x_flat = x.view([batch, heads, length**2 + length * (length - 1)])
- # add 0's in the beginning that will skew the elements after reshape
- x_flat = F.pad(x_flat, commons.convert_pad_shape([[0, 0], [0, 0], [length, 0]]))
- x_final = x_flat.view([batch, heads, length, 2 * length])[:, :, :, 1:]
- return x_final
-
- def _attention_bias_proximal(self, length):
- """Bias for self-attention to encourage attention to close positions.
- Args:
- length: an integer scalar.
- Returns:
- a Tensor with shape [1, 1, length, length]
- """
- r = torch.arange(length, dtype=torch.float32)
- diff = torch.unsqueeze(r, 0) - torch.unsqueeze(r, 1)
- return torch.unsqueeze(torch.unsqueeze(-torch.log1p(torch.abs(diff)), 0), 0)
-
-
-class FFN(nn.Module):
- def __init__(
- self,
- in_channels,
- out_channels,
- filter_channels,
- kernel_size,
- p_dropout=0.0,
- activation=None,
- causal=False,
- ):
- super().__init__()
- self.in_channels = in_channels
- self.out_channels = out_channels
- self.filter_channels = filter_channels
- self.kernel_size = kernel_size
- self.p_dropout = p_dropout
- self.activation = activation
- self.causal = causal
-
- if causal:
- self.padding = self._causal_padding
- else:
- self.padding = self._same_padding
-
- self.conv_1 = nn.Conv1d(in_channels, filter_channels, kernel_size)
- self.conv_2 = nn.Conv1d(filter_channels, out_channels, kernel_size)
- self.drop = nn.Dropout(p_dropout)
-
- def forward(self, x, x_mask):
- x = self.conv_1(self.padding(x * x_mask))
- if self.activation == "gelu":
- x = x * torch.sigmoid(1.702 * x)
- else:
- x = torch.relu(x)
- x = self.drop(x)
- x = self.conv_2(self.padding(x * x_mask))
- return x * x_mask
-
- def _causal_padding(self, x):
- if self.kernel_size == 1:
- return x
- pad_l = self.kernel_size - 1
- pad_r = 0
- padding = [[0, 0], [0, 0], [pad_l, pad_r]]
- x = F.pad(x, commons.convert_pad_shape(padding))
- return x
-
- def _same_padding(self, x):
- if self.kernel_size == 1:
- return x
- pad_l = (self.kernel_size - 1) // 2
- pad_r = self.kernel_size // 2
- padding = [[0, 0], [0, 0], [pad_l, pad_r]]
- x = F.pad(x, commons.convert_pad_shape(padding))
- return x
diff --git a/spaces/Kevin676/Real-Time-Voice-Cloning/encoder/data_objects/__init__.py b/spaces/Kevin676/Real-Time-Voice-Cloning/encoder/data_objects/__init__.py
deleted file mode 100644
index ef04ade68544d0477a7f6deb4e7d51e97f592910..0000000000000000000000000000000000000000
--- a/spaces/Kevin676/Real-Time-Voice-Cloning/encoder/data_objects/__init__.py
+++ /dev/null
@@ -1,2 +0,0 @@
-from encoder.data_objects.speaker_verification_dataset import SpeakerVerificationDataset
-from encoder.data_objects.speaker_verification_dataset import SpeakerVerificationDataLoader
diff --git a/spaces/Kreaols/ChuanhuChatGPT/run_Windows.bat b/spaces/Kreaols/ChuanhuChatGPT/run_Windows.bat
deleted file mode 100644
index 4c18f9ccaeea0af972301ffdf48778641221f76d..0000000000000000000000000000000000000000
--- a/spaces/Kreaols/ChuanhuChatGPT/run_Windows.bat
+++ /dev/null
@@ -1,5 +0,0 @@
-@echo off
-echo Opening ChuanhuChatGPT...
-
-REM Open powershell via bat
-start powershell.exe -NoExit -Command "python ./ChuanhuChatbot.py"
diff --git a/spaces/KyanChen/FunSR/models/mlp.py b/spaces/KyanChen/FunSR/models/mlp.py
deleted file mode 100644
index 94415e26b57219c7e7e41d9c02a45ac9c5dd2874..0000000000000000000000000000000000000000
--- a/spaces/KyanChen/FunSR/models/mlp.py
+++ /dev/null
@@ -1,80 +0,0 @@
-import torch
-import torch.nn as nn
-
-from models import register
-
-
-@register('mlp_pw')
-class MLP(nn.Module):
-
- def __init__(self, in_dim, out_dim, hidden_list):
- super().__init__()
- self.relu_0 = nn.ReLU(inplace=True)
- self.relu_1 = nn.ReLU(inplace=True)
- self.relu_2 = nn.ReLU(inplace=True)
- self.relu_3 = nn.ReLU(inplace=True)
- self.hidden=hidden_list[0]
-
- def forward(self, x,Coeff,basis,bias):
- # x(b*h*w,580)
- # Coeff(b*h*w,10)
- # basis[0](10,16*580)
- # basis[1](10,16*16)
- # basis[2](10,16*16)
- # basis[3](10,16*16)
- # basis[4](10,3*16)
- # bias[0](10,16)
- # bias[1](10,16)
- # bias[2](10,16)
- # bias[3](10,16)
- # bias[4](10,3)
- device=x.device
- # Applies a linear transformation to the incoming data: :math:`y = xA^T + b
- # Layer0
- x = x.unsqueeze(1)
- # sum( (b*h*w,1,580)*(b*h*w,16,580) , dim=2 ) -> (b*h*w,16)
- x = torch.sum(x*torch.matmul(Coeff.to(device),basis[0].to(device)).view(-1,self.hidden,580),dim=2)
- # (b*h*w,16) + (b*h*w,16) -> (b*h*w,16)
- x = x + torch.matmul(Coeff.to(device),bias[0].to(device))
- x = self.relu_0(x)
- # Layer1
- x = x.unsqueeze(1)
- x = torch.sum(x*torch.matmul(Coeff.to(device),basis[1].to(device)).view(-1,self.hidden,self.hidden),dim=2)
- x = x + torch.matmul(Coeff.to(device),bias[1].to(device))
- x = self.relu_1(x)
- # Layer2
- x = x.unsqueeze(1)
- x = torch.sum(x*torch.matmul(Coeff.to(device),basis[2].to(device)).view(-1,self.hidden,self.hidden),dim=2)
- x = x + torch.matmul(Coeff.to(device),bias[2].to(device))
- x = self.relu_2(x)
- # Layer3
- x = x.unsqueeze(1)
- x = torch.sum(x*torch.matmul(Coeff.to(device),basis[3].to(device)).view(-1,self.hidden,self.hidden),dim=2)
- x = x + torch.matmul(Coeff.to(device),bias[3].to(device))
- x = self.relu_3(x)
- # Layer4
- x = x.unsqueeze(1)
- x = torch.sum(x*torch.matmul(Coeff.to(device),basis[4].to(device)).view(-1,3,self.hidden),dim=2)
- x = x + torch.matmul(Coeff.to(device),bias[4].to(device))
-
- return x
-
-
-@register('mlp')
-class MLP(nn.Module):
-
- def __init__(self, in_dim, out_dim, hidden_list):
- super().__init__()
- layers = []
- lastv = in_dim
- for hidden in hidden_list:
- layers.append(nn.Linear(lastv, hidden))
- layers.append(nn.ReLU())
- lastv = hidden
- layers.append(nn.Linear(lastv, out_dim))
- self.layers = nn.Sequential(*layers)
-
- def forward(self, x):
- shape = x.shape[:-1]
- x = self.layers(x.view(-1, x.shape[-1]))
- return x.view(*shape, -1)
diff --git a/spaces/KyanChen/RSPrompter/configs/rsprompter/predict_rsprompter_anchor_nwpu.py b/spaces/KyanChen/RSPrompter/configs/rsprompter/predict_rsprompter_anchor_nwpu.py
deleted file mode 100644
index fe7b5b1934aa577d255dfae374c2e7e9c9c7159c..0000000000000000000000000000000000000000
--- a/spaces/KyanChen/RSPrompter/configs/rsprompter/predict_rsprompter_anchor_nwpu.py
+++ /dev/null
@@ -1,277 +0,0 @@
-custom_imports = dict(
- imports=['mmseg.datasets', 'mmseg.models', 'mmdet.models'],
- allow_failed_imports=False)
-
-sub_model_train = [
- 'panoptic_head',
- 'data_preprocessor'
-]
-
-sub_model_optim = {
- 'panoptic_head': {'lr_mult': 1},
-}
-
-
-max_epochs = 1200
-optimizer = dict(type='AdamW', lr=0.0005, weight_decay=0.0001)
-param_scheduler = [
- dict(
- type='LinearLR',
- start_factor=0.0005,
- by_epoch=True,
- begin=0,
- end=1,
- convert_to_iter_based=True),
- dict(type='CosineAnnealingLR', T_max=120, by_epoch=True, begin=1, end=120)
-]
-
-param_scheduler_callback = dict(type='ParamSchedulerHook')
-evaluator_ = dict(type='MeanAveragePrecision', iou_type='segm')
-evaluator = dict(
- val_evaluator=dict(type='MeanAveragePrecision', iou_type='segm'))
-
-image_size = (1024, 1024)
-
-data_preprocessor = dict(
- type='mmdet.DetDataPreprocessor',
- mean=[123.675, 116.28, 103.53],
- std=[58.395, 57.12, 57.375],
- bgr_to_rgb=True,
- pad_size_divisor=32,
- pad_mask=True,
- mask_pad_value=0,
-)
-
-num_things_classes = 10
-num_stuff_classes = 0
-num_classes = num_things_classes + num_stuff_classes
-prompt_shape = (60, 4)
-
-
-model_cfg = dict(
- type='SegSAMAnchorPLer',
- hyperparameters=dict(
- optimizer=optimizer,
- param_scheduler=param_scheduler,
- evaluator=evaluator,
- ),
- need_train_names=sub_model_train,
- data_preprocessor=data_preprocessor,
- backbone=dict(
- type='vit_h',
- checkpoint='pretrain/sam/sam_vit_h_4b8939.pth',
- # type='vit_b',
- # checkpoint='pretrain/sam/sam_vit_b_01ec64.pth',
- ),
- panoptic_head=dict(
- type='SAMAnchorInstanceHead',
- neck=dict(
- type='SAMAggregatorNeck',
- in_channels=[1280] * 32,
- # in_channels=[768] * 12,
- inner_channels=32,
- selected_channels=range(4, 32, 2),
- # selected_channels=range(4, 12, 2),
- out_channels=256,
- up_sample_scale=4,
- ),
- rpn_head=dict(
- type='mmdet.RPNHead',
- in_channels=256,
- feat_channels=256,
- anchor_generator=dict(
- type='mmdet.AnchorGenerator',
- scales=[2, 4, 8, 16, 32, 64],
- ratios=[0.5, 1.0, 2.0],
- strides=[8, 16, 32]),
- bbox_coder=dict(
- type='mmdet.DeltaXYWHBBoxCoder',
- target_means=[.0, .0, .0, .0],
- target_stds=[1.0, 1.0, 1.0, 1.0]),
- loss_cls=dict(
- type='mmdet.CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0),
- loss_bbox=dict(type='mmdet.SmoothL1Loss', loss_weight=1.0)),
- roi_head=dict(
- type='SAMAnchorPromptRoIHead',
- bbox_roi_extractor=dict(
- type='mmdet.SingleRoIExtractor',
- roi_layer=dict(type='RoIAlign', output_size=7, sampling_ratio=0),
- out_channels=256,
- featmap_strides=[8, 16, 32]),
- bbox_head=dict(
- type='mmdet.Shared2FCBBoxHead',
- in_channels=256,
- fc_out_channels=1024,
- roi_feat_size=7,
- num_classes=num_classes,
- bbox_coder=dict(
- type='mmdet.DeltaXYWHBBoxCoder',
- target_means=[0., 0., 0., 0.],
- target_stds=[0.1, 0.1, 0.2, 0.2]),
- reg_class_agnostic=False,
- loss_cls=dict(
- type='mmdet.CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0),
- loss_bbox=dict(type='mmdet.SmoothL1Loss', loss_weight=1.0)),
- mask_roi_extractor=dict(
- type='mmdet.SingleRoIExtractor',
- roi_layer=dict(type='RoIAlign', output_size=14, sampling_ratio=0),
- out_channels=256,
- featmap_strides=[8, 16, 32]),
- mask_head=dict(
- type='SAMPromptMaskHead',
- per_query_point=prompt_shape[1],
- with_sincos=True,
- class_agnostic=True,
- loss_mask=dict(
- type='mmdet.CrossEntropyLoss', use_mask=True, loss_weight=1.0))),
- # model training and testing settings
- train_cfg=dict(
- rpn=dict(
- assigner=dict(
- type='mmdet.MaxIoUAssigner',
- pos_iou_thr=0.7,
- neg_iou_thr=0.3,
- min_pos_iou=0.3,
- match_low_quality=True,
- ignore_iof_thr=-1),
- sampler=dict(
- type='mmdet.RandomSampler',
- num=512,
- pos_fraction=0.5,
- neg_pos_ub=-1,
- add_gt_as_proposals=False),
- allowed_border=-1,
- pos_weight=-1,
- debug=False),
- rpn_proposal=dict(
- nms_pre=2000,
- max_per_img=1000,
- nms=dict(type='nms', iou_threshold=0.7),
- min_bbox_size=0),
- rcnn=dict(
- assigner=dict(
- type='mmdet.MaxIoUAssigner',
- pos_iou_thr=0.5,
- neg_iou_thr=0.5,
- min_pos_iou=0.5,
- match_low_quality=True,
- ignore_iof_thr=-1),
- sampler=dict(
- type='mmdet.RandomSampler',
- num=256,
- pos_fraction=0.25,
- neg_pos_ub=-1,
- add_gt_as_proposals=True),
- mask_size=1024,
- pos_weight=-1,
- debug=False)),
- test_cfg=dict(
- rpn=dict(
- nms_pre=1000,
- max_per_img=1000,
- nms=dict(type='nms', iou_threshold=0.7),
- min_bbox_size=0),
- rcnn=dict(
- score_thr=0.05,
- nms=dict(type='nms', iou_threshold=0.5),
- max_per_img=100,
- mask_thr_binary=0.5)
- )
- )
-)
-
-
-task_name = 'nwpu_ins'
-exp_name = 'rsprompter_anchor_E20230601_0'
-callbacks = [
- dict(
- type='DetVisualizationHook',
- draw=True,
- interval=1,
- score_thr=0.1,
- show=False,
- wait_time=1.,
- test_out_dir='visualization',
- )
-]
-
-
-vis_backends = [dict(type='mmdet.LocalVisBackend')]
-visualizer = dict(
- type='mmdet.DetLocalVisualizer',
- vis_backends=vis_backends,
- name='visualizer',
- fig_save_cfg=dict(
- frameon=False,
- figsize=(40, 20),
- # dpi=300,
- ),
- line_width=2,
- alpha=0.8
-)
-
-
-trainer_cfg = dict(
- compiled_model=False,
- accelerator='auto',
- strategy='auto',
- devices=[0],
- default_root_dir=f'results/{task_name}/{exp_name}',
- max_epochs=120,
- logger=None,
- callbacks=callbacks,
- log_every_n_steps=20,
- check_val_every_n_epoch=10,
- benchmark=True,
- use_distributed_sampler=True)
-
-backend_args = None
-train_pipeline = [
- dict(type='mmdet.LoadImageFromFile'),
- dict(type='mmdet.LoadAnnotations', with_bbox=True, with_mask=True),
- dict(type='mmdet.Resize', scale=image_size),
- dict(type='mmdet.RandomFlip', prob=0.5),
- dict(type='mmdet.PackDetInputs')
-]
-
-test_pipeline = [
- dict(type='mmdet.LoadImageFromFile', backend_args=backend_args),
- dict(type='mmdet.Resize', scale=image_size),
- # If you don't have a gt annotation, delete the pipeline
- dict(type='mmdet.LoadAnnotations', with_bbox=True, with_mask=True),
- dict(
- type='mmdet.PackDetInputs',
- meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape',
- 'scale_factor'))
-]
-
-train_batch_size_per_gpu = 8
-train_num_workers = 4
-test_batch_size_per_gpu = 2
-test_num_workers = 0
-persistent_workers = False
-
-data_parent = '/mnt/search01/dataset/cky_data/NWPU10'
-train_data_prefix = ''
-val_data_prefix = ''
-
-dataset_type = 'NWPUInsSegDataset'
-val_loader = dict(
- batch_size=test_batch_size_per_gpu,
- num_workers=test_num_workers,
- persistent_workers=persistent_workers,
- pin_memory=True,
- dataset=dict(
- type=dataset_type,
- data_root=data_parent,
- ann_file='NWPU_instances_val.json',
- data_prefix=dict(img_path='positive image set'),
- test_mode=True,
- filter_cfg=dict(filter_empty_gt=True, min_size=32),
- pipeline=test_pipeline,
- backend_args=backend_args))
-
-datamodule_cfg = dict(
- type='PLDataModule',
- predict_loader=val_loader,
-)
diff --git a/spaces/KyanChen/RSPrompter/mmdet/models/detectors/yolox.py b/spaces/KyanChen/RSPrompter/mmdet/models/detectors/yolox.py
deleted file mode 100644
index df9190c93f7b043910fbce3bd5ee8dc0ef7b5f68..0000000000000000000000000000000000000000
--- a/spaces/KyanChen/RSPrompter/mmdet/models/detectors/yolox.py
+++ /dev/null
@@ -1,43 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from mmdet.registry import MODELS
-from mmdet.utils import ConfigType, OptConfigType, OptMultiConfig
-from .single_stage import SingleStageDetector
-
-
-@MODELS.register_module()
-class YOLOX(SingleStageDetector):
- r"""Implementation of `YOLOX: Exceeding YOLO Series in 2021
-
- {file.status === 'loading' && (
-
- ))}
-
-
-
)
- }
- {file.status !== 'error' && (
-
- 
-
)
- }
- {file.status === 'error' && (
-
- uploadImage(file.url)} />
-
- )}
-
- - This page is redundant, Please visit here for the actual site -
- - - - - -You can duplicating this space and use your own session token:
