`` tags. By default, the content is enclosed in a ```` tag, itself wrapped in a ```` tag (but see the `nowrap` option). The ``
``'s CSS class can be set by the `cssclass` option."),
- 'IRCFormatter': ('pygments.formatters.irc', 'IRC', ('irc', 'IRC'), (), 'Format tokens with IRC color sequences'),
- 'ImageFormatter': ('pygments.formatters.img', 'img', ('img', 'IMG', 'png'), ('*.png',), 'Create a PNG image from source code. This uses the Python Imaging Library to generate a pixmap from the source code.'),
- 'JpgImageFormatter': ('pygments.formatters.img', 'img_jpg', ('jpg', 'jpeg'), ('*.jpg',), 'Create a JPEG image from source code. This uses the Python Imaging Library to generate a pixmap from the source code.'),
- 'LatexFormatter': ('pygments.formatters.latex', 'LaTeX', ('latex', 'tex'), ('*.tex',), 'Format tokens as LaTeX code. This needs the `fancyvrb` and `color` standard packages.'),
- 'NullFormatter': ('pygments.formatters.other', 'Text only', ('text', 'null'), ('*.txt',), 'Output the text unchanged without any formatting.'),
- 'PangoMarkupFormatter': ('pygments.formatters.pangomarkup', 'Pango Markup', ('pango', 'pangomarkup'), (), 'Format tokens as Pango Markup code. It can then be rendered to an SVG.'),
- 'RawTokenFormatter': ('pygments.formatters.other', 'Raw tokens', ('raw', 'tokens'), ('*.raw',), 'Format tokens as a raw representation for storing token streams.'),
- 'RtfFormatter': ('pygments.formatters.rtf', 'RTF', ('rtf',), ('*.rtf',), 'Format tokens as RTF markup. This formatter automatically outputs full RTF documents with color information and other useful stuff. Perfect for Copy and Paste into Microsoft(R) Word(R) documents.'),
- 'SvgFormatter': ('pygments.formatters.svg', 'SVG', ('svg',), ('*.svg',), 'Format tokens as an SVG graphics file. This formatter is still experimental. Each line of code is a ``
`` element with explicit ``x`` and ``y`` coordinates containing ```` elements with the individual token styles.'),
- 'Terminal256Formatter': ('pygments.formatters.terminal256', 'Terminal256', ('terminal256', 'console256', '256'), (), 'Format tokens with ANSI color sequences, for output in a 256-color terminal or console. Like in `TerminalFormatter` color sequences are terminated at newlines, so that paging the output works correctly.'),
- 'TerminalFormatter': ('pygments.formatters.terminal', 'Terminal', ('terminal', 'console'), (), 'Format tokens with ANSI color sequences, for output in a text console. Color sequences are terminated at newlines, so that paging the output works correctly.'),
- 'TerminalTrueColorFormatter': ('pygments.formatters.terminal256', 'TerminalTrueColor', ('terminal16m', 'console16m', '16m'), (), 'Format tokens with ANSI color sequences, for output in a true-color terminal or console. Like in `TerminalFormatter` color sequences are terminated at newlines, so that paging the output works correctly.'),
- 'TestcaseFormatter': ('pygments.formatters.other', 'Testcase', ('testcase',), (), 'Format tokens as appropriate for a new testcase.'),
-}
diff --git a/spaces/TandCAcceptMe/face-swap-docker/mynewshinyroop/Lib/site-packages/pip/_vendor/pyparsing/__init__.py b/spaces/TandCAcceptMe/face-swap-docker/mynewshinyroop/Lib/site-packages/pip/_vendor/pyparsing/__init__.py
deleted file mode 100644
index 88bc10ac18a6af79f962fec16091d3494adc9e66..0000000000000000000000000000000000000000
--- a/spaces/TandCAcceptMe/face-swap-docker/mynewshinyroop/Lib/site-packages/pip/_vendor/pyparsing/__init__.py
+++ /dev/null
@@ -1,322 +0,0 @@
-# module pyparsing.py
-#
-# Copyright (c) 2003-2022 Paul T. McGuire
-#
-# Permission is hereby granted, free of charge, to any person obtaining
-# a copy of this software and associated documentation files (the
-# "Software"), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish,
-# distribute, sublicense, and/or sell copies of the Software, and to
-# permit persons to whom the Software is furnished to do so, subject to
-# the following conditions:
-#
-# The above copyright notice and this permission notice shall be
-# included in all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-#
-
-__doc__ = """
-pyparsing module - Classes and methods to define and execute parsing grammars
-=============================================================================
-
-The pyparsing module is an alternative approach to creating and
-executing simple grammars, vs. the traditional lex/yacc approach, or the
-use of regular expressions. With pyparsing, you don't need to learn
-a new syntax for defining grammars or matching expressions - the parsing
-module provides a library of classes that you use to construct the
-grammar directly in Python.
-
-Here is a program to parse "Hello, World!" (or any greeting of the form
-``", !"``), built up using :class:`Word`,
-:class:`Literal`, and :class:`And` elements
-(the :meth:`'+'` operators create :class:`And` expressions,
-and the strings are auto-converted to :class:`Literal` expressions)::
-
- from pip._vendor.pyparsing import Word, alphas
-
- # define grammar of a greeting
- greet = Word(alphas) + "," + Word(alphas) + "!"
-
- hello = "Hello, World!"
- print(hello, "->", greet.parse_string(hello))
-
-The program outputs the following::
-
- Hello, World! -> ['Hello', ',', 'World', '!']
-
-The Python representation of the grammar is quite readable, owing to the
-self-explanatory class names, and the use of :class:`'+'`,
-:class:`'|'`, :class:`'^'` and :class:`'&'` operators.
-
-The :class:`ParseResults` object returned from
-:class:`ParserElement.parse_string` can be
-accessed as a nested list, a dictionary, or an object with named
-attributes.
-
-The pyparsing module handles some of the problems that are typically
-vexing when writing text parsers:
-
- - extra or missing whitespace (the above program will also handle
- "Hello,World!", "Hello , World !", etc.)
- - quoted strings
- - embedded comments
-
-
-Getting Started -
------------------
-Visit the classes :class:`ParserElement` and :class:`ParseResults` to
-see the base classes that most other pyparsing
-classes inherit from. Use the docstrings for examples of how to:
-
- - construct literal match expressions from :class:`Literal` and
- :class:`CaselessLiteral` classes
- - construct character word-group expressions using the :class:`Word`
- class
- - see how to create repetitive expressions using :class:`ZeroOrMore`
- and :class:`OneOrMore` classes
- - use :class:`'+'`, :class:`'|'`, :class:`'^'`,
- and :class:`'&'` operators to combine simple expressions into
- more complex ones
- - associate names with your parsed results using
- :class:`ParserElement.set_results_name`
- - access the parsed data, which is returned as a :class:`ParseResults`
- object
- - find some helpful expression short-cuts like :class:`DelimitedList`
- and :class:`one_of`
- - find more useful common expressions in the :class:`pyparsing_common`
- namespace class
-"""
-from typing import NamedTuple
-
-
-class version_info(NamedTuple):
- major: int
- minor: int
- micro: int
- releaselevel: str
- serial: int
-
- @property
- def __version__(self):
- return (
- f"{self.major}.{self.minor}.{self.micro}"
- + (
- f"{'r' if self.releaselevel[0] == 'c' else ''}{self.releaselevel[0]}{self.serial}",
- "",
- )[self.releaselevel == "final"]
- )
-
- def __str__(self):
- return f"{__name__} {self.__version__} / {__version_time__}"
-
- def __repr__(self):
- return f"{__name__}.{type(self).__name__}({', '.join('{}={!r}'.format(*nv) for nv in zip(self._fields, self))})"
-
-
-__version_info__ = version_info(3, 1, 0, "final", 1)
-__version_time__ = "18 Jun 2023 14:05 UTC"
-__version__ = __version_info__.__version__
-__versionTime__ = __version_time__
-__author__ = "Paul McGuire "
-
-from .util import *
-from .exceptions import *
-from .actions import *
-from .core import __diag__, __compat__
-from .results import *
-from .core import * # type: ignore[misc, assignment]
-from .core import _builtin_exprs as core_builtin_exprs
-from .helpers import * # type: ignore[misc, assignment]
-from .helpers import _builtin_exprs as helper_builtin_exprs
-
-from .unicode import unicode_set, UnicodeRangeList, pyparsing_unicode as unicode
-from .testing import pyparsing_test as testing
-from .common import (
- pyparsing_common as common,
- _builtin_exprs as common_builtin_exprs,
-)
-
-# define backward compat synonyms
-if "pyparsing_unicode" not in globals():
- pyparsing_unicode = unicode # type: ignore[misc]
-if "pyparsing_common" not in globals():
- pyparsing_common = common # type: ignore[misc]
-if "pyparsing_test" not in globals():
- pyparsing_test = testing # type: ignore[misc]
-
-core_builtin_exprs += common_builtin_exprs + helper_builtin_exprs
-
-
-__all__ = [
- "__version__",
- "__version_time__",
- "__author__",
- "__compat__",
- "__diag__",
- "And",
- "AtLineStart",
- "AtStringStart",
- "CaselessKeyword",
- "CaselessLiteral",
- "CharsNotIn",
- "CloseMatch",
- "Combine",
- "DelimitedList",
- "Dict",
- "Each",
- "Empty",
- "FollowedBy",
- "Forward",
- "GoToColumn",
- "Group",
- "IndentedBlock",
- "Keyword",
- "LineEnd",
- "LineStart",
- "Literal",
- "Located",
- "PrecededBy",
- "MatchFirst",
- "NoMatch",
- "NotAny",
- "OneOrMore",
- "OnlyOnce",
- "OpAssoc",
- "Opt",
- "Optional",
- "Or",
- "ParseBaseException",
- "ParseElementEnhance",
- "ParseException",
- "ParseExpression",
- "ParseFatalException",
- "ParseResults",
- "ParseSyntaxException",
- "ParserElement",
- "PositionToken",
- "QuotedString",
- "RecursiveGrammarException",
- "Regex",
- "SkipTo",
- "StringEnd",
- "StringStart",
- "Suppress",
- "Token",
- "TokenConverter",
- "White",
- "Word",
- "WordEnd",
- "WordStart",
- "ZeroOrMore",
- "Char",
- "alphanums",
- "alphas",
- "alphas8bit",
- "any_close_tag",
- "any_open_tag",
- "autoname_elements",
- "c_style_comment",
- "col",
- "common_html_entity",
- "condition_as_parse_action",
- "counted_array",
- "cpp_style_comment",
- "dbl_quoted_string",
- "dbl_slash_comment",
- "delimited_list",
- "dict_of",
- "empty",
- "hexnums",
- "html_comment",
- "identchars",
- "identbodychars",
- "infix_notation",
- "java_style_comment",
- "line",
- "line_end",
- "line_start",
- "lineno",
- "make_html_tags",
- "make_xml_tags",
- "match_only_at_col",
- "match_previous_expr",
- "match_previous_literal",
- "nested_expr",
- "null_debug_action",
- "nums",
- "one_of",
- "original_text_for",
- "printables",
- "punc8bit",
- "pyparsing_common",
- "pyparsing_test",
- "pyparsing_unicode",
- "python_style_comment",
- "quoted_string",
- "remove_quotes",
- "replace_with",
- "replace_html_entity",
- "rest_of_line",
- "sgl_quoted_string",
- "srange",
- "string_end",
- "string_start",
- "token_map",
- "trace_parse_action",
- "ungroup",
- "unicode_set",
- "unicode_string",
- "with_attribute",
- "with_class",
- # pre-PEP8 compatibility names
- "__versionTime__",
- "anyCloseTag",
- "anyOpenTag",
- "cStyleComment",
- "commonHTMLEntity",
- "conditionAsParseAction",
- "countedArray",
- "cppStyleComment",
- "dblQuotedString",
- "dblSlashComment",
- "delimitedList",
- "dictOf",
- "htmlComment",
- "indentedBlock",
- "infixNotation",
- "javaStyleComment",
- "lineEnd",
- "lineStart",
- "locatedExpr",
- "makeHTMLTags",
- "makeXMLTags",
- "matchOnlyAtCol",
- "matchPreviousExpr",
- "matchPreviousLiteral",
- "nestedExpr",
- "nullDebugAction",
- "oneOf",
- "opAssoc",
- "originalTextFor",
- "pythonStyleComment",
- "quotedString",
- "removeQuotes",
- "replaceHTMLEntity",
- "replaceWith",
- "restOfLine",
- "sglQuotedString",
- "stringEnd",
- "stringStart",
- "tokenMap",
- "traceParseAction",
- "unicodeString",
- "withAttribute",
- "withClass",
-]
diff --git a/spaces/TandCAcceptMe/face-swap-docker/roop/ui.py b/spaces/TandCAcceptMe/face-swap-docker/roop/ui.py
deleted file mode 100644
index 6bc10132dcd7732ee5494087d977dbadf302daab..0000000000000000000000000000000000000000
--- a/spaces/TandCAcceptMe/face-swap-docker/roop/ui.py
+++ /dev/null
@@ -1,678 +0,0 @@
-import os
-import time
-import gradio as gr
-import cv2
-import pathlib
-import shutil
-import roop.globals
-import roop.metadata
-import roop.utilities as util
-
-from roop.face_helper import extract_face_images
-from roop.capturer import get_video_frame, get_video_frame_total, get_image_frame
-
-restart_server = False
-live_cam_active = False
-
-RECENT_DIRECTORY_SOURCE = None
-RECENT_DIRECTORY_TARGET = None
-RECENT_DIRECTORY_OUTPUT = None
-
-SELECTION_FACES_DATA = None
-
-last_image = None
-
-input_thumbs = []
-target_thumbs = []
-
-
-IS_INPUT = True
-SELECTED_FACE_INDEX = 0
-
-SELECTED_INPUT_FACE_INDEX = 0
-SELECTED_TARGET_FACE_INDEX = 0
-
-roop.globals.keep_fps = None
-roop.globals.keep_frames = None
-roop.globals.skip_audio = None
-roop.globals.use_batch = None
-
-input_faces = None
-target_faces = None
-face_selection = None
-fake_cam_image = None
-
-current_cam_image = None
-cam_swapping = False
-
-selected_preview_index = 0
-
-
-def prepare_environment():
- roop.globals.output_path = os.path.abspath(os.path.join(os.getcwd(), "output"))
- os.makedirs(roop.globals.output_path, exist_ok=True)
- os.environ["TEMP"] = os.environ["TMP"] = os.path.abspath(os.path.join(os.getcwd(), "temp"))
- os.makedirs(os.environ["TEMP"], exist_ok=True)
- os.environ["GRADIO_TEMP_DIR"] = os.environ["TEMP"]
-
-
-def run():
- from roop.core import suggest_execution_providers
- global input_faces, target_faces, face_selection, fake_cam_image, restart_server, live_cam_active, on_settings_changed
-
- prepare_environment()
-
- available_themes = ["Default", "gradio/glass", "gradio/monochrome", "gradio/seafoam", "gradio/soft", "gstaff/xkcd", "freddyaboulton/dracula_revamped", "ysharma/steampunk"]
- image_formats = ['jpg','png', 'webp']
- video_formats = ['avi','mkv', 'mp4', 'webm']
- video_codecs = ['libx264', 'libx265', 'libvpx-vp9', 'h264_nvenc', 'hevc_nvenc']
- providerlist = suggest_execution_providers()
-
- server_name = roop.globals.CFG.server_name
- if server_name is None or len(server_name) < 1:
- server_name = None
- server_port = roop.globals.CFG.server_port
- if server_port <= 0:
- server_port = None
-
- settings_controls = []
-
- live_cam_active = False
- run_server = True
-
- while run_server:
- with gr.Blocks(title=f'{roop.metadata.name} {roop.metadata.version}', theme=roop.globals.CFG.selected_theme, css="span {color: var(--block-info-text-color)}") as ui:
- with gr.Row(variant='panel'):
- gr.Markdown(f"### [{roop.metadata.name} {roop.metadata.version}](https://github.com/C0untFloyd/roop-unleashed)")
- gr.HTML(util.create_version_html(), elem_id="versions")
- with gr.Tab("Face Swap"):
- with gr.Row():
- with gr.Column():
- input_faces = gr.Gallery(label="Input faces", allow_preview=True, preview=True, height=128, object_fit="scale-down")
- with gr.Row():
- bt_remove_selected_input_face = gr.Button("Remove selected")
- bt_clear_input_faces = gr.Button("Clear all", variant='stop')
- bt_srcimg = gr.Image(label='Source Face Image', type='filepath', tool=None)
- with gr.Column():
- target_faces = gr.Gallery(label="Target faces", allow_preview=True, preview=True, height=128, object_fit="scale-down")
- with gr.Row():
- bt_remove_selected_target_face = gr.Button("Remove selected")
- bt_destfiles = gr.Files(label='Target File(s)', file_count="multiple", elem_id='filelist')
- with gr.Row():
- with gr.Column(visible=False) as dynamic_face_selection:
- face_selection = gr.Gallery(label="Detected faces", allow_preview=True, preview=True, height=256, object_fit="scale-down")
- with gr.Row():
- bt_faceselect = gr.Button("Use selected face")
- bt_cancelfaceselect = gr.Button("Cancel")
-
- with gr.Row():
- with gr.Column():
- selected_face_detection = gr.Dropdown(["First found", "All faces", "Selected face", "All female", "All male"], value="First found", label="Select face swapping method")
- max_face_distance = gr.Slider(0.01, 1.0, value=0.65, label="Max Face Similarity Threshold")
- with gr.Column():
- roop.globals.keep_fps = gr.Checkbox(label="Keep FPS", value=True)
- roop.globals.keep_frames = gr.Checkbox(label="Keep Frames", value=False)
- roop.globals.skip_audio = gr.Checkbox(label="Skip audio", value=False)
- with gr.Row():
- with gr.Column():
- selected_enhancer = gr.Dropdown(["None", "Codeformer", "DMDNet", "GFPGAN"], value="None", label="Select post-processing")
- with gr.Accordion(label="Masking", open=True):
- chk_useclip = gr.Checkbox(label="Use Text to Clip Masking", value=False)
- clip_text = gr.Textbox(label="List of objects to mask and restore back on fake image", placeholder="hands,hair")
-
- with gr.Column():
- blend_ratio = gr.Slider(0.0, 1.0, value=0.65, label="Original/Enhanced image blend ratio")
- with gr.Row(variant='panel'):
- with gr.Column():
- bt_start = gr.Button("Start", variant='primary')
- with gr.Column():
- gr.Markdown(' ')
- with gr.Column():
- fake_preview = gr.Checkbox(label="Face swap frames", value=False)
- with gr.Column():
- bt_refresh_preview = gr.Button("Refresh", variant='secondary')
- with gr.Row(variant='panel'):
- with gr.Column():
- with gr.Accordion(label="Results", open=True):
- resultfiles = gr.Files(label='Processed File(s)', interactive=False)
- resultimage = gr.Image(type='filepath', interactive=False)
- with gr.Column():
- with gr.Accordion(label="Preview Original/Fake Frame", open=True):
- previewimage = gr.Image(label="Preview Image", interactive=False)
- with gr.Column():
- preview_frame_num = gr.Slider(0, 0, value=0, label="Frame Number", step=1.0)
- bt_use_face_from_preview = gr.Button("Use Face from this Frame", variant='primary')
-
- with gr.Tab("Live Cam"):
- cam_toggle = gr.Checkbox(label='Activate', value=live_cam_active)
- if live_cam_active:
- with gr.Row():
- with gr.Column():
- cam = gr.Webcam(label='Camera', source='webcam', interactive=True, streaming=False)
- with gr.Column():
- fake_cam_image = gr.Image(label='Fake Camera Output', interactive=False)
-
-
- with gr.Tab("Extras"):
- with gr.Row():
- files_to_process = gr.Files(label='File(s) to process', file_count="multiple")
- with gr.Row(variant='panel'):
- with gr.Accordion(label="Post process", open=False):
- with gr.Column():
- selected_post_enhancer = gr.Dropdown(["None", "Codeformer", "GFPGAN"], value="None", label="Select post-processing")
- with gr.Column():
- gr.Button("Start").click(fn=lambda: gr.Info('Not yet implemented...'))
- with gr.Row(variant='panel'):
- with gr.Accordion(label="Video/GIF", open=False):
- with gr.Row(variant='panel'):
- with gr.Column():
- gr.Markdown("""
- # Cut video
- Be aware that this means re-encoding the video which might take a longer time.
- Encoding uses your configuration from the Settings Tab.
- """)
- with gr.Column():
- cut_start_time = gr.Slider(0, 100000, value=0, label="Start Frame", step=1.0, interactive=True)
- with gr.Column():
- cut_end_time = gr.Slider(1, 100000, value=1, label="End Frame", step=1.0, interactive=True)
- with gr.Column():
- start_cut_video = gr.Button("Start")
-
- # with gr.Row(variant='panel'):
- # with gr.Column():
- # gr.Markdown("""
- # # Join videos
- # This also re-encodes the videos like cutting above.
- # """)
- # with gr.Column():
- # start_join_videos = gr.Button("Start")
- with gr.Row(variant='panel'):
- gr.Markdown("Extract frames from video")
- start_extract_frames = gr.Button("Start")
- with gr.Row(variant='panel'):
- gr.Markdown("Create video from image files")
- gr.Button("Start").click(fn=lambda: gr.Info('Not yet implemented...'))
- with gr.Row(variant='panel'):
- gr.Markdown("Create GIF from video")
- start_create_gif = gr.Button("Create GIF")
- with gr.Row():
- extra_files_output = gr.Files(label='Resulting output files', file_count="multiple")
-
-
- with gr.Tab("Settings"):
- with gr.Row():
- with gr.Column():
- themes = gr.Dropdown(available_themes, label="Theme", info="Change needs complete restart", value=roop.globals.CFG.selected_theme)
- with gr.Column():
- settings_controls.append(gr.Checkbox(label="Public Server", value=roop.globals.CFG.server_share, elem_id='server_share', interactive=True))
- settings_controls.append(gr.Checkbox(label='Clear output folder before each run', value=roop.globals.CFG.clear_output, elem_id='clear_output', interactive=True))
- with gr.Column():
- input_server_name = gr.Textbox(label="Server Name", lines=1, info="Leave blank to run locally", value=roop.globals.CFG.server_name)
- with gr.Column():
- input_server_port = gr.Number(label="Server Port", precision=0, info="Leave at 0 to use default", value=roop.globals.CFG.server_port)
- with gr.Row():
- with gr.Column():
- max_threads = gr.Slider(1, 64, value=roop.globals.CFG.max_threads, label="Max. Number of Threads", info='default: 8', step=1.0, interactive=True)
- settings_controls.append(gr.Dropdown(image_formats, label="Image Output Format", info='default: png', value=roop.globals.CFG.output_image_format, elem_id='output_image_format', interactive=True))
- button_clean_temp = gr.Button("Clean temp folder")
- with gr.Column():
- settings_controls.append(gr.Dropdown(providerlist, label="Provider", value=roop.globals.CFG.provider, elem_id='provider', interactive=True))
- settings_controls.append(gr.Dropdown(video_formats, label="Video Output Format", info='default: mp4', value=roop.globals.CFG.output_video_format, elem_id='output_video_format', interactive=True))
- button_apply_settings = gr.Button("Apply Settings")
- with gr.Column():
- settings_controls.append(gr.Dropdown(video_codecs, label="Video Codec", info='default: libx264', value=roop.globals.CFG.output_video_codec, elem_id='output_video_codec', interactive=True))
- video_quality = gr.Slider(0, 100, value=roop.globals.CFG.video_quality, label="Video Quality (crf)", info='default: 14', step=1.0, interactive=True)
- with gr.Column():
- button_apply_restart = gr.Button("Restart Server", variant='primary')
-
- input_faces.select(on_select_input_face, None, None)
- bt_remove_selected_input_face.click(fn=remove_selected_input_face, outputs=[input_faces])
- bt_srcimg.change(fn=on_srcimg_changed, show_progress='full', inputs=bt_srcimg, outputs=[dynamic_face_selection, face_selection, input_faces])
-
-
- target_faces.select(on_select_target_face, None, None)
- bt_remove_selected_target_face.click(fn=remove_selected_target_face, outputs=[target_faces])
-
- bt_destfiles.select(fn=on_destfiles_selected, inputs=[bt_destfiles], outputs=[previewimage, preview_frame_num])
- bt_destfiles.clear(fn=on_clear_destfiles, outputs=[target_faces])
- resultfiles.select(fn=on_resultfiles_selected, inputs=[resultfiles], outputs=[resultimage])
-
- face_selection.select(on_select_face, None, None)
- bt_faceselect.click(fn=on_selected_face, outputs=[dynamic_face_selection, face_selection, input_faces, target_faces])
- bt_clear_input_faces.click(fn=on_clear_input_faces, outputs=[input_faces])
-
- bt_start.click(fn=start_swap,
- inputs=[selected_enhancer, selected_face_detection, roop.globals.keep_fps, roop.globals.keep_frames,
- roop.globals.skip_audio, max_face_distance, blend_ratio, bt_destfiles, chk_useclip, clip_text],
- outputs=[resultfiles, resultimage])
-
- previewinputs = [preview_frame_num, bt_destfiles, fake_preview, selected_enhancer, selected_face_detection,
- max_face_distance, blend_ratio, bt_destfiles, chk_useclip, clip_text]
- bt_refresh_preview.click(fn=on_preview_frame_changed, inputs=previewinputs, outputs=[previewimage])
- fake_preview.change(fn=on_preview_frame_changed, inputs=previewinputs, outputs=[previewimage])
- preview_frame_num.change(fn=on_preview_frame_changed, inputs=previewinputs, outputs=[previewimage], show_progress='hidden')
- bt_use_face_from_preview.click(fn=on_use_face_from_selected, show_progress='full', inputs=[bt_destfiles, preview_frame_num], outputs=[dynamic_face_selection, face_selection, target_faces])
-
-
- # Live Cam
- cam_toggle.change(fn=on_cam_toggle, inputs=[cam_toggle])
- if live_cam_active:
- cam.stream(on_stream_swap_cam, inputs=[cam, selected_enhancer, blend_ratio], outputs=[fake_cam_image], show_progress="hidden")
-
- # Extras
- start_cut_video.click(fn=on_cut_video, inputs=[files_to_process, cut_start_time, cut_end_time], outputs=[extra_files_output])
- # start_join_videos.click(fn=on_join_videos, inputs=[files_to_process], outputs=[extra_files_output])
- start_extract_frames.click(fn=on_extract_frames, inputs=[files_to_process], outputs=[extra_files_output])
- start_create_gif.click(fn=on_create_gif, inputs=[files_to_process], outputs=[extra_files_output])
-
- # Settings
- for s in settings_controls:
- s.select(fn=on_settings_changed)
- max_threads.input(fn=lambda a,b='max_threads':on_settings_changed_misc(a,b), inputs=[max_threads])
- video_quality.input(fn=lambda a,b='video_quality':on_settings_changed_misc(a,b), inputs=[video_quality])
-
- button_clean_temp.click(fn=clean_temp, outputs=[bt_srcimg, input_faces, target_faces, bt_destfiles])
- button_apply_settings.click(apply_settings, inputs=[themes, input_server_name, input_server_port])
- button_apply_restart.click(restart)
-
-
-
- restart_server = False
- try:
- ui.queue().launch(inbrowser=True, server_name=server_name, server_port=server_port, prevent_thread_lock=True, show_error=True)
- except:
- restart_server = True
- run_server = False
- try:
- while restart_server == False:
- time.sleep(5.0)
- except (KeyboardInterrupt, OSError):
- print("Keyboard interruption in main thread... closing server.")
- run_server = False
- ui.close()
-
-def on_settings_changed_misc(new_val, attribname):
- if hasattr(roop.globals.CFG, attribname):
- setattr(roop.globals.CFG, attribname, new_val)
- else:
- print("Didn't find attrib!")
-
-
-
-def on_settings_changed(evt: gr.SelectData):
- attribname = evt.target.elem_id
- if isinstance(evt.target, gr.Checkbox):
- if hasattr(roop.globals.CFG, attribname):
- setattr(roop.globals.CFG, attribname, evt.selected)
- return
- elif isinstance(evt.target, gr.Dropdown):
- if hasattr(roop.globals.CFG, attribname):
- setattr(roop.globals.CFG, attribname, evt.value)
- return
-
- raise gr.Error(f'Unhandled Setting for {evt.target}')
-
-
-
-def on_srcimg_changed(imgsrc, progress=gr.Progress()):
- global RECENT_DIRECTORY_SOURCE, SELECTION_FACES_DATA, IS_INPUT, input_faces, face_selection, input_thumbs, last_image
-
- IS_INPUT = True
-
- if imgsrc == None or last_image == imgsrc:
- return gr.Column.update(visible=False), None, input_thumbs
-
- last_image = imgsrc
-
- progress(0, desc="Retrieving faces from image", )
- source_path = imgsrc
- thumbs = []
- if util.is_image(source_path):
- roop.globals.source_path = source_path
- RECENT_DIRECTORY_SOURCE = os.path.dirname(roop.globals.source_path)
- SELECTION_FACES_DATA = extract_face_images(roop.globals.source_path, (False, 0))
- progress(0.5, desc="Retrieving faces from image")
- for f in SELECTION_FACES_DATA:
- image = convert_to_gradio(f[1])
- thumbs.append(image)
-
- progress(1.0, desc="Retrieving faces from image")
- if len(thumbs) < 1:
- raise gr.Error('No faces detected!')
-
- if len(thumbs) == 1:
- roop.globals.SELECTED_FACE_DATA_INPUT = SELECTION_FACES_DATA[0][0]
- input_thumbs.append(thumbs[0])
- return gr.Column.update(visible=False), None, input_thumbs
-
- return gr.Column.update(visible=True), thumbs, gr.Gallery.update(visible=True)
-
-def on_select_input_face(evt: gr.SelectData):
- global SELECTED_INPUT_FACE_INDEX
-
- SELECTED_INPUT_FACE_INDEX = evt.index
-
-def remove_selected_input_face():
- global input_thumbs, SELECTED_INPUT_FACE_INDEX
-
- if len(input_thumbs) > SELECTED_INPUT_FACE_INDEX:
- f = input_thumbs.pop(SELECTED_INPUT_FACE_INDEX)
- del f
-
- return input_thumbs
-
-def on_select_target_face(evt: gr.SelectData):
- global SELECTED_TARGET_FACE_INDEX
-
- SELECTED_TARGET_FACE_INDEX = evt.index
-
-def remove_selected_target_face():
- global target_thumbs, SELECTED_TARGET_FACE_INDEX
-
- if len(target_thumbs) > SELECTED_TARGET_FACE_INDEX:
- f = target_thumbs.pop(SELECTED_TARGET_FACE_INDEX)
- del f
- return target_thumbs
-
-
-
-
-
-def on_use_face_from_selected(files, frame_num):
- global IS_INPUT, SELECTION_FACES_DATA
-
- IS_INPUT = False
- thumbs = []
-
- roop.globals.target_path = files[selected_preview_index].name
- if util.is_image(roop.globals.target_path) and not roop.globals.target_path.lower().endswith(('gif')):
- SELECTION_FACES_DATA = extract_face_images(roop.globals.target_path, (False, 0))
- if len(SELECTION_FACES_DATA) > 0:
- for f in SELECTION_FACES_DATA:
- image = convert_to_gradio(f[1])
- thumbs.append(image)
- else:
- gr.Info('No faces detected!')
- roop.globals.target_path = None
-
- elif util.is_video(roop.globals.target_path) or roop.globals.target_path.lower().endswith(('gif')):
- selected_frame = frame_num
- SELECTION_FACES_DATA = extract_face_images(roop.globals.target_path, (True, selected_frame))
- if len(SELECTION_FACES_DATA) > 0:
- for f in SELECTION_FACES_DATA:
- image = convert_to_gradio(f[1])
- thumbs.append(image)
- else:
- gr.Info('No faces detected!')
- roop.globals.target_path = None
-
- if len(thumbs) == 1:
- roop.globals.SELECTED_FACE_DATA_OUTPUT = SELECTION_FACES_DATA[0][0]
- target_thumbs.append(thumbs[0])
- return gr.Row.update(visible=False), None, target_thumbs
-
- return gr.Row.update(visible=True), thumbs, gr.Gallery.update(visible=True)
-
-
-
-def on_select_face(evt: gr.SelectData): # SelectData is a subclass of EventData
- global SELECTED_FACE_INDEX
- SELECTED_FACE_INDEX = evt.index
-
-
-def on_selected_face():
- global IS_INPUT, SELECTED_FACE_INDEX, SELECTION_FACES_DATA, input_thumbs, target_thumbs
-
- fd = SELECTION_FACES_DATA[SELECTED_FACE_INDEX]
- image = convert_to_gradio(fd[1])
- if IS_INPUT:
- roop.globals.SELECTED_FACE_DATA_INPUT = fd[0]
- input_thumbs.append(image)
- return gr.Column.update(visible=False), None, input_thumbs, gr.Gallery.update(visible=True)
- else:
- roop.globals.SELECTED_FACE_DATA_OUTPUT = fd[0]
- target_thumbs.append(image)
- return gr.Column.update(visible=False), None, gr.Gallery.update(visible=True), target_thumbs
-
-# bt_faceselect.click(fn=on_selected_face, outputs=[dynamic_face_selection, face_selection, input_faces, target_faces])
-
-
-
-
-def on_preview_frame_changed(frame_num, files, fake_preview, enhancer, detection, face_distance, blend_ratio, target_files, use_clip, clip_text):
- from roop.core import live_swap
-
- filename = files[selected_preview_index].name
- if util.is_video(filename) or filename.lower().endswith('gif'):
- current_frame = get_video_frame(filename, frame_num)
- else:
- current_frame = get_image_frame(filename)
- if current_frame is None:
- return None
-
- if not fake_preview or roop.globals.SELECTED_FACE_DATA_INPUT is None:
- return convert_to_gradio(current_frame)
-
- roop.globals.face_swap_mode = translate_swap_mode(detection)
- roop.globals.selected_enhancer = enhancer
- roop.globals.distance_threshold = face_distance
- roop.globals.blend_ratio = blend_ratio
-
- if use_clip and clip_text is None or len(clip_text) < 1:
- use_clip = False
-
- roop.globals.execution_threads = roop.globals.CFG.max_threads
- current_frame = live_swap(current_frame, roop.globals.face_swap_mode, use_clip, clip_text)
- if current_frame is None:
- return None
- return convert_to_gradio(current_frame)
-
-
-
-
-def on_clear_input_faces():
- global input_thumbs
-
- input_thumbs = []
- roop.globals.SELECTED_FACE_DATA_INPUT = None
- return input_thumbs
-
-def on_clear_destfiles():
- global target_thumbs
-
- roop.globals.SELECTED_FACE_DATA_OUTPUT = None
- target_thumbs = []
- return target_thumbs
-
-
-
-def translate_swap_mode(dropdown_text):
- if dropdown_text == "Selected face":
- return "selected"
- elif dropdown_text == "First found":
- return "first"
- elif dropdown_text == "All female":
- return "all_female"
- elif dropdown_text == "All male":
- return "all_male"
-
- return "all"
-
-
-
-def start_swap(enhancer, detection, keep_fps, keep_frames, skip_audio, face_distance, blend_ratio, target_files, use_clip, clip_text):
- from roop.core import batch_process
-
- if target_files is None or len(target_files) <= 0:
- return None, None
-
- if roop.globals.CFG.clear_output:
- shutil.rmtree(roop.globals.output_path)
-
- prepare_environment()
-
- roop.globals.selected_enhancer = enhancer
- roop.globals.target_path = None
- roop.globals.distance_threshold = face_distance
- roop.globals.blend_ratio = blend_ratio
- roop.globals.keep_fps = keep_fps
- roop.globals.keep_frames = keep_frames
- roop.globals.skip_audio = skip_audio
- roop.globals.face_swap_mode = translate_swap_mode(detection)
- if use_clip and clip_text is None or len(clip_text) < 1:
- use_clip = False
-
- if roop.globals.face_swap_mode == 'selected':
- if roop.globals.SELECTED_FACE_DATA_OUTPUT is None or len(roop.globals.SELECTED_FACE_DATA_OUTPUT) < 1:
- gr.Error('No Target Face selected!')
- return None, None
-
- roop.globals.execution_threads = roop.globals.CFG.max_threads
- roop.globals.video_encoder = roop.globals.CFG.output_video_codec
- roop.globals.video_quality = roop.globals.CFG.video_quality
-
- batch_process([file.name for file in target_files], use_clip, clip_text)
- outdir = pathlib.Path(roop.globals.output_path)
- outfiles = [item for item in outdir.iterdir() if item.is_file()]
- if len(outfiles) > 0:
- return outfiles, outfiles[0]
- return None, None
-
-
-
-def on_destfiles_selected(evt: gr.SelectData, target_files):
- global selected_preview_index
-
- selected_preview_index = evt.index
- filename = target_files[selected_preview_index].name
- if util.is_video(filename) or filename.lower().endswith('gif'):
- current_frame = get_video_frame(filename, 0)
- total_frames = get_video_frame_total(filename)
- else:
- current_frame = get_image_frame(filename)
- total_frames = 0
-
- current_frame = convert_to_gradio(current_frame)
- return current_frame, gr.Slider.update(value=0, maximum=total_frames)
-
-
-def on_resultfiles_selected(evt: gr.SelectData, files):
- selected_index = evt.index
- filename = files[selected_index].name
- if util.is_video(filename) or filename.lower().endswith('gif'):
- current_frame = get_video_frame(filename, 0)
- else:
- current_frame = get_image_frame(filename)
- return convert_to_gradio(current_frame)
-
-
-
-def on_cam_toggle(state):
- global live_cam_active, restart_server
-
- live_cam_active = state
- gr.Warning('Server will be restarted for this change!')
- restart_server = True
-
-
-def on_stream_swap_cam(camimage, enhancer, blend_ratio):
- from roop.core import live_swap
- global current_cam_image, cam_counter, cam_swapping, fake_cam_image
-
- roop.globals.selected_enhancer = enhancer
- roop.globals.blend_ratio = blend_ratio
-
- if not cam_swapping and roop.globals.SELECTED_FACE_DATA_INPUT is not None:
- cam_swapping = True
- current_cam_image = live_swap(camimage, "all", False, None)
- cam_swapping = False
-
- return current_cam_image
-
-
-def on_cut_video(files, cut_start_frame, cut_end_frame):
- resultfiles = []
- for tf in files:
- f = tf.name
- # destfile = get_destfilename_from_path(f, resolve_relative_path('./output'), '_cut')
- destfile = util.get_destfilename_from_path(f, './output', '_cut')
- util.cut_video(f, destfile, cut_start_frame, cut_end_frame)
- if os.path.isfile(destfile):
- resultfiles.append(destfile)
- else:
- gr.Error('Cutting video failed!')
- return resultfiles
-
-def on_join_videos(files):
- filenames = []
- for f in files:
- filenames.append(f.name)
- destfile = util.get_destfilename_from_path(filenames[0], './output', '_join')
- util.join_videos(filenames, destfile)
- resultfiles = []
- if os.path.isfile(destfile):
- resultfiles.append(destfile)
- else:
- gr.Error('Joining videos failed!')
- return resultfiles
-
-
-
-
-def on_extract_frames(files):
- resultfiles = []
- for tf in files:
- f = tf.name
- resfolder = util.extract_frames(f)
- for file in os.listdir(resfolder):
- outfile = os.path.join(resfolder, file)
- if os.path.isfile(outfile):
- resultfiles.append(outfile)
- return resultfiles
-
-
-def on_create_gif(files):
- for tf in files:
- f = tf.name
- gifname = util.get_destfilename_from_path(f, './output', '.gif')
- util.create_gif_from_video(f, gifname)
-
- return gifname
-
-
-
-
-
-def clean_temp():
- global input_thumbs, target_thumbs
-
- shutil.rmtree(os.environ["TEMP"])
- prepare_environment()
-
- input_thumbs = []
- roop.globals.SELECTED_FACE_DATA_INPUT = None
- roop.globals.SELECTED_FACE_DATA_OUTPUT = None
- target_thumbs = []
- gr.Info('Temp Files removed')
- return None,None,None,None
-
-
-def apply_settings(themes, input_server_name, input_server_port):
- roop.globals.CFG.selected_theme = themes
- roop.globals.CFG.server_name = input_server_name
- roop.globals.CFG.server_port = input_server_port
- roop.globals.CFG.save()
- gr.Info('Settings saved')
-
-def restart():
- global restart_server
- restart_server = True
-
-
-
-
-# Gradio wants Images in RGB
-def convert_to_gradio(image):
- if image is None:
- return None
- return cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
diff --git a/spaces/TencentARC/T2I-Adapter-SDXL/model.py b/spaces/TencentARC/T2I-Adapter-SDXL/model.py
deleted file mode 100644
index 041d33f6fbb7d8ee97821621c52147b318817f70..0000000000000000000000000000000000000000
--- a/spaces/TencentARC/T2I-Adapter-SDXL/model.py
+++ /dev/null
@@ -1,374 +0,0 @@
-import gc
-import os
-from abc import ABC, abstractmethod
-
-import numpy as np
-import PIL.Image
-import torch
-from controlnet_aux import (
- CannyDetector,
- LineartDetector,
- MidasDetector,
- OpenposeDetector,
- PidiNetDetector,
- ZoeDetector,
-)
-from diffusers import (
- AutoencoderKL,
- EulerAncestralDiscreteScheduler,
- StableDiffusionXLAdapterPipeline,
- T2IAdapter,
-)
-
-SD_XL_BASE_RATIOS = {
- "0.5": (704, 1408),
- "0.52": (704, 1344),
- "0.57": (768, 1344),
- "0.6": (768, 1280),
- "0.68": (832, 1216),
- "0.72": (832, 1152),
- "0.78": (896, 1152),
- "0.82": (896, 1088),
- "0.88": (960, 1088),
- "0.94": (960, 1024),
- "1.0": (1024, 1024),
- "1.07": (1024, 960),
- "1.13": (1088, 960),
- "1.21": (1088, 896),
- "1.29": (1152, 896),
- "1.38": (1152, 832),
- "1.46": (1216, 832),
- "1.67": (1280, 768),
- "1.75": (1344, 768),
- "1.91": (1344, 704),
- "2.0": (1408, 704),
- "2.09": (1472, 704),
- "2.4": (1536, 640),
- "2.5": (1600, 640),
- "2.89": (1664, 576),
- "3.0": (1728, 576),
-}
-
-
-def find_closest_aspect_ratio(target_width: int, target_height: int) -> str:
- target_ratio = target_width / target_height
- closest_ratio = ""
- min_difference = float("inf")
-
- for ratio_str, (width, height) in SD_XL_BASE_RATIOS.items():
- ratio = width / height
- difference = abs(target_ratio - ratio)
-
- if difference < min_difference:
- min_difference = difference
- closest_ratio = ratio_str
-
- return closest_ratio
-
-
-def resize_to_closest_aspect_ratio(image: PIL.Image.Image) -> PIL.Image.Image:
- target_width, target_height = image.size
- closest_ratio = find_closest_aspect_ratio(target_width, target_height)
-
- # Get the dimensions from the closest aspect ratio in the dictionary
- new_width, new_height = SD_XL_BASE_RATIOS[closest_ratio]
-
- # Resize the image to the new dimensions while preserving the aspect ratio
- resized_image = image.resize((new_width, new_height), PIL.Image.LANCZOS)
-
- return resized_image
-
-
-ADAPTER_REPO_IDS = {
- "canny": "TencentARC/t2i-adapter-canny-sdxl-1.0",
- "sketch": "TencentARC/t2i-adapter-sketch-sdxl-1.0",
- "lineart": "TencentARC/t2i-adapter-lineart-sdxl-1.0",
- "depth-midas": "TencentARC/t2i-adapter-depth-midas-sdxl-1.0",
- "depth-zoe": "TencentARC/t2i-adapter-depth-zoe-sdxl-1.0",
- "openpose": "TencentARC/t2i-adapter-openpose-sdxl-1.0",
- # "recolor": "TencentARC/t2i-adapter-recolor-sdxl-1.0",
-}
-ADAPTER_NAMES = list(ADAPTER_REPO_IDS.keys())
-
-
-class Preprocessor(ABC):
- @abstractmethod
- def to(self, device: torch.device | str) -> "Preprocessor":
- pass
-
- @abstractmethod
- def __call__(self, image: PIL.Image.Image) -> PIL.Image.Image:
- pass
-
-
-class CannyPreprocessor(Preprocessor):
- def __init__(self):
- self.model = CannyDetector()
-
- def to(self, device: torch.device | str) -> Preprocessor:
- return self
-
- def __call__(self, image: PIL.Image.Image) -> PIL.Image.Image:
- return self.model(image, detect_resolution=384, image_resolution=1024)
-
-
-class LineartPreprocessor(Preprocessor):
- def __init__(self):
- self.model = LineartDetector.from_pretrained("lllyasviel/Annotators")
-
- def to(self, device: torch.device | str) -> Preprocessor:
- self.model.to(device)
- return self
-
- def __call__(self, image: PIL.Image.Image) -> PIL.Image.Image:
- return self.model(image, detect_resolution=384, image_resolution=1024)
-
-
-class MidasPreprocessor(Preprocessor):
- def __init__(self):
- self.model = MidasDetector.from_pretrained(
- "valhalla/t2iadapter-aux-models", filename="dpt_large_384.pt", model_type="dpt_large"
- )
-
- def to(self, device: torch.device | str) -> Preprocessor:
- self.model.to(device)
- return self
-
- def __call__(self, image: PIL.Image.Image) -> PIL.Image.Image:
- return self.model(image, detect_resolution=512, image_resolution=1024)
-
-
-class OpenposePreprocessor(Preprocessor):
- def __init__(self):
- self.model = OpenposeDetector.from_pretrained("lllyasviel/Annotators")
-
- def to(self, device: torch.device | str) -> Preprocessor:
- self.model.to(device)
- return self
-
- def __call__(self, image: PIL.Image.Image) -> PIL.Image.Image:
- out = self.model(image, detect_resolution=512, image_resolution=1024)
- out = np.array(out)[:, :, ::-1]
- out = PIL.Image.fromarray(np.uint8(out))
- return out
-
-
-class PidiNetPreprocessor(Preprocessor):
- def __init__(self):
- self.model = PidiNetDetector.from_pretrained("lllyasviel/Annotators")
-
- def to(self, device: torch.device | str) -> Preprocessor:
- self.model.to(device)
- return self
-
- def __call__(self, image: PIL.Image.Image) -> PIL.Image.Image:
- return self.model(image, detect_resolution=512, image_resolution=1024, apply_filter=True)
-
-
-class RecolorPreprocessor(Preprocessor):
- def to(self, device: torch.device | str) -> Preprocessor:
- return self
-
- def __call__(self, image: PIL.Image.Image) -> PIL.Image.Image:
- return image.convert("L").convert("RGB")
-
-
-class ZoePreprocessor(Preprocessor):
- def __init__(self):
- self.model = ZoeDetector.from_pretrained(
- "valhalla/t2iadapter-aux-models", filename="zoed_nk.pth", model_type="zoedepth_nk"
- )
-
- def to(self, device: torch.device | str) -> Preprocessor:
- self.model.to(device)
- return self
-
- def __call__(self, image: PIL.Image.Image) -> PIL.Image.Image:
- return self.model(image, gamma_corrected=True, image_resolution=1024)
-
-
-PRELOAD_PREPROCESSORS_IN_GPU_MEMORY = os.getenv("PRELOAD_PREPROCESSORS_IN_GPU_MEMORY", "0") == "1"
-PRELOAD_PREPROCESSORS_IN_CPU_MEMORY = os.getenv("PRELOAD_PREPROCESSORS_IN_CPU_MEMORY", "0") == "1"
-if PRELOAD_PREPROCESSORS_IN_GPU_MEMORY:
- device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
- preprocessors_gpu: dict[str, Preprocessor] = {
- "canny": CannyPreprocessor().to(device),
- "sketch": PidiNetPreprocessor().to(device),
- "lineart": LineartPreprocessor().to(device),
- "depth-midas": MidasPreprocessor().to(device),
- "depth-zoe": ZoePreprocessor().to(device),
- "openpose": OpenposePreprocessor().to(device),
- "recolor": RecolorPreprocessor().to(device),
- }
-
- def get_preprocessor(adapter_name: str) -> Preprocessor:
- return preprocessors_gpu[adapter_name]
-
-elif PRELOAD_PREPROCESSORS_IN_CPU_MEMORY:
- preprocessors_cpu: dict[str, Preprocessor] = {
- "canny": CannyPreprocessor(),
- "sketch": PidiNetPreprocessor(),
- "lineart": LineartPreprocessor(),
- "depth-midas": MidasPreprocessor(),
- "depth-zoe": ZoePreprocessor(),
- "openpose": OpenposePreprocessor(),
- "recolor": RecolorPreprocessor(),
- }
-
- def get_preprocessor(adapter_name: str) -> Preprocessor:
- return preprocessors_cpu[adapter_name]
-
-else:
-
- def get_preprocessor(adapter_name: str) -> Preprocessor:
- if adapter_name == "canny":
- return CannyPreprocessor()
- elif adapter_name == "sketch":
- return PidiNetPreprocessor()
- elif adapter_name == "lineart":
- return LineartPreprocessor()
- elif adapter_name == "depth-midas":
- return MidasPreprocessor()
- elif adapter_name == "depth-zoe":
- return ZoePreprocessor()
- elif adapter_name == "openpose":
- return OpenposePreprocessor()
- elif adapter_name == "recolor":
- return RecolorPreprocessor()
- else:
- raise ValueError(f"Adapter name must be one of {ADAPTER_NAMES}")
-
- def download_all_preprocessors():
- for adapter_name in ADAPTER_NAMES:
- get_preprocessor(adapter_name)
- gc.collect()
-
- download_all_preprocessors()
-
-
-def download_all_adapters():
- for adapter_name in ADAPTER_NAMES:
- T2IAdapter.from_pretrained(
- ADAPTER_REPO_IDS[adapter_name],
- torch_dtype=torch.float16,
- varient="fp16",
- )
- gc.collect()
-
-
-class Model:
- MAX_NUM_INFERENCE_STEPS = 50
-
- def __init__(self, adapter_name: str):
- if adapter_name not in ADAPTER_NAMES:
- raise ValueError(f"Adapter name must be one of {ADAPTER_NAMES}")
-
- self.preprocessor_name = adapter_name
- self.adapter_name = adapter_name
-
- self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
- if torch.cuda.is_available():
- self.preprocessor = get_preprocessor(adapter_name).to(self.device)
-
- model_id = "stabilityai/stable-diffusion-xl-base-1.0"
- adapter = T2IAdapter.from_pretrained(
- ADAPTER_REPO_IDS[adapter_name],
- torch_dtype=torch.float16,
- varient="fp16",
- ).to(self.device)
- self.pipe = StableDiffusionXLAdapterPipeline.from_pretrained(
- model_id,
- vae=AutoencoderKL.from_pretrained("madebyollin/sdxl-vae-fp16-fix", torch_dtype=torch.float16),
- adapter=adapter,
- scheduler=EulerAncestralDiscreteScheduler.from_pretrained(model_id, subfolder="scheduler"),
- torch_dtype=torch.float16,
- variant="fp16",
- ).to(self.device)
- self.pipe.enable_xformers_memory_efficient_attention()
- self.pipe.load_lora_weights(
- "stabilityai/stable-diffusion-xl-base-1.0", weight_name="sd_xl_offset_example-lora_1.0.safetensors"
- )
- self.pipe.fuse_lora(lora_scale=0.4)
- else:
- self.preprocessor = None # type: ignore
- self.pipe = None
-
- def change_preprocessor(self, adapter_name: str) -> None:
- if adapter_name not in ADAPTER_NAMES:
- raise ValueError(f"Adapter name must be one of {ADAPTER_NAMES}")
- if adapter_name == self.preprocessor_name:
- return
-
- if PRELOAD_PREPROCESSORS_IN_GPU_MEMORY:
- pass
- elif PRELOAD_PREPROCESSORS_IN_CPU_MEMORY:
- self.preprocessor.to("cpu")
- else:
- del self.preprocessor
- self.preprocessor = get_preprocessor(adapter_name).to(self.device)
- self.preprocessor_name = adapter_name
- gc.collect()
- torch.cuda.empty_cache()
-
- def change_adapter(self, adapter_name: str) -> None:
- if adapter_name not in ADAPTER_NAMES:
- raise ValueError(f"Adapter name must be one of {ADAPTER_NAMES}")
- if adapter_name == self.adapter_name:
- return
- self.pipe.adapter = T2IAdapter.from_pretrained(
- ADAPTER_REPO_IDS[adapter_name],
- torch_dtype=torch.float16,
- varient="fp16",
- ).to(self.device)
- self.adapter_name = adapter_name
- gc.collect()
- torch.cuda.empty_cache()
-
- def resize_image(self, image: PIL.Image.Image) -> PIL.Image.Image:
- w, h = image.size
- scale = 1024 / max(w, h)
- new_w = int(w * scale)
- new_h = int(h * scale)
- return image.resize((new_w, new_h), PIL.Image.LANCZOS)
-
- def run(
- self,
- image: PIL.Image.Image,
- prompt: str,
- negative_prompt: str,
- adapter_name: str,
- num_inference_steps: int = 30,
- guidance_scale: float = 5.0,
- adapter_conditioning_scale: float = 1.0,
- adapter_conditioning_factor: float = 1.0,
- seed: int = 0,
- apply_preprocess: bool = True,
- ) -> list[PIL.Image.Image]:
- if not torch.cuda.is_available():
- raise RuntimeError("This demo does not work on CPU.")
- if num_inference_steps > self.MAX_NUM_INFERENCE_STEPS:
- raise ValueError(f"Number of steps must be less than {self.MAX_NUM_INFERENCE_STEPS}")
-
- # Resize image to avoid OOM
- image = self.resize_image(image)
-
- self.change_preprocessor(adapter_name)
- self.change_adapter(adapter_name)
-
- if apply_preprocess:
- image = self.preprocessor(image)
-
- image = resize_to_closest_aspect_ratio(image)
-
- generator = torch.Generator(device=self.device).manual_seed(seed)
- out = self.pipe(
- prompt=prompt,
- negative_prompt=negative_prompt,
- image=image,
- num_inference_steps=num_inference_steps,
- adapter_conditioning_scale=adapter_conditioning_scale,
- adapter_conditioning_factor=adapter_conditioning_factor,
- generator=generator,
- guidance_scale=guidance_scale,
- ).images[0]
- return [image, out]
diff --git a/spaces/TencentARC/VLog/models/grit_src/third_party/CenterNet2/detectron2/data/datasets/cityscapes.py b/spaces/TencentARC/VLog/models/grit_src/third_party/CenterNet2/detectron2/data/datasets/cityscapes.py
deleted file mode 100644
index 1e84a5bdb3d4e410d8eef4b80a5d4c099a180104..0000000000000000000000000000000000000000
--- a/spaces/TencentARC/VLog/models/grit_src/third_party/CenterNet2/detectron2/data/datasets/cityscapes.py
+++ /dev/null
@@ -1,329 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-import functools
-import json
-import logging
-import multiprocessing as mp
-import numpy as np
-import os
-from itertools import chain
-import pycocotools.mask as mask_util
-from PIL import Image
-
-from detectron2.structures import BoxMode
-from detectron2.utils.comm import get_world_size
-from detectron2.utils.file_io import PathManager
-from detectron2.utils.logger import setup_logger
-
-try:
- import cv2 # noqa
-except ImportError:
- # OpenCV is an optional dependency at the moment
- pass
-
-
-logger = logging.getLogger(__name__)
-
-
-def _get_cityscapes_files(image_dir, gt_dir):
- files = []
- # scan through the directory
- cities = PathManager.ls(image_dir)
- logger.info(f"{len(cities)} cities found in '{image_dir}'.")
- for city in cities:
- city_img_dir = os.path.join(image_dir, city)
- city_gt_dir = os.path.join(gt_dir, city)
- for basename in PathManager.ls(city_img_dir):
- image_file = os.path.join(city_img_dir, basename)
-
- suffix = "leftImg8bit.png"
- assert basename.endswith(suffix), basename
- basename = basename[: -len(suffix)]
-
- instance_file = os.path.join(city_gt_dir, basename + "gtFine_instanceIds.png")
- label_file = os.path.join(city_gt_dir, basename + "gtFine_labelIds.png")
- json_file = os.path.join(city_gt_dir, basename + "gtFine_polygons.json")
-
- files.append((image_file, instance_file, label_file, json_file))
- assert len(files), "No images found in {}".format(image_dir)
- for f in files[0]:
- assert PathManager.isfile(f), f
- return files
-
-
-def load_cityscapes_instances(image_dir, gt_dir, from_json=True, to_polygons=True):
- """
- Args:
- image_dir (str): path to the raw dataset. e.g., "~/cityscapes/leftImg8bit/train".
- gt_dir (str): path to the raw annotations. e.g., "~/cityscapes/gtFine/train".
- from_json (bool): whether to read annotations from the raw json file or the png files.
- to_polygons (bool): whether to represent the segmentation as polygons
- (COCO's format) instead of masks (cityscapes's format).
-
- Returns:
- list[dict]: a list of dicts in Detectron2 standard format. (See
- `Using Custom Datasets `_ )
- """
- if from_json:
- assert to_polygons, (
- "Cityscapes's json annotations are in polygon format. "
- "Converting to mask format is not supported now."
- )
- files = _get_cityscapes_files(image_dir, gt_dir)
-
- logger.info("Preprocessing cityscapes annotations ...")
- # This is still not fast: all workers will execute duplicate works and will
- # take up to 10m on a 8GPU server.
- pool = mp.Pool(processes=max(mp.cpu_count() // get_world_size() // 2, 4))
-
- ret = pool.map(
- functools.partial(_cityscapes_files_to_dict, from_json=from_json, to_polygons=to_polygons),
- files,
- )
- logger.info("Loaded {} images from {}".format(len(ret), image_dir))
-
- # Map cityscape ids to contiguous ids
- from cityscapesscripts.helpers.labels import labels
-
- labels = [l for l in labels if l.hasInstances and not l.ignoreInEval]
- dataset_id_to_contiguous_id = {l.id: idx for idx, l in enumerate(labels)}
- for dict_per_image in ret:
- for anno in dict_per_image["annotations"]:
- anno["category_id"] = dataset_id_to_contiguous_id[anno["category_id"]]
- return ret
-
-
-def load_cityscapes_semantic(image_dir, gt_dir):
- """
- Args:
- image_dir (str): path to the raw dataset. e.g., "~/cityscapes/leftImg8bit/train".
- gt_dir (str): path to the raw annotations. e.g., "~/cityscapes/gtFine/train".
-
- Returns:
- list[dict]: a list of dict, each has "file_name" and
- "sem_seg_file_name".
- """
- ret = []
- # gt_dir is small and contain many small files. make sense to fetch to local first
- gt_dir = PathManager.get_local_path(gt_dir)
- for image_file, _, label_file, json_file in _get_cityscapes_files(image_dir, gt_dir):
- label_file = label_file.replace("labelIds", "labelTrainIds")
-
- with PathManager.open(json_file, "r") as f:
- jsonobj = json.load(f)
- ret.append(
- {
- "file_name": image_file,
- "sem_seg_file_name": label_file,
- "height": jsonobj["imgHeight"],
- "width": jsonobj["imgWidth"],
- }
- )
- assert len(ret), f"No images found in {image_dir}!"
- assert PathManager.isfile(
- ret[0]["sem_seg_file_name"]
- ), "Please generate labelTrainIds.png with cityscapesscripts/preparation/createTrainIdLabelImgs.py" # noqa
- return ret
-
-
-def _cityscapes_files_to_dict(files, from_json, to_polygons):
- """
- Parse cityscapes annotation files to a instance segmentation dataset dict.
-
- Args:
- files (tuple): consists of (image_file, instance_id_file, label_id_file, json_file)
- from_json (bool): whether to read annotations from the raw json file or the png files.
- to_polygons (bool): whether to represent the segmentation as polygons
- (COCO's format) instead of masks (cityscapes's format).
-
- Returns:
- A dict in Detectron2 Dataset format.
- """
- from cityscapesscripts.helpers.labels import id2label, name2label
-
- image_file, instance_id_file, _, json_file = files
-
- annos = []
-
- if from_json:
- from shapely.geometry import MultiPolygon, Polygon
-
- with PathManager.open(json_file, "r") as f:
- jsonobj = json.load(f)
- ret = {
- "file_name": image_file,
- "image_id": os.path.basename(image_file),
- "height": jsonobj["imgHeight"],
- "width": jsonobj["imgWidth"],
- }
-
- # `polygons_union` contains the union of all valid polygons.
- polygons_union = Polygon()
-
- # CityscapesScripts draw the polygons in sequential order
- # and each polygon *overwrites* existing ones. See
- # (https://github.com/mcordts/cityscapesScripts/blob/master/cityscapesscripts/preparation/json2instanceImg.py) # noqa
- # We use reverse order, and each polygon *avoids* early ones.
- # This will resolve the ploygon overlaps in the same way as CityscapesScripts.
- for obj in jsonobj["objects"][::-1]:
- if "deleted" in obj: # cityscapes data format specific
- continue
- label_name = obj["label"]
-
- try:
- label = name2label[label_name]
- except KeyError:
- if label_name.endswith("group"): # crowd area
- label = name2label[label_name[: -len("group")]]
- else:
- raise
- if label.id < 0: # cityscapes data format
- continue
-
- # Cityscapes's raw annotations uses integer coordinates
- # Therefore +0.5 here
- poly_coord = np.asarray(obj["polygon"], dtype="f4") + 0.5
- # CityscapesScript uses PIL.ImageDraw.polygon to rasterize
- # polygons for evaluation. This function operates in integer space
- # and draws each pixel whose center falls into the polygon.
- # Therefore it draws a polygon which is 0.5 "fatter" in expectation.
- # We therefore dilate the input polygon by 0.5 as our input.
- poly = Polygon(poly_coord).buffer(0.5, resolution=4)
-
- if not label.hasInstances or label.ignoreInEval:
- # even if we won't store the polygon it still contributes to overlaps resolution
- polygons_union = polygons_union.union(poly)
- continue
-
- # Take non-overlapping part of the polygon
- poly_wo_overlaps = poly.difference(polygons_union)
- if poly_wo_overlaps.is_empty:
- continue
- polygons_union = polygons_union.union(poly)
-
- anno = {}
- anno["iscrowd"] = label_name.endswith("group")
- anno["category_id"] = label.id
-
- if isinstance(poly_wo_overlaps, Polygon):
- poly_list = [poly_wo_overlaps]
- elif isinstance(poly_wo_overlaps, MultiPolygon):
- poly_list = poly_wo_overlaps.geoms
- else:
- raise NotImplementedError("Unknown geometric structure {}".format(poly_wo_overlaps))
-
- poly_coord = []
- for poly_el in poly_list:
- # COCO API can work only with exterior boundaries now, hence we store only them.
- # TODO: store both exterior and interior boundaries once other parts of the
- # codebase support holes in polygons.
- poly_coord.append(list(chain(*poly_el.exterior.coords)))
- anno["segmentation"] = poly_coord
- (xmin, ymin, xmax, ymax) = poly_wo_overlaps.bounds
-
- anno["bbox"] = (xmin, ymin, xmax, ymax)
- anno["bbox_mode"] = BoxMode.XYXY_ABS
-
- annos.append(anno)
- else:
- # See also the official annotation parsing scripts at
- # https://github.com/mcordts/cityscapesScripts/blob/master/cityscapesscripts/evaluation/instances2dict.py # noqa
- with PathManager.open(instance_id_file, "rb") as f:
- inst_image = np.asarray(Image.open(f), order="F")
- # ids < 24 are stuff labels (filtering them first is about 5% faster)
- flattened_ids = np.unique(inst_image[inst_image >= 24])
-
- ret = {
- "file_name": image_file,
- "image_id": os.path.basename(image_file),
- "height": inst_image.shape[0],
- "width": inst_image.shape[1],
- }
-
- for instance_id in flattened_ids:
- # For non-crowd annotations, instance_id // 1000 is the label_id
- # Crowd annotations have <1000 instance ids
- label_id = instance_id // 1000 if instance_id >= 1000 else instance_id
- label = id2label[label_id]
- if not label.hasInstances or label.ignoreInEval:
- continue
-
- anno = {}
- anno["iscrowd"] = instance_id < 1000
- anno["category_id"] = label.id
-
- mask = np.asarray(inst_image == instance_id, dtype=np.uint8, order="F")
-
- inds = np.nonzero(mask)
- ymin, ymax = inds[0].min(), inds[0].max()
- xmin, xmax = inds[1].min(), inds[1].max()
- anno["bbox"] = (xmin, ymin, xmax, ymax)
- if xmax <= xmin or ymax <= ymin:
- continue
- anno["bbox_mode"] = BoxMode.XYXY_ABS
- if to_polygons:
- # This conversion comes from D4809743 and D5171122,
- # when Mask-RCNN was first developed.
- contours = cv2.findContours(mask.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)[
- -2
- ]
- polygons = [c.reshape(-1).tolist() for c in contours if len(c) >= 3]
- # opencv's can produce invalid polygons
- if len(polygons) == 0:
- continue
- anno["segmentation"] = polygons
- else:
- anno["segmentation"] = mask_util.encode(mask[:, :, None])[0]
- annos.append(anno)
- ret["annotations"] = annos
- return ret
-
-
-if __name__ == "__main__":
- """
- Test the cityscapes dataset loader.
-
- Usage:
- python -m detectron2.data.datasets.cityscapes \
- cityscapes/leftImg8bit/train cityscapes/gtFine/train
- """
- import argparse
-
- parser = argparse.ArgumentParser()
- parser.add_argument("image_dir")
- parser.add_argument("gt_dir")
- parser.add_argument("--type", choices=["instance", "semantic"], default="instance")
- args = parser.parse_args()
- from detectron2.data.catalog import Metadata
- from detectron2.utils.visualizer import Visualizer
- from cityscapesscripts.helpers.labels import labels
-
- logger = setup_logger(name=__name__)
-
- dirname = "cityscapes-data-vis"
- os.makedirs(dirname, exist_ok=True)
-
- if args.type == "instance":
- dicts = load_cityscapes_instances(
- args.image_dir, args.gt_dir, from_json=True, to_polygons=True
- )
- logger.info("Done loading {} samples.".format(len(dicts)))
-
- thing_classes = [k.name for k in labels if k.hasInstances and not k.ignoreInEval]
- meta = Metadata().set(thing_classes=thing_classes)
-
- else:
- dicts = load_cityscapes_semantic(args.image_dir, args.gt_dir)
- logger.info("Done loading {} samples.".format(len(dicts)))
-
- stuff_classes = [k.name for k in labels if k.trainId != 255]
- stuff_colors = [k.color for k in labels if k.trainId != 255]
- meta = Metadata().set(stuff_classes=stuff_classes, stuff_colors=stuff_colors)
-
- for d in dicts:
- img = np.array(Image.open(PathManager.open(d["file_name"], "rb")))
- visualizer = Visualizer(img, metadata=meta)
- vis = visualizer.draw_dataset_dict(d)
- # cv2.imshow("a", vis.get_image()[:, :, ::-1])
- # cv2.waitKey()
- fpath = os.path.join(dirname, os.path.basename(d["file_name"]))
- vis.save(fpath)
diff --git a/spaces/Thaweewat/ControlNet-Architecture/annotator/openpose/util.py b/spaces/Thaweewat/ControlNet-Architecture/annotator/openpose/util.py
deleted file mode 100644
index 6f91ae0e65abaf0cbd62d803f56498991141e61b..0000000000000000000000000000000000000000
--- a/spaces/Thaweewat/ControlNet-Architecture/annotator/openpose/util.py
+++ /dev/null
@@ -1,164 +0,0 @@
-import math
-import numpy as np
-import matplotlib
-import cv2
-
-
-def padRightDownCorner(img, stride, padValue):
- h = img.shape[0]
- w = img.shape[1]
-
- pad = 4 * [None]
- pad[0] = 0 # up
- pad[1] = 0 # left
- pad[2] = 0 if (h % stride == 0) else stride - (h % stride) # down
- pad[3] = 0 if (w % stride == 0) else stride - (w % stride) # right
-
- img_padded = img
- pad_up = np.tile(img_padded[0:1, :, :]*0 + padValue, (pad[0], 1, 1))
- img_padded = np.concatenate((pad_up, img_padded), axis=0)
- pad_left = np.tile(img_padded[:, 0:1, :]*0 + padValue, (1, pad[1], 1))
- img_padded = np.concatenate((pad_left, img_padded), axis=1)
- pad_down = np.tile(img_padded[-2:-1, :, :]*0 + padValue, (pad[2], 1, 1))
- img_padded = np.concatenate((img_padded, pad_down), axis=0)
- pad_right = np.tile(img_padded[:, -2:-1, :]*0 + padValue, (1, pad[3], 1))
- img_padded = np.concatenate((img_padded, pad_right), axis=1)
-
- return img_padded, pad
-
-# transfer caffe model to pytorch which will match the layer name
-def transfer(model, model_weights):
- transfered_model_weights = {}
- for weights_name in model.state_dict().keys():
- transfered_model_weights[weights_name] = model_weights['.'.join(weights_name.split('.')[1:])]
- return transfered_model_weights
-
-# draw the body keypoint and lims
-def draw_bodypose(canvas, candidate, subset):
- stickwidth = 4
- limbSeq = [[2, 3], [2, 6], [3, 4], [4, 5], [6, 7], [7, 8], [2, 9], [9, 10], \
- [10, 11], [2, 12], [12, 13], [13, 14], [2, 1], [1, 15], [15, 17], \
- [1, 16], [16, 18], [3, 17], [6, 18]]
-
- colors = [[255, 0, 0], [255, 85, 0], [255, 170, 0], [255, 255, 0], [170, 255, 0], [85, 255, 0], [0, 255, 0], \
- [0, 255, 85], [0, 255, 170], [0, 255, 255], [0, 170, 255], [0, 85, 255], [0, 0, 255], [85, 0, 255], \
- [170, 0, 255], [255, 0, 255], [255, 0, 170], [255, 0, 85]]
- for i in range(18):
- for n in range(len(subset)):
- index = int(subset[n][i])
- if index == -1:
- continue
- x, y = candidate[index][0:2]
- cv2.circle(canvas, (int(x), int(y)), 4, colors[i], thickness=-1)
- for i in range(17):
- for n in range(len(subset)):
- index = subset[n][np.array(limbSeq[i]) - 1]
- if -1 in index:
- continue
- cur_canvas = canvas.copy()
- Y = candidate[index.astype(int), 0]
- X = candidate[index.astype(int), 1]
- mX = np.mean(X)
- mY = np.mean(Y)
- length = ((X[0] - X[1]) ** 2 + (Y[0] - Y[1]) ** 2) ** 0.5
- angle = math.degrees(math.atan2(X[0] - X[1], Y[0] - Y[1]))
- polygon = cv2.ellipse2Poly((int(mY), int(mX)), (int(length / 2), stickwidth), int(angle), 0, 360, 1)
- cv2.fillConvexPoly(cur_canvas, polygon, colors[i])
- canvas = cv2.addWeighted(canvas, 0.4, cur_canvas, 0.6, 0)
- # plt.imsave("preview.jpg", canvas[:, :, [2, 1, 0]])
- # plt.imshow(canvas[:, :, [2, 1, 0]])
- return canvas
-
-
-# image drawed by opencv is not good.
-def draw_handpose(canvas, all_hand_peaks, show_number=False):
- edges = [[0, 1], [1, 2], [2, 3], [3, 4], [0, 5], [5, 6], [6, 7], [7, 8], [0, 9], [9, 10], \
- [10, 11], [11, 12], [0, 13], [13, 14], [14, 15], [15, 16], [0, 17], [17, 18], [18, 19], [19, 20]]
-
- for peaks in all_hand_peaks:
- for ie, e in enumerate(edges):
- if np.sum(np.all(peaks[e], axis=1)==0)==0:
- x1, y1 = peaks[e[0]]
- x2, y2 = peaks[e[1]]
- cv2.line(canvas, (x1, y1), (x2, y2), matplotlib.colors.hsv_to_rgb([ie/float(len(edges)), 1.0, 1.0])*255, thickness=2)
-
- for i, keyponit in enumerate(peaks):
- x, y = keyponit
- cv2.circle(canvas, (x, y), 4, (0, 0, 255), thickness=-1)
- if show_number:
- cv2.putText(canvas, str(i), (x, y), cv2.FONT_HERSHEY_SIMPLEX, 0.3, (0, 0, 0), lineType=cv2.LINE_AA)
- return canvas
-
-# detect hand according to body pose keypoints
-# please refer to https://github.com/CMU-Perceptual-Computing-Lab/openpose/blob/master/src/openpose/hand/handDetector.cpp
-def handDetect(candidate, subset, oriImg):
- # right hand: wrist 4, elbow 3, shoulder 2
- # left hand: wrist 7, elbow 6, shoulder 5
- ratioWristElbow = 0.33
- detect_result = []
- image_height, image_width = oriImg.shape[0:2]
- for person in subset.astype(int):
- # if any of three not detected
- has_left = np.sum(person[[5, 6, 7]] == -1) == 0
- has_right = np.sum(person[[2, 3, 4]] == -1) == 0
- if not (has_left or has_right):
- continue
- hands = []
- #left hand
- if has_left:
- left_shoulder_index, left_elbow_index, left_wrist_index = person[[5, 6, 7]]
- x1, y1 = candidate[left_shoulder_index][:2]
- x2, y2 = candidate[left_elbow_index][:2]
- x3, y3 = candidate[left_wrist_index][:2]
- hands.append([x1, y1, x2, y2, x3, y3, True])
- # right hand
- if has_right:
- right_shoulder_index, right_elbow_index, right_wrist_index = person[[2, 3, 4]]
- x1, y1 = candidate[right_shoulder_index][:2]
- x2, y2 = candidate[right_elbow_index][:2]
- x3, y3 = candidate[right_wrist_index][:2]
- hands.append([x1, y1, x2, y2, x3, y3, False])
-
- for x1, y1, x2, y2, x3, y3, is_left in hands:
- # pos_hand = pos_wrist + ratio * (pos_wrist - pos_elbox) = (1 + ratio) * pos_wrist - ratio * pos_elbox
- # handRectangle.x = posePtr[wrist*3] + ratioWristElbow * (posePtr[wrist*3] - posePtr[elbow*3]);
- # handRectangle.y = posePtr[wrist*3+1] + ratioWristElbow * (posePtr[wrist*3+1] - posePtr[elbow*3+1]);
- # const auto distanceWristElbow = getDistance(poseKeypoints, person, wrist, elbow);
- # const auto distanceElbowShoulder = getDistance(poseKeypoints, person, elbow, shoulder);
- # handRectangle.width = 1.5f * fastMax(distanceWristElbow, 0.9f * distanceElbowShoulder);
- x = x3 + ratioWristElbow * (x3 - x2)
- y = y3 + ratioWristElbow * (y3 - y2)
- distanceWristElbow = math.sqrt((x3 - x2) ** 2 + (y3 - y2) ** 2)
- distanceElbowShoulder = math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
- width = 1.5 * max(distanceWristElbow, 0.9 * distanceElbowShoulder)
- # x-y refers to the center --> offset to topLeft point
- # handRectangle.x -= handRectangle.width / 2.f;
- # handRectangle.y -= handRectangle.height / 2.f;
- x -= width / 2
- y -= width / 2 # width = height
- # overflow the image
- if x < 0: x = 0
- if y < 0: y = 0
- width1 = width
- width2 = width
- if x + width > image_width: width1 = image_width - x
- if y + width > image_height: width2 = image_height - y
- width = min(width1, width2)
- # the max hand box value is 20 pixels
- if width >= 20:
- detect_result.append([int(x), int(y), int(width), is_left])
-
- '''
- return value: [[x, y, w, True if left hand else False]].
- width=height since the network require squared input.
- x, y is the coordinate of top left
- '''
- return detect_result
-
-# get max index of 2d array
-def npmax(array):
- arrayindex = array.argmax(1)
- arrayvalue = array.max(1)
- i = arrayvalue.argmax()
- j = arrayindex[i]
- return i, j
diff --git a/spaces/TheFunniestValentine/rp/Dockerfile b/spaces/TheFunniestValentine/rp/Dockerfile
deleted file mode 100644
index 6953fc05439efb70991552cf56f28365b5b6c15b..0000000000000000000000000000000000000000
--- a/spaces/TheFunniestValentine/rp/Dockerfile
+++ /dev/null
@@ -1,11 +0,0 @@
-FROM node:18
-
-WORKDIR /app
-
-RUN npm install express express-http-proxy
-
-COPY . .
-
-EXPOSE 7860
-
-CMD [ "node", "server.js" ]
\ No newline at end of file
diff --git a/spaces/Theivaprakasham/yolov6/yolov6/utils/envs.py b/spaces/Theivaprakasham/yolov6/yolov6/utils/envs.py
deleted file mode 100644
index 10159a9484ed525ad5ef3826ec3db4bf70b4c9cc..0000000000000000000000000000000000000000
--- a/spaces/Theivaprakasham/yolov6/yolov6/utils/envs.py
+++ /dev/null
@@ -1,54 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-import os
-import random
-import numpy as np
-
-import torch
-import torch.backends.cudnn as cudnn
-from yolov6.utils.events import LOGGER
-
-
-def get_envs():
- """Get PyTorch needed environments from system envirionments."""
- local_rank = int(os.getenv('LOCAL_RANK', -1))
- rank = int(os.getenv('RANK', -1))
- world_size = int(os.getenv('WORLD_SIZE', 1))
- return local_rank, rank, world_size
-
-
-def select_device(device):
- """Set devices' information to the program.
- Args:
- device: a string, like 'cpu' or '1,2,3,4'
- Returns:
- torch.device
- """
- if device == 'cpu':
- os.environ['CUDA_VISIBLE_DEVICES'] = '-1'
- LOGGER.info('Using CPU for training... ')
- elif device:
- os.environ['CUDA_VISIBLE_DEVICES'] = device
- assert torch.cuda.is_available()
- nd = len(device.strip().split(','))
- LOGGER.info(f'Using {nd} GPU for training... ')
- cuda = device != 'cpu' and torch.cuda.is_available()
- device = torch.device('cuda:0' if cuda else 'cpu')
- return device
-
-
-def set_random_seed(seed, deterministic=False):
- """ Set random state to random libray, numpy, torch and cudnn.
- Args:
- seed: int value.
- deterministic: bool value.
- """
- random.seed(seed)
- np.random.seed(seed)
- torch.manual_seed(seed)
- if deterministic:
- cudnn.deterministic = True
- cudnn.benchmark = False
- else:
- cudnn.deterministic = False
- cudnn.benchmark = True
diff --git a/spaces/ThirdEyeData/Customer-Conversion-Prediction/supv/regress.py b/spaces/ThirdEyeData/Customer-Conversion-Prediction/supv/regress.py
deleted file mode 100644
index 63153db65a2b13f170f04cb886190ebe374e729f..0000000000000000000000000000000000000000
--- a/spaces/ThirdEyeData/Customer-Conversion-Prediction/supv/regress.py
+++ /dev/null
@@ -1,253 +0,0 @@
-#!/usr/local/bin/python3
-
-# avenir-python: Machine Learning
-# Author: Pranab Ghosh
-#
-# 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.
-
-# Package imports
-import os
-import sys
-import matplotlib.pyplot as plt
-import numpy as np
-import sklearn as sk
-import matplotlib
-import random
-import jprops
-from io import StringIO
-from sklearn.model_selection import cross_val_score
-import joblib
-from random import randint
-from io import StringIO
-from sklearn.linear_model import LinearRegression
-sys.path.append(os.path.abspath("../lib"))
-from util import *
-from mlutil import *
-from pasearch import *
-
-class BaseRegressor(object):
- """
- base regression class
- """
-
- def __init__(self, configFile, defValues):
- """
- intializer
- """
- defValues["common.mode"] = ("train", None)
- defValues["common.model.directory"] = ("model", None)
- defValues["common.model.file"] = (None, None)
- defValues["common.scale.file.path"] = (None, "missing scale file path")
- defValues["common.preprocessing"] = (None, None)
- defValues["common.verbose"] = (False, None)
- defValues["train.data.file"] = (None, "missing training data file")
- defValues["train.data.fields"] = (None, "missing training data field ordinals")
- defValues["train.data.feature.fields"] = (None, "missing training data feature field ordinals")
- defValues["train.data.out.field"] = (None, "missing out field ordinal")
-
- self.config = Configuration(configFile, defValues)
- self.featData = None
- self.outData = None
- self.regressor = None
- self.verbose = self.config.getBooleanConfig("common.verbose")[0]
- self.mode = self.config.getBooleanConfig("common.mode")[0]
- logFilePath = self.config.getStringConfig("common.logging.file")[0]
- logLevName = self.config.getStringConfig("common.logging.level")[0]
- self.logger = createLogger(__name__, logFilePath, logLevName)
- self.logger.info("********* starting session")
-
- def initConfig(self, configFile, defValues):
- """
- initialize config
- """
- self.config = Configuration(configFile, defValues)
-
- def getConfig(self):
- """
- get config object
- """
- return self.config
-
- def setConfigParam(self, name, value):
- """
- set config param
- """
- self.config.setParam(name, value)
-
- def getMode(self):
- """
- get mode
- """
- return self.mode
-
- def train(self):
- """
- train model
- """
- #build model
- self.buildModel()
-
- # training data
- if self.featData is None:
- (featData, outData) = self.prepData("train")
- (self.featData, self.outData) = (featData, outData)
- else:
- (featData, outData) = (self.featData, self.outData)
-
- # parameters
- modelSave = self.config.getBooleanConfig("train.model.save")[0]
-
- #train
- self.logger.info("...training model")
- self.regressor.fit(featData, outData)
- rsqScore = self.regressor.score(featData, outData)
- coef = self.regressor.coef_
- intc = self.regressor.intercept_
- result = (rsqScore, intc, coef)
-
- if modelSave:
- self.logger.info("...saving model")
- modelFilePath = self.getModelFilePath()
- joblib.dump(self.regressor, modelFilePath)
- return result
-
- def validate(self):
- # create model
- self.prepModel()
-
- # prepare test data
- (featData, outDataActual) = self.prepData("validate")
-
- #predict
- self.logger.info("...predicting")
- outDataPred = self.regressor.predict(featData)
-
- #error
- rsqScore = self.regressor.score(featData, outDataActual)
- result = (outDataPred, rsqScore)
- return result
-
- def predict(self):
- """
- predict using trained model
- """
- # create model
- self.prepModel()
-
- # prepare test data
- featData = self.prepData("predict")[0]
-
- #predict
- self.logger.info("...predicting")
- outData = self.regressor.predict(featData)
- return outData
-
- def prepData(self, mode):
- """
- loads and prepares data for training and validation
- """
- # parameters
- key = mode + ".data.file"
- dataFile = self.config.getStringConfig(key)[0]
-
- key = mode + ".data.fields"
- fieldIndices = self.config.getStringConfig(key)[0]
- if not fieldIndices is None:
- fieldIndices = strToIntArray(fieldIndices, ",")
-
-
- key = mode + ".data.feature.fields"
- featFieldIndices = self.config.getStringConfig(key)[0]
- if not featFieldIndices is None:
- featFieldIndices = strToIntArray(featFieldIndices, ",")
-
- if not mode == "predict":
- key = mode + ".data.out.field"
- outFieldIndex = self.config.getIntConfig(key)[0]
-
- #load data
- (data, featData) = loadDataFile(dataFile, ",", fieldIndices, featFieldIndices)
- if (self.config.getStringConfig("common.preprocessing")[0] == "scale"):
- featData = sk.preprocessing.scale(featData)
- outData = None
- if not mode == "predict":
- outData = extrColumns(data, outFieldIndex)
- return (featData, outData)
-
- def prepModel(self):
- """
- load saved model or train model
- """
- useSavedModel = self.config.getBooleanConfig("predict.use.saved.model")[0]
- if (useSavedModel and not self.regressor):
- # load saved model
- self.logger.info("...loading saved model")
- modelFilePath = self.getModelFilePath()
- self.regressor = joblib.load(modelFilePath)
- else:
- # train model
- self.train()
-
-class LinearRegressor(BaseRegressor):
- """
- linear regression
- """
- def __init__(self, configFile):
- defValues = {}
- defValues["train.normalize"] = (False, None)
-
- super(LinearRegressor, self).__init__(configFile, defValues)
-
- def buildModel(self):
- """
- builds model object
- """
- self.logger.info("...building linear regression model")
- normalize = self.config.getBooleanConfig("train.normalize")[0]
- self.regressor = LinearRegression(normalize=normalize)
-
-class ElasticNetRegressor(BaseRegressor):
- """
- elastic net regression
- """
- def __init__(self, configFile):
- defValues = {}
- defValues["train.alpha"] = (1.0, None)
- defValues["train.loneratio"] = (0.5, None)
- defValues["train.normalize"] = (False, None)
- defValues["train.precompute"] = (False, None)
- defValues["train.max.iter"] = (1000, None)
- defValues["train.tol"] = (0.0001, None)
- defValues["train.random.state"] = (None, None)
- defValues["train.selection"] = ("cyclic", None)
-
- super(ElasticNetRegressor, self).__init__(configFile, defValues)
-
- def buildModel(self):
- """
- builds model object
- """
- self.logger.info("...building elastic net regression model")
- alpha = self.config.getFloatConfig("train.alpha")[0]
- loneratio = self.config.getFloatConfig("train.loneratio")[0]
- normalize = self.config.getBooleanConfig("train.normalize")[0]
- precompute = self.config.getBooleanConfig("train.precompute")[0]
- maxIter = self.config.getIntConfig("train.max.iter")[0]
- tol = self.config.getFloatConfig("train.tol")[0]
- randState = self.config.getIntConfig("train.random.state")[0]
- selection = self.config.getIntConfig("train.selection")[0]
-
- self.regressor = ElasticNet(alpha=alpha, l1_ratio=loneratio, normalize=normalize, precompute=precompute,
- max_iter=maxIter, tol=tol, random_state=randState, selection=selection)
-
-
diff --git a/spaces/Volkopat/SegmentAnythingxGroundingDINO/groundingdino/config/GroundingDINO_SwinB_cfg.py b/spaces/Volkopat/SegmentAnythingxGroundingDINO/groundingdino/config/GroundingDINO_SwinB_cfg.py
deleted file mode 100644
index f490c4bbd598a35de43d36ceafcbd769e7ff21bf..0000000000000000000000000000000000000000
--- a/spaces/Volkopat/SegmentAnythingxGroundingDINO/groundingdino/config/GroundingDINO_SwinB_cfg.py
+++ /dev/null
@@ -1,43 +0,0 @@
-batch_size = 1
-modelname = "groundingdino"
-backbone = "swin_B_384_22k"
-position_embedding = "sine"
-pe_temperatureH = 20
-pe_temperatureW = 20
-return_interm_indices = [1, 2, 3]
-backbone_freeze_keywords = None
-enc_layers = 6
-dec_layers = 6
-pre_norm = False
-dim_feedforward = 2048
-hidden_dim = 256
-dropout = 0.0
-nheads = 8
-num_queries = 900
-query_dim = 4
-num_patterns = 0
-num_feature_levels = 4
-enc_n_points = 4
-dec_n_points = 4
-two_stage_type = "standard"
-two_stage_bbox_embed_share = False
-two_stage_class_embed_share = False
-transformer_activation = "relu"
-dec_pred_bbox_embed_share = True
-dn_box_noise_scale = 1.0
-dn_label_noise_ratio = 0.5
-dn_label_coef = 1.0
-dn_bbox_coef = 1.0
-embed_init_tgt = True
-dn_labelbook_size = 2000
-max_text_len = 256
-text_encoder_type = "bert-base-uncased"
-use_text_enhancer = True
-use_fusion_layer = True
-use_checkpoint = True
-use_transformer_ckpt = True
-use_text_cross_attention = True
-text_dropout = 0.0
-fusion_dropout = 0.0
-fusion_droppath = 0.1
-sub_sentence_present = True
diff --git a/spaces/WayneLinn/Singapore_Air_Quality_Prediction/app.py b/spaces/WayneLinn/Singapore_Air_Quality_Prediction/app.py
deleted file mode 100644
index 537b866d27e27cd24cf4e903dbc12f9e27ec4079..0000000000000000000000000000000000000000
--- a/spaces/WayneLinn/Singapore_Air_Quality_Prediction/app.py
+++ /dev/null
@@ -1,59 +0,0 @@
-import gradio as gr
-import numpy as np
-from PIL import Image
-import requests
-import os
-import plotly.express as px
-import pandas as pd
-
-import hopsworks
-import joblib
-
-project = hopsworks.login(project="test42",api_key_value=os.environ.get("HOPSWORKS_API_KEYS"))
-fs = project.get_feature_store()
-dataset_api = project.get_dataset_api()
-dataset_api.download("Resources/aqi_results.csv",overwrite=True)
-aqi = pd.read_csv('aqi_results.csv')
-
-'''
-def update():
- dataset_api.download("Resources/aqi_results.csv")
- aqi = pd.read_csv('aqi_results.csv')
- return aqi
-
-with gr.Blocks() as demo:
- gr.Markdown("Air Quality Index Prediction")
- with gr.Row():
- with gr.Column():
- gr.Label("Predicted AQI in next 7 days in Singapore")
- out = gr.Dataframe()
- btn = gr.Button("Refresh")
- btn.click(fn=update, inputs=None, outputs=out)
-'''
-
-
-
-
-def plotly_plot():
- # prepare some data
- dataset_api.download("Resources/aqi_results.csv",overwrite=True)
- aqi = pd.read_csv('aqi_results.csv')
-
- x = list(aqi['datetime'])
- y = list(aqi['aqi'])
-
- data = pd.DataFrame()
- data['Datetime'] = x
- data['AQI'] = y
- # create a new plot
- p = px.bar(data, x='Datetime', y='AQI')
-
- return p
-
-# show the results
-outputs = gr.Plot()
-
-demo1 = gr.Interface(fn=plotly_plot, inputs=None, outputs=outputs)
-
-
-demo1.launch()
diff --git a/spaces/WhyLIM/ChatGPT-academic/crazy_functions/test_project/latex/attention/background.tex b/spaces/WhyLIM/ChatGPT-academic/crazy_functions/test_project/latex/attention/background.tex
deleted file mode 100644
index 785069dc0f9143bad24e640056dd1072d5c6e5b5..0000000000000000000000000000000000000000
--- a/spaces/WhyLIM/ChatGPT-academic/crazy_functions/test_project/latex/attention/background.tex
+++ /dev/null
@@ -1,58 +0,0 @@
-The goal of reducing sequential computation also forms the foundation of the Extended Neural GPU \citep{extendedngpu}, ByteNet \citep{NalBytenet2017} and ConvS2S \citep{JonasFaceNet2017}, all of which use convolutional neural networks as basic building block, computing hidden representations in parallel for all input and output positions. In these models, the number of operations required to relate signals from two arbitrary input or output positions grows in the distance between positions, linearly for ConvS2S and logarithmically for ByteNet. This makes it more difficult to learn dependencies between distant positions \citep{hochreiter2001gradient}. In the Transformer this is reduced to a constant number of operations, albeit at the cost of reduced effective resolution due to averaging attention-weighted positions, an effect we counteract with Multi-Head Attention as described in section~\ref{sec:attention}.
-
-Self-attention, sometimes called intra-attention is an attention mechanism relating different positions of a single sequence in order to compute a representation of the sequence. Self-attention has been used successfully in a variety of tasks including reading comprehension, abstractive summarization, textual entailment and learning task-independent sentence representations \citep{cheng2016long, decomposableAttnModel, paulus2017deep, lin2017structured}.
-
-End-to-end memory networks are based on a recurrent attention mechanism instead of sequence-aligned recurrence and have been shown to perform well on simple-language question answering and language modeling tasks \citep{sukhbaatar2015}.
-
-To the best of our knowledge, however, the Transformer is the first transduction model relying entirely on self-attention to compute representations of its input and output without using sequence-aligned RNNs or convolution.
-In the following sections, we will describe the Transformer, motivate self-attention and discuss its advantages over models such as \citep{neural_gpu, NalBytenet2017} and \citep{JonasFaceNet2017}.
-
-
-%\citep{JonasFaceNet2017} report new SOTA on machine translation for English-to-German (EnDe), Enlish-to-French (EnFr) and English-to-Romanian language pairs.
-
-%For example,! in MT, we must draw information from both input and previous output words to translate an output word accurately. An attention layer \citep{bahdanau2014neural} can connect a very large number of positions at low computation cost, making it an essential ingredient in competitive recurrent models for machine translation.
-
-%A natural question to ask then is, "Could we replace recurrence with attention?". \marginpar{Don't know if it's the most natural question to ask given the previous statements. Also, need to say that the complexity table summarizes these statements} Such a model would be blessed with the computational efficiency of attention and the power of cross-positional communication. In this work, show that pure attention models work remarkably well for MT, achieving new SOTA results on EnDe and EnFr, and can be trained in under $2$ days on xyz architecture.
-
-%After the seminal models introduced in \citep{sutskever14, bahdanau2014neural, cho2014learning}, recurrent models have become the dominant solution for both sequence modeling and sequence-to-sequence transduction. Many efforts such as \citep{wu2016google,luong2015effective,jozefowicz2016exploring} have pushed the boundaries of machine translation (MT) and language modeling with recurrent endoder-decoder and recurrent language models. Recent effort \citep{shazeer2017outrageously} has successfully combined the power of conditional computation with sequence models to train very large models for MT, pushing SOTA at lower computational cost.
-
-%Recurrent models compute a vector of hidden states $h_t$, for each time step $t$ of computation. $h_t$ is a function of both the input at time $t$ and the previous hidden state $h_t$. This dependence on the previous hidden state precludes processing all timesteps at once, instead requiring long sequences of sequential operations. In practice, this results in greatly reduced computational efficiency, as on modern computing hardware, a single operation on a large batch is much faster than a large number of operations on small batches. The problem gets worse at longer sequence lengths. Although sequential computation is not a severe bottleneck at inference time, as autoregressively generating each output requires all previous outputs, the inability to compute scores at all output positions at once hinders us from rapidly training our models over large datasets. Although impressive work such as \citep{Kuchaiev2017Factorization} is able to significantly accelerate the training of LSTMs with factorization tricks, we are still bound by the linear dependence on sequence length.
-
-%If the model could compute hidden states at each time step using only the inputs and outputs, it would be liberated from the dependence on results from previous time steps during training. This line of thought is the foundation of recent efforts such as the Markovian neural GPU \citep{neural_gpu}, ByteNet \citep{NalBytenet2017} and ConvS2S \citep{JonasFaceNet2017}, all of which use convolutional neural networks as a building block to compute hidden representations simultaneously for all timesteps, resulting in $O(1)$ sequential time complexity. \citep{JonasFaceNet2017} report new SOTA on machine translation for English-to-German (EnDe), Enlish-to-French (EnFr) and English-to-Romanian language pairs.
-
-%A crucial component for accurate sequence prediction is modeling cross-positional communication. For example, in MT, we must draw information from both input and previous output words to translate an output word accurately. An attention layer \citep{bahdanau2014neural} can connect a very large number of positions at a low computation cost, also $O(1)$ sequential time complexity, making it an essential ingredient in recurrent encoder-decoder architectures for MT. A natural question to ask then is, "Could we replace recurrence with attention?". \marginpar{Don't know if it's the most natural question to ask given the previous statements. Also, need to say that the complexity table summarizes these statements} Such a model would be blessed with the computational efficiency of attention and the power of cross-positional communication. In this work, show that pure attention models work remarkably well for MT, achieving new SOTA results on EnDe and EnFr, and can be trained in under $2$ days on xyz architecture.
-
-
-
-%Note: Facebook model is no better than RNNs in this regard, since it requires a number of layers proportional to the distance you want to communicate. Bytenet is more promising, since it requires a logarithmnic number of layers (does bytenet have SOTA results)?
-
-%Note: An attention layer can connect a very large number of positions at a low computation cost in O(1) sequential operations. This is why encoder-decoder attention has been so successful in seq-to-seq models so far. It is only natural, then, to also use attention to connect the timesteps of the same sequence.
-
-%Note: I wouldn't say that long sequences are not a problem during inference. It would be great if we could infer with no long sequences. We could just say later on that, while our training graph is constant-depth, our model still requires sequential operations in the decoder part during inference due to the autoregressive nature of the model.
-
-%\begin{table}[h!]
-%\caption{Attention models are quite efficient for cross-positional communications when sequence length is smaller than channel depth. $n$ represents the sequence length and $d$ represents the channel depth.}
-%\label{tab:op_complexities}
-%\begin{center}
-%\vspace{-5pt}
-%\scalebox{0.75}{
-
-%\begin{tabular}{l|c|c|c}
-%\hline \hline
-%Layer Type & Receptive & Complexity & Sequential \\
-% & Field & & Operations \\
-%\hline
-%Pointwise Feed-Forward & $1$ & $O(n \cdot d^2)$ & $O(1)$ \\
-%\hline
-%Recurrent & $n$ & $O(n \cdot d^2)$ & $O(n)$ \\
-%\hline
-%Convolutional & $r$ & $O(r \cdot n \cdot d^2)$ & $O(1)$ \\
-%\hline
-%Convolutional (separable) & $r$ & $O(r \cdot n \cdot d + n %\cdot d^2)$ & $O(1)$ \\
-%\hline
-%Attention & $r$ & $O(r \cdot n \cdot d)$ & $O(1)$ \\
-%\hline \hline
-%\end{tabular}
-%}
-%\end{center}
-%\end{table}
\ No newline at end of file
diff --git a/spaces/XzJosh/Lumi-Bert-VITS2/preprocess_text.py b/spaces/XzJosh/Lumi-Bert-VITS2/preprocess_text.py
deleted file mode 100644
index 5eb0f3b9e929fcbe91dcbeb653391227a2518a15..0000000000000000000000000000000000000000
--- a/spaces/XzJosh/Lumi-Bert-VITS2/preprocess_text.py
+++ /dev/null
@@ -1,64 +0,0 @@
-import json
-from random import shuffle
-
-import tqdm
-from text.cleaner import clean_text
-from collections import defaultdict
-stage = [1,2,3]
-
-transcription_path = 'filelists/genshin.list'
-train_path = 'filelists/train.list'
-val_path = 'filelists/val.list'
-config_path = "configs/config.json"
-val_per_spk = 4
-max_val_total = 8
-
-if 1 in stage:
- with open( transcription_path+'.cleaned', 'w', encoding='utf-8') as f:
- for line in tqdm.tqdm(open(transcription_path, encoding='utf-8').readlines()):
- try:
- utt, spk, language, text = line.strip().split('|')
- norm_text, phones, tones, word2ph = clean_text(text, language)
- f.write('{}|{}|{}|{}|{}|{}|{}\n'.format(utt, spk, language, norm_text, ' '.join(phones),
- " ".join([str(i) for i in tones]),
- " ".join([str(i) for i in word2ph])))
- except Exception as error :
- print("err!", utt, error)
-
-if 2 in stage:
- spk_utt_map = defaultdict(list)
- spk_id_map = {}
- current_sid = 0
-
- with open( transcription_path+'.cleaned', encoding='utf-8') as f:
- for line in f.readlines():
- utt, spk, language, text, phones, tones, word2ph = line.strip().split('|')
- spk_utt_map[spk].append(line)
- if spk not in spk_id_map.keys():
- spk_id_map[spk] = current_sid
- current_sid += 1
- train_list = []
- val_list = []
-
- for spk, utts in spk_utt_map.items():
- shuffle(utts)
- val_list+=utts[:val_per_spk]
- train_list+=utts[val_per_spk:]
- if len(val_list) > max_val_total:
- train_list+=val_list[max_val_total:]
- val_list = val_list[:max_val_total]
-
- with open( train_path,"w", encoding='utf-8') as f:
- for line in train_list:
- f.write(line)
-
- with open(val_path, "w", encoding='utf-8') as f:
- for line in val_list:
- f.write(line)
-
-if 3 in stage:
- assert 2 in stage
- config = json.load(open(config_path, encoding='utf-8'))
- config["data"]['spk2id'] = spk_id_map
- with open(config_path, 'w', encoding='utf-8') as f:
- json.dump(config, f, indent=2, ensure_ascii=False)
diff --git a/spaces/YeOldHermit/Super-Resolution-Anime-Diffusion/diffusers/models/unet_1d.py b/spaces/YeOldHermit/Super-Resolution-Anime-Diffusion/diffusers/models/unet_1d.py
deleted file mode 100644
index 29d1d707f55a026458defd2bc0ec089ecc10653a..0000000000000000000000000000000000000000
--- a/spaces/YeOldHermit/Super-Resolution-Anime-Diffusion/diffusers/models/unet_1d.py
+++ /dev/null
@@ -1,245 +0,0 @@
-# Copyright 2022 The HuggingFace Team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from dataclasses import dataclass
-from typing import Optional, Tuple, Union
-
-import torch
-import torch.nn as nn
-
-from ..configuration_utils import ConfigMixin, register_to_config
-from ..modeling_utils import ModelMixin
-from ..utils import BaseOutput
-from .embeddings import GaussianFourierProjection, TimestepEmbedding, Timesteps
-from .unet_1d_blocks import get_down_block, get_mid_block, get_out_block, get_up_block
-
-
-@dataclass
-class UNet1DOutput(BaseOutput):
- """
- Args:
- sample (`torch.FloatTensor` of shape `(batch_size, num_channels, sample_size)`):
- Hidden states output. Output of last layer of model.
- """
-
- sample: torch.FloatTensor
-
-
-class UNet1DModel(ModelMixin, ConfigMixin):
- r"""
- UNet1DModel is a 1D UNet model that takes in a noisy sample and a timestep and returns sample shaped output.
-
- This model inherits from [`ModelMixin`]. Check the superclass documentation for the generic methods the library
- implements for all the model (such as downloading or saving, etc.)
-
- Parameters:
- sample_size (`int`, *optional*): Default length of sample. Should be adaptable at runtime.
- in_channels (`int`, *optional*, defaults to 2): Number of channels in the input sample.
- out_channels (`int`, *optional*, defaults to 2): Number of channels in the output.
- time_embedding_type (`str`, *optional*, defaults to `"fourier"`): Type of time embedding to use.
- freq_shift (`float`, *optional*, defaults to 0.0): Frequency shift for fourier time embedding.
- flip_sin_to_cos (`bool`, *optional*, defaults to :
- obj:`False`): Whether to flip sin to cos for fourier time embedding.
- down_block_types (`Tuple[str]`, *optional*, defaults to :
- obj:`("DownBlock1D", "DownBlock1DNoSkip", "AttnDownBlock1D")`): Tuple of downsample block types.
- up_block_types (`Tuple[str]`, *optional*, defaults to :
- obj:`("UpBlock1D", "UpBlock1DNoSkip", "AttnUpBlock1D")`): Tuple of upsample block types.
- block_out_channels (`Tuple[int]`, *optional*, defaults to :
- obj:`(32, 32, 64)`): Tuple of block output channels.
- mid_block_type (`str`, *optional*, defaults to "UNetMidBlock1D"): block type for middle of UNet.
- out_block_type (`str`, *optional*, defaults to `None`): optional output processing of UNet.
- act_fn (`str`, *optional*, defaults to None): optional activitation function in UNet blocks.
- norm_num_groups (`int`, *optional*, defaults to 8): group norm member count in UNet blocks.
- layers_per_block (`int`, *optional*, defaults to 1): added number of layers in a UNet block.
- downsample_each_block (`int`, *optional*, defaults to False:
- experimental feature for using a UNet without upsampling.
- """
-
- @register_to_config
- def __init__(
- self,
- sample_size: int = 65536,
- sample_rate: Optional[int] = None,
- in_channels: int = 2,
- out_channels: int = 2,
- extra_in_channels: int = 0,
- time_embedding_type: str = "fourier",
- flip_sin_to_cos: bool = True,
- use_timestep_embedding: bool = False,
- freq_shift: float = 0.0,
- down_block_types: Tuple[str] = ("DownBlock1DNoSkip", "DownBlock1D", "AttnDownBlock1D"),
- up_block_types: Tuple[str] = ("AttnUpBlock1D", "UpBlock1D", "UpBlock1DNoSkip"),
- mid_block_type: Tuple[str] = "UNetMidBlock1D",
- out_block_type: str = None,
- block_out_channels: Tuple[int] = (32, 32, 64),
- act_fn: str = None,
- norm_num_groups: int = 8,
- layers_per_block: int = 1,
- downsample_each_block: bool = False,
- ):
- super().__init__()
- self.sample_size = sample_size
-
- # time
- if time_embedding_type == "fourier":
- self.time_proj = GaussianFourierProjection(
- embedding_size=8, set_W_to_weight=False, log=False, flip_sin_to_cos=flip_sin_to_cos
- )
- timestep_input_dim = 2 * block_out_channels[0]
- elif time_embedding_type == "positional":
- self.time_proj = Timesteps(
- block_out_channels[0], flip_sin_to_cos=flip_sin_to_cos, downscale_freq_shift=freq_shift
- )
- timestep_input_dim = block_out_channels[0]
-
- if use_timestep_embedding:
- time_embed_dim = block_out_channels[0] * 4
- self.time_mlp = TimestepEmbedding(
- in_channels=timestep_input_dim,
- time_embed_dim=time_embed_dim,
- act_fn=act_fn,
- out_dim=block_out_channels[0],
- )
-
- self.down_blocks = nn.ModuleList([])
- self.mid_block = None
- self.up_blocks = nn.ModuleList([])
- self.out_block = None
-
- # down
- output_channel = in_channels
- for i, down_block_type in enumerate(down_block_types):
- input_channel = output_channel
- output_channel = block_out_channels[i]
-
- if i == 0:
- input_channel += extra_in_channels
-
- is_final_block = i == len(block_out_channels) - 1
-
- down_block = get_down_block(
- down_block_type,
- num_layers=layers_per_block,
- in_channels=input_channel,
- out_channels=output_channel,
- temb_channels=block_out_channels[0],
- add_downsample=not is_final_block or downsample_each_block,
- )
- self.down_blocks.append(down_block)
-
- # mid
- self.mid_block = get_mid_block(
- mid_block_type,
- in_channels=block_out_channels[-1],
- mid_channels=block_out_channels[-1],
- out_channels=block_out_channels[-1],
- embed_dim=block_out_channels[0],
- num_layers=layers_per_block,
- add_downsample=downsample_each_block,
- )
-
- # up
- reversed_block_out_channels = list(reversed(block_out_channels))
- output_channel = reversed_block_out_channels[0]
- if out_block_type is None:
- final_upsample_channels = out_channels
- else:
- final_upsample_channels = block_out_channels[0]
-
- for i, up_block_type in enumerate(up_block_types):
- prev_output_channel = output_channel
- output_channel = (
- reversed_block_out_channels[i + 1] if i < len(up_block_types) - 1 else final_upsample_channels
- )
-
- is_final_block = i == len(block_out_channels) - 1
-
- up_block = get_up_block(
- up_block_type,
- num_layers=layers_per_block,
- in_channels=prev_output_channel,
- out_channels=output_channel,
- temb_channels=block_out_channels[0],
- add_upsample=not is_final_block,
- )
- self.up_blocks.append(up_block)
- prev_output_channel = output_channel
-
- # out
- num_groups_out = norm_num_groups if norm_num_groups is not None else min(block_out_channels[0] // 4, 32)
- self.out_block = get_out_block(
- out_block_type=out_block_type,
- num_groups_out=num_groups_out,
- embed_dim=block_out_channels[0],
- out_channels=out_channels,
- act_fn=act_fn,
- fc_dim=block_out_channels[-1] // 4,
- )
-
- def forward(
- self,
- sample: torch.FloatTensor,
- timestep: Union[torch.Tensor, float, int],
- return_dict: bool = True,
- ) -> Union[UNet1DOutput, Tuple]:
- r"""
- Args:
- sample (`torch.FloatTensor`): `(batch_size, sample_size, num_channels)` noisy inputs tensor
- timestep (`torch.FloatTensor` or `float` or `int): (batch) timesteps
- return_dict (`bool`, *optional*, defaults to `True`):
- Whether or not to return a [`~models.unet_1d.UNet1DOutput`] instead of a plain tuple.
-
- Returns:
- [`~models.unet_1d.UNet1DOutput`] or `tuple`: [`~models.unet_1d.UNet1DOutput`] if `return_dict` is True,
- otherwise a `tuple`. When returning a tuple, the first element is the sample tensor.
- """
-
- # 1. time
- timesteps = timestep
- if not torch.is_tensor(timesteps):
- timesteps = torch.tensor([timesteps], dtype=torch.long, device=sample.device)
- elif torch.is_tensor(timesteps) and len(timesteps.shape) == 0:
- timesteps = timesteps[None].to(sample.device)
-
- timestep_embed = self.time_proj(timesteps)
- if self.config.use_timestep_embedding:
- timestep_embed = self.time_mlp(timestep_embed)
- else:
- timestep_embed = timestep_embed[..., None]
- timestep_embed = timestep_embed.repeat([1, 1, sample.shape[2]]).to(sample.dtype)
-
- # 2. down
- down_block_res_samples = ()
- for downsample_block in self.down_blocks:
- sample, res_samples = downsample_block(hidden_states=sample, temb=timestep_embed)
- down_block_res_samples += res_samples
-
- # 3. mid
- if self.mid_block:
- sample = self.mid_block(sample, timestep_embed)
-
- # 4. up
- for i, upsample_block in enumerate(self.up_blocks):
- res_samples = down_block_res_samples[-1:]
- down_block_res_samples = down_block_res_samples[:-1]
- sample = upsample_block(sample, res_hidden_states_tuple=res_samples, temb=timestep_embed)
-
- # 5. post-process
- if self.out_block:
- sample = self.out_block(sample, timestep_embed)
-
- if not return_dict:
- return (sample,)
-
- return UNet1DOutput(sample=sample)
diff --git a/spaces/Yiqin/ChatVID/model/fastchat/serve/model_worker.py b/spaces/Yiqin/ChatVID/model/fastchat/serve/model_worker.py
deleted file mode 100644
index 65aa2b726fd8de9b57bebdcd73ec4ee350f88af2..0000000000000000000000000000000000000000
--- a/spaces/Yiqin/ChatVID/model/fastchat/serve/model_worker.py
+++ /dev/null
@@ -1,268 +0,0 @@
-"""
-A model worker executes the model.
-"""
-import argparse
-import asyncio
-import dataclasses
-import logging
-import json
-import os
-import time
-from typing import List, Union
-import threading
-import uuid
-
-from fastapi import FastAPI, Request, BackgroundTasks
-from fastapi.responses import StreamingResponse
-import requests
-
-try:
- from transformers import (
- AutoTokenizer,
- AutoModelForCausalLM,
- LlamaTokenizer,
- AutoModel,
- )
-except ImportError:
- from transformers import (
- AutoTokenizer,
- AutoModelForCausalLM,
- LLaMATokenizer,
- AutoModel,
- )
-import torch
-import uvicorn
-
-from fastchat.constants import WORKER_HEART_BEAT_INTERVAL
-from fastchat.serve.inference import load_model, generate_stream
-from fastchat.serve.serve_chatglm import chatglm_generate_stream
-from fastchat.utils import build_logger, server_error_msg, pretty_print_semaphore
-
-GB = 1 << 30
-
-worker_id = str(uuid.uuid4())[:6]
-logger = build_logger("model_worker", f"model_worker_{worker_id}.log")
-global_counter = 0
-
-model_semaphore = None
-
-
-def heart_beat_worker(controller):
- while True:
- time.sleep(WORKER_HEART_BEAT_INTERVAL)
- controller.send_heart_beat()
-
-
-class ModelWorker:
- def __init__(
- self,
- controller_addr,
- worker_addr,
- worker_id,
- no_register,
- model_path,
- model_name,
- device,
- num_gpus,
- max_gpu_memory,
- load_8bit=False,
- ):
- self.controller_addr = controller_addr
- self.worker_addr = worker_addr
- self.worker_id = worker_id
- if model_path.endswith("/"):
- model_path = model_path[:-1]
- self.model_name = model_name or model_path.split("/")[-1]
- self.device = device
-
- logger.info(f"Loading the model {self.model_name} on worker {worker_id} ...")
- self.model, self.tokenizer = load_model(
- model_path, device, num_gpus, max_gpu_memory, load_8bit
- )
-
- if hasattr(self.model.config, "max_sequence_length"):
- self.context_len = self.model.config.max_sequence_length
- elif hasattr(self.model.config, "max_position_embeddings"):
- self.context_len = self.model.config.max_position_embeddings
- else:
- self.context_len = 2048
-
- is_chatglm = "chatglm" in str(type(self.model)).lower()
- if is_chatglm:
- self.generate_stream_func = chatglm_generate_stream
- else:
- self.generate_stream_func = generate_stream
-
- if not no_register:
- self.register_to_controller()
- self.heart_beat_thread = threading.Thread(
- target=heart_beat_worker, args=(self,)
- )
- self.heart_beat_thread.start()
-
- def register_to_controller(self):
- logger.info("Register to controller")
-
- url = self.controller_addr + "/register_worker"
- data = {
- "worker_name": self.worker_addr,
- "check_heart_beat": True,
- "worker_status": self.get_status(),
- }
- r = requests.post(url, json=data)
- assert r.status_code == 200
-
- def send_heart_beat(self):
- logger.info(
- f"Send heart beat. Models: {[self.model_name]}. "
- f"Semaphore: {pretty_print_semaphore(model_semaphore)}. "
- f"global_counter: {global_counter}"
- )
-
- url = self.controller_addr + "/receive_heart_beat"
-
- while True:
- try:
- ret = requests.post(
- url,
- json={
- "worker_name": self.worker_addr,
- "queue_length": self.get_queue_length(),
- },
- timeout=5,
- )
- exist = ret.json()["exist"]
- break
- except requests.exceptions.RequestException as e:
- logger.error(f"heart beat error: {e}")
- time.sleep(5)
-
- if not exist:
- self.register_to_controller()
-
- def get_queue_length(self):
- if (
- model_semaphore is None
- or model_semaphore._value is None
- or model_semaphore._waiters is None
- ):
- return 0
- else:
- return (
- args.limit_model_concurrency
- - model_semaphore._value
- + len(model_semaphore._waiters)
- )
-
- def get_status(self):
- return {
- "model_names": [self.model_name],
- "speed": 1,
- "queue_length": self.get_queue_length(),
- }
-
- def generate_stream_gate(self, params):
- try:
- for output in self.generate_stream_func(
- self.model,
- self.tokenizer,
- params,
- self.device,
- self.context_len,
- args.stream_interval,
- ):
- ret = {
- "text": output,
- "error_code": 0,
- }
- yield json.dumps(ret).encode() + b"\0"
- except torch.cuda.OutOfMemoryError:
- ret = {
- "text": server_error_msg,
- "error_code": 1,
- }
- yield json.dumps(ret).encode() + b"\0"
-
-
-app = FastAPI()
-
-
-def release_model_semaphore():
- model_semaphore.release()
-
-
-@app.post("/worker_generate_stream")
-async def api_generate_stream(request: Request):
- global model_semaphore, global_counter
- global_counter += 1
- params = await request.json()
-
- if model_semaphore is None:
- model_semaphore = asyncio.Semaphore(args.limit_model_concurrency)
- await model_semaphore.acquire()
- generator = worker.generate_stream_gate(params)
- background_tasks = BackgroundTasks()
- background_tasks.add_task(release_model_semaphore)
- return StreamingResponse(generator, background=background_tasks)
-
-
-@app.post("/worker_get_status")
-async def api_get_status(request: Request):
- return worker.get_status()
-
-
-if __name__ == "__main__":
- parser = argparse.ArgumentParser()
- parser.add_argument("--host", type=str, default="localhost")
- parser.add_argument("--port", type=int, default=21002)
- parser.add_argument("--worker-address", type=str, default="http://localhost:21002")
- parser.add_argument(
- "--controller-address", type=str, default="http://localhost:21001"
- )
- parser.add_argument(
- "--model-path",
- type=str,
- default="facebook/opt-350m",
- help="The path to the weights",
- )
- parser.add_argument("--model-name", type=str, help="Optional name")
- parser.add_argument(
- "--device", type=str, choices=["cpu", "cuda", "mps"], default="cuda"
- )
- parser.add_argument("--num-gpus", type=int, default=1)
- parser.add_argument(
- "--gpus",
- type=str,
- default=None,
- help="A single GPU like 1 or multiple GPUs like 0,2"
- )
- parser.add_argument(
- "--max-gpu-memory",
- type=str,
- help="The maximum memory per gpu. Use a string like '13Gib'",
- )
- parser.add_argument("--load-8bit", action="store_true")
- parser.add_argument("--limit-model-concurrency", type=int, default=5)
- parser.add_argument("--stream-interval", type=int, default=2)
- parser.add_argument("--no-register", action="store_true")
- args = parser.parse_args()
- logger.info(f"args: {args}")
-
- if args.gpus:
- if args.num_gpus and len(args.gpus.split(",")) < int(args.num_gpus):
- raise ValueError(f"Larger --num-gpus ({args.num_gpus}) than --gpus {args.gpus}!")
- os.environ["CUDA_VISIBLE_DEVICES"] = args.gpus
-
- worker = ModelWorker(
- args.controller_address,
- args.worker_address,
- worker_id,
- args.no_register,
- args.model_path,
- args.model_name,
- args.device,
- args.num_gpus,
- args.max_gpu_memory,
- args.load_8bit,
- )
- uvicorn.run(app, host=args.host, port=args.port, log_level="info")
diff --git a/spaces/YlcldKlns/bing/src/components/header.tsx b/spaces/YlcldKlns/bing/src/components/header.tsx
deleted file mode 100644
index dc298b722154d1ac6d7a7e148204605562d6cc58..0000000000000000000000000000000000000000
--- a/spaces/YlcldKlns/bing/src/components/header.tsx
+++ /dev/null
@@ -1,12 +0,0 @@
-import * as React from 'react'
-import { UserMenu } from './user-menu'
-
-export async function Header() {
- return (
-
- )
-}
diff --git a/spaces/Yoyo1123/text_generator/app.py b/spaces/Yoyo1123/text_generator/app.py
deleted file mode 100644
index c027232bef8ec3c494d02ee67479d9b0901a6cbc..0000000000000000000000000000000000000000
--- a/spaces/Yoyo1123/text_generator/app.py
+++ /dev/null
@@ -1,11 +0,0 @@
-import gradio as gr
-from gradio.mix import Parallel
-
-title="My First Text Generator"
-description="Input text."
-
-model1=gr.Interface.load("huggingface/EleutherAI/gpt-j-6B")
-model2=gr.Interface.load("huggingface/gpt2")
-model3=gr.Interface.load("huggingface/EleutherAI/gpt-neo-125M")
-
-gr.Parallel(model1, model2 , model3 , title=title , description=description).launch()
\ No newline at end of file
diff --git a/spaces/Yuliang/ICON/lib/renderer/glm.py b/spaces/Yuliang/ICON/lib/renderer/glm.py
deleted file mode 100644
index 65b1407e6edba36ac5883166a45bbe3ad8fadcce..0000000000000000000000000000000000000000
--- a/spaces/Yuliang/ICON/lib/renderer/glm.py
+++ /dev/null
@@ -1,143 +0,0 @@
-
-# -*- coding: utf-8 -*-
-
-# Max-Planck-Gesellschaft zur Förderung der Wissenschaften e.V. (MPG) is
-# holder of all proprietary rights on this computer program.
-# You can only use this computer program if you have closed
-# a license agreement with MPG or you get the right to use the computer
-# program from someone who is authorized to grant you that right.
-# Any use of the computer program without a valid license is prohibited and
-# liable to prosecution.
-#
-# Copyright©2019 Max-Planck-Gesellschaft zur Förderung
-# der Wissenschaften e.V. (MPG). acting on behalf of its Max Planck Institute
-# for Intelligent Systems. All rights reserved.
-#
-# Contact: ps-license@tuebingen.mpg.de
-
-import numpy as np
-
-
-def vec3(x, y, z):
- return np.array([x, y, z], dtype=np.float32)
-
-
-def radians(v):
- return np.radians(v)
-
-
-def identity():
- return np.identity(4, dtype=np.float32)
-
-
-def empty():
- return np.zeros([4, 4], dtype=np.float32)
-
-
-def magnitude(v):
- return np.linalg.norm(v)
-
-
-def normalize(v):
- m = magnitude(v)
- return v if m == 0 else v / m
-
-
-def dot(u, v):
- return np.sum(u * v)
-
-
-def cross(u, v):
- res = vec3(0, 0, 0)
- res[0] = u[1] * v[2] - u[2] * v[1]
- res[1] = u[2] * v[0] - u[0] * v[2]
- res[2] = u[0] * v[1] - u[1] * v[0]
- return res
-
-
-# below functions can be optimized
-
-
-def translate(m, v):
- res = np.copy(m)
- res[:, 3] = m[:, 0] * v[0] + m[:, 1] * v[1] + m[:, 2] * v[2] + m[:, 3]
- return res
-
-
-def rotate(m, angle, v):
- a = angle
- c = np.cos(a)
- s = np.sin(a)
-
- axis = normalize(v)
- temp = (1 - c) * axis
-
- rot = empty()
- rot[0][0] = c + temp[0] * axis[0]
- rot[0][1] = temp[0] * axis[1] + s * axis[2]
- rot[0][2] = temp[0] * axis[2] - s * axis[1]
-
- rot[1][0] = temp[1] * axis[0] - s * axis[2]
- rot[1][1] = c + temp[1] * axis[1]
- rot[1][2] = temp[1] * axis[2] + s * axis[0]
-
- rot[2][0] = temp[2] * axis[0] + s * axis[1]
- rot[2][1] = temp[2] * axis[1] - s * axis[0]
- rot[2][2] = c + temp[2] * axis[2]
-
- res = empty()
- res[:, 0] = m[:, 0] * rot[0][0] + m[:, 1] * rot[0][1] + m[:, 2] * rot[0][2]
- res[:, 1] = m[:, 0] * rot[1][0] + m[:, 1] * rot[1][1] + m[:, 2] * rot[1][2]
- res[:, 2] = m[:, 0] * rot[2][0] + m[:, 1] * rot[2][1] + m[:, 2] * rot[2][2]
- res[:, 3] = m[:, 3]
- return res
-
-
-def perspective(fovy, aspect, zNear, zFar):
- tanHalfFovy = np.tan(fovy / 2)
-
- res = empty()
- res[0][0] = 1 / (aspect * tanHalfFovy)
- res[1][1] = 1 / (tanHalfFovy)
- res[2][3] = -1
- res[2][2] = -(zFar + zNear) / (zFar - zNear)
- res[3][2] = -(2 * zFar * zNear) / (zFar - zNear)
-
- return res.T
-
-
-def ortho(left, right, bottom, top, zNear, zFar):
- # res = np.ones([4, 4], dtype=np.float32)
- res = identity()
- res[0][0] = 2 / (right - left)
- res[1][1] = 2 / (top - bottom)
- res[2][2] = -2 / (zFar - zNear)
- res[3][0] = -(right + left) / (right - left)
- res[3][1] = -(top + bottom) / (top - bottom)
- res[3][2] = -(zFar + zNear) / (zFar - zNear)
- return res.T
-
-
-def lookat(eye, center, up):
- f = normalize(center - eye)
- s = normalize(cross(f, up))
- u = cross(s, f)
-
- res = identity()
- res[0][0] = s[0]
- res[1][0] = s[1]
- res[2][0] = s[2]
- res[0][1] = u[0]
- res[1][1] = u[1]
- res[2][1] = u[2]
- res[0][2] = -f[0]
- res[1][2] = -f[1]
- res[2][2] = -f[2]
- res[3][0] = -dot(s, eye)
- res[3][1] = -dot(u, eye)
- res[3][2] = -dot(f, eye)
- return res.T
-
-
-def transform(d, m):
- return np.dot(m, d.T).T
diff --git a/spaces/Zaixi/ICLR_FLAG/utils/__init__.py b/spaces/Zaixi/ICLR_FLAG/utils/__init__.py
deleted file mode 100644
index b66cfe3a767f1adc6218dfda70bbd93a77b0b9fc..0000000000000000000000000000000000000000
--- a/spaces/Zaixi/ICLR_FLAG/utils/__init__.py
+++ /dev/null
@@ -1,3 +0,0 @@
-from .dihedral_utils import batch_dihedrals, rotation_matrix_v2, von_Mises_loss
-from .chemutils import get_clique_mol, tree_decomp, get_mol, get_smiles, set_atommap, get_clique_mol_simple, assemble, mol_to_graph_data_obj_simple
-from .dihedral_utils import rotation_matrix_v2, von_Mises_loss, batch_dihedrals
diff --git a/spaces/Zaixi/ICLR_FLAG/utils/dihedral_utils.py b/spaces/Zaixi/ICLR_FLAG/utils/dihedral_utils.py
deleted file mode 100644
index 1aea8c4bb0ec001677659d3bcfcff1f5eae5888a..0000000000000000000000000000000000000000
--- a/spaces/Zaixi/ICLR_FLAG/utils/dihedral_utils.py
+++ /dev/null
@@ -1,383 +0,0 @@
-import torch
-import torch_geometric as tg
-from torch_geometric.utils import degree
-import networkx as nx
-
-device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
-angle_mask_ref = torch.LongTensor([[0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0],
- [1, 0, 0, 0, 0, 0],
- [1, 1, 1, 0, 0, 0],
- [1, 1, 1, 1, 1, 1]]).to(device)
-
-angle_combos = torch.LongTensor([[0, 1],
- [0, 2],
- [1, 2],
- [0, 3],
- [1, 3],
- [2, 3]]).to(device)
-
-
-def get_neighbor_ids(data):
- """
- Takes the edge indices and returns dictionary mapping atom index to neighbor indices
- Note: this only includes atoms with degree > 1
- """
- # start, end = edge_index
- # idxs, vals = torch.unique(start, return_counts=True)
- # vs = torch.split_with_sizes(end, tuple(vals))
- # return {k.item(): v for k, v in zip(idxs, vs) if len(v) > 1}
- neighbors = data.neighbors.pop(0)
- n_atoms_per_mol = data.batch.bincount()
- n_atoms_prev_mol = 0
-
- for i, n_dict in enumerate(data.neighbors):
- new_dict = {}
- n_atoms_prev_mol += n_atoms_per_mol[i].item()
- for k, v in n_dict.items():
- new_dict[k + n_atoms_prev_mol] = v + n_atoms_prev_mol
- neighbors.update(new_dict)
- return neighbors
-
-
-def get_neighbor_bonds(edge_index, bond_type):
- """
- Takes the edge indices and bond type and returns dictionary mapping atom index to neighbor bond types
- Note: this only includes atoms with degree > 1
- """
- start, end = edge_index
- idxs, vals = torch.unique(start, return_counts=True)
- vs = torch.split_with_sizes(bond_type, tuple(vals))
- return {k.item(): v for k, v in zip(idxs, vs) if len(v) > 1}
-
-
-def get_leaf_hydrogens(neighbors, x):
- """
- Takes the edge indices and atom features and returns dictionary mapping atom index to neighbors, indicating true
- for hydrogens that are leaf nodes
- Note: this only works because degree = 1 and hydrogen atomic number = 1 (checks when 1 == 1)
- Note: we use the 5th feature index bc this corresponds to the atomic number
- """
- # start, end = edge_index
- # degrees = degree(end)
- # idxs, vals = torch.unique(start, return_counts=True)
- # vs = torch.split_with_sizes(end, tuple(vals))
- # return {k.item(): degrees[v] == x[v, 5] for k, v in zip(idxs, vs) if len(v) > 1}
- leaf_hydrogens = {}
- h_mask = x[:, 0] == 1
- for k, v in neighbors.items():
- leaf_hydrogens[k] = h_mask[neighbors[k]]
- return leaf_hydrogens
-
-
-def get_dihedral_pairs(edge_index, data):
- """
- Given edge indices, return pairs of indices that we must calculate dihedrals for
- """
- start, end = edge_index
- degrees = degree(end)
- dihedral_pairs_true = torch.nonzero(torch.logical_and(degrees[start] > 1, degrees[end] > 1))
- dihedral_pairs = edge_index[:, dihedral_pairs_true].squeeze(-1)
-
- # # first method which removes one (pseudo) random edge from a cycle
- dihedral_idxs = torch.nonzero(dihedral_pairs.sort(dim=0).indices[0, :] == 0).squeeze().detach().cpu().numpy()
-
- # prioritize rings for assigning dihedrals
- dihedral_pairs = dihedral_pairs.t()[dihedral_idxs]
- G = nx.to_undirected(tg.utils.to_networkx(data))
- cycles = nx.cycle_basis(G)
- keep, sorted_keep = [], []
-
- if len(dihedral_pairs.shape) == 1:
- dihedral_pairs = dihedral_pairs.unsqueeze(0)
-
- for pair in dihedral_pairs:
- x, y = pair
-
- if sorted(pair) in sorted_keep:
- continue
-
- y_cycle_check = [y in cycle for cycle in cycles]
- x_cycle_check = [x in cycle for cycle in cycles]
-
- if any(x_cycle_check) and any(y_cycle_check): # both in new cycle
- cycle_indices = get_current_cycle_indices(cycles, x_cycle_check, x)
- keep.extend(cycle_indices)
-
- sorted_keep.extend([sorted(c) for c in cycle_indices])
- continue
-
- if any(y_cycle_check):
- cycle_indices = get_current_cycle_indices(cycles, y_cycle_check, y)
- keep.append(pair)
- keep.extend(cycle_indices)
-
- sorted_keep.append(sorted(pair))
- sorted_keep.extend([sorted(c) for c in cycle_indices])
- continue
-
- keep.append(pair)
-
- keep = [t.to(device) for t in keep]
- return torch.stack(keep).t()
-
-
-def batch_distance_metrics_from_coords(coords, mask):
- """
- Given coordinates of neighboring atoms, compute bond
- distances and 2-hop distances in local neighborhood
- """
- d_mat_mask = mask.unsqueeze(1) * mask.unsqueeze(2)
-
- if coords.dim() == 4:
- two_dop_d_mat = torch.square(coords.unsqueeze(1) - coords.unsqueeze(2) + 1e-10).sum(dim=-1).sqrt() * d_mat_mask.unsqueeze(-1)
- one_hop_ds = torch.linalg.norm(torch.zeros_like(coords[0]).unsqueeze(0) - coords, dim=-1)
- elif coords.dim() == 5:
- two_dop_d_mat = torch.square(coords.unsqueeze(2) - coords.unsqueeze(3) + 1e-10).sum(dim=-1).sqrt() * d_mat_mask.unsqueeze(-1).unsqueeze(1)
- one_hop_ds = torch.linalg.norm(torch.zeros_like(coords[0]).unsqueeze(0) - coords, dim=-1)
-
- return one_hop_ds, two_dop_d_mat
-
-
-def batch_angle_between_vectors(a, b):
- """
- Compute angle between two batches of input vectors
- """
- inner_product = (a * b).sum(dim=-1)
-
- # norms
- a_norm = torch.linalg.norm(a, dim=-1)
- b_norm = torch.linalg.norm(b, dim=-1)
-
- # protect denominator during division
- den = a_norm * b_norm + 1e-10
- cos = inner_product / den
-
- return cos
-
-
-def batch_angles_from_coords(coords, mask):
- """
- Given coordinates, compute all local neighborhood angles
- """
- if coords.dim() == 4:
- all_possible_combos = coords[:, angle_combos]
- v_a, v_b = all_possible_combos.split(1, dim=2) # does one of these need to be negative?
- angle_mask = angle_mask_ref[mask.sum(dim=1).long()]
- angles = batch_angle_between_vectors(v_a.squeeze(2), v_b.squeeze(2)) * angle_mask.unsqueeze(-1)
- elif coords.dim() == 5:
- all_possible_combos = coords[:, :, angle_combos]
- v_a, v_b = all_possible_combos.split(1, dim=3) # does one of these need to be negative?
- angle_mask = angle_mask_ref[mask.sum(dim=1).long()]
- angles = batch_angle_between_vectors(v_a.squeeze(3), v_b.squeeze(3)) * angle_mask.unsqueeze(-1).unsqueeze(-1)
-
- return angles
-
-
-def batch_local_stats_from_coords(coords, mask):
- """
- Given neighborhood neighbor coordinates, compute bond distances,
- 2-hop distances, and angles in local neighborhood (this assumes
- the central atom has coordinates at the origin)
- """
- one_hop_ds, two_dop_d_mat = batch_distance_metrics_from_coords(coords, mask)
- angles = batch_angles_from_coords(coords, mask)
- return one_hop_ds, two_dop_d_mat, angles
-
-
-def batch_dihedrals(p0, p1, p2, p3, angle=False):
-
- s1 = p1 - p0
- s2 = p2 - p1
- s3 = p3 - p2
-
- sin_d_ = torch.linalg.norm(s2, dim=-1) * torch.sum(s1 * torch.cross(s2, s3, dim=-1), dim=-1)
- cos_d_ = torch.sum(torch.cross(s1, s2, dim=-1) * torch.cross(s2, s3, dim=-1), dim=-1)
-
- if angle:
- return torch.atan2(sin_d_, cos_d_ + 1e-10)
-
- else:
- den = torch.linalg.norm(torch.cross(s1, s2, dim=-1), dim=-1) * torch.linalg.norm(torch.cross(s2, s3, dim=-1), dim=-1) + 1e-10
- return sin_d_/den, cos_d_/den
-
-
-def batch_vector_angles(xn, x, y, yn):
- uT = xn.view(-1, 3)
- uX = x.view(-1, 3)
- uY = y.view(-1, 3)
- uZ = yn.view(-1, 3)
-
- b1 = uT - uX
- b2 = uZ - uY
-
- num = torch.bmm(b1.view(-1, 1, 3), b2.view(-1, 3, 1)).squeeze(-1).squeeze(-1)
- den = torch.linalg.norm(b1, dim=-1) * torch.linalg.norm(b2, dim=-1) + 1e-10
-
- return (num / den).view(-1, 9)
-
-
-def von_Mises_loss(a, b, a_sin=None, b_sin=None):
- """
- :param a: cos of first angle
- :param b: cos of second angle
- :return: difference of cosines
- """
- if torch.is_tensor(a_sin):
- out = a * b + a_sin * b_sin
- else:
- out = a * b + torch.sqrt(1-a**2 + 1e-5) * torch.sqrt(1-b**2 + 1e-5)
- return out
-
-
-def rotation_matrix(neighbor_coords, neighbor_mask, neighbor_map, mu=None):
- """
- Given predicted neighbor coordinates from model, return rotation matrix
-
- :param neighbor_coords: neighbor coordinates for each edge as defined by dihedral_pairs
- (n_dihedral_pairs, 4, n_generated_confs, 3)
- :param neighbor_mask: mask describing which atoms are present (n_dihedral_pairs, 4)
- :param neighbor_map: mask describing which neighbor corresponds to the other central dihedral atom
- (n_dihedral_pairs, 4) each entry in neighbor_map should have one TRUE entry with the rest as FALSE
- :return: rotation matrix (n_dihedral_pairs, n_model_confs, 3, 3)
- """
-
- if not torch.is_tensor(mu):
- # mu = neighbor_coords.sum(dim=1, keepdim=True) / (neighbor_mask.sum(dim=-1, keepdim=True).unsqueeze(-1).unsqueeze(-1) + 1e-10)
- mu_num = neighbor_coords[~neighbor_map.bool()].view(neighbor_coords.size(0), 3, neighbor_coords.size(2), -1).sum(dim=1)
- mu_den = (neighbor_mask.sum(dim=-1, keepdim=True).unsqueeze(-1) - 1 + 1e-10)
- mu = mu_num / mu_den # (n_dihedral_pairs, n_model_confs, 10)
- mu = mu.squeeze(1) # (n_dihedral_pairs, n_model_confs, 10)
-
- p_Y = neighbor_coords[neighbor_map.bool(), :]
- h1 = p_Y / (torch.linalg.norm(p_Y, dim=-1, keepdim=True) + 1e-10) # (n_dihedral_pairs, n_model_confs, 10)
-
- h3_1 = torch.cross(p_Y, mu, dim=-1)
- h3 = h3_1 / (torch.linalg.norm(h3_1, dim=-1, keepdim=True) + 1e-10) # (n_dihedral_pairs, n_model_confs, 10)
-
- h2 = -torch.cross(h1, h3, dim=-1) # (n_dihedral_pairs, n_model_confs, 10)
-
- H = torch.cat([h1.unsqueeze(-2),
- h2.unsqueeze(-2),
- h3.unsqueeze(-2)], dim=-2)
-
- return H
-
-
-def rotation_matrix_v2(neighbor_coords):
- """
- Given predicted neighbor coordinates from model, return rotation matrix
- :param neighbor_coords: y or x coordinates for the x or y center node
- (n_dihedral_pairs, 3)
- :return: rotation matrix (n_dihedral_pairs, 3, 3)
- """
-
- p_Y = neighbor_coords
-
- eta_1 = torch.rand_like(p_Y)
- eta_2 = eta_1 - torch.sum(eta_1 * p_Y, dim=-1, keepdim=True) / (torch.linalg.norm(p_Y, dim=-1, keepdim=True)**2 + 1e-10) * p_Y
- eta = eta_2 / torch.linalg.norm(eta_2, dim=-1, keepdim=True)
-
- h1 = p_Y / (torch.linalg.norm(p_Y, dim=-1, keepdim=True) + 1e-10) # (n_dihedral_pairs, n_model_confs, 10)
-
- h3_1 = torch.cross(p_Y, eta, dim=-1)
- h3 = h3_1 / (torch.linalg.norm(h3_1, dim=-1, keepdim=True) + 1e-10) # (n_dihedral_pairs, n_model_confs, 10)
-
- h2 = -torch.cross(h1, h3, dim=-1) # (n_dihedral_pairs, n_model_confs, 10)
-
- H = torch.cat([h1.unsqueeze(-2),
- h2.unsqueeze(-2),
- h3.unsqueeze(-2)], dim=-2)
-
- return H
-
-
-def signed_volume(local_coords):
- """
- Compute signed volume given ordered neighbor local coordinates
-
- :param local_coords: (n_tetrahedral_chiral_centers, 4, n_generated_confs, 3)
- :return: signed volume of each tetrahedral center (n_tetrahedral_chiral_centers, n_generated_confs)
- """
- v1 = local_coords[:, 0] - local_coords[:, 3]
- v2 = local_coords[:, 1] - local_coords[:, 3]
- v3 = local_coords[:, 2] - local_coords[:, 3]
- cp = v2.cross(v3, dim=-1)
- vol = torch.sum(v1 * cp, dim=-1)
- return torch.sign(vol)
-
-
-def rotation_matrix_inf(neighbor_coords, neighbor_mask, neighbor_map):
- """
- Given predicted neighbor coordinates from model, return rotation matrix
-
- :param neighbor_coords: neighbor coordinates for each edge as defined by dihedral_pairs (4, n_model_confs, 3)
- :param neighbor_mask: mask describing which atoms are present (4)
- :param neighbor_map: mask describing which neighbor corresponds to the other central dihedral atom (4)
- each entry in neighbor_map should have one TRUE entry with the rest as FALSE
- :return: rotation matrix (3, 3)
- """
-
- mu = neighbor_coords.sum(dim=0, keepdim=True) / (neighbor_mask.sum(dim=-1, keepdim=True).unsqueeze(-1) + 1e-10)
- mu = mu.squeeze(0)
- p_Y = neighbor_coords[neighbor_map.bool(), :].squeeze(0)
-
- h1 = p_Y / (torch.linalg.norm(p_Y, dim=-1, keepdim=True) + 1e-10)
-
- h3_1 = torch.cross(p_Y, mu, dim=-1)
- h3 = h3_1 / (torch.linalg.norm(h3_1, dim=-1, keepdim=True) + 1e-10)
-
- h2 = -torch.cross(h1, h3, dim=-1)
-
- H = torch.cat([h1.unsqueeze(-2),
- h2.unsqueeze(-2),
- h3.unsqueeze(-2)], dim=-2)
-
- return H
-
-
-def build_alpha_rotation_inf(alpha, n_model_confs):
-
- H_alpha = torch.FloatTensor([[[1, 0, 0], [0, 0, 0], [0, 0, 0]]]).repeat(n_model_confs, 1, 1)
- H_alpha[:, 1, 1] = torch.cos(alpha)
- H_alpha[:, 1, 2] = -torch.sin(alpha)
- H_alpha[:, 2, 1] = torch.sin(alpha)
- H_alpha[:, 2, 2] = torch.cos(alpha)
-
- return H_alpha
-
-
-def random_rotation_matrix(dim):
- yaw = torch.rand(dim)
- pitch = torch.rand(dim)
- roll = torch.rand(dim)
-
- R = torch.stack([torch.stack([torch.cos(yaw) * torch.cos(pitch),
- torch.cos(yaw) * torch.sin(pitch) * torch.sin(roll) - torch.sin(yaw) * torch.cos(
- roll),
- torch.cos(yaw) * torch.sin(pitch) * torch.cos(roll) + torch.sin(yaw) * torch.sin(
- roll)], dim=-1),
- torch.stack([torch.sin(yaw) * torch.cos(pitch),
- torch.sin(yaw) * torch.sin(pitch) * torch.sin(roll) + torch.cos(yaw) * torch.cos(
- roll),
- torch.sin(yaw) * torch.sin(pitch) * torch.cos(roll) - torch.cos(yaw) * torch.sin(
- roll)], dim=-1),
- torch.stack([-torch.sin(pitch),
- torch.cos(pitch) * torch.sin(roll),
- torch.cos(pitch) * torch.cos(roll)], dim=-1)], dim=-2)
-
- return R
-
-
-def length_to_mask(length, max_len=None, dtype=None):
- """length: B.
- return B x max_len.
- If max_len is None, then max of length will be used.
- """
- assert len(length.shape) == 1, 'Length shape should be 1 dimensional.'
- max_len = max_len or length.max().item()
- mask = torch.arange(max_len, device=length.device,
- dtype=length.dtype).expand(len(length), max_len) < length.unsqueeze(1)
- if dtype is not None:
- mask = torch.as_tensor(mask, dtype=dtype, device=length.device)
- return mask
diff --git a/spaces/abby711/FaceRestoration/gfpgan/weights/README.md b/spaces/abby711/FaceRestoration/gfpgan/weights/README.md
deleted file mode 100644
index 4d7b7e642591ef88575d9e6c360a4d29e0cc1a4f..0000000000000000000000000000000000000000
--- a/spaces/abby711/FaceRestoration/gfpgan/weights/README.md
+++ /dev/null
@@ -1,3 +0,0 @@
-# Weights
-
-Put the downloaded weights to this folder.
diff --git a/spaces/abdvl/datahub_qa_bot/docs/how/kafka-config.md b/spaces/abdvl/datahub_qa_bot/docs/how/kafka-config.md
deleted file mode 100644
index f3f81c3d07c01462f675931e26e79ea4f39a13f6..0000000000000000000000000000000000000000
--- a/spaces/abdvl/datahub_qa_bot/docs/how/kafka-config.md
+++ /dev/null
@@ -1,220 +0,0 @@
----
-title: "Configuring Kafka"
-hide_title: true
----
-
-# Configuring Kafka in DataHub
-
-DataHub requires Kafka to operate. Kafka is used as a durable log that can be used to store inbound
-requests to update the Metadata Graph (Metadata Change Proposal), or as a change log detailing the updates
-that have been made to the Metadata Graph (Metadata Change Log).
-
-## Environment Variables
-
-The following environment variables can be used to customize DataHub's connection to Kafka for the following DataHub components,
-each of which requires a connection to Kafka:
-
-- `metadata-service` (datahub-gms container)
-- (Advanced - if standalone consumers are deployed) `mce-consumer-job` (datahub-mce-consumer container)
-- (Advanced - if standalone consumers are deployed) `mae-consumer-job` (datahub-mae-consumer container)
-- (Advanced - if product analytics are enabled) datahub-frontend
-
-### Connection Configuration
-
-With the exception of `KAFKA_BOOTSTRAP_SERVER` and `KAFKA_SCHEMAREGISTRY_URL`, Kafka is configured via [spring-boot](https://spring.io/projects/spring-boot), specifically with [KafkaProperties](https://docs.spring.io/spring-boot/docs/current/api/org/springframework/boot/autoconfigure/kafka/KafkaProperties.html). See [Integration Properties](https://docs.spring.io/spring-boot/docs/current/reference/html/appendix-application-properties.html#integration-properties) prefixed with `spring.kafka`.
-
-Below is an example of how SASL/GSSAPI properties can be configured via environment variables:
-
-```bash
-export KAFKA_BOOTSTRAP_SERVER=broker:29092
-export KAFKA_SCHEMAREGISTRY_URL=http://schema-registry:8081
-export SPRING_KAFKA_PROPERTIES_SASL_KERBEROS_SERVICE_NAME=kafka
-export SPRING_KAFKA_PROPERTIES_SECURITY_PROTOCOL=SASL_PLAINTEXT
-export SPRING_KAFKA_PROPERTIES_SASL_JAAS_CONFIG=com.sun.security.auth.module.Krb5LoginModule required principal='principal@REALM' useKeyTab=true storeKey=true keyTab='/keytab';
-```
-
-#### Example: Connecting using AWS IAM (MSK)
-
-Here is another example of how SASL_SSL can be configured for AWS_MSK_IAM when connecting to MSK using IAM via environment variables
-```bash
-SPRING_KAFKA_PROPERTIES_SECURITY_PROTOCOL=SASL_SSL
-SPRING_KAFKA_PROPERTIES_SSL_TRUSTSTORE_LOCATION=/tmp/kafka.client.truststore.jks
-SPRING_KAFKA_PROPERTIES_SASL_MECHANISM=AWS_MSK_IAM
-SPRING_KAFKA_PROPERTIES_SASL_JAAS_CONFIG=software.amazon.msk.auth.iam.IAMLoginModule required;
-SPRING_KAFKA_PROPERTIES_SASL_CLIENT_CALLBACK_HANDLER_CLASS=software.amazon.msk.auth.iam.IAMClientCallbackHandler
-```
-
-For more information about configuring these variables, check out Spring's [Externalized Configuration](https://docs.spring.io/spring-boot/docs/current/reference/html/spring-boot-features.html#boot-features-external-config) to see how this works.
-Also see [Kafka Connect Security](https://docs.confluent.io/current/connect/security.html) for more ways to connect.
-
-
-### Topic Configuration
-
-By default, DataHub relies on the a set of Kafka topics to operate. By default, they have the following names:
-
-- **MetadataChangeProposal_v1**
-- **FailedMetadataChangeProposal_v1**
-- **MetadataChangeLog_Versioned_v1**
-- **MetadataChangeLog_Timeseries_v1**
-- **DataHubUsageEvent_v1**: User behavior tracking event for UI
-6. (Deprecated) **MetadataChangeEvent_v4**: Metadata change proposal messages
-7. (Deprecated) **MetadataAuditEvent_v4**: Metadata change log messages
-8. (Deprecated) **FailedMetadataChangeEvent_v4**: Failed to process #1 event
-
-These topics are discussed at more length in [Metadata Events](../what/mxe.md).
-
-We've included environment variables to customize the name each of these topics, for cases where an organization has naming rules for your topics.
-
-### Metadata Service (datahub-gms)
-
-The following are environment variables you can use to configure topic names used in the Metadata Service container:
-
-- `METADATA_CHANGE_PROPOSAL_TOPIC_NAME`: The name of the topic for Metadata Change Proposals emitted by the ingestion framework.
-- `FAILED_METADATA_CHANGE_PROPOSAL_TOPIC_NAME`: The name of the topic for Metadata Change Proposals emitted when MCPs fail processing.
-- `METADATA_CHANGE_LOG_VERSIONED_TOPIC_NAME`: The name of the topic for Metadata Change Logs that are produced for Versioned Aspects.
-- `METADATA_CHANGE_LOG_TIMESERIES_TOPIC_NAME`: The name of the topic for Metadata Change Logs that are produced for Timeseries Aspects.
-- `PLATFORM_EVENT_TOPIC_NAME`: The name of the topic for Platform Events (high-level semantic events).
-- `DATAHUB_USAGE_EVENT_NAME`: The name of the topic for product analytics events.
-- (Deprecated) `METADATA_CHANGE_EVENT_NAME`: The name of the metadata change event topic.
-- (Deprecated) `METADATA_AUDIT_EVENT_NAME`: The name of the metadata audit event topic.
-- (Deprecated) `FAILED_METADATA_CHANGE_EVENT_NAME`: The name of the failed metadata change event topic.
-
-### MCE Consumer (datahub-mce-consumer)
-
-- `METADATA_CHANGE_PROPOSAL_TOPIC_NAME`: The name of the topic for Metadata Change Proposals emitted by the ingestion framework.
-- `FAILED_METADATA_CHANGE_PROPOSAL_TOPIC_NAME`: The name of the topic for Metadata Change Proposals emitted when MCPs fail processing.
-- (Deprecated) `METADATA_CHANGE_EVENT_NAME`: The name of the deprecated topic that an embedded MCE consumer will consume from.
-- (Deprecated) `FAILED_METADATA_CHANGE_EVENT_NAME`: The name of the deprecated topic that failed MCEs will be written to.
-
-### MAE Consumer (datahub-mae-consumer)
-
-- `METADATA_CHANGE_LOG_VERSIONED_TOPIC_NAME`: The name of the topic for Metadata Change Logs that are produced for Versioned Aspects.
-- `METADATA_CHANGE_LOG_TIMESERIES_TOPIC_NAME`: The name of the topic for Metadata Change Logs that are produced for Timeseries Aspects.
-- `PLATFORM_EVENT_TOPIC_NAME`: The name of the topic for Platform Events (high-level semantic events).
-- `DATAHUB_USAGE_EVENT_NAME`: The name of the topic for product analytics events.
-- (Deprecated) `METADATA_AUDIT_EVENT_NAME`: The name of the deprecated metadata audit event topic.
-
-### DataHub Frontend (datahub-frontend-react)
-
-- `DATAHUB_TRACKING_TOPIC`: The name of the topic used for storing DataHub usage events.
-It should contain the same value as `DATAHUB_USAGE_EVENT_NAME` in the Metadata Service container.
-
-Please ensure that these environment variables are set consistently throughout your ecosystem. DataHub has a few different applications running which communicate with Kafka (see above).
-
-## Configuring Consumer Group Id
-
-Kafka Consumers in Spring are configured using Kafka listeners. By default, consumer group id is same as listener id.
-
-We've included an environment variable to customize the consumer group id, if your company or organization has specific naming rules.
-
-### datahub-mce-consumer and datahub-mae-consumer
-
-- `KAFKA_CONSUMER_GROUP_ID`: The name of the kafka consumer's group id.
-
-## Applying Configurations
-
-### Docker
-
-Simply add the above environment variables to the required `docker.env` files for the containers. These can
-be found inside the `docker` folder of the repository.
-
-
-### Helm
-
-On Helm, you'll need to configure these environment variables using the `extraEnvs` sections of the specific container's
-configurations inside your `values.yaml` file.
-```
-datahub-gms:
- ...
- extraEnvs:
- - name: METADATA_CHANGE_PROPOSAL_TOPIC_NAME
- value: "CustomMetadataChangeProposal_v1"
- - name: METADATA_CHANGE_LOG_VERSIONED_TOPIC_NAME
- value: "CustomMetadataChangeLogVersioned_v1"
- - name: FAILED_METADATA_CHANGE_PROPOSAL_TOPIC_NAME
- value: "CustomFailedMetadataChangeProposal_v1"
- - name: KAFKA_CONSUMER_GROUP_ID
- value: "my-apps-mae-consumer"
- ....
-
-datahub-frontend:
- ...
- extraEnvs:
- - name: DATAHUB_TRACKING_TOPIC
- value: "MyCustomTrackingEvent"
-
-# If standalone consumers are enabled
-datahub-mae-consumer;
- extraEnvs:
- - name: METADATA_CHANGE_LOG_VERSIONED_TOPIC_NAME
- value: "CustomMetadataChangeLogVersioned_v1"
- ....
- - name: METADATA_AUDIT_EVENT_NAME
- value: "MetadataAuditEvent"
-datahub-mce-consumer;
- extraEnvs:
- - name: METADATA_CHANGE_PROPOSAL_TOPIC_NAME
- value: "CustomMetadataChangeLogVersioned_v1"
- ....
- - name: METADATA_CHANGE_EVENT_NAME
- value: "MetadataChangeEvent"
- ....
-```
-
-## Other Components that use Kafka can be configured using environment variables:
-- kafka-setup
-- schema-registry
-
-## SASL/GSSAPI properties for kafka-setup and datahub-frontend via environment variables
-```bash
-KAFKA_BOOTSTRAP_SERVER=broker:29092
-KAFKA_SCHEMAREGISTRY_URL=http://schema-registry:8081
-KAFKA_PROPERTIES_SASL_KERBEROS_SERVICE_NAME=kafka
-KAFKA_PROPERTIES_SECURITY_PROTOCOL=SASL_PLAINTEXT
-KAFKA_PROPERTIES_SASL_JAAS_CONFIG=com.sun.security.auth.module.Krb5LoginModule required principal='principal@REALM' useKeyTab=true storeKey=true keyTab='/keytab';
-```
-
-## SASL/GSSAPI properties for schema-registry via environment variables
-```bash
-SCHEMA_REGISTRY_KAFKASTORE_BOOTSTRAP_SERVERS=broker:29092
-SCHEMA_REGISTRY_KAFKASTORE_SASL_KERBEROS_SERVICE_NAME=kafka
-SCHEMA_REGISTRY_KAFKASTORE_SECURITY_PROTOCOL=SASL_PLAINTEXT
-SCHEMA_REGISTRY_KAFKASTORE_SASL_JAAS_CONFIG=com.sun.security.auth.module.Krb5LoginModule required principal='principal@REALM' useKeyTab=true storeKey=true keyTab='/keytab';
-```
-
-
-## SSL
-
-### Kafka
-
-We are using the Spring Boot framework to start our apps, including setting up Kafka. You can
-[use environment variables to set system properties](https://docs.spring.io/spring-boot/docs/current/reference/html/spring-boot-features.html#boot-features-external-config-relaxed-binding-from-environment-variables),
-including [Kafka properties](https://docs.spring.io/spring-boot/docs/current/reference/html/appendix-application-properties.html#integration-properties).
-From there you can set your SSL configuration for Kafka.
-
-### Schema Registry
-If Schema Registry is configured to use security (SSL), then you also need to set additional values.
-
-The [MCE](../../metadata-jobs/mce-consumer-job) and [MAE](../../metadata-jobs/mae-consumer-job) consumers can set
-default Spring Kafka environment values, for example:
-- `SPRING_KAFKA_PROPERTIES_SCHEMA_REGISTRY_SECURITY_PROTOCOL`
-- `SPRING_KAFKA_PROPERTIES_SCHEMA_REGISTRY_SSL_KEYSTORE_LOCATION`
-- `SPRING_KAFKA_PROPERTIES_SCHEMA_REGISTRY_SSL_KEYSTORE_PASSWORD`
-- `SPRING_KAFKA_PROPERTIES_SCHEMA_REGISTRY_SSL_TRUSTSTORE_LOCATION`
-- `SPRING_KAFKA_PROPERTIES_SCHEMA_REGISTRY_SSL_TRUSTSTORE_PASSWORD`
-
-[GMS](../what/gms.md) can set the following environment variables that will be passed as properties when creating the Schema Registry
-Client.
-- `KAFKA_SCHEMA_REGISTRY_SECURITY_PROTOCOL`
-- `KAFKA_SCHEMA_REGISTRY_SSL_KEYSTORE_LOCATION`
-- `KAFKA_SCHEMA_REGISTRY_SSL_KEYSTORE_PASSWORD`
-- `KAFKA_SCHEMA_REGISTRY_SSL_TRUSTSTORE_LOCATION`
-- `KAFKA_SCHEMA_REGISTRY_SSL_TRUSTSTORE_PASSWORD`
-
-> **Note** In the logs you might see something like
-> `The configuration 'kafkastore.ssl.truststore.password' was supplied but isn't a known config.` The configuration is
-> not a configuration required for the producer. These WARN message can be safely ignored. Each of Datahub services are
-> passed a full set of configuration but may not require all the configurations that are passed to them. These warn
-> messages indicate that the service was passed a configuration that is not relevant to it and can be safely ignored.
-
->Other errors: `Failed to start bean 'org.springframework.kafka.config.internalKafkaListenerEndpointRegistry'; nested exception is org.apache.kafka.common.errors.TopicAuthorizationException: Not authorized to access topics: [DataHubUsageEvent_v1]`. Please check ranger permissions or kafka broker logs.
diff --git a/spaces/abhishek/sketch-to-image/annotator/uniformer/exp/upernet_global_small/test_config_g.py b/spaces/abhishek/sketch-to-image/annotator/uniformer/exp/upernet_global_small/test_config_g.py
deleted file mode 100644
index e43737a98a3b174a9f2fe059c06d511144686459..0000000000000000000000000000000000000000
--- a/spaces/abhishek/sketch-to-image/annotator/uniformer/exp/upernet_global_small/test_config_g.py
+++ /dev/null
@@ -1,38 +0,0 @@
-_base_ = [
- '../../configs/_base_/models/upernet_uniformer.py',
- '../../configs/_base_/datasets/ade20k.py',
- '../../configs/_base_/default_runtime.py',
- '../../configs/_base_/schedules/schedule_160k.py'
-]
-model = dict(
- backbone=dict(
- type='UniFormer',
- embed_dim=[64, 128, 320, 512],
- layers=[3, 4, 8, 3],
- head_dim=64,
- drop_path_rate=0.25,
- windows=False,
- hybrid=False,
- ),
- decode_head=dict(
- in_channels=[64, 128, 320, 512],
- num_classes=150
- ),
- auxiliary_head=dict(
- in_channels=320,
- num_classes=150
- ))
-
-# AdamW optimizer, no weight decay for position embedding & layer norm in backbone
-optimizer = dict(_delete_=True, type='AdamW', lr=0.00006, betas=(0.9, 0.999), weight_decay=0.01,
- paramwise_cfg=dict(custom_keys={'absolute_pos_embed': dict(decay_mult=0.),
- 'relative_position_bias_table': dict(decay_mult=0.),
- 'norm': dict(decay_mult=0.)}))
-
-lr_config = dict(_delete_=True, policy='poly',
- warmup='linear',
- warmup_iters=1500,
- warmup_ratio=1e-6,
- power=1.0, min_lr=0.0, by_epoch=False)
-
-data=dict(samples_per_gpu=2)
\ No newline at end of file
diff --git a/spaces/abrar-lohia/text-2-character-anim/VQTrans/models/smpl.py b/spaces/abrar-lohia/text-2-character-anim/VQTrans/models/smpl.py
deleted file mode 100644
index c4229abdcc9fd2cc8c1951005ca842e1ca191fae..0000000000000000000000000000000000000000
--- a/spaces/abrar-lohia/text-2-character-anim/VQTrans/models/smpl.py
+++ /dev/null
@@ -1,97 +0,0 @@
-# This code is based on https://github.com/Mathux/ACTOR.git
-import numpy as np
-import torch
-
-import contextlib
-
-from smplx import SMPLLayer as _SMPLLayer
-from smplx.lbs import vertices2joints
-
-
-# action2motion_joints = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 21, 24, 38]
-# change 0 and 8
-action2motion_joints = [8, 1, 2, 3, 4, 5, 6, 7, 0, 9, 10, 11, 12, 13, 14, 21, 24, 38]
-
-from VQTrans.utils.config import SMPL_MODEL_PATH, JOINT_REGRESSOR_TRAIN_EXTRA
-
-JOINTSTYPE_ROOT = {"a2m": 0, # action2motion
- "smpl": 0,
- "a2mpl": 0, # set(smpl, a2m)
- "vibe": 8} # 0 is the 8 position: OP MidHip below
-
-JOINT_MAP = {
- 'OP Nose': 24, 'OP Neck': 12, 'OP RShoulder': 17,
- 'OP RElbow': 19, 'OP RWrist': 21, 'OP LShoulder': 16,
- 'OP LElbow': 18, 'OP LWrist': 20, 'OP MidHip': 0,
- 'OP RHip': 2, 'OP RKnee': 5, 'OP RAnkle': 8,
- 'OP LHip': 1, 'OP LKnee': 4, 'OP LAnkle': 7,
- 'OP REye': 25, 'OP LEye': 26, 'OP REar': 27,
- 'OP LEar': 28, 'OP LBigToe': 29, 'OP LSmallToe': 30,
- 'OP LHeel': 31, 'OP RBigToe': 32, 'OP RSmallToe': 33, 'OP RHeel': 34,
- 'Right Ankle': 8, 'Right Knee': 5, 'Right Hip': 45,
- 'Left Hip': 46, 'Left Knee': 4, 'Left Ankle': 7,
- 'Right Wrist': 21, 'Right Elbow': 19, 'Right Shoulder': 17,
- 'Left Shoulder': 16, 'Left Elbow': 18, 'Left Wrist': 20,
- 'Neck (LSP)': 47, 'Top of Head (LSP)': 48,
- 'Pelvis (MPII)': 49, 'Thorax (MPII)': 50,
- 'Spine (H36M)': 51, 'Jaw (H36M)': 52,
- 'Head (H36M)': 53, 'Nose': 24, 'Left Eye': 26,
- 'Right Eye': 25, 'Left Ear': 28, 'Right Ear': 27
-}
-
-JOINT_NAMES = [
- 'OP Nose', 'OP Neck', 'OP RShoulder',
- 'OP RElbow', 'OP RWrist', 'OP LShoulder',
- 'OP LElbow', 'OP LWrist', 'OP MidHip',
- 'OP RHip', 'OP RKnee', 'OP RAnkle',
- 'OP LHip', 'OP LKnee', 'OP LAnkle',
- 'OP REye', 'OP LEye', 'OP REar',
- 'OP LEar', 'OP LBigToe', 'OP LSmallToe',
- 'OP LHeel', 'OP RBigToe', 'OP RSmallToe', 'OP RHeel',
- 'Right Ankle', 'Right Knee', 'Right Hip',
- 'Left Hip', 'Left Knee', 'Left Ankle',
- 'Right Wrist', 'Right Elbow', 'Right Shoulder',
- 'Left Shoulder', 'Left Elbow', 'Left Wrist',
- 'Neck (LSP)', 'Top of Head (LSP)',
- 'Pelvis (MPII)', 'Thorax (MPII)',
- 'Spine (H36M)', 'Jaw (H36M)',
- 'Head (H36M)', 'Nose', 'Left Eye',
- 'Right Eye', 'Left Ear', 'Right Ear'
-]
-
-
-# adapted from VIBE/SPIN to output smpl_joints, vibe joints and action2motion joints
-class SMPL(_SMPLLayer):
- """ Extension of the official SMPL implementation to support more joints """
-
- def __init__(self, model_path=SMPL_MODEL_PATH, **kwargs):
- kwargs["model_path"] = model_path
-
- # remove the verbosity for the 10-shapes beta parameters
- with contextlib.redirect_stdout(None):
- super(SMPL, self).__init__(**kwargs)
-
- J_regressor_extra = np.load(JOINT_REGRESSOR_TRAIN_EXTRA)
- self.register_buffer('J_regressor_extra', torch.tensor(J_regressor_extra, dtype=torch.float32))
- vibe_indexes = np.array([JOINT_MAP[i] for i in JOINT_NAMES])
- a2m_indexes = vibe_indexes[action2motion_joints]
- smpl_indexes = np.arange(24)
- a2mpl_indexes = np.unique(np.r_[smpl_indexes, a2m_indexes])
-
- self.maps = {"vibe": vibe_indexes,
- "a2m": a2m_indexes,
- "smpl": smpl_indexes,
- "a2mpl": a2mpl_indexes}
-
- def forward(self, *args, **kwargs):
- smpl_output = super(SMPL, self).forward(*args, **kwargs)
-
- extra_joints = vertices2joints(self.J_regressor_extra, smpl_output.vertices)
- all_joints = torch.cat([smpl_output.joints, extra_joints], dim=1)
-
- output = {"vertices": smpl_output.vertices}
-
- for joinstype, indexes in self.maps.items():
- output[joinstype] = all_joints[:, indexes]
-
- return output
\ No newline at end of file
diff --git a/spaces/ahmetfirat/KORKUT_A_Spacetime_Odyssey/README.md b/spaces/ahmetfirat/KORKUT_A_Spacetime_Odyssey/README.md
deleted file mode 100644
index 76b21864ee9174c37e8a5aba82f83b997a86b231..0000000000000000000000000000000000000000
--- a/spaces/ahmetfirat/KORKUT_A_Spacetime_Odyssey/README.md
+++ /dev/null
@@ -1,14 +0,0 @@
----
-title: KORKUT A Spacetime Odyssey
-emoji: 🚀
-colorFrom: red
-colorTo: blue
-sdk: gradio
-sdk_version: 3.28.2
-app_file: app.py
-pinned: false
-python_version: 3.9
-license: other
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/akhaliq/RealBasicVSR/app.py b/spaces/akhaliq/RealBasicVSR/app.py
deleted file mode 100644
index fcd31ed4484945428b5bc1338125fd4f67f55f77..0000000000000000000000000000000000000000
--- a/spaces/akhaliq/RealBasicVSR/app.py
+++ /dev/null
@@ -1,37 +0,0 @@
-import os
-import sys
-
-os.system("pip install mmcv-full -f https://download.openmmlab.com/mmcv/dist/cpu/torch1.10/index.html")
-os.system("pip install mmedit")
-os.system("git clone https://github.com/ckkelvinchan/RealBasicVSR.git")
-os.chdir("RealBasicVSR")
-os.system("wget https://upload.wikimedia.org/wikipedia/commons/thumb/e/ec/Mona_Lisa%2C_by_Leonardo_da_Vinci%2C_from_C2RMF_retouched.jpg/800px-Mona_Lisa%2C_by_Leonardo_da_Vinci%2C_from_C2RMF_retouched.jpg -O mona.jpg")
-import gradio as gr
-os.system("wget https://huggingface.co/akhaliq/RealBasicVSR_x4/resolve/main/RealBasicVSR_x4.pth")
-sys.path.append("RealBasicVSR")
-
-os.mkdir("test")
-from PIL import Image
-
-
-def resize(width,img):
- basewidth = width
- wpercent = (basewidth/float(img.size[0]))
- hsize = int((float(img.size[1])*float(wpercent)))
- img = img.resize((basewidth,hsize), Image.ANTIALIAS)
- return img
-
-def inference(img):
- img = resize(256,img)
- img.save("test/test.png")
- os.system("python inference_realbasicvsr.py configs/realbasicvsr_x4.py RealBasicVSR_x4.pth test/ results/demo_000")
- return "results/demo_000/test.png"
-
-title="RealBasicVSR"
-description="Gradio demo for Investigating Tradeoffs in Real-World Video Super-Resolution. To use it, simply upload your image or click on one of the examples to load them. Read more at the links below."
-
-article = "Investigating Tradeoffs in Real-World Video Super-Resolution | Github Repo
"
-
-examples=[['mona.jpg']]
-
-gr.Interface(inference,gr.inputs.Image(type="pil"),gr.outputs.Image(type="file"),title=title,description=description,article=article,examples=examples).launch(enable_queue=True)
diff --git a/spaces/akhaliq/VQMIVC/ParallelWaveGAN/egs/README.md b/spaces/akhaliq/VQMIVC/ParallelWaveGAN/egs/README.md
deleted file mode 100644
index 197444c11e73febf0da40a5db49f9908dfe598f3..0000000000000000000000000000000000000000
--- a/spaces/akhaliq/VQMIVC/ParallelWaveGAN/egs/README.md
+++ /dev/null
@@ -1,165 +0,0 @@
-# Kaldi-style all-in-one recipes
-
-This repository provides [Kaldi](https://github.com/kaldi-asr/kaldi)-style recipes, as the same as [ESPnet](https://github.com/espnet/espnet).
-Currently, the following recipes are supported.
-
-- [LJSpeech](https://keithito.com/LJ-Speech-Dataset/): English female speaker
-- [JSUT](https://sites.google.com/site/shinnosuketakamichi/publication/jsut): Japanese female speaker
-- [JSSS](https://sites.google.com/site/shinnosuketakamichi/research-topics/jsss_corpus): Japanese female speaker
-- [CSMSC](https://www.data-baker.com/open_source.html): Mandarin female speaker
-- [CMU Arctic](http://www.festvox.org/cmu_arctic/): English speakers
-- [JNAS](http://research.nii.ac.jp/src/en/JNAS.html): Japanese multi-speaker
-- [VCTK](https://homepages.inf.ed.ac.uk/jyamagis/page3/page58/page58.html): English multi-speaker
-- [LibriTTS](https://arxiv.org/abs/1904.02882): English multi-speaker
-- [YesNo](https://arxiv.org/abs/1904.02882): English speaker (For debugging)
-
-
-## How to run the recipe
-
-```bash
-# Let us move on the recipe directory
-$ cd egs/ljspeech/voc1
-
-# Run the recipe from scratch
-$ ./run.sh
-
-# You can change config via command line
-$ ./run.sh --conf
-
-# You can select the stage to start and stop
-$ ./run.sh --stage 2 --stop_stage 2
-
-# If you want to specify the gpu
-$ CUDA_VISIBLE_DEVICES=1 ./run.sh --stage 2
-
-# If you want to resume training from 10000 steps checkpoint
-$ ./run.sh --stage 2 --resume //checkpoint-10000steps.pkl
-```
-
-You can check the command line options in `run.sh`.
-
-The integration with job schedulers such as [slurm](https://slurm.schedmd.com/documentation.html) can be done via `cmd.sh` and `conf/slurm.conf`.
-If you want to use it, please check [this page](https://kaldi-asr.org/doc/queue.html).
-
-All of the hyperparameters are written in a single yaml format configuration file.
-Please check [this example](https://github.com/kan-bayashi/ParallelWaveGAN/blob/master/egs/ljspeech/voc1/conf/parallel_wavegan.v1.yaml) in ljspeech recipe.
-
-You can monitor the training progress via tensorboard.
-
-```bash
-$ tensorboard --logdir exp
-```
-
-
-
-If you want to accelerate the training, you can try distributed multi-gpu training based on apex.
-You need to install apex for distributed training. Please make sure you already installed it.
-Then you can run distributed multi-gpu training via following command:
-
-```bash
-# in the case of the number of gpus = 8
-$ CUDA_VISIBLE_DEVICES="0,1,2,3,4,5,6,7" ./run.sh --stage 2 --n_gpus 8
-```
-
-In the case of distributed training, the batch size will be automatically multiplied by the number of gpus.
-Please be careful.
-
-## How to make the recipe for your own dateset
-
-Here, I will show how to make the recipe for your own dataset.
-
-1. Setup your dataset to be the following structure.
-
- ```bash
- # For single-speaker case
- $ tree /path/to/databse
- /path/to/database
- ├── utt_1.wav
- ├── utt_2.wav
- │ ...
- └── utt_N.wav
- # The directory can be nested, but each filename must be unique
-
- # For multi-speaker case
- $ tree /path/to/databse
- /path/to/database
- ├── spk_1
- │ ├── utt1.wav
- ├── spk_2
- │ ├── utt1.wav
- │ ...
- └── spk_N
- ├── utt1.wav
- ...
- # The directory under each speaker can be nested, but each filename in each speaker directory must be unique
- ```
-
-2. Copy the template directory.
-
- ```bash
- cd egs
-
- # For single speaker case
- cp -r template_single_spk
-
- # For multi speaker case
- cp -r template_multi_spk
-
- # Move on your recipe
- cd egs//voc1
- ```
-
-3. Modify the options in `run.sh`.
- What you need to change at least in `run.sh` is as follows:
- - `db_root`: Root path of the database.
- - `num_dev`: The number of utterances for development set.
- - `num_eval`: The number of utterances for evaluation set.
-
-4. Modify the hyperpameters in `conf/parallel_wavegan.v1.yaml`.
- What you need to change at least in config is as follows:
- - `sampling_rate`: If you can specify the lower sampling rate, the audio will be downsampled by sox.
-
-5. (Optional) Change command backend in `cmd.sh`.
- If you are not familiar with kaldi and run in your local env, you do not need to change.
- See more info on https://kaldi-asr.org/doc/queue.html.
-
-6. Run your recipe.
-
- ```bash
- # Run all stages from the first stage
- ./run.sh
-
- # If you want to specify CUDA device
- CUDA_VISIBLE_DEVICES=0 ./run.sh
- ```
-
-If you want to try the other advanced model, please check the config files in `egs/ljspeech/voc1/conf`.
-
-## Run training using ESPnet2-TTS recipe within 5 minutes
-
-Make sure already you finished the espnet2-tts recipe experiments (at least starting the training).
-
-```bash
-cd egs
-
-# Please use single spk template for both single and multi spk case
-cp -r template_single_spk
-
-# Move on your recipe
-cd egs//voc1
-
-# Make symlink of data directory (Better to use absolute path)
-mkdir dump data
-ln -s /path/to/espnet/egs2//tts1/dump/raw dump/
-ln -s /path/to/espnet/egs2//tts1/dump/raw/tr_no_dev data/train_nodev
-ln -s /path/to/espnet/egs2//tts1/dump/raw/dev data/dev
-ln -s /path/to/espnet/egs2//tts1/dump/raw/eval1 data/eval
-
-# Edit config to match TTS model setting
-vim conf/parallel_wavegan.v1.yaml
-
-# Run from stage 1
-./run.sh --stage 1 --conf conf/parallel_wavegan.v1.yaml
-```
-
-That's it!
diff --git a/spaces/akhaliq/lama/bin/paper_runfiles/generate_test_paris_256.sh b/spaces/akhaliq/lama/bin/paper_runfiles/generate_test_paris_256.sh
deleted file mode 100644
index 67061298b601ce4e1c37966852421f2153a0d686..0000000000000000000000000000000000000000
--- a/spaces/akhaliq/lama/bin/paper_runfiles/generate_test_paris_256.sh
+++ /dev/null
@@ -1,17 +0,0 @@
-#!/usr/bin/env bash
-
-# paths to data are valid for mml-ws01
-OUT_DIR="/media/inpainting/paper_data/Paris_StreetView_Dataset_val_256"
-
-source "$(dirname $0)/env.sh"
-
-for datadir in paris_eval_gt
-do
- for conf in random_thin_256 random_medium_256 random_thick_256 segm_256
- do
- "$BINDIR/gen_mask_dataset_hydra.py" -cn $conf datadir=$datadir location=mml-ws01-paris \
- location.out_dir=$OUT_DIR cropping.out_square_crop=False cropping.out_min_size=256
-
- "$BINDIR/calc_dataset_stats.py" --samples-n 20 "$OUT_DIR/$datadir/$conf" "$OUT_DIR/$datadir/${conf}_stats"
- done
-done
diff --git a/spaces/alexray/btc_predictor/venv/lib/python3.10/site-packages/pip/_internal/commands/search.py b/spaces/alexray/btc_predictor/venv/lib/python3.10/site-packages/pip/_internal/commands/search.py
deleted file mode 100644
index 03ed925b246dd551ec2ef45095ed6cad00fd2745..0000000000000000000000000000000000000000
--- a/spaces/alexray/btc_predictor/venv/lib/python3.10/site-packages/pip/_internal/commands/search.py
+++ /dev/null
@@ -1,174 +0,0 @@
-import logging
-import shutil
-import sys
-import textwrap
-import xmlrpc.client
-from collections import OrderedDict
-from optparse import Values
-from typing import TYPE_CHECKING, Dict, List, Optional
-
-from pip._vendor.packaging.version import parse as parse_version
-
-from pip._internal.cli.base_command import Command
-from pip._internal.cli.req_command import SessionCommandMixin
-from pip._internal.cli.status_codes import NO_MATCHES_FOUND, SUCCESS
-from pip._internal.exceptions import CommandError
-from pip._internal.metadata import get_default_environment
-from pip._internal.models.index import PyPI
-from pip._internal.network.xmlrpc import PipXmlrpcTransport
-from pip._internal.utils.logging import indent_log
-from pip._internal.utils.misc import write_output
-
-if TYPE_CHECKING:
- from typing import TypedDict
-
- class TransformedHit(TypedDict):
- name: str
- summary: str
- versions: List[str]
-
-
-logger = logging.getLogger(__name__)
-
-
-class SearchCommand(Command, SessionCommandMixin):
- """Search for PyPI packages whose name or summary contains ."""
-
- usage = """
- %prog [options] """
- ignore_require_venv = True
-
- def add_options(self) -> None:
- self.cmd_opts.add_option(
- "-i",
- "--index",
- dest="index",
- metavar="URL",
- default=PyPI.pypi_url,
- help="Base URL of Python Package Index (default %default)",
- )
-
- self.parser.insert_option_group(0, self.cmd_opts)
-
- def run(self, options: Values, args: List[str]) -> int:
- if not args:
- raise CommandError("Missing required argument (search query).")
- query = args
- pypi_hits = self.search(query, options)
- hits = transform_hits(pypi_hits)
-
- terminal_width = None
- if sys.stdout.isatty():
- terminal_width = shutil.get_terminal_size()[0]
-
- print_results(hits, terminal_width=terminal_width)
- if pypi_hits:
- return SUCCESS
- return NO_MATCHES_FOUND
-
- def search(self, query: List[str], options: Values) -> List[Dict[str, str]]:
- index_url = options.index
-
- session = self.get_default_session(options)
-
- transport = PipXmlrpcTransport(index_url, session)
- pypi = xmlrpc.client.ServerProxy(index_url, transport)
- try:
- hits = pypi.search({"name": query, "summary": query}, "or")
- except xmlrpc.client.Fault as fault:
- message = "XMLRPC request failed [code: {code}]\n{string}".format(
- code=fault.faultCode,
- string=fault.faultString,
- )
- raise CommandError(message)
- assert isinstance(hits, list)
- return hits
-
-
-def transform_hits(hits: List[Dict[str, str]]) -> List["TransformedHit"]:
- """
- The list from pypi is really a list of versions. We want a list of
- packages with the list of versions stored inline. This converts the
- list from pypi into one we can use.
- """
- packages: Dict[str, "TransformedHit"] = OrderedDict()
- for hit in hits:
- name = hit["name"]
- summary = hit["summary"]
- version = hit["version"]
-
- if name not in packages.keys():
- packages[name] = {
- "name": name,
- "summary": summary,
- "versions": [version],
- }
- else:
- packages[name]["versions"].append(version)
-
- # if this is the highest version, replace summary and score
- if version == highest_version(packages[name]["versions"]):
- packages[name]["summary"] = summary
-
- return list(packages.values())
-
-
-def print_dist_installation_info(name: str, latest: str) -> None:
- env = get_default_environment()
- dist = env.get_distribution(name)
- if dist is not None:
- with indent_log():
- if dist.version == latest:
- write_output("INSTALLED: %s (latest)", dist.version)
- else:
- write_output("INSTALLED: %s", dist.version)
- if parse_version(latest).pre:
- write_output(
- "LATEST: %s (pre-release; install"
- " with `pip install --pre`)",
- latest,
- )
- else:
- write_output("LATEST: %s", latest)
-
-
-def print_results(
- hits: List["TransformedHit"],
- name_column_width: Optional[int] = None,
- terminal_width: Optional[int] = None,
-) -> None:
- if not hits:
- return
- if name_column_width is None:
- name_column_width = (
- max(
- [
- len(hit["name"]) + len(highest_version(hit.get("versions", ["-"])))
- for hit in hits
- ]
- )
- + 4
- )
-
- for hit in hits:
- name = hit["name"]
- summary = hit["summary"] or ""
- latest = highest_version(hit.get("versions", ["-"]))
- if terminal_width is not None:
- target_width = terminal_width - name_column_width - 5
- if target_width > 10:
- # wrap and indent summary to fit terminal
- summary_lines = textwrap.wrap(summary, target_width)
- summary = ("\n" + " " * (name_column_width + 3)).join(summary_lines)
-
- name_latest = f"{name} ({latest})"
- line = f"{name_latest:{name_column_width}} - {summary}"
- try:
- write_output(line)
- print_dist_installation_info(name, latest)
- except UnicodeEncodeError:
- pass
-
-
-def highest_version(versions: List[str]) -> str:
- return max(versions, key=parse_version)
diff --git a/spaces/alexray/btc_predictor/venv/lib/python3.10/site-packages/pip/_vendor/rich/padding.py b/spaces/alexray/btc_predictor/venv/lib/python3.10/site-packages/pip/_vendor/rich/padding.py
deleted file mode 100644
index 1b2204f59f2ce4d9c8f2cca85326e4d81f8805bb..0000000000000000000000000000000000000000
--- a/spaces/alexray/btc_predictor/venv/lib/python3.10/site-packages/pip/_vendor/rich/padding.py
+++ /dev/null
@@ -1,141 +0,0 @@
-from typing import cast, List, Optional, Tuple, TYPE_CHECKING, Union
-
-if TYPE_CHECKING:
- from .console import (
- Console,
- ConsoleOptions,
- RenderableType,
- RenderResult,
- )
-from .jupyter import JupyterMixin
-from .measure import Measurement
-from .style import Style
-from .segment import Segment
-
-
-PaddingDimensions = Union[int, Tuple[int], Tuple[int, int], Tuple[int, int, int, int]]
-
-
-class Padding(JupyterMixin):
- """Draw space around content.
-
- Example:
- >>> print(Padding("Hello", (2, 4), style="on blue"))
-
- Args:
- renderable (RenderableType): String or other renderable.
- pad (Union[int, Tuple[int]]): Padding for top, right, bottom, and left borders.
- May be specified with 1, 2, or 4 integers (CSS style).
- style (Union[str, Style], optional): Style for padding characters. Defaults to "none".
- expand (bool, optional): Expand padding to fit available width. Defaults to True.
- """
-
- def __init__(
- self,
- renderable: "RenderableType",
- pad: "PaddingDimensions" = (0, 0, 0, 0),
- *,
- style: Union[str, Style] = "none",
- expand: bool = True,
- ):
- self.renderable = renderable
- self.top, self.right, self.bottom, self.left = self.unpack(pad)
- self.style = style
- self.expand = expand
-
- @classmethod
- def indent(cls, renderable: "RenderableType", level: int) -> "Padding":
- """Make padding instance to render an indent.
-
- Args:
- renderable (RenderableType): String or other renderable.
- level (int): Number of characters to indent.
-
- Returns:
- Padding: A Padding instance.
- """
-
- return Padding(renderable, pad=(0, 0, 0, level), expand=False)
-
- @staticmethod
- def unpack(pad: "PaddingDimensions") -> Tuple[int, int, int, int]:
- """Unpack padding specified in CSS style."""
- if isinstance(pad, int):
- return (pad, pad, pad, pad)
- if len(pad) == 1:
- _pad = pad[0]
- return (_pad, _pad, _pad, _pad)
- if len(pad) == 2:
- pad_top, pad_right = cast(Tuple[int, int], pad)
- return (pad_top, pad_right, pad_top, pad_right)
- if len(pad) == 4:
- top, right, bottom, left = cast(Tuple[int, int, int, int], pad)
- return (top, right, bottom, left)
- raise ValueError(f"1, 2 or 4 integers required for padding; {len(pad)} given")
-
- def __repr__(self) -> str:
- return f"Padding({self.renderable!r}, ({self.top},{self.right},{self.bottom},{self.left}))"
-
- def __rich_console__(
- self, console: "Console", options: "ConsoleOptions"
- ) -> "RenderResult":
- style = console.get_style(self.style)
- if self.expand:
- width = options.max_width
- else:
- width = min(
- Measurement.get(console, options, self.renderable).maximum
- + self.left
- + self.right,
- options.max_width,
- )
- render_options = options.update_width(width - self.left - self.right)
- if render_options.height is not None:
- render_options = render_options.update_height(
- height=render_options.height - self.top - self.bottom
- )
- lines = console.render_lines(
- self.renderable, render_options, style=style, pad=True
- )
- _Segment = Segment
-
- left = _Segment(" " * self.left, style) if self.left else None
- right = (
- [_Segment(f'{" " * self.right}', style), _Segment.line()]
- if self.right
- else [_Segment.line()]
- )
- blank_line: Optional[List[Segment]] = None
- if self.top:
- blank_line = [_Segment(f'{" " * width}\n', style)]
- yield from blank_line * self.top
- if left:
- for line in lines:
- yield left
- yield from line
- yield from right
- else:
- for line in lines:
- yield from line
- yield from right
- if self.bottom:
- blank_line = blank_line or [_Segment(f'{" " * width}\n', style)]
- yield from blank_line * self.bottom
-
- def __rich_measure__(
- self, console: "Console", options: "ConsoleOptions"
- ) -> "Measurement":
- max_width = options.max_width
- extra_width = self.left + self.right
- if max_width - extra_width < 1:
- return Measurement(max_width, max_width)
- measure_min, measure_max = Measurement.get(console, options, self.renderable)
- measurement = Measurement(measure_min + extra_width, measure_max + extra_width)
- measurement = measurement.with_maximum(max_width)
- return measurement
-
-
-if __name__ == "__main__": # pragma: no cover
- from pip._vendor.rich import print
-
- print(Padding("Hello, World", (2, 4), style="on blue"))
diff --git a/spaces/amarchheda/ChordDuplicate/portaudio/src/common/pa_converters.h b/spaces/amarchheda/ChordDuplicate/portaudio/src/common/pa_converters.h
deleted file mode 100644
index 96edf1c92cf4cb4e61b50a9d3cbf4a0577ffbeba..0000000000000000000000000000000000000000
--- a/spaces/amarchheda/ChordDuplicate/portaudio/src/common/pa_converters.h
+++ /dev/null
@@ -1,263 +0,0 @@
-#ifndef PA_CONVERTERS_H
-#define PA_CONVERTERS_H
-/*
- * $Id$
- * Portable Audio I/O Library sample conversion mechanism
- *
- * Based on the Open Source API proposed by Ross Bencina
- * Copyright (c) 1999-2002 Phil Burk, Ross Bencina
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files
- * (the "Software"), to deal in the Software without restriction,
- * including without limitation the rights to use, copy, modify, merge,
- * publish, distribute, sublicense, and/or sell copies of the Software,
- * and to permit persons to whom the Software is furnished to do so,
- * subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
- * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
- * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- */
-
-/*
- * The text above constitutes the entire PortAudio license; however,
- * the PortAudio community also makes the following non-binding requests:
- *
- * Any person wishing to distribute modifications to the Software is
- * requested to send the modifications to the original developer so that
- * they can be incorporated into the canonical version. It is also
- * requested that these non-binding requests be included along with the
- * license above.
- */
-
-/** @file
- @ingroup common_src
-
- @brief Conversion functions used to convert buffers of samples from one
- format to another.
-*/
-
-
-#include "portaudio.h" /* for PaSampleFormat */
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif /* __cplusplus */
-
-
-struct PaUtilTriangularDitherGenerator;
-
-
-/** Choose an available sample format which is most appropriate for
- representing the requested format. If the requested format is not available
- higher quality formats are considered before lower quality formats.
- @param availableFormats A variable containing the logical OR of all available
- formats.
- @param format The desired format.
- @return The most appropriate available format for representing the requested
- format.
-*/
-PaSampleFormat PaUtil_SelectClosestAvailableFormat(
- PaSampleFormat availableFormats, PaSampleFormat format );
-
-
-/* high level conversions functions for use by implementations */
-
-
-/** The generic sample converter prototype. Sample converters convert count
- samples from sourceBuffer to destinationBuffer. The actual type of the data
- pointed to by these parameters varys for different converter functions.
- @param destinationBuffer A pointer to the first sample of the destination.
- @param destinationStride An offset between successive destination samples
- expressed in samples (not bytes.) It may be negative.
- @param sourceBuffer A pointer to the first sample of the source.
- @param sourceStride An offset between successive source samples
- expressed in samples (not bytes.) It may be negative.
- @param count The number of samples to convert.
- @param ditherState State information used to calculate dither. Converters
- that do not perform dithering will ignore this parameter, in which case
- NULL or invalid dither state may be passed.
-*/
-typedef void PaUtilConverter(
- void *destinationBuffer, signed int destinationStride,
- void *sourceBuffer, signed int sourceStride,
- unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator );
-
-
-/** Find a sample converter function for the given source and destinations
- formats and flags (clip and dither.)
- @return
- A pointer to a PaUtilConverter which will perform the requested
- conversion, or NULL if the given format conversion is not supported.
- For conversions where clipping or dithering is not necessary, the
- clip and dither flags are ignored and a non-clipping or dithering
- version is returned.
- If the source and destination formats are the same, a function which
- copies data of the appropriate size will be returned.
-*/
-PaUtilConverter* PaUtil_SelectConverter( PaSampleFormat sourceFormat,
- PaSampleFormat destinationFormat, PaStreamFlags flags );
-
-
-/** The generic buffer zeroer prototype. Buffer zeroers copy count zeros to
- destinationBuffer. The actual type of the data pointed to varys for
- different zeroer functions.
- @param destinationBuffer A pointer to the first sample of the destination.
- @param destinationStride An offset between successive destination samples
- expressed in samples (not bytes.) It may be negative.
- @param count The number of samples to zero.
-*/
-typedef void PaUtilZeroer(
- void *destinationBuffer, signed int destinationStride, unsigned int count );
-
-
-/** Find a buffer zeroer function for the given destination format.
- @return
- A pointer to a PaUtilZeroer which will perform the requested
- zeroing.
-*/
-PaUtilZeroer* PaUtil_SelectZeroer( PaSampleFormat destinationFormat );
-
-/*----------------------------------------------------------------------------*/
-/* low level functions and data structures which may be used for
- substituting conversion functions */
-
-
-/** The type used to store all sample conversion functions.
- @see paConverters;
-*/
-typedef struct{
- PaUtilConverter *Float32_To_Int32;
- PaUtilConverter *Float32_To_Int32_Dither;
- PaUtilConverter *Float32_To_Int32_Clip;
- PaUtilConverter *Float32_To_Int32_DitherClip;
-
- PaUtilConverter *Float32_To_Int24;
- PaUtilConverter *Float32_To_Int24_Dither;
- PaUtilConverter *Float32_To_Int24_Clip;
- PaUtilConverter *Float32_To_Int24_DitherClip;
-
- PaUtilConverter *Float32_To_Int16;
- PaUtilConverter *Float32_To_Int16_Dither;
- PaUtilConverter *Float32_To_Int16_Clip;
- PaUtilConverter *Float32_To_Int16_DitherClip;
-
- PaUtilConverter *Float32_To_Int8;
- PaUtilConverter *Float32_To_Int8_Dither;
- PaUtilConverter *Float32_To_Int8_Clip;
- PaUtilConverter *Float32_To_Int8_DitherClip;
-
- PaUtilConverter *Float32_To_UInt8;
- PaUtilConverter *Float32_To_UInt8_Dither;
- PaUtilConverter *Float32_To_UInt8_Clip;
- PaUtilConverter *Float32_To_UInt8_DitherClip;
-
- PaUtilConverter *Int32_To_Float32;
- PaUtilConverter *Int32_To_Int24;
- PaUtilConverter *Int32_To_Int24_Dither;
- PaUtilConverter *Int32_To_Int16;
- PaUtilConverter *Int32_To_Int16_Dither;
- PaUtilConverter *Int32_To_Int8;
- PaUtilConverter *Int32_To_Int8_Dither;
- PaUtilConverter *Int32_To_UInt8;
- PaUtilConverter *Int32_To_UInt8_Dither;
-
- PaUtilConverter *Int24_To_Float32;
- PaUtilConverter *Int24_To_Int32;
- PaUtilConverter *Int24_To_Int16;
- PaUtilConverter *Int24_To_Int16_Dither;
- PaUtilConverter *Int24_To_Int8;
- PaUtilConverter *Int24_To_Int8_Dither;
- PaUtilConverter *Int24_To_UInt8;
- PaUtilConverter *Int24_To_UInt8_Dither;
-
- PaUtilConverter *Int16_To_Float32;
- PaUtilConverter *Int16_To_Int32;
- PaUtilConverter *Int16_To_Int24;
- PaUtilConverter *Int16_To_Int8;
- PaUtilConverter *Int16_To_Int8_Dither;
- PaUtilConverter *Int16_To_UInt8;
- PaUtilConverter *Int16_To_UInt8_Dither;
-
- PaUtilConverter *Int8_To_Float32;
- PaUtilConverter *Int8_To_Int32;
- PaUtilConverter *Int8_To_Int24;
- PaUtilConverter *Int8_To_Int16;
- PaUtilConverter *Int8_To_UInt8;
-
- PaUtilConverter *UInt8_To_Float32;
- PaUtilConverter *UInt8_To_Int32;
- PaUtilConverter *UInt8_To_Int24;
- PaUtilConverter *UInt8_To_Int16;
- PaUtilConverter *UInt8_To_Int8;
-
- PaUtilConverter *Copy_8_To_8; /* copy without any conversion */
- PaUtilConverter *Copy_16_To_16; /* copy without any conversion */
- PaUtilConverter *Copy_24_To_24; /* copy without any conversion */
- PaUtilConverter *Copy_32_To_32; /* copy without any conversion */
-} PaUtilConverterTable;
-
-
-/** A table of pointers to all required converter functions.
- PaUtil_SelectConverter() uses this table to lookup the appropriate
- conversion functions. The fields of this structure are initialized
- with default conversion functions. Fields may be NULL, indicating that
- no conversion function is available. User code may substitute optimised
- conversion functions by assigning different function pointers to
- these fields.
-
- @note
- If the PA_NO_STANDARD_CONVERTERS preprocessor variable is defined,
- PortAudio's standard converters will not be compiled, and all fields
- of this structure will be initialized to NULL. In such cases, users
- should supply their own conversion functions if the require PortAudio
- to open a stream that requires sample conversion.
-
- @see PaUtilConverterTable, PaUtilConverter, PaUtil_SelectConverter
-*/
-extern PaUtilConverterTable paConverters;
-
-
-/** The type used to store all buffer zeroing functions.
- @see paZeroers;
-*/
-typedef struct{
- PaUtilZeroer *ZeroU8; /* unsigned 8 bit, zero == 128 */
- PaUtilZeroer *Zero8;
- PaUtilZeroer *Zero16;
- PaUtilZeroer *Zero24;
- PaUtilZeroer *Zero32;
-} PaUtilZeroerTable;
-
-
-/** A table of pointers to all required zeroer functions.
- PaUtil_SelectZeroer() uses this table to lookup the appropriate
- conversion functions. The fields of this structure are initialized
- with default conversion functions. User code may substitute optimised
- conversion functions by assigning different function pointers to
- these fields.
-
- @note
- If the PA_NO_STANDARD_ZEROERS preprocessor variable is defined,
- PortAudio's standard zeroers will not be compiled, and all fields
- of this structure will be initialized to NULL. In such cases, users
- should supply their own zeroing functions for the sample sizes which
- they intend to use.
-
- @see PaUtilZeroerTable, PaUtilZeroer, PaUtil_SelectZeroer
-*/
-extern PaUtilZeroerTable paZeroers;
-
-#ifdef __cplusplus
-}
-#endif /* __cplusplus */
-#endif /* PA_CONVERTERS_H */
diff --git a/spaces/amarchheda/ChordDuplicate/portaudio/src/common/pa_cpuload.c b/spaces/amarchheda/ChordDuplicate/portaudio/src/common/pa_cpuload.c
deleted file mode 100644
index de57db26ab281e5af9f5d0370cc5dc24bc247ba6..0000000000000000000000000000000000000000
--- a/spaces/amarchheda/ChordDuplicate/portaudio/src/common/pa_cpuload.c
+++ /dev/null
@@ -1,105 +0,0 @@
-/*
- * $Id$
- * Portable Audio I/O Library CPU Load measurement functions
- * Portable CPU load measurement facility.
- *
- * Based on the Open Source API proposed by Ross Bencina
- * Copyright (c) 2002 Ross Bencina
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files
- * (the "Software"), to deal in the Software without restriction,
- * including without limitation the rights to use, copy, modify, merge,
- * publish, distribute, sublicense, and/or sell copies of the Software,
- * and to permit persons to whom the Software is furnished to do so,
- * subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
- * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
- * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- */
-
-/*
- * The text above constitutes the entire PortAudio license; however,
- * the PortAudio community also makes the following non-binding requests:
- *
- * Any person wishing to distribute modifications to the Software is
- * requested to send the modifications to the original developer so that
- * they can be incorporated into the canonical version. It is also
- * requested that these non-binding requests be included along with the
- * license above.
- */
-
-/** @file
- @ingroup common_src
-
- @brief Functions to assist in measuring the CPU utilization of a callback
- stream. Used to implement the Pa_GetStreamCpuLoad() function.
-
- @todo Dynamically calculate the coefficients used to smooth the CPU Load
- Measurements over time to provide a uniform characterisation of CPU Load
- independent of rate at which PaUtil_BeginCpuLoadMeasurement /
- PaUtil_EndCpuLoadMeasurement are called. see http://www.portaudio.com/trac/ticket/113
-*/
-
-
-#include "pa_cpuload.h"
-
-#include
-
-#include "pa_util.h" /* for PaUtil_GetTime() */
-
-
-void PaUtil_InitializeCpuLoadMeasurer( PaUtilCpuLoadMeasurer* measurer, double sampleRate )
-{
- assert( sampleRate > 0 );
-
- measurer->samplingPeriod = 1. / sampleRate;
- measurer->averageLoad = 0.;
-}
-
-void PaUtil_ResetCpuLoadMeasurer( PaUtilCpuLoadMeasurer* measurer )
-{
- measurer->averageLoad = 0.;
-}
-
-void PaUtil_BeginCpuLoadMeasurement( PaUtilCpuLoadMeasurer* measurer )
-{
- measurer->measurementStartTime = PaUtil_GetTime();
-}
-
-
-void PaUtil_EndCpuLoadMeasurement( PaUtilCpuLoadMeasurer* measurer, unsigned long framesProcessed )
-{
- double measurementEndTime, secondsFor100Percent, measuredLoad;
-
- if( framesProcessed > 0 ){
- measurementEndTime = PaUtil_GetTime();
-
- assert( framesProcessed > 0 );
- secondsFor100Percent = framesProcessed * measurer->samplingPeriod;
-
- measuredLoad = (measurementEndTime - measurer->measurementStartTime) / secondsFor100Percent;
-
- /* Low pass filter the calculated CPU load to reduce jitter using a simple IIR low pass filter. */
- /** FIXME @todo these coefficients shouldn't be hardwired see: http://www.portaudio.com/trac/ticket/113 */
-#define LOWPASS_COEFFICIENT_0 (0.9)
-#define LOWPASS_COEFFICIENT_1 (0.99999 - LOWPASS_COEFFICIENT_0)
-
- measurer->averageLoad = (LOWPASS_COEFFICIENT_0 * measurer->averageLoad) +
- (LOWPASS_COEFFICIENT_1 * measuredLoad);
- }
-}
-
-
-double PaUtil_GetCpuLoad( PaUtilCpuLoadMeasurer* measurer )
-{
- return measurer->averageLoad;
-}
diff --git a/spaces/anaclaudia13ct/insect_detection/export.py b/spaces/anaclaudia13ct/insect_detection/export.py
deleted file mode 100644
index 928992903b0b2a0e2a4fb072a4a373b8afddf208..0000000000000000000000000000000000000000
--- a/spaces/anaclaudia13ct/insect_detection/export.py
+++ /dev/null
@@ -1,653 +0,0 @@
-# YOLOv5 🚀 by Ultralytics, GPL-3.0 license
-"""
-Export a YOLOv5 PyTorch model to other formats. TensorFlow exports authored by https://github.com/zldrobit
-
-Format | `export.py --include` | Model
---- | --- | ---
-PyTorch | - | yolov5s.pt
-TorchScript | `torchscript` | yolov5s.torchscript
-ONNX | `onnx` | yolov5s.onnx
-OpenVINO | `openvino` | yolov5s_openvino_model/
-TensorRT | `engine` | yolov5s.engine
-CoreML | `coreml` | yolov5s.mlmodel
-TensorFlow SavedModel | `saved_model` | yolov5s_saved_model/
-TensorFlow GraphDef | `pb` | yolov5s.pb
-TensorFlow Lite | `tflite` | yolov5s.tflite
-TensorFlow Edge TPU | `edgetpu` | yolov5s_edgetpu.tflite
-TensorFlow.js | `tfjs` | yolov5s_web_model/
-PaddlePaddle | `paddle` | yolov5s_paddle_model/
-
-Requirements:
- $ pip install -r requirements.txt coremltools onnx onnx-simplifier onnxruntime openvino-dev tensorflow-cpu # CPU
- $ pip install -r requirements.txt coremltools onnx onnx-simplifier onnxruntime-gpu openvino-dev tensorflow # GPU
-
-Usage:
- $ python export.py --weights yolov5s.pt --include torchscript onnx openvino engine coreml tflite ...
-
-Inference:
- $ python detect.py --weights yolov5s.pt # PyTorch
- yolov5s.torchscript # TorchScript
- yolov5s.onnx # ONNX Runtime or OpenCV DNN with --dnn
- yolov5s_openvino_model # OpenVINO
- yolov5s.engine # TensorRT
- yolov5s.mlmodel # CoreML (macOS-only)
- yolov5s_saved_model # TensorFlow SavedModel
- yolov5s.pb # TensorFlow GraphDef
- yolov5s.tflite # TensorFlow Lite
- yolov5s_edgetpu.tflite # TensorFlow Edge TPU
- yolov5s_paddle_model # PaddlePaddle
-
-TensorFlow.js:
- $ cd .. && git clone https://github.com/zldrobit/tfjs-yolov5-example.git && cd tfjs-yolov5-example
- $ npm install
- $ ln -s ../../yolov5/yolov5s_web_model public/yolov5s_web_model
- $ npm start
-"""
-
-import argparse
-import contextlib
-import json
-import os
-import platform
-import re
-import subprocess
-import sys
-import time
-import warnings
-from pathlib import Path
-
-import pandas as pd
-import torch
-from torch.utils.mobile_optimizer import optimize_for_mobile
-
-FILE = Path(__file__).resolve()
-ROOT = FILE.parents[0] # YOLOv5 root directory
-if str(ROOT) not in sys.path:
- sys.path.append(str(ROOT)) # add ROOT to PATH
-if platform.system() != 'Windows':
- ROOT = Path(os.path.relpath(ROOT, Path.cwd())) # relative
-
-from models.experimental import attempt_load
-from models.yolo import ClassificationModel, Detect, DetectionModel, SegmentationModel
-from utils.dataloaders import LoadImages
-from utils.general import (LOGGER, Profile, check_dataset, check_img_size, check_requirements, check_version,
- check_yaml, colorstr, file_size, get_default_args, print_args, url2file, yaml_save)
-from utils.torch_utils import select_device, smart_inference_mode
-
-MACOS = platform.system() == 'Darwin' # macOS environment
-
-
-def export_formats():
- # YOLOv5 export formats
- x = [
- ['PyTorch', '-', '.pt', True, True],
- ['TorchScript', 'torchscript', '.torchscript', True, True],
- ['ONNX', 'onnx', '.onnx', True, True],
- ['OpenVINO', 'openvino', '_openvino_model', True, False],
- ['TensorRT', 'engine', '.engine', False, True],
- ['CoreML', 'coreml', '.mlmodel', True, False],
- ['TensorFlow SavedModel', 'saved_model', '_saved_model', True, True],
- ['TensorFlow GraphDef', 'pb', '.pb', True, True],
- ['TensorFlow Lite', 'tflite', '.tflite', True, False],
- ['TensorFlow Edge TPU', 'edgetpu', '_edgetpu.tflite', False, False],
- ['TensorFlow.js', 'tfjs', '_web_model', False, False],
- ['PaddlePaddle', 'paddle', '_paddle_model', True, True],]
- return pd.DataFrame(x, columns=['Format', 'Argument', 'Suffix', 'CPU', 'GPU'])
-
-
-def try_export(inner_func):
- # YOLOv5 export decorator, i..e @try_export
- inner_args = get_default_args(inner_func)
-
- def outer_func(*args, **kwargs):
- prefix = inner_args['prefix']
- try:
- with Profile() as dt:
- f, model = inner_func(*args, **kwargs)
- LOGGER.info(f'{prefix} export success ✅ {dt.t:.1f}s, saved as {f} ({file_size(f):.1f} MB)')
- return f, model
- except Exception as e:
- LOGGER.info(f'{prefix} export failure ❌ {dt.t:.1f}s: {e}')
- return None, None
-
- return outer_func
-
-
-@try_export
-def export_torchscript(model, im, file, optimize, prefix=colorstr('TorchScript:')):
- # YOLOv5 TorchScript model export
- LOGGER.info(f'\n{prefix} starting export with torch {torch.__version__}...')
- f = file.with_suffix('.torchscript')
-
- ts = torch.jit.trace(model, im, strict=False)
- d = {"shape": im.shape, "stride": int(max(model.stride)), "names": model.names}
- extra_files = {'config.txt': json.dumps(d)} # torch._C.ExtraFilesMap()
- if optimize: # https://pytorch.org/tutorials/recipes/mobile_interpreter.html
- optimize_for_mobile(ts)._save_for_lite_interpreter(str(f), _extra_files=extra_files)
- else:
- ts.save(str(f), _extra_files=extra_files)
- return f, None
-
-
-@try_export
-def export_onnx(model, im, file, opset, dynamic, simplify, prefix=colorstr('ONNX:')):
- # YOLOv5 ONNX export
- check_requirements('onnx')
- import onnx
-
- LOGGER.info(f'\n{prefix} starting export with onnx {onnx.__version__}...')
- f = file.with_suffix('.onnx')
-
- output_names = ['output0', 'output1'] if isinstance(model, SegmentationModel) else ['output0']
- if dynamic:
- dynamic = {'images': {0: 'batch', 2: 'height', 3: 'width'}} # shape(1,3,640,640)
- if isinstance(model, SegmentationModel):
- dynamic['output0'] = {0: 'batch', 1: 'anchors'} # shape(1,25200,85)
- dynamic['output1'] = {0: 'batch', 2: 'mask_height', 3: 'mask_width'} # shape(1,32,160,160)
- elif isinstance(model, DetectionModel):
- dynamic['output0'] = {0: 'batch', 1: 'anchors'} # shape(1,25200,85)
-
- torch.onnx.export(
- model.cpu() if dynamic else model, # --dynamic only compatible with cpu
- im.cpu() if dynamic else im,
- f,
- verbose=False,
- opset_version=opset,
- do_constant_folding=True, # WARNING: DNN inference with torch>=1.12 may require do_constant_folding=False
- input_names=['images'],
- output_names=output_names,
- dynamic_axes=dynamic or None)
-
- # Checks
- model_onnx = onnx.load(f) # load onnx model
- onnx.checker.check_model(model_onnx) # check onnx model
-
- # Metadata
- d = {'stride': int(max(model.stride)), 'names': model.names}
- for k, v in d.items():
- meta = model_onnx.metadata_props.add()
- meta.key, meta.value = k, str(v)
- onnx.save(model_onnx, f)
-
- # Simplify
- if simplify:
- try:
- cuda = torch.cuda.is_available()
- check_requirements(('onnxruntime-gpu' if cuda else 'onnxruntime', 'onnx-simplifier>=0.4.1'))
- import onnxsim
-
- LOGGER.info(f'{prefix} simplifying with onnx-simplifier {onnxsim.__version__}...')
- model_onnx, check = onnxsim.simplify(model_onnx)
- assert check, 'assert check failed'
- onnx.save(model_onnx, f)
- except Exception as e:
- LOGGER.info(f'{prefix} simplifier failure: {e}')
- return f, model_onnx
-
-
-@try_export
-def export_openvino(file, metadata, half, prefix=colorstr('OpenVINO:')):
- # YOLOv5 OpenVINO export
- check_requirements('openvino-dev') # requires openvino-dev: https://pypi.org/project/openvino-dev/
- import openvino.inference_engine as ie
-
- LOGGER.info(f'\n{prefix} starting export with openvino {ie.__version__}...')
- f = str(file).replace('.pt', f'_openvino_model{os.sep}')
-
- cmd = f"mo --input_model {file.with_suffix('.onnx')} --output_dir {f} --data_type {'FP16' if half else 'FP32'}"
- subprocess.run(cmd.split(), check=True, env=os.environ) # export
- yaml_save(Path(f) / file.with_suffix('.yaml').name, metadata) # add metadata.yaml
- return f, None
-
-
-@try_export
-def export_paddle(model, im, file, metadata, prefix=colorstr('PaddlePaddle:')):
- # YOLOv5 Paddle export
- check_requirements(('paddlepaddle', 'x2paddle'))
- import x2paddle
- from x2paddle.convert import pytorch2paddle
-
- LOGGER.info(f'\n{prefix} starting export with X2Paddle {x2paddle.__version__}...')
- f = str(file).replace('.pt', f'_paddle_model{os.sep}')
-
- pytorch2paddle(module=model, save_dir=f, jit_type='trace', input_examples=[im]) # export
- yaml_save(Path(f) / file.with_suffix('.yaml').name, metadata) # add metadata.yaml
- return f, None
-
-
-@try_export
-def export_coreml(model, im, file, int8, half, prefix=colorstr('CoreML:')):
- # YOLOv5 CoreML export
- check_requirements('coremltools')
- import coremltools as ct
-
- LOGGER.info(f'\n{prefix} starting export with coremltools {ct.__version__}...')
- f = file.with_suffix('.mlmodel')
-
- ts = torch.jit.trace(model, im, strict=False) # TorchScript model
- ct_model = ct.convert(ts, inputs=[ct.ImageType('image', shape=im.shape, scale=1 / 255, bias=[0, 0, 0])])
- bits, mode = (8, 'kmeans_lut') if int8 else (16, 'linear') if half else (32, None)
- if bits < 32:
- if MACOS: # quantization only supported on macOS
- with warnings.catch_warnings():
- warnings.filterwarnings("ignore", category=DeprecationWarning) # suppress numpy==1.20 float warning
- ct_model = ct.models.neural_network.quantization_utils.quantize_weights(ct_model, bits, mode)
- else:
- print(f'{prefix} quantization only supported on macOS, skipping...')
- ct_model.save(f)
- return f, ct_model
-
-
-@try_export
-def export_engine(model, im, file, half, dynamic, simplify, workspace=4, verbose=False, prefix=colorstr('TensorRT:')):
- # YOLOv5 TensorRT export https://developer.nvidia.com/tensorrt
- assert im.device.type != 'cpu', 'export running on CPU but must be on GPU, i.e. `python export.py --device 0`'
- try:
- import tensorrt as trt
- except Exception:
- if platform.system() == 'Linux':
- check_requirements('nvidia-tensorrt', cmds='-U --index-url https://pypi.ngc.nvidia.com')
- import tensorrt as trt
-
- if trt.__version__[0] == '7': # TensorRT 7 handling https://github.com/ultralytics/yolov5/issues/6012
- grid = model.model[-1].anchor_grid
- model.model[-1].anchor_grid = [a[..., :1, :1, :] for a in grid]
- export_onnx(model, im, file, 12, dynamic, simplify) # opset 12
- model.model[-1].anchor_grid = grid
- else: # TensorRT >= 8
- check_version(trt.__version__, '8.0.0', hard=True) # require tensorrt>=8.0.0
- export_onnx(model, im, file, 12, dynamic, simplify) # opset 12
- onnx = file.with_suffix('.onnx')
-
- LOGGER.info(f'\n{prefix} starting export with TensorRT {trt.__version__}...')
- assert onnx.exists(), f'failed to export ONNX file: {onnx}'
- f = file.with_suffix('.engine') # TensorRT engine file
- logger = trt.Logger(trt.Logger.INFO)
- if verbose:
- logger.min_severity = trt.Logger.Severity.VERBOSE
-
- builder = trt.Builder(logger)
- config = builder.create_builder_config()
- config.max_workspace_size = workspace * 1 << 30
- # config.set_memory_pool_limit(trt.MemoryPoolType.WORKSPACE, workspace << 30) # fix TRT 8.4 deprecation notice
-
- flag = (1 << int(trt.NetworkDefinitionCreationFlag.EXPLICIT_BATCH))
- network = builder.create_network(flag)
- parser = trt.OnnxParser(network, logger)
- if not parser.parse_from_file(str(onnx)):
- raise RuntimeError(f'failed to load ONNX file: {onnx}')
-
- inputs = [network.get_input(i) for i in range(network.num_inputs)]
- outputs = [network.get_output(i) for i in range(network.num_outputs)]
- for inp in inputs:
- LOGGER.info(f'{prefix} input "{inp.name}" with shape{inp.shape} {inp.dtype}')
- for out in outputs:
- LOGGER.info(f'{prefix} output "{out.name}" with shape{out.shape} {out.dtype}')
-
- if dynamic:
- if im.shape[0] <= 1:
- LOGGER.warning(f"{prefix} WARNING ⚠️ --dynamic model requires maximum --batch-size argument")
- profile = builder.create_optimization_profile()
- for inp in inputs:
- profile.set_shape(inp.name, (1, *im.shape[1:]), (max(1, im.shape[0] // 2), *im.shape[1:]), im.shape)
- config.add_optimization_profile(profile)
-
- LOGGER.info(f'{prefix} building FP{16 if builder.platform_has_fast_fp16 and half else 32} engine as {f}')
- if builder.platform_has_fast_fp16 and half:
- config.set_flag(trt.BuilderFlag.FP16)
- with builder.build_engine(network, config) as engine, open(f, 'wb') as t:
- t.write(engine.serialize())
- return f, None
-
-
-@try_export
-def export_saved_model(model,
- im,
- file,
- dynamic,
- tf_nms=False,
- agnostic_nms=False,
- topk_per_class=100,
- topk_all=100,
- iou_thres=0.45,
- conf_thres=0.25,
- keras=False,
- prefix=colorstr('TensorFlow SavedModel:')):
- # YOLOv5 TensorFlow SavedModel export
- try:
- import tensorflow as tf
- except Exception:
- check_requirements(f"tensorflow{'' if torch.cuda.is_available() else '-macos' if MACOS else '-cpu'}")
- import tensorflow as tf
- from tensorflow.python.framework.convert_to_constants import convert_variables_to_constants_v2
-
- from models.tf import TFModel
-
- LOGGER.info(f'\n{prefix} starting export with tensorflow {tf.__version__}...')
- f = str(file).replace('.pt', '_saved_model')
- batch_size, ch, *imgsz = list(im.shape) # BCHW
-
- tf_model = TFModel(cfg=model.yaml, model=model, nc=model.nc, imgsz=imgsz)
- im = tf.zeros((batch_size, *imgsz, ch)) # BHWC order for TensorFlow
- _ = tf_model.predict(im, tf_nms, agnostic_nms, topk_per_class, topk_all, iou_thres, conf_thres)
- inputs = tf.keras.Input(shape=(*imgsz, ch), batch_size=None if dynamic else batch_size)
- outputs = tf_model.predict(inputs, tf_nms, agnostic_nms, topk_per_class, topk_all, iou_thres, conf_thres)
- keras_model = tf.keras.Model(inputs=inputs, outputs=outputs)
- keras_model.trainable = False
- keras_model.summary()
- if keras:
- keras_model.save(f, save_format='tf')
- else:
- spec = tf.TensorSpec(keras_model.inputs[0].shape, keras_model.inputs[0].dtype)
- m = tf.function(lambda x: keras_model(x)) # full model
- m = m.get_concrete_function(spec)
- frozen_func = convert_variables_to_constants_v2(m)
- tfm = tf.Module()
- tfm.__call__ = tf.function(lambda x: frozen_func(x)[:4] if tf_nms else frozen_func(x), [spec])
- tfm.__call__(im)
- tf.saved_model.save(tfm,
- f,
- options=tf.saved_model.SaveOptions(experimental_custom_gradients=False) if check_version(
- tf.__version__, '2.6') else tf.saved_model.SaveOptions())
- return f, keras_model
-
-
-@try_export
-def export_pb(keras_model, file, prefix=colorstr('TensorFlow GraphDef:')):
- # YOLOv5 TensorFlow GraphDef *.pb export https://github.com/leimao/Frozen_Graph_TensorFlow
- import tensorflow as tf
- from tensorflow.python.framework.convert_to_constants import convert_variables_to_constants_v2
-
- LOGGER.info(f'\n{prefix} starting export with tensorflow {tf.__version__}...')
- f = file.with_suffix('.pb')
-
- m = tf.function(lambda x: keras_model(x)) # full model
- m = m.get_concrete_function(tf.TensorSpec(keras_model.inputs[0].shape, keras_model.inputs[0].dtype))
- frozen_func = convert_variables_to_constants_v2(m)
- frozen_func.graph.as_graph_def()
- tf.io.write_graph(graph_or_graph_def=frozen_func.graph, logdir=str(f.parent), name=f.name, as_text=False)
- return f, None
-
-
-@try_export
-def export_tflite(keras_model, im, file, int8, data, nms, agnostic_nms, prefix=colorstr('TensorFlow Lite:')):
- # YOLOv5 TensorFlow Lite export
- import tensorflow as tf
-
- LOGGER.info(f'\n{prefix} starting export with tensorflow {tf.__version__}...')
- batch_size, ch, *imgsz = list(im.shape) # BCHW
- f = str(file).replace('.pt', '-fp16.tflite')
-
- converter = tf.lite.TFLiteConverter.from_keras_model(keras_model)
- converter.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS]
- converter.target_spec.supported_types = [tf.float16]
- converter.optimizations = [tf.lite.Optimize.DEFAULT]
- if int8:
- from models.tf import representative_dataset_gen
- dataset = LoadImages(check_dataset(check_yaml(data))['train'], img_size=imgsz, auto=False)
- converter.representative_dataset = lambda: representative_dataset_gen(dataset, ncalib=100)
- converter.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS_INT8]
- converter.target_spec.supported_types = []
- converter.inference_input_type = tf.uint8 # or tf.int8
- converter.inference_output_type = tf.uint8 # or tf.int8
- converter.experimental_new_quantizer = True
- f = str(file).replace('.pt', '-int8.tflite')
- if nms or agnostic_nms:
- converter.target_spec.supported_ops.append(tf.lite.OpsSet.SELECT_TF_OPS)
-
- tflite_model = converter.convert()
- open(f, "wb").write(tflite_model)
- return f, None
-
-
-@try_export
-def export_edgetpu(file, prefix=colorstr('Edge TPU:')):
- # YOLOv5 Edge TPU export https://coral.ai/docs/edgetpu/models-intro/
- cmd = 'edgetpu_compiler --version'
- help_url = 'https://coral.ai/docs/edgetpu/compiler/'
- assert platform.system() == 'Linux', f'export only supported on Linux. See {help_url}'
- if subprocess.run(f'{cmd} >/dev/null', shell=True).returncode != 0:
- LOGGER.info(f'\n{prefix} export requires Edge TPU compiler. Attempting install from {help_url}')
- sudo = subprocess.run('sudo --version >/dev/null', shell=True).returncode == 0 # sudo installed on system
- for c in (
- 'curl https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add -',
- 'echo "deb https://packages.cloud.google.com/apt coral-edgetpu-stable main" | sudo tee /etc/apt/sources.list.d/coral-edgetpu.list',
- 'sudo apt-get update', 'sudo apt-get install edgetpu-compiler'):
- subprocess.run(c if sudo else c.replace('sudo ', ''), shell=True, check=True)
- ver = subprocess.run(cmd, shell=True, capture_output=True, check=True).stdout.decode().split()[-1]
-
- LOGGER.info(f'\n{prefix} starting export with Edge TPU compiler {ver}...')
- f = str(file).replace('.pt', '-int8_edgetpu.tflite') # Edge TPU model
- f_tfl = str(file).replace('.pt', '-int8.tflite') # TFLite model
-
- cmd = f"edgetpu_compiler -s -d -k 10 --out_dir {file.parent} {f_tfl}"
- subprocess.run(cmd.split(), check=True)
- return f, None
-
-
-@try_export
-def export_tfjs(file, prefix=colorstr('TensorFlow.js:')):
- # YOLOv5 TensorFlow.js export
- check_requirements('tensorflowjs')
- import tensorflowjs as tfjs
-
- LOGGER.info(f'\n{prefix} starting export with tensorflowjs {tfjs.__version__}...')
- f = str(file).replace('.pt', '_web_model') # js dir
- f_pb = file.with_suffix('.pb') # *.pb path
- f_json = f'{f}/model.json' # *.json path
-
- cmd = f'tensorflowjs_converter --input_format=tf_frozen_model ' \
- f'--output_node_names=Identity,Identity_1,Identity_2,Identity_3 {f_pb} {f}'
- subprocess.run(cmd.split())
-
- json = Path(f_json).read_text()
- with open(f_json, 'w') as j: # sort JSON Identity_* in ascending order
- subst = re.sub(
- r'{"outputs": {"Identity.?.?": {"name": "Identity.?.?"}, '
- r'"Identity.?.?": {"name": "Identity.?.?"}, '
- r'"Identity.?.?": {"name": "Identity.?.?"}, '
- r'"Identity.?.?": {"name": "Identity.?.?"}}}', r'{"outputs": {"Identity": {"name": "Identity"}, '
- r'"Identity_1": {"name": "Identity_1"}, '
- r'"Identity_2": {"name": "Identity_2"}, '
- r'"Identity_3": {"name": "Identity_3"}}}', json)
- j.write(subst)
- return f, None
-
-
-def add_tflite_metadata(file, metadata, num_outputs):
- # Add metadata to *.tflite models per https://www.tensorflow.org/lite/models/convert/metadata
- with contextlib.suppress(ImportError):
- # check_requirements('tflite_support')
- from tflite_support import flatbuffers
- from tflite_support import metadata as _metadata
- from tflite_support import metadata_schema_py_generated as _metadata_fb
-
- tmp_file = Path('/tmp/meta.txt')
- with open(tmp_file, 'w') as meta_f:
- meta_f.write(str(metadata))
-
- model_meta = _metadata_fb.ModelMetadataT()
- label_file = _metadata_fb.AssociatedFileT()
- label_file.name = tmp_file.name
- model_meta.associatedFiles = [label_file]
-
- subgraph = _metadata_fb.SubGraphMetadataT()
- subgraph.inputTensorMetadata = [_metadata_fb.TensorMetadataT()]
- subgraph.outputTensorMetadata = [_metadata_fb.TensorMetadataT()] * num_outputs
- model_meta.subgraphMetadata = [subgraph]
-
- b = flatbuffers.Builder(0)
- b.Finish(model_meta.Pack(b), _metadata.MetadataPopulator.METADATA_FILE_IDENTIFIER)
- metadata_buf = b.Output()
-
- populator = _metadata.MetadataPopulator.with_model_file(file)
- populator.load_metadata_buffer(metadata_buf)
- populator.load_associated_files([str(tmp_file)])
- populator.populate()
- tmp_file.unlink()
-
-
-@smart_inference_mode()
-def run(
- data=ROOT / 'data/coco128.yaml', # 'dataset.yaml path'
- weights=ROOT / 'yolov5s.pt', # weights path
- imgsz=(640, 640), # image (height, width)
- batch_size=1, # batch size
- device='cpu', # cuda device, i.e. 0 or 0,1,2,3 or cpu
- include=('torchscript', 'onnx'), # include formats
- half=False, # FP16 half-precision export
- inplace=False, # set YOLOv5 Detect() inplace=True
- keras=False, # use Keras
- optimize=False, # TorchScript: optimize for mobile
- int8=False, # CoreML/TF INT8 quantization
- dynamic=False, # ONNX/TF/TensorRT: dynamic axes
- simplify=False, # ONNX: simplify model
- opset=12, # ONNX: opset version
- verbose=False, # TensorRT: verbose log
- workspace=4, # TensorRT: workspace size (GB)
- nms=False, # TF: add NMS to model
- agnostic_nms=False, # TF: add agnostic NMS to model
- topk_per_class=100, # TF.js NMS: topk per class to keep
- topk_all=100, # TF.js NMS: topk for all classes to keep
- iou_thres=0.45, # TF.js NMS: IoU threshold
- conf_thres=0.25, # TF.js NMS: confidence threshold
-):
- t = time.time()
- include = [x.lower() for x in include] # to lowercase
- fmts = tuple(export_formats()['Argument'][1:]) # --include arguments
- flags = [x in include for x in fmts]
- assert sum(flags) == len(include), f'ERROR: Invalid --include {include}, valid --include arguments are {fmts}'
- jit, onnx, xml, engine, coreml, saved_model, pb, tflite, edgetpu, tfjs, paddle = flags # export booleans
- file = Path(url2file(weights) if str(weights).startswith(('http:/', 'https:/')) else weights) # PyTorch weights
-
- # Load PyTorch model
- device = select_device(device)
- if half:
- assert device.type != 'cpu' or coreml, '--half only compatible with GPU export, i.e. use --device 0'
- assert not dynamic, '--half not compatible with --dynamic, i.e. use either --half or --dynamic but not both'
- model = attempt_load(weights, device=device, inplace=True, fuse=True) # load FP32 model
-
- # Checks
- imgsz *= 2 if len(imgsz) == 1 else 1 # expand
- if optimize:
- assert device.type == 'cpu', '--optimize not compatible with cuda devices, i.e. use --device cpu'
-
- # Input
- gs = int(max(model.stride)) # grid size (max stride)
- imgsz = [check_img_size(x, gs) for x in imgsz] # verify img_size are gs-multiples
- im = torch.zeros(batch_size, 3, *imgsz).to(device) # image size(1,3,320,192) BCHW iDetection
-
- # Update model
- model.eval()
- for k, m in model.named_modules():
- if isinstance(m, Detect):
- m.inplace = inplace
- m.dynamic = dynamic
- m.export = True
-
- for _ in range(2):
- y = model(im) # dry runs
- if half and not coreml:
- im, model = im.half(), model.half() # to FP16
- shape = tuple((y[0] if isinstance(y, tuple) else y).shape) # model output shape
- metadata = {'stride': int(max(model.stride)), 'names': model.names} # model metadata
- LOGGER.info(f"\n{colorstr('PyTorch:')} starting from {file} with output shape {shape} ({file_size(file):.1f} MB)")
-
- # Exports
- f = [''] * len(fmts) # exported filenames
- warnings.filterwarnings(action='ignore', category=torch.jit.TracerWarning) # suppress TracerWarning
- if jit: # TorchScript
- f[0], _ = export_torchscript(model, im, file, optimize)
- if engine: # TensorRT required before ONNX
- f[1], _ = export_engine(model, im, file, half, dynamic, simplify, workspace, verbose)
- if onnx or xml: # OpenVINO requires ONNX
- f[2], _ = export_onnx(model, im, file, opset, dynamic, simplify)
- if xml: # OpenVINO
- f[3], _ = export_openvino(file, metadata, half)
- if coreml: # CoreML
- f[4], _ = export_coreml(model, im, file, int8, half)
- if any((saved_model, pb, tflite, edgetpu, tfjs)): # TensorFlow formats
- assert not tflite or not tfjs, 'TFLite and TF.js models must be exported separately, please pass only one type.'
- assert not isinstance(model, ClassificationModel), 'ClassificationModel export to TF formats not yet supported.'
- f[5], s_model = export_saved_model(model.cpu(),
- im,
- file,
- dynamic,
- tf_nms=nms or agnostic_nms or tfjs,
- agnostic_nms=agnostic_nms or tfjs,
- topk_per_class=topk_per_class,
- topk_all=topk_all,
- iou_thres=iou_thres,
- conf_thres=conf_thres,
- keras=keras)
- if pb or tfjs: # pb prerequisite to tfjs
- f[6], _ = export_pb(s_model, file)
- if tflite or edgetpu:
- f[7], _ = export_tflite(s_model, im, file, int8 or edgetpu, data=data, nms=nms, agnostic_nms=agnostic_nms)
- if edgetpu:
- f[8], _ = export_edgetpu(file)
- add_tflite_metadata(f[8] or f[7], metadata, num_outputs=len(s_model.outputs))
- if tfjs:
- f[9], _ = export_tfjs(file)
- if paddle: # PaddlePaddle
- f[10], _ = export_paddle(model, im, file, metadata)
-
- # Finish
- f = [str(x) for x in f if x] # filter out '' and None
- if any(f):
- cls, det, seg = (isinstance(model, x) for x in (ClassificationModel, DetectionModel, SegmentationModel)) # type
- det &= not seg # segmentation models inherit from SegmentationModel(DetectionModel)
- dir = Path('segment' if seg else 'classify' if cls else '')
- h = '--half' if half else '' # --half FP16 inference arg
- s = "# WARNING ⚠️ ClassificationModel not yet supported for PyTorch Hub AutoShape inference" if cls else \
- "# WARNING ⚠️ SegmentationModel not yet supported for PyTorch Hub AutoShape inference" if seg else ''
- LOGGER.info(f'\nExport complete ({time.time() - t:.1f}s)'
- f"\nResults saved to {colorstr('bold', file.parent.resolve())}"
- f"\nDetect: python {dir / ('detect.py' if det else 'predict.py')} --weights {f[-1]} {h}"
- f"\nValidate: python {dir / 'val.py'} --weights {f[-1]} {h}"
- f"\nPyTorch Hub: model = torch.hub.load('ultralytics/yolov5', 'custom', '{f[-1]}') {s}"
- f"\nVisualize: https://netron.app")
- return f # return list of exported files/dirs
-
-
-def parse_opt():
- parser = argparse.ArgumentParser()
- parser.add_argument('--data', type=str, default=ROOT / 'data/coco128.yaml', help='dataset.yaml path')
- parser.add_argument('--weights', nargs='+', type=str, default=ROOT / 'yolov5s.pt', help='model.pt path(s)')
- parser.add_argument('--imgsz', '--img', '--img-size', nargs='+', type=int, default=[640, 640], help='image (h, w)')
- parser.add_argument('--batch-size', type=int, default=1, help='batch size')
- parser.add_argument('--device', default='cpu', help='cuda device, i.e. 0 or 0,1,2,3 or cpu')
- parser.add_argument('--half', action='store_true', help='FP16 half-precision export')
- parser.add_argument('--inplace', action='store_true', help='set YOLOv5 Detect() inplace=True')
- parser.add_argument('--keras', action='store_true', help='TF: use Keras')
- parser.add_argument('--optimize', action='store_true', help='TorchScript: optimize for mobile')
- parser.add_argument('--int8', action='store_true', help='CoreML/TF INT8 quantization')
- parser.add_argument('--dynamic', action='store_true', help='ONNX/TF/TensorRT: dynamic axes')
- parser.add_argument('--simplify', action='store_true', help='ONNX: simplify model')
- parser.add_argument('--opset', type=int, default=12, help='ONNX: opset version')
- parser.add_argument('--verbose', action='store_true', help='TensorRT: verbose log')
- parser.add_argument('--workspace', type=int, default=4, help='TensorRT: workspace size (GB)')
- parser.add_argument('--nms', action='store_true', help='TF: add NMS to model')
- parser.add_argument('--agnostic-nms', action='store_true', help='TF: add agnostic NMS to model')
- parser.add_argument('--topk-per-class', type=int, default=100, help='TF.js NMS: topk per class to keep')
- parser.add_argument('--topk-all', type=int, default=100, help='TF.js NMS: topk for all classes to keep')
- parser.add_argument('--iou-thres', type=float, default=0.45, help='TF.js NMS: IoU threshold')
- parser.add_argument('--conf-thres', type=float, default=0.25, help='TF.js NMS: confidence threshold')
- parser.add_argument(
- '--include',
- nargs='+',
- default=['torchscript'],
- help='torchscript, onnx, openvino, engine, coreml, saved_model, pb, tflite, edgetpu, tfjs, paddle')
- opt = parser.parse_args()
- print_args(vars(opt))
- return opt
-
-
-def main(opt):
- for opt.weights in (opt.weights if isinstance(opt.weights, list) else [opt.weights]):
- run(**vars(opt))
-
-
-if __name__ == "__main__":
- opt = parse_opt()
- main(opt)
diff --git a/spaces/aphenx/bingo/src/components/chat-header.tsx b/spaces/aphenx/bingo/src/components/chat-header.tsx
deleted file mode 100644
index c6664b8dee61179f844d45c5bd650518fc2cb4c2..0000000000000000000000000000000000000000
--- a/spaces/aphenx/bingo/src/components/chat-header.tsx
+++ /dev/null
@@ -1,12 +0,0 @@
-import LogoIcon from '@/assets/images/logo.svg'
-import Image from 'next/image'
-
-export function ChatHeader() {
- return (
-
-
- 欢迎使用新必应
- 由 AI 支持的网页版 Copilot
-
-
- {children}
-
-
-)
-DialogPortal.displayName = DialogPrimitive.Portal.displayName
-
-const DialogOverlay = React.forwardRef<
- React.ElementRef,
- React.ComponentPropsWithoutRef
->(({ className, ...props }, ref) => (
- ,
- React.ComponentPropsWithoutRef
->(({ className, children, ...props }, ref) => (
-
-
- {children}
-
- Close
-
-
-
-))
-DialogContent.displayName = DialogPrimitive.Content.displayName
-
-const DialogHeader = ({
- className,
- ...props
-}: React.HTMLAttributes) => (
-
-)
-DialogHeader.displayName = 'DialogHeader'
-
-const DialogFooter = ({
- className,
- ...props
-}: React.HTMLAttributes) => (
-
-)
-DialogFooter.displayName = 'DialogFooter'
-
-const DialogTitle = React.forwardRef<
- React.ElementRef,
- React.ComponentPropsWithoutRef
->(({ className, ...props }, ref) => (
- ,
- React.ComponentPropsWithoutRef
->(({ className, ...props }, ref) => (
- THREE).OrbitControls(camera);
-const ambientLight = new THREE.AmbientLight(0xffffff, 1);
-scene.add(ambientLight);
-const renderer = new THREE.WebGLRenderer({ antialias: true });
-renderer.setPixelRatio(window.devicePixelRatio);
-renderer.setSize(window.innerWidth, window.innerHeight);
-document.body.appendChild(renderer.domElement);
-const stats = new Stats();
-document.body.appendChild(stats.dom);
-/// Anim mixer
-const mixers: THREE.AnimationMixer[] = [];
-
-class Assets {
- private static loadEggMtl(): Promise {
- return new Promise((resolve, reject) => {
- const loader: THREE.AnyLoader = new (THREE).MTLLoader();
- loader.load(
- `models/Egg_from_Poly_uovo/Egg from Poly uovo.mtl`,
- (materials) => {
- materials.preload();
- resolve(materials);
- },
- (xhr) => {},
- reject
- );
- });
- }
- private static loadEggObj(materials: THREE.Material[]): Promise {
- return new Promise((resolve, reject) => {
- const loader: THREE.AnyLoader = new (THREE).OBJLoader();
- (loader).setMaterials(materials);
- loader.load(
- `models/Egg_from_Poly_uovo/Egg from Poly uovo.obj`,
- (object: THREE.Object3D) => {
- resolve(object);
- },
- (xhr) => {
- // c.log(`${ xhr.loaded / xhr.total * 100 }% loaded`);
- },
- (error) => {
- c.error(error);
- reject(error);
- }
- );
- });
- }
- static async loadEgg(): Promise {
- const materialCreator = await this.loadEggMtl();
- return this.loadEggObj(materialCreator);
- }
- static loadEggGltf(): Promise {
- return new Promise((resolve, reject) => {
- const loader: THREE.AnyLoader = new (THREE).GLTFLoader();
- loader.load(
- `models/Egg_gltf/Egg from Poly uovo copy.gltf`,
- (gltf) => {
- c.log(gltf);
- resolve(gltf.scene);
- }
- );
- });
- }
- static loadDogDae(): Promise<{
- animations: THREE.AnimationClip[];
- scene: THREE.Group;
- }> {
- /// In Dae/Collada: did not manage to get
- /// either the anims or the texture.
- return new Promise((resolve, reject) => {
- const loader: THREE.AnyLoader = new (THREE).ColladaLoader();
- loader.load(
- `models/dog/pup_lohound.dae`,
- (collada) => {
- resolve(collada);
- }
- );
- });
- }
- static loadDogFbx(): Promise {
- return new Promise((resolve, reject) => {
- const loader: THREE.AnyLoader = new (THREE).FBXLoader();
- loader.load(
- `models/dog_fbx/puppy-snapchat.fbx`,
- (fbx) => {
- resolve(fbx);
- }
- );
- });
- }
- static loadBoloss(): Promise<{
- animations: THREE.AnimationClip[];
- scene: THREE.Group;
- }> {
- return new Promise((resolve, reject) => {
- const loader: THREE.AnyLoader = new (THREE).ColladaLoader();
- loader.load(
- `models/boloss/Boloss-3d v10.dae`,
- (collada) => {
- resolve(collada);
- }
- );
- });
- }
-}
-class TUtils {
- static boundingBox(o: THREE.Object3D): THREE.Box3 {
- const bbox = new THREE.Box3().setFromObject(o);
- return bbox;
- }
- static flushYZero(o: THREE.Object3D) {
- o.position.y = -(this.boundingBox(o)).min.y;
- }
- static perform(tween: TWEEN.Tween): Promise {
- return new Promise(resolve => {
- tween.onComplete(resolve).start();
- });
- }
-}
-(async () => {
- /**
- * scene construction
- */
- const gridHelper = new THREE.GridHelper(100, 100);
- scene.add(gridHelper);
- const axesHelper = new THREE.AxesHelper(50);
- scene.add(axesHelper);
-
-
- {
- const egg = await Assets.loadEgg();
- c.log(egg);
- egg.scale.setScalar(.2);
- egg.rotateX(-Math.PI / 2);
- egg.position.x = -18;
- TUtils.flushYZero(egg);
- const box = new THREE.BoxHelper(egg);
- scene.add(box);
- scene.add(egg);
- ///// Manually set the material, for fun.
- // const eggFace = egg.getObjectByName("CallKit-IconMask") as THREE.Mesh;
- // c.log(eggFace.material);
- // ((eggFace.material)).color.set(0x000000);
- }
- {
- const egg = await Assets.loadEggGltf();
- c.log(egg);
- egg.scale.setScalar(100);
- egg.position.x = -28;
- TUtils.flushYZero(egg);
- egg.remove(egg.getObjectByName('Camera')!);
- scene.add(egg);
- // c.log(Utils.boundingBox(egg));
- const box = new THREE.BoxHelper(egg, new THREE.Color('red'));
- scene.add(box);
- }
- {
- ////// dog_fbx
- const dog = await Assets.loadDogFbx();
- // c.log((dog).animations);
- const mixer = new THREE.AnimationMixer(dog);
- const clip: THREE.AnimationClip = (dog).animations.find(clip => clip.name === "lohound|lohoundAction");
- /// ^^ this is the main parent animation! Do not play all children.
- c.log(clip);
- mixer.clipAction(clip).play();
- mixers.push(mixer);
- const container = new THREE.Group();
- container.add(dog);
- container.scale.setScalar(0.007); /// <- scale a container, not the dog itself or it'll fuck the anims.
- container.position.x = -6;
- scene.add(container);
- const box = new THREE.BoxHelper(container, new THREE.Color('green'));
- scene.add(box);
- }
- {
- const boloss = (await Assets.loadBoloss()).scene;
- c.log(boloss);
- boloss.position.x = 16;
- TUtils.flushYZero(boloss);
- scene.add(boloss);
- const box = new THREE.BoxHelper(boloss, new THREE.Color('blue'));
- scene.add(box);
- /// Anims like in AudioBoloss
- const rootModel = boloss.getObjectByName(`SketchUp`)!;
- const pupilL = boloss.getObjectByName(`Pupil-left`)!;
- const pupilR = boloss.getObjectByName(`Pupil-right`)!;
- const pupils = new THREE.Group();
- pupils.add(pupilL, pupilR);
- rootModel.add(pupils);
- (async () => {
- while (true) {
- const translatePupil = new TWEEN.Tween(pupils.position)
- .to({ x: "-1", y: "-1" }, 200)
- .easing(TWEEN.Easing.Quadratic.Out)
- ;
- const translatePupilRev = new TWEEN.Tween(pupils.position)
- .to({ x: "+1", y: "+1" }, 200)
- .easing(TWEEN.Easing.Quadratic.Out)
- ;
- await TUtils.perform(translatePupil);
- await Utils.wait(4, 1);
- await TUtils.perform(translatePupilRev);
- await Utils.wait(8, 3);
- }
- })();
- const eyebrowL = boloss.getObjectByName(`Eyebrow-left`)!;
- const eyebrowR = boloss.getObjectByName(`Eyebrow-right`)!;
- const eyebrows = new THREE.Group();
- eyebrows.add(eyebrowL, eyebrowR);
- rootModel.add(eyebrows);
- (async () => {
- while (true) {
- const scaleEyebrow = new TWEEN.Tween(eyebrows.scale)
- .to({ x: 1.08, y: 1.08, z: 1.08 }, 100)
- .easing(TWEEN.Easing.Quadratic.InOut)
- ;
- const scaleEyebrowRev = new TWEEN.Tween(eyebrows.scale)
- .to({ x: 1, y: 1, z: 1 }, 100)
- .easing(TWEEN.Easing.Quadratic.InOut)
- ;
- await Utils.wait(6, 6);
- await TUtils.perform(scaleEyebrow);
- await TUtils.perform(scaleEyebrowRev);
- await Utils.wait(0.14);
- await TUtils.perform(scaleEyebrow);
- await TUtils.perform(scaleEyebrowRev);
- }
- })();
- (async () => {
- while (true) {
- const angle = Utils.randomFloat(-0.2, 0.3);
- const dummyL = new THREE.Object3D();
- dummyL.rotateOnAxis(new THREE.Vector3(0, 1, 0.8), angle);
- const dummyR = new THREE.Object3D();
- dummyR.rotateOnAxis(new THREE.Vector3(0, -1, -0.8), angle);
- /// ^^ exact same result as keeping the same vector and negating the angle.
- const rotateBrowL = new TWEEN.Tween(eyebrowL.rotation)
- .to({
- x: dummyL.rotation.x,
- y: dummyL.rotation.y,
- z: dummyL.rotation.z,
- }, 300)
- ;
- const rotateBrowR = new TWEEN.Tween(eyebrowR.rotation)
- .to({
- x: dummyR.rotation.x,
- y: dummyR.rotation.y,
- z: dummyR.rotation.z,
- }, 300)
- ;
- await Promise.all([
- TUtils.perform(rotateBrowL),
- TUtils.perform(rotateBrowR),
- ]);
- await Utils.wait(1, 1);
- await Promise.all([
- TUtils.perform(
- new TWEEN.Tween(eyebrowL.rotation).to({ x: 0, y: 0, z: 0 }, 300)
- ),
- TUtils.perform(
- new TWEEN.Tween(eyebrowR.rotation).to({ x: 0, y: 0, z: 0 }, 300)
- ),
- ]);
- await Utils.wait(1, 1);
- /// ^^ not the exact same behavior as in AudioBoloss (all waits are actually randoms there.)
- }
- })();
- }
-
-})();
-
-/**
- * MAIN()
- */
-window.addEventListener('resize', onWindowResize, false);
-function onWindowResize() {
- camera.aspect = window.innerWidth / window.innerHeight;
- camera.updateProjectionMatrix();
- renderer.setSize(window.innerWidth, window.innerHeight);
-}
-function render() {
- const delta = clock.getDelta();
- for (const mixer of mixers) {
- mixer.update(delta);
- }
- renderer.render(scene, camera);
-}
-function animate() {
- requestAnimationFrame(animate);
- TWEEN.update();
- render();
- stats.update();
-}
-animate();
-
diff --git a/spaces/bhkkhjgkk/Voice/app.py b/spaces/bhkkhjgkk/Voice/app.py
deleted file mode 100644
index 462e7a42271c8702e25fc26a963623542d19f581..0000000000000000000000000000000000000000
--- a/spaces/bhkkhjgkk/Voice/app.py
+++ /dev/null
@@ -1,166 +0,0 @@
-from turtle import title
-import gradio as gr
-
-import git
-import os
-# os.system('pip install git')
-os.system('git clone https://github.com/Edresson/Coqui-TTS -b multilingual-torchaudio-SE TTS')
-os.system('pip install -q -e TTS/')
-os.system('pip install -q torchaudio==0.9.0')
-
-import sys
-TTS_PATH = "TTS/"
-
-# add libraries into environment
-sys.path.append(TTS_PATH) # set this if TTS is not installed globally
-
-import os
-import string
-import time
-import argparse
-import json
-
-import numpy as np
-import IPython
-from IPython.display import Audio
-
-
-import torch
-
-from TTS.tts.utils.synthesis import synthesis
-from TTS.tts.utils.text.symbols import make_symbols, phonemes, symbols
-try:
- from TTS.utils.audio import AudioProcessor
-except:
- from TTS.utils.audio import AudioProcessor
-
-
-from TTS.tts.models import setup_model
-from TTS.config import load_config
-from TTS.tts.models.vits import *
-
-OUT_PATH = 'out/'
-
-# create output path
-os.makedirs(OUT_PATH, exist_ok=True)
-
-# model vars
-MODEL_PATH = '/home/user/app/best_model_latest.pth.tar'
-CONFIG_PATH = '/home/user/app/config.json'
-TTS_LANGUAGES = "/home/user/app/language_ids.json"
-TTS_SPEAKERS = "/home/user/app/speakers.json"
-USE_CUDA = torch.cuda.is_available()
-
-# load the config
-C = load_config(CONFIG_PATH)
-
-
-# load the audio processor
-ap = AudioProcessor(**C.audio)
-
-speaker_embedding = None
-
-C.model_args['d_vector_file'] = TTS_SPEAKERS
-C.model_args['use_speaker_encoder_as_loss'] = False
-
-model = setup_model(C)
-model.language_manager.set_language_ids_from_file(TTS_LANGUAGES)
-# print(model.language_manager.num_languages, model.embedded_language_dim)
-# print(model.emb_l)
-cp = torch.load(MODEL_PATH, map_location=torch.device('cpu'))
-# remove speaker encoder
-model_weights = cp['model'].copy()
-for key in list(model_weights.keys()):
- if "speaker_encoder" in key:
- del model_weights[key]
-
-model.load_state_dict(model_weights)
-
-
-model.eval()
-
-if USE_CUDA:
- model = model.cuda()
-
-# synthesize voice
-use_griffin_lim = False
-
-os.system('pip install -q pydub ffmpeg-normalize')
-
-CONFIG_SE_PATH = "config_se.json"
-CHECKPOINT_SE_PATH = "SE_checkpoint.pth.tar"
-
-from TTS.tts.utils.speakers import SpeakerManager
-from pydub import AudioSegment
-import librosa
-
-SE_speaker_manager = SpeakerManager(encoder_model_path=CHECKPOINT_SE_PATH, encoder_config_path=CONFIG_SE_PATH, use_cuda=USE_CUDA)
-
-def compute_spec(ref_file):
- y, sr = librosa.load(ref_file, sr=ap.sample_rate)
- spec = ap.spectrogram(y)
- spec = torch.FloatTensor(spec).unsqueeze(0)
- return spec
-
-
-
-def greet(Text,Voicetoclone,VoiceMicrophone):
- text= "%s" % (Text)
- if Voicetoclone is not None:
- reference_files= "%s" % (Voicetoclone)
- print("path url")
- print(Voicetoclone)
- sample= str(Voicetoclone)
- else:
- reference_files= "%s" % (VoiceMicrophone)
- print("path url")
- print(VoiceMicrophone)
- sample= str(VoiceMicrophone)
- size= len(reference_files)*sys.getsizeof(reference_files)
- size2= size / 1000000
- if (size2 > 0.012) or len(text)>2000:
- message="File is greater than 30mb or Text inserted is longer than 2000 characters. Please re-try with smaller sizes."
- print(message)
- raise SystemExit("File is greater than 30mb. Please re-try or Text inserted is longer than 2000 characters. Please re-try with smaller sizes.")
- else:
- os.system('ffmpeg-normalize $sample -nt rms -t=-27 -o $sample -ar 16000 -f')
- reference_emb = SE_speaker_manager.compute_d_vector_from_clip(reference_files)
- model.length_scale = 1 # scaler for the duration predictor. The larger it is, the slower the speech.
- model.inference_noise_scale = 0.3 # defines the noise variance applied to the random z vector at inference.
- model.inference_noise_scale_dp = 0.3 # defines the noise variance applied to the duration predictor z vector at inference.
- text = text
- model.language_manager.language_id_mapping
- language_id = 0
-
- print(" > text: {}".format(text))
- wav, alignment, _, _ = synthesis(
- model,
- text,
- C,
- "cuda" in str(next(model.parameters()).device),
- ap,
- speaker_id=None,
- d_vector=reference_emb,
- style_wav=None,
- language_id=language_id,
- enable_eos_bos_chars=C.enable_eos_bos_chars,
- use_griffin_lim=True,
- do_trim_silence=False,
- ).values()
- print("Generated Audio")
- IPython.display.display(Audio(wav, rate=ap.sample_rate))
- #file_name = text.replace(" ", "_")
- #file_name = file_name.translate(str.maketrans('', '', string.punctuation.replace('_', ''))) + '.wav'
- file_name="Audio.wav"
- out_path = os.path.join(OUT_PATH, file_name)
- print(" > Saving output to {}".format(out_path))
- ap.save_wav(wav, out_path)
- return out_path
-
-demo = gr.Interface(
- fn=greet,
- inputs=[gr.inputs.Textbox(label='What would you like the voice to say? (max. 2000 characters per request)'),gr.Audio(type="filepath",source="upload",label='Please upload a voice to clone (max. 30mb)'),gr.Audio(source="microphone", type="filepath", streaming=True)],
- outputs="audio",
- title="Cloning Interface"
- )
-demo.launch()
\ No newline at end of file
diff --git a/spaces/bigjoker/stable-diffusion-webui/javascript/ui.js b/spaces/bigjoker/stable-diffusion-webui/javascript/ui.js
deleted file mode 100644
index b7a8268a8fcdf9821cb3af31efea9e0283da1bfe..0000000000000000000000000000000000000000
--- a/spaces/bigjoker/stable-diffusion-webui/javascript/ui.js
+++ /dev/null
@@ -1,338 +0,0 @@
-// various functions for interaction with ui.py not large enough to warrant putting them in separate files
-
-function set_theme(theme){
- gradioURL = window.location.href
- if (!gradioURL.includes('?__theme=')) {
- window.location.replace(gradioURL + '?__theme=' + theme);
- }
-}
-
-function selected_gallery_index(){
- var buttons = gradioApp().querySelectorAll('[style="display: block;"].tabitem div[id$=_gallery] .gallery-item')
- var button = gradioApp().querySelector('[style="display: block;"].tabitem div[id$=_gallery] .gallery-item.\\!ring-2')
-
- var result = -1
- buttons.forEach(function(v, i){ if(v==button) { result = i } })
-
- return result
-}
-
-function extract_image_from_gallery(gallery){
- if(gallery.length == 1){
- return [gallery[0]]
- }
-
- index = selected_gallery_index()
-
- if (index < 0 || index >= gallery.length){
- return [null]
- }
-
- return [gallery[index]];
-}
-
-function args_to_array(args){
- res = []
- for(var i=0;i label > textarea");
-
- if(counter.parentElement == prompt.parentElement){
- return
- }
-
- prompt.parentElement.insertBefore(counter, prompt)
- counter.classList.add("token-counter")
- prompt.parentElement.style.position = "relative"
-
- promptTokecountUpdateFuncs[id] = function(){ update_token_counter(id_button); }
- textarea.addEventListener("input", promptTokecountUpdateFuncs[id]);
- }
-
- registerTextarea('txt2img_prompt', 'txt2img_token_counter', 'txt2img_token_button')
- registerTextarea('txt2img_neg_prompt', 'txt2img_negative_token_counter', 'txt2img_negative_token_button')
- registerTextarea('img2img_prompt', 'img2img_token_counter', 'img2img_token_button')
- registerTextarea('img2img_neg_prompt', 'img2img_negative_token_counter', 'img2img_negative_token_button')
-
- show_all_pages = gradioApp().getElementById('settings_show_all_pages')
- settings_tabs = gradioApp().querySelector('#settings div')
- if(show_all_pages && settings_tabs){
- settings_tabs.appendChild(show_all_pages)
- show_all_pages.onclick = function(){
- gradioApp().querySelectorAll('#settings > div').forEach(function(elem){
- elem.style.display = "block";
- })
- }
- }
-})
-
-onOptionsChanged(function(){
- elem = gradioApp().getElementById('sd_checkpoint_hash')
- sd_checkpoint_hash = opts.sd_checkpoint_hash || ""
- shorthash = sd_checkpoint_hash.substr(0,10)
-
- if(elem && elem.textContent != shorthash){
- elem.textContent = shorthash
- elem.title = sd_checkpoint_hash
- elem.href = "https://google.com/search?q=" + sd_checkpoint_hash
- }
-})
-
-let txt2img_textarea, img2img_textarea = undefined;
-let wait_time = 800
-let token_timeouts = {};
-
-function update_txt2img_tokens(...args) {
- update_token_counter("txt2img_token_button")
- if (args.length == 2)
- return args[0]
- return args;
-}
-
-function update_img2img_tokens(...args) {
- update_token_counter("img2img_token_button")
- if (args.length == 2)
- return args[0]
- return args;
-}
-
-function update_token_counter(button_id) {
- if (token_timeouts[button_id])
- clearTimeout(token_timeouts[button_id]);
- token_timeouts[button_id] = setTimeout(() => gradioApp().getElementById(button_id)?.click(), wait_time);
-}
-
-function restart_reload(){
- document.body.innerHTML='Reloading... ';
- setTimeout(function(){location.reload()},2000)
-
- return []
-}
-
-// Simulate an `input` DOM event for Gradio Textbox component. Needed after you edit its contents in javascript, otherwise your edits
-// will only visible on web page and not sent to python.
-function updateInput(target){
- let e = new Event("input", { bubbles: true })
- Object.defineProperty(e, "target", {value: target})
- target.dispatchEvent(e);
-}
-
-
-var desiredCheckpointName = null;
-function selectCheckpoint(name){
- desiredCheckpointName = name;
- gradioApp().getElementById('change_checkpoint').click()
-}
diff --git a/spaces/binarycache/voice_to_image/Makefile b/spaces/binarycache/voice_to_image/Makefile
deleted file mode 100644
index 9e75a07104b1452e482d9b151e00fb30965b56e9..0000000000000000000000000000000000000000
--- a/spaces/binarycache/voice_to_image/Makefile
+++ /dev/null
@@ -1,27 +0,0 @@
-install:
- python.exe -m pip install --upgrade pip &&\
- pip install -r requirements.txt
-
-test:
- python -m pytest -vvv --cov=hello --cov=greeting \
- --cov=smath --cov=web tests
- python -m pytest --nbval notebook.ipynb #tests our jupyter notebook
- #python -m pytest -v tests/test_web.py #if you just want to test web
-
-debug:
- python -m pytest -vv --pdb #Debugger is invoked
-
-one-test:
- python -m pytest -vv tests/test_greeting.py::test_my_name4
-
-debugthree:
- #not working the way I expect
- python -m pytest -vv --pdb --maxfail=4 # drop to PDB for first three failures
-
-format:
- black *.py
-
-lint:
- pylint --disable=R,C *.py
-
-all: install lint test format
\ No newline at end of file
diff --git a/spaces/bingbing520/ChatGPT/modules/presets.py b/spaces/bingbing520/ChatGPT/modules/presets.py
deleted file mode 100644
index c941ff940016efa3c4f30b540aefe7ab03fbda7a..0000000000000000000000000000000000000000
--- a/spaces/bingbing520/ChatGPT/modules/presets.py
+++ /dev/null
@@ -1,222 +0,0 @@
-# -*- coding:utf-8 -*-
-import os
-from pathlib import Path
-import gradio as gr
-from .webui_locale import I18nAuto
-
-i18n = I18nAuto() # internationalization
-
-CHATGLM_MODEL = None
-CHATGLM_TOKENIZER = None
-LLAMA_MODEL = None
-LLAMA_INFERENCER = None
-
-# ChatGPT 设置
-INITIAL_SYSTEM_PROMPT = "You are a helpful assistant."
-API_HOST = "api.openai.com"
-COMPLETION_URL = "https://api.openai.com/v1/chat/completions"
-BALANCE_API_URL="https://api.openai.com/dashboard/billing/credit_grants"
-USAGE_API_URL="https://api.openai.com/dashboard/billing/usage"
-HISTORY_DIR = Path("history")
-HISTORY_DIR = "history"
-TEMPLATES_DIR = "templates"
-
-# 错误信息
-STANDARD_ERROR_MSG = i18n("☹️发生了错误：") # 错误信息的标准前缀
-GENERAL_ERROR_MSG = i18n("获取对话时发生错误，请查看后台日志")
-ERROR_RETRIEVE_MSG = i18n("请检查网络连接，或者API-Key是否有效。")
-CONNECTION_TIMEOUT_MSG = i18n("连接超时，无法获取对话。") # 连接超时
-READ_TIMEOUT_MSG = i18n("读取超时，无法获取对话。") # 读取超时
-PROXY_ERROR_MSG = i18n("代理错误，无法获取对话。") # 代理错误
-SSL_ERROR_PROMPT = i18n("SSL错误，无法获取对话。") # SSL 错误
-NO_APIKEY_MSG = i18n("API key为空，请检查是否输入正确。") # API key 长度不足 51 位
-NO_INPUT_MSG = i18n("请输入对话内容。") # 未输入对话内容
-BILLING_NOT_APPLICABLE_MSG = i18n("账单信息不适用") # 本地运行的模型返回的账单信息
-
-TIMEOUT_STREAMING = 60 # 流式对话时的超时时间
-TIMEOUT_ALL = 200 # 非流式对话时的超时时间
-ENABLE_STREAMING_OPTION = True # 是否启用选择选择是否实时显示回答的勾选框
-HIDE_MY_KEY = False # 如果你想在UI中隐藏你的 API 密钥，将此值设置为 True
-CONCURRENT_COUNT = 100 # 允许同时使用的用户数量
-
-SIM_K = 5
-INDEX_QUERY_TEMPRATURE = 1.0
-
-CHUANHU_TITLE = i18n("BingChat 🚀")
-
-CHUANHU_DESCRIPTION = i18n("")
-
-FOOTER = """{versions}
"""
-
-APPEARANCE_SWITCHER = """
-
-
"""+ i18n("切换亮暗色主题") + """
-
-
-
-
Free Download Mchillipepper Gta San Andreas Samp C carnet baiser medici Download File ⚹ https://urloso.com/2uyPNx
diff --git a/spaces/bioriAsaeru/text-to-voice/How to Use Autodesk ImageModeler 2009 SP1 build for Photorealistic Reconstruction.md b/spaces/bioriAsaeru/text-to-voice/How to Use Autodesk ImageModeler 2009 SP1 build for Photorealistic Reconstruction.md
deleted file mode 100644
index 25092b6bd2c642b4ff25430c91a5bf742a6dd149..0000000000000000000000000000000000000000
--- a/spaces/bioriAsaeru/text-to-voice/How to Use Autodesk ImageModeler 2009 SP1 build for Photorealistic Reconstruction.md
+++ /dev/null
@@ -1,7 +0,0 @@
-Autocad 2017 running on all supported operating systems and languages.service pack to the.autodesk revit 2017 service pack 1. Obtained from improvements included in.service pack to the following autodesk products running on all.the program automates most of the stages of the.users can now use interactive 3d cad vivotek camera models directly in their building plans and. Autodesk imagemodeler.note.autocad 2017 sp1 32 bit exekb.autodesk stitcher unlimited 2009 build 61.autodesk imagemodeler 2009 sp1 x86 build autodesk imagemodeler 2009 software generates 3d models from 2d digital images, giving architects, designers, and.consult the enhancements documentation for areas improved by this update. This.autodesk 3ds max design 2015 service pack 1 and security fix. Please verify.build 61.autodesk builds software that helps people imagine, design, and create a better world.this service pack.
-Autodesk ImageModeler 2009 SP1 build Download File > https://urloso.com/2uyPhN
Can be applied to autocad 2017 installed as a standalone.sign up, it unlocks. Autodesk.imagemodeler.2009.sp1.x86.build. nope.rar.look at most relevant autodesk imagemodeler 2009 sp1 build x86 websites out of 15 at keyoptimize. Autodesk imagemodeler 2009 sp1 build. 2017.you can apply this update release to autodesk revit 2017 running on all.free shipping on qualified orders.download realviz imagemodeler build or any other.autodesk inventor 2017 build 142. Windows 7 sp1 64 bit: windows update is in the control panel, which is accessible from the start menu.autodesk imagemodeler 2009 sp1 build torrent download locations. Jekyll.and.hyde 1s, bairavaa tamil movies s, the water horse tamil 0s,.we would like to show you a description here but the site wont allow us.autodesk stitcher unlimited 2009.
-.on demand webinar: the presentation lifecyclehow to create,.autodesk imagemodeler 2009 image based modeling software is not available as a stand alone product.autocad 2017 service pack 1. Autodesk autocad with advance steel.general. The sp1build 196 installs on autodesk inventor.autocad 2017 service pack 1. Download. You can apply this update to.this update release addresses issues reported to autodesk against autodesk revit 2017.imagemodeler is available with some autodesk products with.this readme contains the latest information regarding the installation and use of this service pack.autodesk imagemodeler 2009 sp1 32bit.update required revit state to apply update release date update build versio.software per progettazione 3d, ingegneria e intrattenimento.look at most relevant autodesk imagemodeler 2009 sp1 x86 build websites out of 34.1 thousand at keyoptimize. Autodesk imagemodeler 2009 sp1 x86 build .
aaccfb2cb3"+ "user" + "\n" + message['content'] + "\n")
- elif message['role'] == "assistant":
- final_prompt += (""+ "assistant" + "\n" + message['content'] + "\n")
- else:
- final_prompt += (""+ "system" + "\n" + message['content'] + "\n")
- final_prompt = tprompt + final_prompt
- final_prompt = final_prompt + "assistant"
- data["prompt"] = final_prompt
- data['stop'] = data.get('stop', [""])
- data['max_tokens'] = data.get('max_tokens', max(get_max_context_length(LLM) - count_tokens(LLM_encoding, final_prompt), 1))
- return data
-
-def send_request(data):
- global HEADER
- openaikey = data.pop("openaikey")
- if use_completion:
- data = convert_chat_to_completion(data)
- if openaikey and openaikey.startswith("sk-"):
- HEADER = {
- "Authorization": f"Bearer {openaikey}"
- }
-
- response = requests.post(endpoint, json=data, headers=HEADER, proxies=PROXY)
- logger.debug(response.text.strip())
- if "choices" not in response.json():
- return response.json()
- if use_completion:
- return response.json()["choices"][0]["text"].strip()
- else:
- return response.json()["choices"][0]["message"]["content"].strip()
-
-def replace_slot(text, entries):
- for key, value in entries.items():
- if not isinstance(value, str):
- value = str(value)
- text = text.replace("{{" + key +"}}", value.replace('"', "'").replace('\n', ""))
- return text
-
-def find_json(s):
- s = s.replace("\'", "\"")
- start = s.find("{")
- end = s.rfind("}")
- res = s[start:end+1]
- res = res.replace("\n", "")
- return res
-
-def field_extract(s, field):
- try:
- field_rep = re.compile(f'{field}.*?:.*?"(.*?)"', re.IGNORECASE)
- extracted = field_rep.search(s).group(1).replace("\"", "\'")
- except:
- field_rep = re.compile(f'{field}:\ *"(.*?)"', re.IGNORECASE)
- extracted = field_rep.search(s).group(1).replace("\"", "\'")
- return extracted
-
-def get_id_reason(choose_str):
- reason = field_extract(choose_str, "reason")
- id = field_extract(choose_str, "id")
- choose = {"id": id, "reason": reason}
- return id.strip(), reason.strip(), choose
-
-def record_case(success, **args):
- if success:
- f = open("logs/log_success.jsonl", "a")
- else:
- f = open("logs/log_fail.jsonl", "a")
- log = args
- f.write(json.dumps(log) + "\n")
- f.close()
-
-def image_to_bytes(img_url):
- img_byte = io.BytesIO()
- type = img_url.split(".")[-1]
- load_image(img_url).save(img_byte, format="png")
- img_data = img_byte.getvalue()
- return img_data
-
-def resource_has_dep(command):
- args = command["args"]
- for _, v in args.items():
- if "" in v:
- return True
- return False
-
-def fix_dep(tasks):
- for task in tasks:
- args = task["args"]
- task["dep"] = []
- for k, v in args.items():
- if "" in v:
- dep_task_id = int(v.split("-")[1])
- if dep_task_id not in task["dep"]:
- task["dep"].append(dep_task_id)
- if len(task["dep"]) == 0:
- task["dep"] = [-1]
- return tasks
-
-def unfold(tasks):
- flag_unfold_task = False
- try:
- for task in tasks:
- for key, value in task["args"].items():
- if "" in value:
- generated_items = value.split(",")
- if len(generated_items) > 1:
- flag_unfold_task = True
- for item in generated_items:
- new_task = copy.deepcopy(task)
- dep_task_id = int(item.split("-")[1])
- new_task["dep"] = [dep_task_id]
- new_task["args"][key] = item
- tasks.append(new_task)
- tasks.remove(task)
- except Exception as e:
- print(e)
- traceback.print_exc()
- logger.debug("unfold task failed.")
-
- if flag_unfold_task:
- logger.debug(f"unfold tasks: {tasks}")
-
- return tasks
-
-def chitchat(messages, openaikey=None):
- data = {
- "model": LLM,
- "messages": messages,
- "openaikey": openaikey
- }
- return send_request(data)
-
-def parse_task(context, input, openaikey=None):
- demos_or_presteps = parse_task_demos_or_presteps
- messages = json.loads(demos_or_presteps)
- messages.insert(0, {"role": "system", "content": parse_task_tprompt})
-
- # cut chat logs
- start = 0
- while start <= len(context):
- history = context[start:]
- prompt = replace_slot(parse_task_prompt, {
- "input": input,
- "context": history
- })
- messages.append({"role": "user", "content": prompt})
- history_text = "\nuser".join([m["content"] for m in messages])
- num = count_tokens(LLM_encoding, history_text)
- if get_max_context_length(LLM) - num > 800:
- break
- messages.pop()
- start += 2
-
- logger.debug(messages)
- data = {
- "model": LLM,
- "messages": messages,
- "temperature": 0,
- "logit_bias": {item: config["logit_bias"]["parse_task"] for item in task_parsing_highlight_ids},
- "openaikey": openaikey
- }
- return send_request(data)
-
-def choose_model(input, task, metas, openaikey = None):
- prompt = replace_slot(choose_model_prompt, {
- "input": input,
- "task": task,
- "metas": metas,
- })
- demos_or_presteps = replace_slot(choose_model_demos_or_presteps, {
- "input": input,
- "task": task,
- "metas": metas
- })
- messages = json.loads(demos_or_presteps)
- messages.insert(0, {"role": "system", "content": choose_model_tprompt})
- messages.append({"role": "user", "content": prompt})
- logger.debug(messages)
- data = {
- "model": LLM,
- "messages": messages,
- "temperature": 0,
- "logit_bias": {item: config["logit_bias"]["choose_model"] for item in choose_model_highlight_ids}, # 5
- "openaikey": openaikey
- }
- return send_request(data)
-
-
-def response_results(input, results, openaikey=None):
- results = [v for k, v in sorted(results.items(), key=lambda item: item[0])]
- prompt = replace_slot(response_results_prompt, {
- "input": input,
- })
- demos_or_presteps = replace_slot(response_results_demos_or_presteps, {
- "input": input,
- "processes": results
- })
- messages = json.loads(demos_or_presteps)
- messages.insert(0, {"role": "system", "content": response_results_tprompt})
- messages.append({"role": "user", "content": prompt})
- logger.debug(messages)
- data = {
- "model": LLM,
- "messages": messages,
- "temperature": 0,
- "openaikey": openaikey
- }
- return send_request(data)
-
-def huggingface_model_inference(model_id, data, task, huggingfacetoken=None):
- if huggingfacetoken is None:
- HUGGINGFACE_HEADERS = {}
- else:
- HUGGINGFACE_HEADERS = {
- "Authorization": f"Bearer {huggingfacetoken}",
- }
- task_url = f"https://api-inference.huggingface.co/models/{model_id}" # InferenceApi does not yet support some tasks
- inference = InferenceApi(repo_id=model_id, token=huggingfacetoken)
-
- # NLP tasks
- if task == "question-answering":
- inputs = {"question": data["text"], "context": (data["context"] if "context" in data else "" )}
- result = inference(inputs)
- if task == "sentence-similarity":
- inputs = {"source_sentence": data["text1"], "target_sentence": data["text2"]}
- result = inference(inputs)
- if task in ["text-classification", "token-classification", "text2text-generation", "summarization", "translation", "conversational", "text-generation"]:
- inputs = data["text"]
- result = inference(inputs)
-
- # CV tasks
- if task == "visual-question-answering" or task == "document-question-answering":
- img_url = data["image"]
- text = data["text"]
- img_data = image_to_bytes(img_url)
- img_base64 = base64.b64encode(img_data).decode("utf-8")
- json_data = {}
- json_data["inputs"] = {}
- json_data["inputs"]["question"] = text
- json_data["inputs"]["image"] = img_base64
- result = requests.post(task_url, headers=HUGGINGFACE_HEADERS, json=json_data).json()
- # result = inference(inputs) # not support
-
- if task == "image-to-image":
- img_url = data["image"]
- img_data = image_to_bytes(img_url)
- # result = inference(data=img_data) # not support
- HUGGINGFACE_HEADERS["Content-Length"] = str(len(img_data))
- r = requests.post(task_url, headers=HUGGINGFACE_HEADERS, data=img_data)
- result = r.json()
- if "path" in result:
- result["generated image"] = result.pop("path")
-
- if task == "text-to-image":
- inputs = data["text"]
- img = inference(inputs)
- name = str(uuid.uuid4())[:4]
- img.save(f"public/images/{name}.png")
- result = {}
- result["generated image"] = f"/images/{name}.png"
-
- if task == "image-segmentation":
- img_url = data["image"]
- img_data = image_to_bytes(img_url)
- image = Image.open(BytesIO(img_data))
- predicted = inference(data=img_data)
- colors = []
- for i in range(len(predicted)):
- colors.append((random.randint(100, 255), random.randint(100, 255), random.randint(100, 255), 155))
- for i, pred in enumerate(predicted):
- label = pred["label"]
- mask = pred.pop("mask").encode("utf-8")
- mask = base64.b64decode(mask)
- mask = Image.open(BytesIO(mask), mode='r')
- mask = mask.convert('L')
-
- layer = Image.new('RGBA', mask.size, colors[i])
- image.paste(layer, (0, 0), mask)
- name = str(uuid.uuid4())[:4]
- image.save(f"public/images/{name}.jpg")
- result = {}
- result["generated image with segmentation mask"] = f"/images/{name}.jpg"
- result["predicted"] = predicted
-
- if task == "object-detection":
- img_url = data["image"]
- img_data = image_to_bytes(img_url)
- predicted = inference(data=img_data)
- image = Image.open(BytesIO(img_data))
- draw = ImageDraw.Draw(image)
- labels = list(item['label'] for item in predicted)
- color_map = {}
- for label in labels:
- if label not in color_map:
- color_map[label] = (random.randint(0, 255), random.randint(0, 100), random.randint(0, 255))
- for label in predicted:
- box = label["box"]
- draw.rectangle(((box["xmin"], box["ymin"]), (box["xmax"], box["ymax"])), outline=color_map[label["label"]], width=2)
- draw.text((box["xmin"]+5, box["ymin"]-15), label["label"], fill=color_map[label["label"]])
- name = str(uuid.uuid4())[:4]
- image.save(f"public/images/{name}.jpg")
- result = {}
- result["generated image with predicted box"] = f"/images/{name}.jpg"
- result["predicted"] = predicted
-
- if task in ["image-classification"]:
- img_url = data["image"]
- img_data = image_to_bytes(img_url)
- result = inference(data=img_data)
-
- if task == "image-to-text":
- img_url = data["image"]
- img_data = image_to_bytes(img_url)
- HUGGINGFACE_HEADERS["Content-Length"] = str(len(img_data))
- r = requests.post(task_url, headers=HUGGINGFACE_HEADERS, data=img_data)
- result = {}
- if "generated_text" in r.json()[0]:
- result["generated text"] = r.json()[0].pop("generated_text")
-
- # AUDIO tasks
- if task == "text-to-speech":
- inputs = data["text"]
- response = inference(inputs, raw_response=True)
- # response = requests.post(task_url, headers=HUGGINGFACE_HEADERS, json={"inputs": text})
- name = str(uuid.uuid4())[:4]
- with open(f"public/audios/{name}.flac", "wb") as f:
- f.write(response.content)
- result = {"generated audio": f"/audios/{name}.flac"}
- if task in ["automatic-speech-recognition", "audio-to-audio", "audio-classification"]:
- audio_url = data["audio"]
- audio_data = requests.get(audio_url, timeout=10).content
- response = inference(data=audio_data, raw_response=True)
- result = response.json()
- if task == "audio-to-audio":
- content = None
- type = None
- for k, v in result[0].items():
- if k == "blob":
- content = base64.b64decode(v.encode("utf-8"))
- if k == "content-type":
- type = "audio/flac".split("/")[-1]
- audio = AudioSegment.from_file(BytesIO(content))
- name = str(uuid.uuid4())[:4]
- audio.export(f"public/audios/{name}.{type}", format=type)
- result = {"generated audio": f"/audios/{name}.{type}"}
- return result
-
-def local_model_inference(model_id, data, task):
- inference = partial(models, model_id)
- # contronlet
- if model_id.startswith("lllyasviel/sd-controlnet-"):
- img_url = data["image"]
- text = data["text"]
- results = inference({"img_url": img_url, "text": text})
- if "path" in results:
- results["generated image"] = results.pop("path")
- return results
- if model_id.endswith("-control"):
- img_url = data["image"]
- results = inference({"img_url": img_url})
- if "path" in results:
- results["generated image"] = results.pop("path")
- return results
-
- if task == "text-to-video":
- results = inference(data)
- if "path" in results:
- results["generated video"] = results.pop("path")
- return results
-
- # NLP tasks
- if task == "question-answering" or task == "sentence-similarity":
- results = inference(json=data)
- return results
- if task in ["text-classification", "token-classification", "text2text-generation", "summarization", "translation", "conversational", "text-generation"]:
- results = inference(json=data)
- return results
-
- # CV tasks
- if task == "depth-estimation":
- img_url = data["image"]
- results = inference({"img_url": img_url})
- if "path" in results:
- results["generated depth image"] = results.pop("path")
- return results
- if task == "image-segmentation":
- img_url = data["image"]
- results = inference({"img_url": img_url})
- results["generated image with segmentation mask"] = results.pop("path")
- return results
- if task == "image-to-image":
- img_url = data["image"]
- results = inference({"img_url": img_url})
- if "path" in results:
- results["generated image"] = results.pop("path")
- return results
- if task == "text-to-image":
- results = inference(data)
- if "path" in results:
- results["generated image"] = results.pop("path")
- return results
- if task == "object-detection":
- img_url = data["image"]
- predicted = inference({"img_url": img_url})
- if "error" in predicted:
- return predicted
- image = load_image(img_url)
- draw = ImageDraw.Draw(image)
- labels = list(item['label'] for item in predicted)
- color_map = {}
- for label in labels:
- if label not in color_map:
- color_map[label] = (random.randint(0, 255), random.randint(0, 100), random.randint(0, 255))
- for label in predicted:
- box = label["box"]
- draw.rectangle(((box["xmin"], box["ymin"]), (box["xmax"], box["ymax"])), outline=color_map[label["label"]], width=2)
- draw.text((box["xmin"]+5, box["ymin"]-15), label["label"], fill=color_map[label["label"]])
- name = str(uuid.uuid4())[:4]
- image.save(f"public/images/{name}.jpg")
- results = {}
- results["generated image with predicted box"] = f"/images/{name}.jpg"
- results["predicted"] = predicted
- return results
- if task in ["image-classification", "image-to-text", "document-question-answering", "visual-question-answering"]:
- img_url = data["image"]
- text = None
- if "text" in data:
- text = data["text"]
- results = inference({"img_url": img_url, "text": text})
- return results
- # AUDIO tasks
- if task == "text-to-speech":
- results = inference(data)
- if "path" in results:
- results["generated audio"] = results.pop("path")
- return results
- if task in ["automatic-speech-recognition", "audio-to-audio", "audio-classification"]:
- audio_url = data["audio"]
- results = inference({"audio_url": audio_url})
- return results
-
-
-def model_inference(model_id, data, hosted_on, task, huggingfacetoken=None):
- if huggingfacetoken:
- HUGGINGFACE_HEADERS = {
- "Authorization": f"Bearer {huggingfacetoken}",
- }
- else:
- HUGGINGFACE_HEADERS = None
- if hosted_on == "unknown":
- r = status(model_id)
- logger.debug("Local Server Status: " + str(r))
- if "loaded" in r and r["loaded"]:
- hosted_on = "local"
- else:
- huggingfaceStatusUrl = f"https://api-inference.huggingface.co/status/{model_id}"
- r = requests.get(huggingfaceStatusUrl, headers=HUGGINGFACE_HEADERS, proxies=PROXY)
- logger.debug("Huggingface Status: " + str(r.json()))
- if "loaded" in r and r["loaded"]:
- hosted_on = "huggingface"
- try:
- if hosted_on == "local":
- inference_result = local_model_inference(model_id, data, task)
- elif hosted_on == "huggingface":
- inference_result = huggingface_model_inference(model_id, data, task, huggingfacetoken)
- except Exception as e:
- print(e)
- traceback.print_exc()
- inference_result = {"error":{"message": str(e)}}
- return inference_result
-
-
-def get_model_status(model_id, url, headers, queue = None):
- endpoint_type = "huggingface" if "huggingface" in url else "local"
- if "huggingface" in url:
- r = requests.get(url, headers=headers, proxies=PROXY)
- else:
- r = status(model_id)
- if "loaded" in r and r["loaded"]:
- if queue:
- queue.put((model_id, True, endpoint_type))
- return True
- else:
- if queue:
- queue.put((model_id, False, None))
- return False
-
-def get_avaliable_models(candidates, topk=10, huggingfacetoken = None):
- all_available_models = {"local": [], "huggingface": []}
- threads = []
- result_queue = Queue()
- HUGGINGFACE_HEADERS = {
- "Authorization": f"Bearer {huggingfacetoken}",
- }
- for candidate in candidates:
- model_id = candidate["id"]
-
- if inference_mode != "local":
- huggingfaceStatusUrl = f"https://api-inference.huggingface.co/status/{model_id}"
- thread = threading.Thread(target=get_model_status, args=(model_id, huggingfaceStatusUrl, HUGGINGFACE_HEADERS, result_queue))
- threads.append(thread)
- thread.start()
-
- if inference_mode != "huggingface" and config["local_deployment"] != "minimal":
- thread = threading.Thread(target=get_model_status, args=(model_id, "", {}, result_queue))
- threads.append(thread)
- thread.start()
-
- result_count = len(threads)
- while result_count:
- model_id, status, endpoint_type = result_queue.get()
- if status and model_id not in all_available_models:
- all_available_models[endpoint_type].append(model_id)
- if len(all_available_models["local"] + all_available_models["huggingface"]) >= topk:
- break
- result_count -= 1
-
- for thread in threads:
- thread.join()
-
- return all_available_models
-
-def collect_result(command, choose, inference_result):
- result = {"task": command}
- result["inference result"] = inference_result
- result["choose model result"] = choose
- logger.debug(f"inference result: {inference_result}")
- return result
-
-
-def run_task(input, command, results, openaikey = None, huggingfacetoken = None):
- id = command["id"]
- args = command["args"]
- task = command["task"]
- deps = command["dep"]
- if deps[0] != -1:
- dep_tasks = [results[dep] for dep in deps]
- else:
- dep_tasks = []
-
- logger.debug(f"Run task: {id} - {task}")
- logger.debug("Deps: " + json.dumps(dep_tasks))
-
- if deps[0] != -1:
- if "image" in args and "-" in args["image"]:
- resource_id = int(args["image"].split("-")[1])
- if "generated image" in results[resource_id]["inference result"]:
- args["image"] = results[resource_id]["inference result"]["generated image"]
- if "audio" in args and "-" in args["audio"]:
- resource_id = int(args["audio"].split("-")[1])
- if "generated audio" in results[resource_id]["inference result"]:
- args["audio"] = results[resource_id]["inference result"]["generated audio"]
- if "text" in args and "-" in args["text"]:
- resource_id = int(args["text"].split("-")[1])
- if "generated text" in results[resource_id]["inference result"]:
- args["text"] = results[resource_id]["inference result"]["generated text"]
-
- text = image = audio = None
- for dep_task in dep_tasks:
- if "generated text" in dep_task["inference result"]:
- text = dep_task["inference result"]["generated text"]
- logger.debug("Detect the generated text of dependency task (from results):" + text)
- elif "text" in dep_task["task"]["args"]:
- text = dep_task["task"]["args"]["text"]
- logger.debug("Detect the text of dependency task (from args): " + text)
- if "generated image" in dep_task["inference result"]:
- image = dep_task["inference result"]["generated image"]
- logger.debug("Detect the generated image of dependency task (from results): " + image)
- elif "image" in dep_task["task"]["args"]:
- image = dep_task["task"]["args"]["image"]
- logger.debug("Detect the image of dependency task (from args): " + image)
- if "generated audio" in dep_task["inference result"]:
- audio = dep_task["inference result"]["generated audio"]
- logger.debug("Detect the generated audio of dependency task (from results): " + audio)
- elif "audio" in dep_task["task"]["args"]:
- audio = dep_task["task"]["args"]["audio"]
- logger.debug("Detect the audio of dependency task (from args): " + audio)
-
- if "image" in args and "" in args["image"]:
- if image:
- args["image"] = image
- if "audio" in args and "" in args["audio"]:
- if audio:
- args["audio"] = audio
- if "text" in args and "" in args["text"]:
- if text:
- args["text"] = text
-
- for resource in ["image", "audio"]:
- if resource in args and not args[resource].startswith("public/") and len(args[resource]) > 0 and not args[resource].startswith("http"):
- args[resource] = f"public/{args[resource]}"
-
- if "-text-to-image" in command['task'] and "text" not in args:
- logger.debug("control-text-to-image task, but text is empty, so we use control-generation instead.")
- control = task.split("-")[0]
-
- if control == "seg":
- task = "image-segmentation"
- command['task'] = task
- elif control == "depth":
- task = "depth-estimation"
- command['task'] = task
- else:
- task = f"{control}-control"
-
- command["args"] = args
- logger.debug(f"parsed task: {command}")
-
- if task.endswith("-text-to-image") or task.endswith("-control"):
- if inference_mode != "huggingface":
- if task.endswith("-text-to-image"):
- control = task.split("-")[0]
- best_model_id = f"lllyasviel/sd-controlnet-{control}"
- else:
- best_model_id = task
- hosted_on = "local"
- reason = "ControlNet is the best model for this task."
- choose = {"id": best_model_id, "reason": reason}
- logger.debug(f"chosen model: {choose}")
- else:
- logger.warning(f"Task {command['task']} is not available. ControlNet need to be deployed locally.")
- record_case(success=False, **{"input": input, "task": command, "reason": f"Task {command['task']} is not available. ControlNet need to be deployed locally.", "op":"message"})
- inference_result = {"error": f"service related to ControlNet is not available."}
- results[id] = collect_result(command, "", inference_result)
- return False
- elif task in ["summarization", "translation", "conversational", "text-generation", "text2text-generation"]: # ChatGPT Can do
- best_model_id = "ChatGPT"
- reason = "ChatGPT performs well on some NLP tasks as well."
- choose = {"id": best_model_id, "reason": reason}
- messages = [{
- "role": "user",
- "content": f"[ {input} ] contains a task in JSON format {command}, 'task' indicates the task type and 'args' indicates the arguments required for the task. Don't explain the task to me, just help me do it and give me the result. The result must be in text form without any urls."
- }]
- response = chitchat(messages, openaikey)
- results[id] = collect_result(command, choose, {"response": response})
- return True
- else:
- if task not in MODELS_MAP:
- logger.warning(f"no available models on {task} task.")
- record_case(success=False, **{"input": input, "task": command, "reason": f"task not support: {command['task']}", "op":"message"})
- inference_result = {"error": f"{command['task']} not found in available tasks."}
- results[id] = collect_result(command, "", inference_result)
- return False
-
- candidates = MODELS_MAP[task][:20]
- all_avaliable_models = get_avaliable_models(candidates, config["num_candidate_models"], huggingfacetoken)
- all_avaliable_model_ids = all_avaliable_models["local"] + all_avaliable_models["huggingface"]
- logger.debug(f"avaliable models on {command['task']}: {all_avaliable_models}")
-
- if len(all_avaliable_model_ids) == 0:
- logger.warning(f"no available models on {command['task']}")
- record_case(success=False, **{"input": input, "task": command, "reason": f"no available models: {command['task']}", "op":"message"})
- inference_result = {"error": f"no available models on {command['task']} task."}
- results[id] = collect_result(command, "", inference_result)
- return False
-
- if len(all_avaliable_model_ids) == 1:
- best_model_id = all_avaliable_model_ids[0]
- hosted_on = "local" if best_model_id in all_avaliable_models["local"] else "huggingface"
- reason = "Only one model available."
- choose = {"id": best_model_id, "reason": reason}
- logger.debug(f"chosen model: {choose}")
- else:
- cand_models_info = [
- {
- "id": model["id"],
- "inference endpoint": all_avaliable_models.get(
- "local" if model["id"] in all_avaliable_models["local"] else "huggingface"
- ),
- "likes": model.get("likes"),
- "description": model.get("description", "")[:config["max_description_length"]],
- "language": model.get("language"),
- "tags": model.get("tags"),
- }
- for model in candidates
- if model["id"] in all_avaliable_model_ids
- ]
-
- choose_str = choose_model(input, command, cand_models_info, openaikey)
- logger.debug(f"chosen model: {choose_str}")
- try:
- choose = json.loads(choose_str)
- reason = choose["reason"]
- best_model_id = choose["id"]
- hosted_on = "local" if best_model_id in all_avaliable_models["local"] else "huggingface"
- except Exception as e:
- logger.warning(f"the response [ {choose_str} ] is not a valid JSON, try to find the model id and reason in the response.")
- choose_str = find_json(choose_str)
- best_model_id, reason, choose = get_id_reason(choose_str)
- hosted_on = "local" if best_model_id in all_avaliable_models["local"] else "huggingface"
- inference_result = model_inference(best_model_id, args, hosted_on, command['task'], huggingfacetoken)
-
- if "error" in inference_result:
- logger.warning(f"Inference error: {inference_result['error']}")
- record_case(success=False, **{"input": input, "task": command, "reason": f"inference error: {inference_result['error']}", "op":"message"})
- results[id] = collect_result(command, choose, inference_result)
- return False
-
- results[id] = collect_result(command, choose, inference_result)
- return True
-
-def chat_huggingface(messages, openaikey = None, huggingfacetoken = None, return_planning = False, return_results = False):
- start = time.time()
- context = messages[:-1]
- input = messages[-1]["content"]
- logger.info("*"*80)
- logger.info(f"input: {input}")
-
- task_str = parse_task(context, input, openaikey)
- logger.info(task_str)
-
- if "error" in task_str:
- return str(task_str), {}
- else:
- task_str = task_str.strip()
-
- try:
- tasks = json.loads(task_str)
- except Exception as e:
- logger.debug(e)
- response = chitchat(messages, openaikey)
- record_case(success=False, **{"input": input, "task": task_str, "reason": "task parsing fail", "op":"chitchat"})
- return response, {}
-
- if task_str == "[]": # using LLM response for empty task
- record_case(success=False, **{"input": input, "task": [], "reason": "task parsing fail: empty", "op": "chitchat"})
- response = chitchat(messages, openaikey)
- return response, {}
-
- if len(tasks)==1 and tasks[0]["task"] in ["summarization", "translation", "conversational", "text-generation", "text2text-generation"]:
- record_case(success=True, **{"input": input, "task": tasks, "reason": "task parsing fail: empty", "op": "chitchat"})
- response = chitchat(messages, openaikey)
- best_model_id = "ChatGPT"
- reason = "ChatGPT performs well on some NLP tasks as well."
- choose = {"id": best_model_id, "reason": reason}
- return response, collect_result(tasks[0], choose, {"response": response})
-
-
- tasks = unfold(tasks)
- tasks = fix_dep(tasks)
- logger.debug(tasks)
-
- if return_planning:
- return tasks
-
- results = {}
- threads = []
- tasks = tasks[:]
- d = dict()
- retry = 0
- while True:
- num_threads = len(threads)
- for task in tasks:
- dep = task["dep"]
- # logger.debug(f"d.keys(): {d.keys()}, dep: {dep}")
- for dep_id in dep:
- if dep_id >= task["id"]:
- task["dep"] = [-1]
- dep = [-1]
- break
- if len(list(set(dep).intersection(d.keys()))) == len(dep) or dep[0] == -1:
- tasks.remove(task)
- thread = threading.Thread(target=run_task, args=(input, task, d, openaikey, huggingfacetoken))
- thread.start()
- threads.append(thread)
- if num_threads == len(threads):
- time.sleep(0.5)
- retry += 1
- if retry > 160:
- logger.debug("User has waited too long, Loop break.")
- break
- if len(tasks) == 0:
- break
- for thread in threads:
- thread.join()
-
- results = d.copy()
-
- logger.debug(results)
- if return_results:
- return results
-
- response = response_results(input, results, openaikey).strip()
-
- end = time.time()
- during = end - start
-
- answer = {"message": response}
- record_case(success=True, **{"input": input, "task": task_str, "results": results, "response": response, "during": during, "op":"response"})
- logger.info(f"response: {response}")
- return response, results
\ No newline at end of file
diff --git a/spaces/cccccch/VITS-fast-fine-tuning-DingZhen/README_ZH.md b/spaces/cccccch/VITS-fast-fine-tuning-DingZhen/README_ZH.md
deleted file mode 100644
index 269546ccb91643bef62d872b39a90bf19a8393aa..0000000000000000000000000000000000000000
--- a/spaces/cccccch/VITS-fast-fine-tuning-DingZhen/README_ZH.md
+++ /dev/null
@@ -1,60 +0,0 @@
-English Documentation Please Click [here](https://github.com/Plachtaa/VITS-fast-fine-tuning/blob/main/README.md)
-# VITS 快速微调
-这个代码库会指导你如何将自定义角色（甚至你自己），加入预训练的VITS模型中，在1小时内的微调使模型具备如下功能：
-1. 在 模型所包含的任意两个角色 之间进行声线转换
-2. 以 你加入的角色声线 进行中日英三语 文本到语音合成。
-
-本项目使用的底模涵盖常见二次元男/女配音声线（来自原神数据集）以及现实世界常见男/女声线（来自VCTK数据集），支持中日英三语，保证能够在微调时快速适应新的声线。
-
-欢迎体验微调所使用的底模！
-
-中日英：[](https://huggingface.co/spaces/Plachta/VITS-Umamusume-voice-synthesizer) 作者：我
-
-中日：[](https://huggingface.co/spaces/sayashi/vits-uma-genshin-honkai) 作者：[SayaSS](https://github.com/SayaSS)
-
-### 目前支持的任务:
-- [x] 从 10条以上的短音频 克隆角色声音
-- [x] 从 3分钟以上的长音频（单个音频只能包含单说话人） 克隆角色声音
-- [x] 从 3分钟以上的视频（单个视频只能包含单说话人） 克隆角色声音
-- [x] 通过输入 bilibili视频链接（单个视频只能包含单说话人） 克隆角色声音
-
-### 目前支持声线转换和中日英三语TTS的角色
-- [x] 任意角色（只要你有角色的声音样本）
-（注意：声线转换只能在任意两个存在于模型中的说话人之间进行）
-
-
-
-
-## 微调
-建议使用 [Google Colab](https://colab.research.google.com/drive/1pn1xnFfdLK63gVXDwV4zCXfVeo8c-I-0?usp=sharing)
-进行微调任务，因为VITS在多语言情况下的某些环境依赖相当难以配置。
-### 在Google Colab里，我需要花多长时间？
-1. 安装依赖 (3 min)
-2. 选择预训练模型，详细区别参见[Colab 笔记本页面](https://colab.research.google.com/drive/1pn1xnFfdLK63gVXDwV4zCXfVeo8c-I-0?usp=sharing)。
-3. 上传你希望加入的其它角色声音，详细上传方式见[DATA.MD](https://github.com/Plachtaa/VITS-fast-fine-tuning/blob/main/DATA.MD)
-4. 进行微调，根据选择的微调方式和样本数量不同，花费时长可能在20分钟到2小时不等。
-
-微调结束后可以直接下载微调好的模型，日后在本地运行（不需要GPU）
-
-## 本地运行和推理
-0. 记得下载微调好的模型和config文件！
-1. 下载最新的Release包（在Github页面的右侧）
-2. 把下载的模型和config文件放在 `inference`文件夹下, 其文件名分别为 `G_latest.pth` 和 `finetune_speaker.json`。
-3. 一切准备就绪后，文件结构应该如下所示:
-```
-inference
-├───inference.exe
-├───...
-├───finetune_speaker.json
-└───G_latest.pth
-```
-4. 运行 `inference.exe`, 浏览器会自动弹出窗口, 注意其所在路径不能有中文字符或者空格.
-
-## 在MoeGoe使用
-0. MoeGoe以及类似其它VITS推理UI使用的config格式略有不同，需要下载的文件为模型`G_latest.pth`和配置文件`moegoe_config.json`
-1. 按照[MoeGoe](https://github.com/CjangCjengh/MoeGoe)页面的提示配置路径即可使用。
-2. MoeGoe在输入句子时需要使用相应的语言标记包裹句子才能正常合成。（日语用[JA], 中文用[ZH], 英文用[EN]），例如：
-[JA]こんにちわ。[JA]
-[ZH]你好！[ZH]
-[EN]Hello![EN]
-
diff --git a/spaces/chaowei100/ChatGPT_Taiyi-Stable-Diffusion/app.py b/spaces/chaowei100/ChatGPT_Taiyi-Stable-Diffusion/app.py
deleted file mode 100644
index 8ddfd37f6c6d264befdc815a2d9bcc6894fddb44..0000000000000000000000000000000000000000
--- a/spaces/chaowei100/ChatGPT_Taiyi-Stable-Diffusion/app.py
+++ /dev/null
@@ -1,140 +0,0 @@
-import os; os.environ['no_proxy'] = '*' # 避免代理网络产生意外污染
-import gradio as gr
-from predict import predict
-from funtional_picture import infer_text2img
-from toolbox import format_io, find_free_port, get_conf
-import numpy as np
-
-# 建议您复制一个config_private.py放自己的秘密, 如API和代理网址, 避免不小心传github被别人看到
-proxies, WEB_PORT, LLM_MODEL, CONCURRENT_COUNT, AUTHENTICATION, CHATBOT_HEIGHT = \
- get_conf('proxies', 'WEB_PORT', 'LLM_MODEL', 'CONCURRENT_COUNT', 'AUTHENTICATION', 'CHATBOT_HEIGHT')
-
-# 如果WEB_PORT是-1, 则随机选取WEB端口
-PORT = find_free_port() if WEB_PORT <= 0 else WEB_PORT
-if not AUTHENTICATION: AUTHENTICATION = None
-
-initial_prompt = "Serve me as a writing and programming assistant."
-title_html = "展示你的机器学习模型 "
-description = """"""
-
-# 问询记录, python 版本建议3.9+（越新越好）
-import logging
-os.makedirs("work_log", exist_ok=True)
-try:logging.basicConfig(filename="work_log/chat_secrets.log", level=logging.INFO, encoding="utf-8")
-except:logging.basicConfig(filename="gpt_log/chat_secrets.log", level=logging.INFO)
-print("所有问询记录将自动保存在本地目录./gpt_log/chat_secrets.log, 请注意自我隐私保护哦！")
-
-# 一些普通功能模块
-from functional import get_functionals
-functional = get_functionals()
-
-
-
-# 处理markdown文本格式的转变
-gr.Chatbot.postprocess = format_io
-
-# 做一些外观色彩上的调整
-from theme import adjust_theme, advanced_css
-set_theme = adjust_theme()
-
-cancel_handles = []
-with gr.Blocks(theme=set_theme, analytics_enabled=False, css=advanced_css) as demo:
- gr.HTML(title_html)
- with gr.Tab("ChatGPT"):
- with gr.Row().style(equal_height=True):
- with gr.Column(scale=2):
- chatbot = gr.Chatbot()
- chatbot.style(height=CHATBOT_HEIGHT/2)
- history = gr.State([])
- with gr.Row():
- txt = gr.Textbox(show_label=False, placeholder="Input question here.").style(container=False)
- with gr.Row():
- submitBtn = gr.Button("提交", variant="primary")
- with gr.Row():
- resetBtn = gr.Button("重置", variant="secondary");
- resetBtn.style(size="sm")
- stopBtn = gr.Button("停止", variant="secondary");
- stopBtn.style(size="sm")
-
- with gr.Column(scale=1):
- with gr.Row():
- from check_proxy import check_proxy
- status = gr.Markdown(f"Tip: 按Enter提交, 按Shift+Enter换行。当前模型: {LLM_MODEL} \n {check_proxy(proxies)}")
- with gr.Accordion("基础功能区", open=True) as area_basic_fn:
- with gr.Row():
- for k in functional:
- variant = functional[k]["Color"] if "Color" in functional[k] else "secondary"
- functional[k]["Button"] = gr.Button(k, variant=variant)
- with gr.Accordion("展开SysPrompt & 交互界面布局 & Github地址", open=True):
- system_prompt = gr.Textbox(show_label=True, placeholder=f"System Prompt", label="System prompt", value=initial_prompt)
- top_p = gr.Slider(minimum=-0, maximum=1.0, value=1.0, step=0.01,interactive=True, label="Top-p (nucleus sampling)",)
- temperature = gr.Slider(minimum=-0, maximum=2.0, value=1.0, step=0.01, interactive=True, label="Temperature",)
- checkboxes = gr.CheckboxGroup(["基础功能区", "函数插件区"], value=["基础功能区", "函数插件区"], label="显示/隐藏功能区")
- gr.Markdown(description)
- with gr.Tab("AI绘画"):
- examples = [
- ["铁马冰河入梦来, 梦幻, 插画"],
- ["东临碣石, 以观沧海, 波涛汹涌, 插画"],
- ["孤帆远影碧空尽，惟见长江天际流,油画"],
- ["动漫化，帅气，插画"],
- ["女孩背影, 日落, 唯美插画"],
- ]
- with gr.Row():
- with gr.Column(scale=1, ):
- image_out = gr.Image(label='输出(output)')
- with gr.Column(scale=1, ):
- image_in = gr.Image(source='upload', elem_id="image_upload", type="pil", label="参考图（非必须）(ref)")
- prompt = gr.Textbox(label='提示词(prompt)')
- submit_btn = gr.Button("生成图像(Generate)")
- with gr.Row(scale=0.5):
- guide = gr.Slider(2, 15, value=7, step=0.1, label='文本引导强度(guidance scale)')
- steps = gr.Slider(10, 30, value=20, step=1, label='迭代次数(inference steps)')
- width = gr.Slider(384, 640, value=512, step=64, label='宽度(width)')
- height = gr.Slider(384, 640, value=512, step=64, label='高度(height)')
- strength = gr.Slider(0, 1.0, value=0.8, step=0.02, label='参考图改变程度(strength)')
- ex = gr.Examples(examples, fn=infer_text2img, inputs=[prompt, guide, steps, width, height],
- outputs=image_out)
-
- submit_btn.click(fn=infer_text2img, inputs=[prompt, guide, steps, width, height, image_in, strength],
- outputs=image_out)
-
- # demo.queue(concurrency_count=1, max_size=8).launch()
-
-
- # 功能区显示开关与功能区的互动
- def fn_area_visibility(a):
- ret = {}
- ret.update({area_basic_fn: gr.update(visible=("基础功能区" in a))})
- return ret
-
- checkboxes.select(fn_area_visibility, [checkboxes], [area_basic_fn])
- # 整理反复出现的控件句柄组合
- input_combo = [txt, top_p, temperature, chatbot, history, system_prompt]
- output_combo = [chatbot, history, status]
- predict_args = dict(fn=predict, inputs=input_combo, outputs=output_combo)
- empty_txt_args = dict(fn=lambda: "", inputs=[], outputs=[txt]) # 用于在提交后清空输入栏
- # 提交按钮、重置按钮
- cancel_handles.append(txt.submit(**predict_args)) #; txt.submit(**empty_txt_args) 在提交后清空输入栏
- cancel_handles.append(submitBtn.click(**predict_args)) #; submitBtn.click(**empty_txt_args) 在提交后清空输入栏
- resetBtn.click(lambda: ([], [], "已重置"), None, output_combo)
- # 基础功能区的回调函数注册
- for k in functional:
- click_handle = functional[k]["Button"].click(predict, [*input_combo, gr.State(True), gr.State(k)], output_combo)
- cancel_handles.append(click_handle)
- cancel_handles.append(click_handle)
- # 终止按钮的回调函数注册
- stopBtn.click(fn=None, inputs=None, outputs=None, cancels=cancel_handles)
-
-
-
-# gradio的inbrowser触发不太稳定，回滚代码到原始的浏览器打开函数
-def auto_opentab_delay():
- import threading, webbrowser, time
- print(f"如果浏览器没有自动打开，请复制并转到以下URL: http://localhost:{PORT}")
- def open():
- time.sleep(2)
- webbrowser.open_new_tab(f"http://localhost:{PORT}")
- threading.Thread(target=open, name="open-browser", daemon=True).start()
-auto_opentab_delay()
-demo.title = "展示你的机器学习模型"
-demo.queue(concurrency_count=CONCURRENT_COUNT).launch()
diff --git a/spaces/chasetank/manual_assistant/InnovationHub/llm/vector_store.py b/spaces/chasetank/manual_assistant/InnovationHub/llm/vector_store.py
deleted file mode 100644
index 35513a8c51f7f3d3b8351d143c71e88312d83df8..0000000000000000000000000000000000000000
--- a/spaces/chasetank/manual_assistant/InnovationHub/llm/vector_store.py
+++ /dev/null
@@ -1,179 +0,0 @@
-import plotly.graph_objs as go
-from sklearn.cluster import KMeans
-from sklearn.decomposition import PCA
-import plotly.express as px
-import numpy as np
-import os
-import pprint
-import codecs
-import chardet
-import gradio as gr
-from langchain.llms import HuggingFacePipeline
-from langchain.text_splitter import RecursiveCharacterTextSplitter
-from langchain.embeddings import HuggingFaceEmbeddings
-from langchain.vectorstores import FAISS
-from langchain import OpenAI, ConversationChain, LLMChain, PromptTemplate
-from langchain.memory import ConversationBufferWindowMemory
-
-
-def get_content(input_file):
- # Read the input file in binary mode
- with open(input_file, 'rb') as f:
- raw_data = f.read()
-
- # Detect the encoding of the file
- result = chardet.detect(raw_data)
- encoding = result['encoding']
-
- # Decode the contents using the detected encoding
- with codecs.open(input_file, 'r', encoding=encoding) as f:
- raw_text = f.read()
-
- # Return the content of the input file
- return raw_text
-
-
-def split_text(input_file, chunk_size=1000, chunk_overlap=0):
- text_splitter = RecursiveCharacterTextSplitter(
- chunk_size=chunk_size,
- chunk_overlap=chunk_overlap,
- length_function=len,
- )
-
- basename = os.path.basename(input_file)
- basename = os.path.splitext(basename)[0]
- raw_text = get_content(input_file=input_file)
-
- texts = text_splitter.split_text(text=raw_text)
- metadatas = [{"source": f"{basename}[{i}]"} for i in range(len(texts))]
- docs = text_splitter.create_documents(texts=texts, metadatas=metadatas)
-
- return texts, metadatas, docs
-
-
-def create_docs(input_file):
- # Create a text splitter object with a separator character
- text_splitter = RecursiveCharacterTextSplitter(
- chunk_size=1000,
- chunk_overlap=0,
- length_function=len,
- )
-
- basename = os.path.basename(input_file)
- basename = os.path.splitext(basename)[0]
- texts = get_content(input_file=input_file)
- metadatas = {'source': basename}
- docs = text_splitter.create_documents(texts=[texts], metadatas=[metadatas])
- return docs
-
-
-def get_similar_docs(query, index, k=5):
- similar_docs = index.similarity_search(query=query, k=k)
- result = [(d.summary, d.metadata) for d in similar_docs]
- return result
-
-
-def convert_to_html(similar_docs):
- result = []
- for summary, metadata in similar_docs:
- record = '' + summary + ' ' + \
- metadata['source'] + ' Page Content Source ' + \
- '\n'.join(result) + '
'
- return html
-
-
-def create_similarity_plot(embeddings, labels, query, n_clusters=3):
- # Only include embeddings that have corresponding labels
- embeddings_with_labels = [
- embedding for i, embedding in enumerate(embeddings) if i < len(labels)]
-
- # Reduce the dimensionality of the embeddings using PCA
- pca = PCA(n_components=3)
- pca_embeddings = pca.fit_transform(embeddings_with_labels)
-
- # Cluster the embeddings using k-means
- kmeans = KMeans(n_clusters=n_clusters)
- kmeans.fit(embeddings_with_labels)
-
- # Create a trace for the query point
- query_trace = go.Scatter3d(
- x=[pca_embeddings[-1, 0]],
- y=[pca_embeddings[-1, 1]],
- z=[pca_embeddings[-1, 2]],
- mode='markers',
- marker=dict(
- color='black',
- symbol='diamond',
- size=10
- ),
- name=f"Query: '{query}'"
- )
-
- # Create a trace for the other points
- points_trace = go.Scatter3d(
- x=pca_embeddings[:, 0],
- y=pca_embeddings[:, 1],
- z=pca_embeddings[:, 2],
- mode='markers',
- marker=dict(
- color=kmeans.labels_,
- colorscale=px.colors.qualitative.Alphabet,
- size=5
- ),
- text=labels,
- name='Points'
- )
-
- # Create the figure
- fig = go.Figure(data=[query_trace, points_trace])
-
- # Add a title and legend
- fig.update_layout(
- title="3D Similarity Plot",
- legend_title_text="Cluster"
- )
-
- # Show the plot
- fig.show()
-
-
-def plot_similarities(query, index, embeddings=HuggingFaceEmbeddings(), k=5):
- query_embeddings = embeddings.embed_query(text=query)
-
- similar_docs = get_similar_docs(query=query, index=index, k=k)
- texts = []
- for d in similar_docs:
- texts.append(d[0])
-
- embeddings_array = embeddings.embed_documents(texts=texts)
-
- # Get the index of the query point
- query_index = len(embeddings_array) - 1
-
- create_similarity_plot(
- embeddings=embeddings_array,
- labels=texts,
- query_index=query_index,
- n_clusters=3
- )
-
-
-def start_ui(index):
- def query_index(query):
- similar_docs = get_similar_docs(query=query, index=index)
- formatted_output = convert_to_html(similar_docs=similar_docs)
- return formatted_output
-
- # Define input and output types
- input = gr.inputs.Textbox(lines=2)
- output = gr.outputs.HTML()
-
- # Create interface object
- iface = gr.Interface(fn=query_index,
- inputs=input,
- outputs=output)
-
- # Launch interface
- iface.launch()
\ No newline at end of file
diff --git a/spaces/chendl/compositional_test/transformers/examples/research_projects/bert-loses-patience/pabee/__init__.py b/spaces/chendl/compositional_test/transformers/examples/research_projects/bert-loses-patience/pabee/__init__.py
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/spaces/chendl/compositional_test/transformers/examples/research_projects/rag/callbacks_rag.py b/spaces/chendl/compositional_test/transformers/examples/research_projects/rag/callbacks_rag.py
deleted file mode 100644
index d75f97995bd16f75396f1c32392d6b65137b8169..0000000000000000000000000000000000000000
--- a/spaces/chendl/compositional_test/transformers/examples/research_projects/rag/callbacks_rag.py
+++ /dev/null
@@ -1,116 +0,0 @@
-import logging
-from pathlib import Path
-
-import numpy as np
-import pytorch_lightning as pl
-import torch
-from pytorch_lightning.callbacks import EarlyStopping, ModelCheckpoint
-from pytorch_lightning.utilities import rank_zero_only
-from utils_rag import save_json
-
-
-def count_trainable_parameters(model):
- model_parameters = filter(lambda p: p.requires_grad, model.parameters())
- params = sum([np.prod(p.size()) for p in model_parameters])
- return params
-
-
-logger = logging.getLogger(__name__)
-
-
-def get_checkpoint_callback(output_dir, metric):
- """Saves the best model by validation EM score."""
- if metric == "rouge2":
- exp = "{val_avg_rouge2:.4f}-{step_count}"
- elif metric == "bleu":
- exp = "{val_avg_bleu:.4f}-{step_count}"
- elif metric == "em":
- exp = "{val_avg_em:.4f}-{step_count}"
- else:
- raise NotImplementedError(
- f"seq2seq callbacks only support rouge2 and bleu, got {metric}, You can make your own by adding to this"
- " function."
- )
-
- checkpoint_callback = ModelCheckpoint(
- dirpath=output_dir,
- filename=exp,
- monitor=f"val_{metric}",
- mode="max",
- save_top_k=3,
- every_n_epochs=1, # maybe save a checkpoint every time val is run, not just end of epoch.
- )
- return checkpoint_callback
-
-
-def get_early_stopping_callback(metric, patience):
- return EarlyStopping(
- monitor=f"val_{metric}", # does this need avg?
- mode="min" if "loss" in metric else "max",
- patience=patience,
- verbose=True,
- )
-
-
-class Seq2SeqLoggingCallback(pl.Callback):
- def on_batch_end(self, trainer, pl_module):
- lrs = {f"lr_group_{i}": param["lr"] for i, param in enumerate(pl_module.trainer.optimizers[0].param_groups)}
- pl_module.logger.log_metrics(lrs)
-
- @rank_zero_only
- def _write_logs(
- self, trainer: pl.Trainer, pl_module: pl.LightningModule, type_path: str, save_generations=True
- ) -> None:
- logger.info(f"***** {type_path} results at step {trainer.global_step:05d} *****")
- metrics = trainer.callback_metrics
- trainer.logger.log_metrics({k: v for k, v in metrics.items() if k not in ["log", "progress_bar", "preds"]})
- # Log results
- od = Path(pl_module.hparams.output_dir)
- if type_path == "test":
- results_file = od / "test_results.txt"
- generations_file = od / "test_generations.txt"
- else:
- # this never gets hit. I prefer not to save intermediate generations, and results are in metrics.json
- # If people want this it will be easy enough to add back.
- results_file = od / f"{type_path}_results/{trainer.global_step:05d}.txt"
- generations_file = od / f"{type_path}_generations/{trainer.global_step:05d}.txt"
- results_file.parent.mkdir(exist_ok=True)
- generations_file.parent.mkdir(exist_ok=True)
- with open(results_file, "a+") as writer:
- for key in sorted(metrics):
- if key in ["log", "progress_bar", "preds"]:
- continue
- val = metrics[key]
- if isinstance(val, torch.Tensor):
- val = val.item()
- msg = f"{key}: {val:.6f}\n"
- writer.write(msg)
-
- if not save_generations:
- return
-
- if "preds" in metrics:
- content = "\n".join(metrics["preds"])
- generations_file.open("w+").write(content)
-
- @rank_zero_only
- def on_train_start(self, trainer, pl_module):
- try:
- npars = pl_module.model.model.num_parameters()
- except AttributeError:
- npars = pl_module.model.num_parameters()
-
- n_trainable_pars = count_trainable_parameters(pl_module)
- # mp stands for million parameters
- trainer.logger.log_metrics({"n_params": npars, "mp": npars / 1e6, "grad_mp": n_trainable_pars / 1e6})
-
- @rank_zero_only
- def on_test_end(self, trainer: pl.Trainer, pl_module: pl.LightningModule):
- save_json(pl_module.metrics, pl_module.metrics_save_path)
- return self._write_logs(trainer, pl_module, "test")
-
- @rank_zero_only
- def on_validation_end(self, trainer: pl.Trainer, pl_module):
- save_json(pl_module.metrics, pl_module.metrics_save_path)
- # Uncommenting this will save val generations
- # return self._write_logs(trainer, pl_module, "valid")
diff --git a/spaces/chendl/compositional_test/transformers/examples/research_projects/rag/utils_rag.py b/spaces/chendl/compositional_test/transformers/examples/research_projects/rag/utils_rag.py
deleted file mode 100644
index ec98c1d782e0ea2a00d80420c88702acdd8da98d..0000000000000000000000000000000000000000
--- a/spaces/chendl/compositional_test/transformers/examples/research_projects/rag/utils_rag.py
+++ /dev/null
@@ -1,244 +0,0 @@
-import itertools
-import json
-import linecache
-import os
-import pickle
-import re
-import socket
-import string
-from collections import Counter
-from logging import getLogger
-from pathlib import Path
-from typing import Callable, Dict, Iterable, List
-
-import git
-import torch
-from torch.utils.data import Dataset
-
-from transformers import BartTokenizer, RagTokenizer, T5Tokenizer
-
-
-def encode_line(tokenizer, line, max_length, padding_side, pad_to_max_length=True, return_tensors="pt"):
- extra_kw = {"add_prefix_space": True} if isinstance(tokenizer, BartTokenizer) and not line.startswith(" ") else {}
- tokenizer.padding_side = padding_side
- return tokenizer(
- [line],
- max_length=max_length,
- padding="max_length" if pad_to_max_length else None,
- truncation=True,
- return_tensors=return_tensors,
- add_special_tokens=True,
- **extra_kw,
- )
-
-
-def trim_batch(
- input_ids,
- pad_token_id,
- attention_mask=None,
-):
- """Remove columns that are populated exclusively by pad_token_id"""
- keep_column_mask = input_ids.ne(pad_token_id).any(dim=0)
- if attention_mask is None:
- return input_ids[:, keep_column_mask]
- else:
- return (input_ids[:, keep_column_mask], attention_mask[:, keep_column_mask])
-
-
-class Seq2SeqDataset(Dataset):
- def __init__(
- self,
- tokenizer,
- data_dir,
- max_source_length,
- max_target_length,
- type_path="train",
- n_obs=None,
- src_lang=None,
- tgt_lang=None,
- prefix="",
- ):
- super().__init__()
- self.src_file = Path(data_dir).joinpath(type_path + ".source")
- self.tgt_file = Path(data_dir).joinpath(type_path + ".target")
- self.src_lens = self.get_char_lens(self.src_file)
- self.max_source_length = max_source_length
- self.max_target_length = max_target_length
- assert min(self.src_lens) > 0, f"found empty line in {self.src_file}"
- self.tokenizer = tokenizer
- self.prefix = prefix
- if n_obs is not None:
- self.src_lens = self.src_lens[:n_obs]
- self.src_lang = src_lang
- self.tgt_lang = tgt_lang
-
- def __len__(self):
- return len(self.src_lens)
-
- def __getitem__(self, index) -> Dict[str, torch.Tensor]:
- index = index + 1 # linecache starts at 1
- source_line = self.prefix + linecache.getline(str(self.src_file), index).rstrip("\n")
- tgt_line = linecache.getline(str(self.tgt_file), index).rstrip("\n")
- assert source_line, f"empty source line for index {index}"
- assert tgt_line, f"empty tgt line for index {index}"
-
- # Need to add eos token manually for T5
- if isinstance(self.tokenizer, T5Tokenizer):
- source_line += self.tokenizer.eos_token
- tgt_line += self.tokenizer.eos_token
-
- # Pad source and target to the right
- source_tokenizer = (
- self.tokenizer.question_encoder if isinstance(self.tokenizer, RagTokenizer) else self.tokenizer
- )
- target_tokenizer = self.tokenizer.generator if isinstance(self.tokenizer, RagTokenizer) else self.tokenizer
-
- source_inputs = encode_line(source_tokenizer, source_line, self.max_source_length, "right")
- target_inputs = encode_line(target_tokenizer, tgt_line, self.max_target_length, "right")
-
- source_ids = source_inputs["input_ids"].squeeze()
- target_ids = target_inputs["input_ids"].squeeze()
- src_mask = source_inputs["attention_mask"].squeeze()
- return {
- "input_ids": source_ids,
- "attention_mask": src_mask,
- "decoder_input_ids": target_ids,
- }
-
- @staticmethod
- def get_char_lens(data_file):
- return [len(x) for x in Path(data_file).open().readlines()]
-
- def collate_fn(self, batch) -> Dict[str, torch.Tensor]:
- input_ids = torch.stack([x["input_ids"] for x in batch])
- masks = torch.stack([x["attention_mask"] for x in batch])
- target_ids = torch.stack([x["decoder_input_ids"] for x in batch])
- tgt_pad_token_id = (
- self.tokenizer.generator.pad_token_id
- if isinstance(self.tokenizer, RagTokenizer)
- else self.tokenizer.pad_token_id
- )
- src_pad_token_id = (
- self.tokenizer.question_encoder.pad_token_id
- if isinstance(self.tokenizer, RagTokenizer)
- else self.tokenizer.pad_token_id
- )
- y = trim_batch(target_ids, tgt_pad_token_id)
- source_ids, source_mask = trim_batch(input_ids, src_pad_token_id, attention_mask=masks)
- batch = {
- "input_ids": source_ids,
- "attention_mask": source_mask,
- "decoder_input_ids": y,
- }
- return batch
-
-
-logger = getLogger(__name__)
-
-
-def flatten_list(summary_ids: List[List]):
- return list(itertools.chain.from_iterable(summary_ids))
-
-
-def save_git_info(folder_path: str) -> None:
- """Save git information to output_dir/git_log.json"""
- repo_infos = get_git_info()
- save_json(repo_infos, os.path.join(folder_path, "git_log.json"))
-
-
-def save_json(content, path, indent=4, **json_dump_kwargs):
- with open(path, "w") as f:
- json.dump(content, f, indent=indent, **json_dump_kwargs)
-
-
-def load_json(path):
- with open(path) as f:
- return json.load(f)
-
-
-def get_git_info():
- repo = git.Repo(search_parent_directories=True)
- repo_infos = {
- "repo_id": str(repo),
- "repo_sha": str(repo.head.object.hexsha),
- "repo_branch": str(repo.active_branch),
- "hostname": str(socket.gethostname()),
- }
- return repo_infos
-
-
-def lmap(f: Callable, x: Iterable) -> List:
- """list(map(f, x))"""
- return list(map(f, x))
-
-
-def pickle_save(obj, path):
- """pickle.dump(obj, path)"""
- with open(path, "wb") as f:
- return pickle.dump(obj, f)
-
-
-def normalize_answer(s):
- """Lower text and remove punctuation, articles and extra whitespace."""
-
- def remove_articles(text):
- return re.sub(r"\b(a|an|the)\b", " ", text)
-
- def white_space_fix(text):
- return " ".join(text.split())
-
- def remove_punc(text):
- exclude = set(string.punctuation)
- return "".join(ch for ch in text if ch not in exclude)
-
- def lower(text):
- return text.lower()
-
- return white_space_fix(remove_articles(remove_punc(lower(s))))
-
-
-def f1_score(prediction, ground_truth):
- prediction_tokens = normalize_answer(prediction).split()
- ground_truth_tokens = normalize_answer(ground_truth).split()
- common = Counter(prediction_tokens) & Counter(ground_truth_tokens)
- num_same = sum(common.values())
- if num_same == 0:
- return 0
- precision = 1.0 * num_same / len(prediction_tokens)
- recall = 1.0 * num_same / len(ground_truth_tokens)
- f1 = (2 * precision * recall) / (precision + recall)
- return f1
-
-
-def exact_match_score(prediction, ground_truth):
- return normalize_answer(prediction) == normalize_answer(ground_truth)
-
-
-def calculate_exact_match(output_lns: List[str], reference_lns: List[str]) -> Dict:
- assert len(output_lns) == len(reference_lns)
- em = 0
- for hypo, pred in zip(output_lns, reference_lns):
- em += exact_match_score(hypo, pred)
- if len(output_lns) > 0:
- em /= len(output_lns)
- return {"em": em}
-
-
-def is_rag_model(model_prefix):
- return model_prefix.startswith("rag")
-
-
-def set_extra_model_params(extra_params, hparams, config):
- equivalent_param = {p: p for p in extra_params}
- # T5 models don't have `dropout` param, they have `dropout_rate` instead
- equivalent_param["dropout"] = "dropout_rate"
- for p in extra_params:
- if getattr(hparams, p, None):
- if not hasattr(config, p) and not hasattr(config, equivalent_param[p]):
- logger.info("config doesn't have a `{}` attribute".format(p))
- delattr(hparams, p)
- continue
- set_p = p if hasattr(config, p) else equivalent_param[p]
- setattr(config, set_p, getattr(hparams, p))
- delattr(hparams, p)
- return hparams, config
diff --git a/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/PIL/XpmImagePlugin.py b/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/PIL/XpmImagePlugin.py
deleted file mode 100644
index 5d5bdc3edfa7be8d235fd6ef4176cc6cebee541c..0000000000000000000000000000000000000000
--- a/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/PIL/XpmImagePlugin.py
+++ /dev/null
@@ -1,128 +0,0 @@
-#
-# The Python Imaging Library.
-# $Id$
-#
-# XPM File handling
-#
-# History:
-# 1996-12-29 fl Created
-# 2001-02-17 fl Use 're' instead of 'regex' (Python 2.1) (0.7)
-#
-# Copyright (c) Secret Labs AB 1997-2001.
-# Copyright (c) Fredrik Lundh 1996-2001.
-#
-# See the README file for information on usage and redistribution.
-#
-
-
-import re
-
-from . import Image, ImageFile, ImagePalette
-from ._binary import o8
-
-# XPM header
-xpm_head = re.compile(b'"([0-9]*) ([0-9]*) ([0-9]*) ([0-9]*)')
-
-
-def _accept(prefix):
- return prefix[:9] == b"/* XPM */"
-
-
-##
-# Image plugin for X11 pixel maps.
-
-
-class XpmImageFile(ImageFile.ImageFile):
- format = "XPM"
- format_description = "X11 Pixel Map"
-
- def _open(self):
- if not _accept(self.fp.read(9)):
- msg = "not an XPM file"
- raise SyntaxError(msg)
-
- # skip forward to next string
- while True:
- s = self.fp.readline()
- if not s:
- msg = "broken XPM file"
- raise SyntaxError(msg)
- m = xpm_head.match(s)
- if m:
- break
-
- self._size = int(m.group(1)), int(m.group(2))
-
- pal = int(m.group(3))
- bpp = int(m.group(4))
-
- if pal > 256 or bpp != 1:
- msg = "cannot read this XPM file"
- raise ValueError(msg)
-
- #
- # load palette description
-
- palette = [b"\0\0\0"] * 256
-
- for _ in range(pal):
- s = self.fp.readline()
- if s[-2:] == b"\r\n":
- s = s[:-2]
- elif s[-1:] in b"\r\n":
- s = s[:-1]
-
- c = s[1]
- s = s[2:-2].split()
-
- for i in range(0, len(s), 2):
- if s[i] == b"c":
- # process colour key
- rgb = s[i + 1]
- if rgb == b"None":
- self.info["transparency"] = c
- elif rgb[:1] == b"#":
- # FIXME: handle colour names (see ImagePalette.py)
- rgb = int(rgb[1:], 16)
- palette[c] = (
- o8((rgb >> 16) & 255) + o8((rgb >> 8) & 255) + o8(rgb & 255)
- )
- else:
- # unknown colour
- msg = "cannot read this XPM file"
- raise ValueError(msg)
- break
-
- else:
- # missing colour key
- msg = "cannot read this XPM file"
- raise ValueError(msg)
-
- self.mode = "P"
- self.palette = ImagePalette.raw("RGB", b"".join(palette))
-
- self.tile = [("raw", (0, 0) + self.size, self.fp.tell(), ("P", 0, 1))]
-
- def load_read(self, bytes):
- #
- # load all image data in one chunk
-
- xsize, ysize = self.size
-
- s = [None] * ysize
-
- for i in range(ysize):
- s[i] = self.fp.readline()[1 : xsize + 1].ljust(xsize)
-
- return b"".join(s)
-
-
-#
-# Registry
-
-
-Image.register_open(XpmImageFile.format, XpmImageFile, _accept)
-
-Image.register_extension(XpmImageFile.format, ".xpm")
-
-Image.register_mime(XpmImageFile.format, "image/xpm")
diff --git a/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/clickhouse_connect/driver/insert.py b/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/clickhouse_connect/driver/insert.py
deleted file mode 100644
index da606402f49748735fb1b8c7814e160b91b15ba0..0000000000000000000000000000000000000000
--- a/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/clickhouse_connect/driver/insert.py
+++ /dev/null
@@ -1,200 +0,0 @@
-import logging
-from math import log
-from typing import Iterable, Sequence, Optional, Any, Dict, NamedTuple, Generator, Union, TYPE_CHECKING
-
-from clickhouse_connect.driver.query import quote_identifier
-
-from clickhouse_connect.driver.ctypes import data_conv
-from clickhouse_connect.driver.context import BaseQueryContext
-from clickhouse_connect.driver.options import np, pd
-from clickhouse_connect.driver.exceptions import ProgrammingError
-
-if TYPE_CHECKING:
- from clickhouse_connect.datatypes.base import ClickHouseType
-
-logger = logging.getLogger(__name__)
-DEFAULT_BLOCK_BYTES = 1 << 24 # Try to generate blocks between 16 and 32MB in raw size
-
-
-class InsertBlock(NamedTuple):
- prefix: bytes
- column_count: int
- row_count: int
- column_names: Iterable[str]
- column_types: Iterable['ClickHouseType']
- column_data: Iterable[Sequence[Any]]
-
-
-# pylint: disable=too-many-instance-attributes
-class InsertContext(BaseQueryContext):
- """
- Reusable Argument/parameter object for inserts.
- """
-
- # pylint: disable=too-many-arguments
- def __init__(self,
- table: str,
- column_names: Sequence[str],
- column_types: Sequence['ClickHouseType'],
- data: Any = None,
- column_oriented: Optional[bool] = None,
- settings: Optional[Dict[str, Any]] = None,
- compression: Optional[Union[str, bool]] = None,
- query_formats: Optional[Dict[str, str]] = None,
- column_formats: Optional[Dict[str, Union[str, Dict[str, str]]]] = None,
- block_size: Optional[int] = None):
- super().__init__(settings, query_formats, column_formats)
- self.table = table
- self.column_names = column_names
- self.column_types = column_types
- self.column_oriented = False if column_oriented is None else column_oriented
- self.compression = compression
- self.req_block_size = block_size
- self.block_size = DEFAULT_BLOCK_BYTES
- self.data = data
- self.insert_exception = None
-
- @property
- def empty(self) -> bool:
- return self._data is None
-
- @property
- def data(self):
- return self._raw_data
-
- @data.setter
- def data(self, data: Any):
- self._raw_data = data
- self.current_block = 0
- self.current_row = 0
- self.row_count = 0
- self.column_count = 0
- self._data = None
- if data is None or len(data) == 0:
- return
- if pd and isinstance(data, pd.DataFrame):
- data = self._convert_pandas(data)
- self.column_oriented = True
- if np and isinstance(data, np.ndarray):
- data = self._convert_numpy(data)
- if self.column_oriented:
- self._next_block_data = self._column_block_data
- self._block_columns = data # [SliceView(column) for column in data]
- self._block_rows = None
- self.column_count = len(data)
- self.row_count = len(data[0])
- else:
- self._next_block_data = self._row_block_data
- self._block_rows = data
- self._block_columns = None
- self.row_count = len(data)
- self.column_count = len(data[0])
- if self.row_count and self.column_count:
- if self.column_count != len(self.column_names):
- raise ProgrammingError('Insert data column count does not match column names')
- self._data = data
- self.block_size = self._calc_block_size()
-
- def _calc_block_size(self) -> int:
- if self.req_block_size:
- return self.req_block_size
- row_size = 0
- sample_size = min((log(self.row_count) + 1) * 2, 64)
- sample_freq = max(1, int(self.row_count / sample_size))
- for i, d_type in enumerate(self.column_types):
- if d_type.byte_size:
- row_size += d_type.byte_size
- continue
- if self.column_oriented:
- col_data = self._data[i]
- if sample_freq == 1:
- d_size = d_type.data_size(col_data)
- else:
- sample = [col_data[j] for j in range(0, self.row_count, sample_freq)]
- d_size = d_type.data_size(sample)
- else:
- data = self._data
- sample = [data[j][i] for j in range(0, self.row_count, sample_freq)]
- d_size = d_type.data_size(sample)
- row_size += d_size
- return 1 << (24 - int(log(row_size, 2)))
-
- def next_block(self) -> Generator[InsertBlock, None, None]:
- while True:
- block_end = min(self.current_row + self.block_size, self.row_count)
- row_count = block_end - self.current_row
- if row_count <= 0:
- return
- if self.current_block == 0:
- cols = f" ({', '.join([quote_identifier(x) for x in self.column_names])})"
- prefix = f'INSERT INTO {self.table}{cols} FORMAT Native\n'.encode()
- else:
- prefix = bytes()
- self.current_block += 1
- data = self._next_block_data(self.current_row, block_end)
- yield InsertBlock(prefix, self.column_count, row_count, self.column_names, self.column_types, data)
- self.current_row = block_end
-
- def _column_block_data(self, block_start, block_end):
- if block_start == 0 and self.row_count <= block_end:
- return self._block_columns # Optimization if we don't need to break up the block
- return [col[block_start: block_end] for col in self._block_columns]
-
- def _row_block_data(self, block_start, block_end):
- return data_conv.pivot(self._block_rows, block_start, block_end)
-
- def _convert_pandas(self, df):
- data = []
- for df_col_name, col_name, ch_type in zip(df.columns, self.column_names, self.column_types):
- df_col = df[df_col_name]
- d_type = str(df_col.dtype)
- if ch_type.python_type == int:
- if 'float' in d_type:
- df_col = df_col.round().astype(ch_type.base_type, copy=False)
- else:
- df_col = df_col.astype(ch_type.base_type, copy=False)
- elif 'datetime' in ch_type.np_type and (pd.core.dtypes.common.is_datetime_or_timedelta_dtype(df_col)
- or 'datetime64[ns' in d_type):
- div = ch_type.nano_divisor
- data.append([None if pd.isnull(x) else x.value // div for x in df_col])
- self.column_formats[col_name] = 'int'
- continue
- if ch_type.nullable:
- if d_type == 'object':
- # This is ugly, but the multiple replaces seem required as a result of this bug:
- # https://github.com/pandas-dev/pandas/issues/29024
- df_col = df_col.replace({pd.NaT: None}).replace({np.nan: None})
- elif 'Float' in ch_type.base_type:
- # This seems to be the only way to convert any null looking things to nan
- df_col = df_col.astype(ch_type.np_type)
- else:
- df_col = df_col.replace({np.nan: None})
- data.append(df_col.to_numpy(copy=False))
- return data
-
- def _convert_numpy(self, np_array):
- if np_array.dtype.names is None:
- if 'date' in str(np_array.dtype):
- for col_name, col_type in zip(self.column_names, self.column_types):
- if 'date' in col_type.np_type:
- self.column_formats[col_name] = 'int'
- return np_array.astype('int').tolist()
- for col_type in self.column_types:
- if col_type.byte_size == 0 or col_type.byte_size > np_array.dtype.itemsize:
- return np_array.tolist()
- return np_array
-
- if set(self.column_names).issubset(set(np_array.dtype.names)):
- data = [np_array[col_name] for col_name in self.column_names]
- else:
- # Column names don't match, so we have to assume they are in order
- data = [np_array[col_name] for col_name in np_array.dtype.names]
- for ix, (col_name, col_type) in enumerate(zip(self.column_names, self.column_types)):
- d_type = data[ix].dtype
- if 'date' in str(d_type) and 'date' in col_type.np_type:
- self.column_formats[col_name] = 'int'
- data[ix] = data[ix].astype(int).tolist()
- elif col_type.byte_size == 0 or col_type.byte_size > d_type.itemsize:
- data[ix] = data[ix].tolist()
- self.column_oriented = True
- return data
diff --git a/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/dotenv/__init__.py b/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/dotenv/__init__.py
deleted file mode 100644
index 7f4c631ba11786bceebd22591f91bd378d8b232c..0000000000000000000000000000000000000000
--- a/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/dotenv/__init__.py
+++ /dev/null
@@ -1,49 +0,0 @@
-from typing import Any, Optional
-
-from .main import (dotenv_values, find_dotenv, get_key, load_dotenv, set_key,
- unset_key)
-
-
-def load_ipython_extension(ipython: Any) -> None:
- from .ipython import load_ipython_extension
- load_ipython_extension(ipython)
-
-
-def get_cli_string(
- path: Optional[str] = None,
- action: Optional[str] = None,
- key: Optional[str] = None,
- value: Optional[str] = None,
- quote: Optional[str] = None,
-):
- """Returns a string suitable for running as a shell script.
-
- Useful for converting a arguments passed to a fabric task
- to be passed to a `local` or `run` command.
- """
- command = ['dotenv']
- if quote:
- command.append(f'-q {quote}')
- if path:
- command.append(f'-f {path}')
- if action:
- command.append(action)
- if key:
- command.append(key)
- if value:
- if ' ' in value:
- command.append(f'"{value}"')
- else:
- command.append(value)
-
- return ' '.join(command).strip()
-
-
-__all__ = ['get_cli_string',
- 'load_dotenv',
- 'dotenv_values',
- 'get_key',
- 'set_key',
- 'unset_key',
- 'find_dotenv',
- 'load_ipython_extension']
diff --git a/spaces/cihyFjudo/fairness-paper-search/4YoGirlAnd8YoSuckLookPtscKleuterkutjeHussyfanYamad LINK.md b/spaces/cihyFjudo/fairness-paper-search/4YoGirlAnd8YoSuckLookPtscKleuterkutjeHussyfanYamad LINK.md
deleted file mode 100644
index 9e93ba50bb13144a7d9e652b5b6c818c00086f5a..0000000000000000000000000000000000000000
--- a/spaces/cihyFjudo/fairness-paper-search/4YoGirlAnd8YoSuckLookPtscKleuterkutjeHussyfanYamad LINK.md
+++ /dev/null
@@ -1,6 +0,0 @@
-4YoGirlAnd8YoSuckLookPtscKleuterkutjeHussyfanYamad DOWNLOAD ► https://tinurli.com/2uwjtU
diff --git a/spaces/cihyFjudo/fairness-paper-search/6 Best Malayalam gangster movies of all times - OTTplay[2].md b/spaces/cihyFjudo/fairness-paper-search/6 Best Malayalam gangster movies of all times - OTTplay[2].md
deleted file mode 100644
index 93469cc3d2fa51e1f759789bf105636947feb778..0000000000000000000000000000000000000000
--- a/spaces/cihyFjudo/fairness-paper-search/6 Best Malayalam gangster movies of all times - OTTplay[2].md
+++ /dev/null
@@ -1,6 +0,0 @@
-Malayalam Ek Tha Gangster 720p premiere lista animo Download ✦✦✦ https://tinurli.com/2uwi8l
diff --git a/spaces/cihyFjudo/fairness-paper-search/A Pdf Rename 4.0.0 Crack Why You Need This Software to Manage Your PDF Files.md b/spaces/cihyFjudo/fairness-paper-search/A Pdf Rename 4.0.0 Crack Why You Need This Software to Manage Your PDF Files.md
deleted file mode 100644
index c7d1ed384c3f5ea9339eb1a7b8254ca5e4ed87ab..0000000000000000000000000000000000000000
--- a/spaces/cihyFjudo/fairness-paper-search/A Pdf Rename 4.0.0 Crack Why You Need This Software to Manage Your PDF Files.md
+++ /dev/null
@@ -1,7 +0,0 @@
-
-Nested Symbols is something we tried, a long time ago, with Mockups 3. It turned out that the feature was just too much for our little Flex app, so we shelved it, knowing we would have to return when our rebuilt apps were ready. When we were planning features for 2021, Nested Symbols was the very obvious elephant in the room. When Peldi suggested we take another crack at it, it was kind of a shock for us. It had been the feature for so long, it became something of a white whale for us.
-A Pdf Rename 4.0.0 Crack Download Zip ››› https://tinurli.com/2uwhZO
Do not transmit plain (unencrypted) data over the Internet. Such data isaccessible to everyone who has the time and ability to intercept it and useit for their own purposes. Instead, use an encrypted protocol such as SSL orSSH. MySQL supports internal SSL connections as of Version 4.0.0.SSH port-forwarding can be used to create an encrypted (and compressed)tunnel for the communication.
-When you connect to a MySQL server, you normally should use apassword. The password is not transmitted in clear text over theconnection, however the encryption algorithm is not very strong, andwith some effort a clever attacker can crack the password if he is ableto sniff the traffic between the client and the server. If theconnection between the client and the server goes through an untrustednetwork, you should use an SSH tunnel to encrypt thecommunication.
aaccfb2cb3Acoustica Mixcraft Pro Studio 8.0 Build 375 Incl Keygen-SadeemPC Download Pc Download » https://tinurli.com/2uwjM5
diff --git a/spaces/cihyFjudo/fairness-paper-search/Install Oracle 10g Release 2 Odac 64 Bit.md b/spaces/cihyFjudo/fairness-paper-search/Install Oracle 10g Release 2 Odac 64 Bit.md
deleted file mode 100644
index ce653199a4d5c436f3e47d604159afb61757647b..0000000000000000000000000000000000000000
--- a/spaces/cihyFjudo/fairness-paper-search/Install Oracle 10g Release 2 Odac 64 Bit.md
+++ /dev/null
@@ -1,16 +0,0 @@
-
-Step 1:Oracle install client (never succeeded with that, not recommended) or Oracle client (succeeded on Win7 ultimate 64bit, file win64_11gR1_client.zip, installed with "Runtime" option selected). After client install make sure you can connect. From command line try "tnsping yourtnanamesentry" to check if tnsnames is ok, and after that "sqlplus username/pwd@yourtnsnamesentry" to check if you know valid user and password and really can connect. Memorize or write down oracle home name and path you choosed during install.
-Install Oracle 10g Release 2 Odac 64 Bit Download ★★★★★ https://tinurli.com/2uwiuY
I'm not sure if Step 1 is really needed or not, because maybe step3 really uses just oracle instant client.I know, it is real pain, but this works. It took me 2 days to connect to oracle, and I had to install almost 1GB of downloaded oracle software. They could and should make that much, much, much, much easier. Like one-click install that just works. This is shame how complicated client install is.
-Wonderful article. This has fixed my issue after i install and uninstall oracle 32bit and oracle 64bit clients. I am glad that we don't need the 32bit Oracle client after all (as in other blog indicated). I have apply this to SQL2012 x64 with Oracle 11gr2 x64.
-We are currently facing the problem with building 64 Bit SSIS pacakages(located on DB Server..which is 2003 Server Edition, 64 Bit) with connecting 32 bit oracle(loaded on the App Server..Windows 2003, 32 bit) in Business Intelligent Development Studio(Integration Services) with Sql Server 2005 64 Bit. We have installed 64 bit Oracle client and network tools and drivers on Database Server(DB Server), but we are still unable to connect from to Oracle from the BIDS for making the 64 bit SSIS packages.
-
-You can execute Oracle Migration Workbench from a 32-bit Windows environment to migrate third-party databases, as supported by release 9.2.0.2.1 or later, to an Oracle Database 10g Release 2 (10.2) database installed on a 64-bit Windows computer.
-They provide support for .NET Framework 2.0 and higher, and Microsoft Visual Studio 2005. These components were released after the original Oracle Database 10g Release 2 (10.2.0.1), that is the reason they require ODAC installation.
-The steps in the following two sections assume you've installed the ODAC 18.x files to the c:\oracle64 folder for 64-bit versions of Power BI Desktop, or to the c:\oracle32 folder for the 32-bit versions of Power BI Desktop. Follow these steps to register Unmanaged ODP.NET :
-Working on getting my oracle connections to work again. We were running SQL Server 2012 and using VS2010 and I had all my SSIS projects working just fine. Upgrading the SQL server to 2014 is require us to update VS to 2013 so we can keep working with SSIS. The problem is now SSIS no longer connects to Oracle.
-I have installed ODAC 11.2.0.3 64 bit on local machine and i have oracle client 11.2.0.3 installed on my local machine moreover OraOLEDB.oracle installed on SQL server.After the installation SQL server also rebooted but i am not able to see oracle OLEDB provider under the SSDT_BI tools (SSIS) for OLEDB source.
-I am facing same issue in my laptop 64 bit, I installed Visual studio 2015 and relevant SSDT set up but I cannot connect to oracle data base can some help me is resolving this by providing step by step by procedure
-Hi,
aaccfb2cb3
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#include
-#include
-#include
-#include
-
-#include "compat/va_copy.h"
-#include "libavutil/error.h"
-
-#if defined(__MINGW32__)
-#define EOVERFLOW EFBIG
-#endif
-
-int avpriv_snprintf(char *s, size_t n, const char *fmt, ...)
-{
- va_list ap;
- int ret;
-
- va_start(ap, fmt);
- ret = avpriv_vsnprintf(s, n, fmt, ap);
- va_end(ap);
-
- return ret;
-}
-
-int avpriv_vsnprintf(char *s, size_t n, const char *fmt,
- va_list ap)
-{
- int ret;
- va_list ap_copy;
-
- if (n == 0)
- return _vscprintf(fmt, ap);
- else if (n > INT_MAX)
- return AVERROR(EOVERFLOW);
-
- /* we use n - 1 here because if the buffer is not big enough, the MS
- * runtime libraries don't add a terminating zero at the end. MSDN
- * recommends to provide _snprintf/_vsnprintf() a buffer size that
- * is one less than the actual buffer, and zero it before calling
- * _snprintf/_vsnprintf() to workaround this problem.
- * See https://web.archive.org/web/20151214111935/http://msdn.microsoft.com/en-us/library/1kt27hek(v=vs.80).aspx */
- memset(s, 0, n);
- va_copy(ap_copy, ap);
- ret = _vsnprintf(s, n - 1, fmt, ap_copy);
- va_end(ap_copy);
- if (ret == -1)
- ret = _vscprintf(fmt, ap);
-
- return ret;
-}
diff --git a/spaces/colakin/video-generater/public/ffmpeg/libavcodec/lossless_videoencdsp.h b/spaces/colakin/video-generater/public/ffmpeg/libavcodec/lossless_videoencdsp.h
deleted file mode 100644
index f2c287848569c60886ddcd980fad1ce8101899ee..0000000000000000000000000000000000000000
--- a/spaces/colakin/video-generater/public/ffmpeg/libavcodec/lossless_videoencdsp.h
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVCODEC_LOSSLESS_VIDEOENCDSP_H
-#define AVCODEC_LOSSLESS_VIDEOENCDSP_H
-
-#include
-#include
-
-typedef struct LLVidEncDSPContext {
- void (*diff_bytes)(uint8_t *dst /* align 16 */,
- const uint8_t *src1 /* align 16 */,
- const uint8_t *src2 /* align 1 */,
- intptr_t w);
- /**
- * Subtract HuffYUV's variant of median prediction.
- * Note, this might read from src1[-1], src2[-1].
- */
- void (*sub_median_pred)(uint8_t *dst, const uint8_t *src1,
- const uint8_t *src2, intptr_t w,
- int *left, int *left_top);
-
- void (*sub_left_predict)(uint8_t *dst, const uint8_t *src,
- ptrdiff_t stride, ptrdiff_t width, int height);
-} LLVidEncDSPContext;
-
-void ff_llvidencdsp_init(LLVidEncDSPContext *c);
-void ff_llvidencdsp_init_x86(LLVidEncDSPContext *c);
-
-#endif /* AVCODEC_LOSSLESS_VIDEOENCDSP_H */
diff --git a/spaces/congsaPfin/Manga-OCR/logs/BitLife God Mode APK The Ultimate Guide to Living Any Life You Want.md b/spaces/congsaPfin/Manga-OCR/logs/BitLife God Mode APK The Ultimate Guide to Living Any Life You Want.md
deleted file mode 100644
index 783abb22b57614e132a7920502fdaa6c58a6524d..0000000000000000000000000000000000000000
--- a/spaces/congsaPfin/Manga-OCR/logs/BitLife God Mode APK The Ultimate Guide to Living Any Life You Want.md
+++ /dev/null
@@ -1,91 +0,0 @@
-BitLife God Mode APK: How to Download and Play with Unlimited Possibilities
-Have you ever wondered what your life would be like if you could control everything and everyone around you? If you could change your appearance, personality, skills, relationships, and even your fate? Well, now you can with BitLife God Mode APK, a modded version of the popular life simulator game BitLife. In this article, we will tell you what BitLife is, what BitLife God Mode APK is, how to download and install it, and how to play it with unlimited possibilities.
-What is BitLife?
-A realistic life simulator game
-BitLife is a game that lets you live a virtual life from birth to death. You can choose your name, gender, country, and appearance. You can also make decisions that affect your happiness, health, intelligence, looks, and money. You can go to school, get a job, date, get married, have kids, buy a house, commit crimes, and more. You can also interact with other characters in the game, such as your parents, siblings, friends, lovers, enemies, and celebrities. You can see how your choices shape your life and what kind of legacy you leave behind.
-bitlife god mode apk DOWNLOAD ✫ https://urlca.com/2uO5nl
A game of choices and consequences
-BitLife is not just a game of simulation, but also a game of choices and consequences. Every decision you make has an impact on your life and the lives of others. Some choices are easy, some are hard, some are funny, some are serious, some are moral, some are immoral. Some choices can lead you to success, happiness, fame, or fortune. Some choices can lead you to failure, misery, infamy, or prison. Some choices can even lead you to death. You never know what will happen next in BitLife.
-What is BitLife God Mode APK?
-A modded version of BitLife with extra features
-BitLife God Mode APK is a modded version of BitLife that gives you access to extra features that are not available in the original game. One of these features is God Mode, which allows you to edit your character and other people in the game as you wish. You can change their name, age, gender, appearance, stats, traits, relationships, careers, assets, health conditions, and even their cause of death. You can also give yourself unlimited money and ribbons.
-A way to customize your character and other people in the game
-BitLife God Mode APK is a way to customize your character and other people in the game according to your preferences. You can create your ideal self or someone else you admire or despise. You can make yourself more attractive, smarter, richer, or happier. You can also make other people more loyal, friendly, supportive, or respectful towards you. You can also make them more ugly, stupid, poor, or miserable. You can also make them love you or hate you. You can also kill them or save them from death.
-How to download and install BitLife God Mode APK?
-The steps to download the APK file from a trusted source
-To download BitLife God Mode APK, you need to find a trusted source that provides the latest version of the modded file. One such source is APKdone.com , which is a reliable website that offers free and safe APK downloads for Android devices. You can visit the website and search for BitLife God Mode APK or click on this link: https://apkdone.com/bitlife-mod-apk/ . You will see a download button on the page. Click on it and wait for the download to complete.
-The steps to install the APK file on your device
-To install BitLife God Mode APK, you need to enable the installation of apps from unknown sources on your device. To do this, go to your device settings and look for the security or privacy option. Then, find the option that says "allow installation of apps from unknown sources" or something similar. Turn it on and confirm your choice. Then, go to your file manager and locate the downloaded APK file. Tap on it and follow the instructions to install it. Once the installation is done, you can open the app and enjoy BitLife God Mode APK.
-How to play BitLife God Mode APK?
-The benefits of having God Mode in BitLife
-Playing BitLife God Mode APK gives you many benefits that make the game more fun and exciting. Some of these benefits are:
-
-You can create your own character or edit an existing one with God Mode. You can change their name, age, gender, appearance, stats, traits, relationships, careers, assets, health conditions, and even their cause of death.
-You can also edit other people in the game with God Mode. You can change their name, age, gender, appearance, stats, traits, relationships, careers, assets, health conditions, and even their cause of death.
-You can give yourself unlimited money and ribbons with God Mode. You can buy anything you want and achieve any goal you have.
-You can also control the events and scenarios that happen in the game with God Mode. You can choose what kind of situations you want to encounter and how you want to react to them.
-You can also have fun with God Mode by experimenting with different outcomes and possibilities. You can see what happens if you do something crazy or outrageous. You can also see what happens if you do something good or noble.
-
-The tips and tricks to make the most of your life in BitLife
-Playing BitLife God Mode APK is not just about having fun, but also about making the most of your life in the game. Here are some tips and tricks to help you do that:
-
-Set a goal for yourself and work towards it. Whether you want to be rich, famous, happy, or successful, you need to have a clear vision of what you want and how to get it.
-Make smart choices and avoid bad ones. Even with God Mode, you still need to be careful about what you do and how it affects your life and others. Some choices can have negative consequences that can ruin your life or make you unhappy.
-Take care of your health and happiness. Even with God Mode, you still need to maintain your physical and mental well-being. You need to eat well, exercise regularly, visit the doctor when needed, avoid stress, and do things that make you happy.
-Build positive relationships with others. Even with God Mode, you still need to have good social skills and connections. You need to be kind, respectful, loyal, and supportive to your family, friends, lovers, and colleagues.
-Have fun and enjoy your life. Even with God Mode, you still need to have a sense of humor and adventure. You need to try new things, explore new places, learn new skills, and have fun with your hobbies.
-
-Conclusion
-A summary of the main points of the article
-In conclusion, BitLife God Mode APK is a modded version of BitLife that gives you access to extra features that are not available in the original game. One of these features is God Mode, which allows you to edit your character and other people in the game as you wish. You can also give yourself unlimited money and ribbons. To download and install BitLife God Mode APK, you need to find a trusted source that provides the latest version of the modded file. Then, you need to enable the installation of apps from unknown sources on your device. Then, you need to install the APK file on your device. To play BitLife God Mode APK, you need to create or edit your character with God Mode. You can also edit other people in the game with God Mode. You can also control the events and scenarios that happen in the game with God Mode. You can also have fun with God Mode by experimenting with different outcomes and possibilities
. You can also make the most of your life in the game by setting a goal for yourself, making smart choices, taking care of your health and happiness, building positive relationships with others, and having fun and enjoying your life.
-bitlife life simulator mod apk with god mode
-A call to action for the readers
-If you are interested in playing BitLife God Mode APK, you can download it from the link below and start living your dream life. You can also share your experiences and feedback with us in the comments section. We would love to hear from you. Thank you for reading this article and have a great day!
-Download BitLife God Mode APK here
-FAQs
-What is BitLife?
-BitLife is a realistic life simulator game that lets you live a virtual life from birth to death. You can make decisions that affect your happiness, health, intelligence, looks, and money. You can also interact with other characters in the game.
-What is BitLife God Mode APK?
-BitLife God Mode APK is a modded version of BitLife that gives you access to extra features that are not available in the original game. One of these features is God Mode, which allows you to edit your character and other people in the game as you wish. You can also give yourself unlimited money and ribbons.
-How to download and install BitLife God Mode APK?
-To download and install BitLife God Mode APK, you need to find a trusted source that provides the latest version of the modded file. Then, you need to enable the installation of apps from unknown sources on your device. Then, you need to install the APK file on your device.
-How to play BitLife God Mode APK?
-To play BitLife God Mode APK, you need to create or edit your character with God Mode. You can also edit other people in the game with God Mode. You can also control the events and scenarios that happen in the game with God Mode. You can also have fun with God Mode by experimenting with different outcomes and possibilities. You can also make the most of your life in the game by setting a goal for yourself, making smart choices, taking care of your health and happiness, building positive relationships with others, and having fun and enjoying your life.
-Is BitLife God Mode APK safe to use?
-BitLife God Mode APK is safe to use as long as you download it from a trusted source and follow the instructions carefully. However, you should be aware that using modded apps may violate the terms and conditions of the original game and may result in bans or other consequences. You should also be careful about what you do with God Mode and respect the rights and feelings of other people in the game.
197e85843dRed Line v3.0: A Roblox Cheat You Need to Know
-Roblox is one of the most popular online gaming platforms in the world, with millions of players creating and exploring various games every day. However, not everyone is satisfied with the default gameplay and limitations of Roblox. Some players want to have more fun, freedom, and power in their gaming experience. That's why they use cheats and hacks to modify the game and gain an edge over other players.
-red line v3 0 download mega DOWNLOAD ✶✶✶ https://urlca.com/2uOcf7
One of the most widely used cheats for Roblox is Red Line v3.0, a powerful exploit that allows you to do almost anything you want in any Roblox game. In this article, we will tell you everything you need to know about Red Line v3.0, including what it is, how to download it from Mega, how to install it on your PC, how to use it in Roblox games, and why you should or shouldn't use it.
-What is Red Line v3.0?
-Red Line v3.0 is a cheat or exploit for Roblox that enables you to manipulate the game code and execute various commands and scripts that are not normally possible in the game. It is also known as a level 7 executor, which means it can run any script or code that you want in Roblox.
-Features of Red Line v3.0
-Red Line v3.0 has many features that make it one of the best cheats for Roblox. Some of these features are:
-
-Easy to use interface: Red Line v3.0 has a simple and user-friendly interface that allows you to easily access and activate different functions and options.Multiple games support: Red Line v3.0 works on almost any Roblox game, whether it is popular or obscure, new or old, single-player or multiplayer.Customizable settings: Red Line v3.0 lets you customize various settings and preferences according to your needs and preferences.Frequent updates: Red Line v3.0 is constantly updated by its developers to ensure that it works smoothly and efficiently on the latest version of Roblox and its games.Lots of scripts: Red Line v3.0 comes with a huge library of scripts that you can use to perform different actions and effects in Roblox games. You can also add your own scripts or download scripts from other sources.
-How to download Red Line v3.0 from Mega
-Mega is one of the most popular file-sharing platforms on the internet, where you can upload and download files for free. It is also where you can find the latest version of Red Line v3.0 for download.
-red line v3 0 roblox cheat download
-To download Red Line v3.0 from Mega, follow these steps:
-
-Go to this link: [4](https://mega.nz/#)!qjATTapB!Q2vruqMDHv...
-Click on the "Download" button and wait for the file to be downloaded on your PC.
-The file name should be "Redline_v30.zip" and the file size should be around 10 MB.
-
-How to install Red Line v3.0 on your PC
-After downloading Red Line v3.0 from Mega, you need to install it on your PC before you can use it in Roblox games. To install Red Line v3.0 on your PC, follow these steps:
-
-Extract the "Redline_v30.zip" file using a program like WinRAR or 7-Zip.
-Open the extracted folder and double-click on the "Redline.exe" file to run the cheat.
-You may see a warning message from your antivirus or firewall, asking you to allow or block the cheat. Choose to allow or unblock the cheat, as it is not harmful to your PC.
-You should see a window with the Red Line v3.0 logo and a menu with different options and tabs.
-Congratulations, you have successfully installed Red Line v3.0 on your PC!
-
-How to use Red Line v3.0 in Roblox games
-Now that you have installed Red Line v3.0 on your PC, you can use it to cheat and hack in any Roblox game you want. To use Red Line v3.0 in Roblox games, follow these steps:
-
-Open Roblox on your PC and log in to your account.
-Choose a game that you want to play and join a server.
-Switch back to the Red Line v3.0 window and select the "Scripts" tab.
-Browse through the list of scripts and choose one that suits your needs and preferences. You can also search for scripts by name or category.
-Click on the "Execute" button to run the script in the game.
-You should see a confirmation message on the top left corner of the game screen, indicating that the script has been executed successfully.
-Enjoy the game with your new cheat and hack!
-
-Why use Red Line v3.0?
-Red Line v3.0 is one of the most popular and powerful cheats for Roblox, but why should you use it? What are the benefits and risks of using it? Let's find out.
-Benefits of using Red Line v3.0
-Using Red Line v3.0 can give you many advantages and benefits in Roblox games, such as:
-
-Get unlimited Robux and other resources: Robux is the currency of Roblox, which you can use to buy items, skins, game passes, and more. However, getting Robux can be hard and expensive, especially if you want to get a lot of them. With Red Line v3.0, you can get unlimited Robux and other resources for free, without spending any real money or time.Unlock all items and skins: There are thousands of items and skins in Roblox, which you can use to customize your avatar and make it look cool and unique. However, some of these items and skins are locked behind paywalls or require certain achievements or levels to unlock them. With Red Line v3.0, you can unlock all items and skins in Roblox, without any restrictions or limitations.Bypass anti-cheat systems and avoid bans: Roblox has a strict policy against cheating and hacking, which means that if you are caught using cheats or hacks in Roblox games, you may face consequences such as account suspension or termination. However, with Red Line v3.0, you can bypass anti-cheat systems and avoid bans, as it is undetectable by most anti-cheat software and has a built-in anti-ban feature that protects your account from being banned.
-Risks of using Red Line v3.0
-However, using Red Line v3.0 also comes with some risks and drawbacks that you should be aware of, such as:
-
-Potential malware and viruses: Although Red Line v3.0 is not harmful to your PC, there is always a possibility that some malicious files or programs may be hidden or attached to it, which may infect your PC with malware or viruses. Therefore, you should always scan the cheat file with a reliable antivirus program before installing it on your PC.Account suspension or termination: Even though Red Line v3.0 has an anti-ban feature that protects your account from being banned, there is still a chance that you may get caught by Roblox moderators or other players who may report you for cheating or hacking. If this happens, you may face account suspension or termination, which means that you will lose access to your account and all its data and progress.Ethical and legal issues: Cheating and hacking in Roblox games is not only against the rules and terms of service of Roblox, but also unethical and unfair to other players who play the game legitimately and honestly. Moreover, some cheats and hacks may violate the intellectual property rights of Roblox or its game developers, which may result in legal actions or lawsuits against you. Therefore, you should always respect the rights and interests of Roblox and its community, and use cheats and hacks at your own risk and responsibility.
-Conclusion
-Red Line v3.0 is a cheat or exploit for Roblox that allows you to do almost anything you want in any Roblox game. It has many features and functions that can enhance your gaming experience and give you an edge over other players. However, it also has some risks and drawbacks that you should be aware of, such as potential malware and viruses, account suspension or termination, and ethical and legal issues.
-Therefore, before you decide to use Red Line v3.0, you should weigh the pros and cons carefully, and consider the consequences and implications of your actions. You should also follow the instructions on how to download, install, and use Red Line v3.0 properly, to avoid any problems or errors.
-We hope this article has given you a comprehensive overview of Red Line v3.0, and helped you make an informed decision on whether to use it or not. If you have any questions or comments, feel free to leave them below. Thank you for reading!
-FAQs
-Here are some frequently asked questions about Red Line v3.0:
-
-Q: Is Red Line v3.0 safe to use? A: Red Line v3.0 is not harmful to your PC, but it may contain some malware or viruses that may infect your PC. Therefore, you should always scan the cheat file with a reliable antivirus program before installing it on your PC.
-Q: Is Red Line v3.0 free to use? A: Yes, Red Line v3.0 is free to use, and you can download it from Mega without paying any money.
-Q: Does Red Line v3.0 work on all Roblox games? A: Yes, Red Line v3.0 works on almost any Roblox game, whether it is popular or obscure, new or old, single-player or multiplayer.
-Q: How often is Red Line v3.0 updated? A: Red Line v3.0 is constantly updated by its developers to ensure that it works smoothly and efficiently on the latest version of Roblox and its games.
-Q: Where can I find more scripts for Red Line v3.0? A: You can find more scripts for Red Line v3.0 on various websites and forums that specialize in Roblox cheats and hacks, such as [5](https://v3rmillion.net/) or [6](https://robloxscripts.com/). You can also create your own scripts or download scripts from other sources.
- 401be4b1e0Far Cry 6 APK: How to Download and Play the Latest Installment of the Popular Shooter Series on Your Mobile Device
- Introduction
- Are you a fan of the Far Cry series, the action-adventure shooter games that take you to exotic and dangerous locations around the world? If so, you must be excited about the upcoming release of Far Cry 6, the sixth main entry in the franchise. But did you know that you can also play Far Cry 6 on your mobile device, thanks to the Far Cry 6 APK?
- What is Far Cry 6?
- Far Cry 6 is a video game developed by Ubisoft Toronto and published by Ubisoft. It is set to be released on October 7, 2023, for Windows, PlayStation 4, PlayStation 5, Xbox One, Xbox Series X/S, and Stadia. It is also available for mobile devices through the Far Cry 6 APK, which is a modified version of the game that can run on Android and iOS platforms.
-far cry 6 apk DOWNLOAD ✪✪✪ https://urlca.com/2uObpd
What are the features of Far Cry 6?
- Far Cry 6 is a first-person shooter game that lets you experience the thrill and chaos of guerrilla warfare in a fictional Caribbean island called Yara. You will play as Dani Rojas, a local Yaran who joins a resistance movement called Libertad, to overthrow the tyrannical regime of Anton Castillo, a dictator who wants to restore Yara to its former glory by any means necessary.
- Some of the features of Far Cry 6 are:
-
-A massive open-world map that you can explore by foot, vehicle, or animal.
-A variety of weapons, vehicles, and gadgets that you can customize and craft to suit your playstyle.
-A dynamic weather system and a day-night cycle that affect the gameplay and environment.
-A co-op mode that allows you to play with a friend online or offline.
-A multiplayer mode that pits you against other players in various modes and maps.
-
- How to download and install Far Cry 6 APK on your Android or iOS device?
- If you want to play Far Cry 6 on your mobile device, you will need to download and install the Far Cry 6 APK file. This is a simple process that only takes a few minutes. Here are the steps you need to follow:
-
-Go to https://apkrey.com/far-cry-6-mobile-download/ , which is a trusted and reliable source for downloading the Far Cry 6 APK file.
-Click on the download button and wait for the file to be downloaded on your device.
-Once the download is complete, locate the file in your device's storage and tap on it to start the installation process.
-Follow the instructions on the screen and allow the necessary permissions for the app to run smoothly.
-After the installation is done, launch the app and enjoy playing Far Cry 6 on your mobile device.
-
- Main Body
- The story and setting of Far Cry 6
- Far Cry 6 takes place in Yara, a fictional island nation in the Caribbean that is inspired by Cuba. Yara is a tropical paradise that has been frozen in time due to a decades-long economic embargo. However, beneath its beauty lies a dark and
oppressive history of violence and corruption. You will join the ranks of Libertad, a ragtag group of rebels who fight for freedom and democracy against Castillo's regime.
- The island of Yara and its dictator Anton Castillo
- Yara is a fictional island nation in the Caribbean that is inspired by Cuba. It is a tropical paradise that has been frozen in time due to a decades-long economic embargo. However, beneath its beauty lies a dark and oppressive history of violence and corruption. Yara is ruled by Anton Castillo, a dictator who wants to restore Yara to its former glory by any means necessary. He is a charismatic and ruthless leader who uses propaganda, fear, and force to maintain his power. He is also grooming his son Diego to be his successor, but Diego has doubts about his father's methods and motives.
- The protagonist Dani Rojas and the resistance movement Libertad
- You will play as Dani Rojas, a local Yaran who joins a resistance movement called Libertad, to overthrow Castillo's regime. Dani is an orphan who was sent to a military academy at 16, where they learned how to handle a gun until they were dishonorably discharged and sent out to the streets. Dani is a reluctant hero who initially wants to escape Yara, but decides to stay and fight for their homeland after witnessing the atrocities committed by Castillo's forces. Libertad is a group of rebels who fight for freedom and democracy against Castillo's tyranny. They are led by Clara Garcia, a charismatic and idealistic leader who believes in the power of the people. Libertad consists of various factions and allies, such as the Montero clan, the Maximas Matanzas, the Legends of '67, and La Moral.
- The gameplay and mechanics of Far Cry 6
- Far Cry 6 is a first-person shooter game that lets you experience the thrill and chaos of guerrilla warfare in Yara. You will have access to a variety of weapons, vehicles, gadgets, and animal companions (called Amigos) that you can use to explore, fight, and survive in the open-world environment. You will also be able to customize and craft your weapons and gear to suit your playstyle and preferences.
-far cry 6 mobile apk download
- The open-world exploration and combat
- Far Cry 6 features a massive open-world map that you can explore by foot, vehicle, or animal. You can travel across different regions of Yara, such as jungles, beaches, cities, farms, and mountains. You can also discover various points of interest, such as outposts, checkpoints, FND caches, Yaran contraband, treasure hunts, criptograma chests, relics, side missions, and more. You can also interact with various characters and factions that will offer you quests, information, rewards, or challenges.
- The combat in Far Cry 6 is fast-paced and explosive. You can choose to approach your enemies stealthily or loudly, depending on your strategy and situation. You can use various weapons, such as rifles, shotguns, pistols, bows, launchers, resolver weapons (which are improvised weapons made from scrap materials), and supremo weapons (which are powerful backpack devices that can unleash devastating effects). You can also use various gadgets, such as grenades, mines, throwing knives, molotovs, EMPs, medkits, and more. You can also use your animal companions (such as Chorizo the wiener dog or Guapo the crocodile) to distract or attack your enemies.
- The customization and crafting options
- Far Cry 6 allows you to customize and craft your weapons and gear to fit your playstyle and preferences. You can modify your weapons with various attachments, such as scopes, silencers, magazines, barrels, stocks, and skins. You can also craft your own resolver weapons from various parts and materials that you can find or buy in the world. You can also customize your gear, such as your clothes, shoes, hats, glasses, masks, and backpacks. You can also craft your own supremo weapons from various blueprints and components that you can unlock or earn in the game.
- The co-op and multiplayer modes
- Far Cry 6 also offers a co-op mode that allows you to play with a friend online or offline. You can join forces with another player and explore the entire map of Yara together. You can also share your weapons, vehicles, and gadgets with your co-op partner. You can also tackle any mission, activity, or challenge together, and enjoy the dynamic events and surprises that the game will throw at you.
- The multiplayer mode of Far Cry 6 is still under development, but it is expected to feature various modes and maps that will pit you against other players in competitive matches. You will be able to use your customized weapons and gear in the multiplayer mode, and earn rewards and ranks for your performance.
- Conclusion
- Far Cry 6 is a game that promises to deliver an immersive and exhilarating experience of guerrilla warfare in a tropical paradise. You will be able to explore a vast and diverse open-world map, customize and craft your weapons and gear, and fight against a ruthless dictator and his army. You will also be able to play with a friend in co-op mode, or challenge other players in multiplayer mode. Far Cry 6 is a game that you should not miss if you are a fan of the shooter genre.
- Why you should play Far Cry 6 APK on your mobile device
- If you want to enjoy Far Cry 6 on your mobile device, you should download and install the Far Cry 6 APK file. This is a modified version of the game that can run on Android and iOS platforms. By playing Far Cry 6 APK on your mobile device, you will be able to:
-
-Play the game anytime and anywhere, without the need for a console or a PC.
-Experience the game with high-quality graphics and sound, optimized for your device's specifications.
-Control the game with intuitive touch-screen controls, or use a compatible controller for more accuracy and comfort.
-Save your progress on the cloud, and sync it across different devices.
-Access exclusive content and features that are only available for mobile users.
-
- FAQs
- Here are some frequently asked questions about Far Cry 6 APK:
-
-Q: Is Far Cry 6 APK safe to download and install?
-A: Yes, Far Cry 6 APK is safe to download and install, as long as you use a trusted and reliable source like https://apkrey.com/far-cry-6-mobile-download/ . This site has been verified by many users and reviewers, and it does not contain any viruses or malware.
-Q: Is Far Cry 6 APK free to play?
-A: Yes, Far Cry 6 APK is free to play, but it may contain some in-app purchases or ads that you can choose to support or ignore.
-Q: Do I need an internet connection to play Far Cry 6 APK?
-A: Yes, you will need an internet connection to play Far Cry 6 APK, as it is an online game that requires data transfer and verification. However, you can also play the game offline if you have already downloaded the necessary files on your device.
-Q: How much storage space do I need to download and install Far Cry 6 APK?
-A: You will need at least 4 GB of free storage space on your device to download and install Far Cry 6 APK. However, you may need more space if you want to download additional content or updates for the game.
-Q: Can I play Far Cry 6 APK with my friends?
-A: Yes, you can play Far Cry 6 APK with your friends in co-op mode or multiplayer mode. You can invite your friends to join your game through the app's interface, or join their games through the same method. You can also chat with your friends through voice or text messages while playing the game.
- 197e85843dHow to Download 4K Hindi Video Songs in 2020
-If you are a fan of Hindi music, you might have heard of 4K video songs. These are songs that have a resolution of 3840 x 2160 pixels, which is four times higher than the standard HD resolution of 1920 x 1080 pixels. 4K video songs offer a stunning visual experience that can make you feel like you are watching a live performance. However, downloading 4K video songs can be tricky, as they have some challenges and limitations. In this article, we will explain what are 4K video songs, why are they popular, what are the benefits and challenges of 4K video songs, and how to download them easily and efficiently.
-4k hindi video songs download 2020 Download ☆ https://urlca.com/2uOasX
Benefits of 4K Video Songs
-4K video songs have many advantages over lower-resolution videos. Here are some of the benefits of 4K video songs:
-
-Higher resolution: 4K video songs have a resolution of 3840 x 2160 pixels, which is four times higher than the standard HD resolution of 1920 x 1080 pixels. This means that they have more details, clarity, and sharpness than HD videos. You can see every facial expression, every movement, and every color more vividly and realistically.Better quality: 4K video songs have a higher bit rate than HD videos, which means that they have more data and information per second. This results in better quality, as there is less compression, noise, and distortion in the video. You can enjoy a smoother and clearer playback without any lag or buffering.Immersive experience: 4K video songs can create an immersive experience for the viewers, as they can fill up the entire screen of a large TV or monitor. You can feel like you are part of the scene, as the images are more lifelike and realistic. You can also enjoy a wider viewing angle, as the images are not stretched or distorted.
- Challenges of 4K Video Songs
-Despite the benefits of 4K video songs, they also have some drawbacks and limitations. Here are some of the challenges of 4K video songs:
-
-Large file size: 4K video songs have a large file size, as they have more pixels and data than HD videos. For example, a typical HD video song might have a file size of around 100 MB, while a typical 4K video song might have a file size of around 400 MB. This means that downloading or storing 4K video songs can take up a lot of space and time on your device.Limited compatibility: Not all devices and platforms support 4K video songs. You need to have a device that has a screen resolution of at least 3840 x 2160 pixels to watch 4K video songs in their full glory. You also need to have a compatible media player or browser that can play 4K videos without any issues. Some older devices or platforms might not be able to play or display 4K videos at all.High bandwidth requirement: To stream or download 4K video songs online, you need to have a high-speed internet connection that can handle the large amount of data. According to Netflix, you need to have at least a speed of 25 Mbps to stream their content in Ultra HD quality. If your internet connection is slow or unstable, you might experience buffering, lagging, or poor quality when watching or downloading 4K video songs.
- Solutions for 4K Video Songs
-If you
If you want to download 4K video songs in 2020, you have some options to overcome the challenges and enjoy the benefits. Here are some of the solutions for 4K video songs:
-
-4K video downloader: This is a software or app that can download 4K video songs from various online sources, such as YouTube, Vimeo, Dailymotion, etc. You can choose the quality, format, and destination of the downloaded videos, and also convert them to other formats if needed. Some examples of 4K video downloaders are 4K Video Downloader, WinX HD Video Converter Deluxe, VideoProc, etc.Online converter: This is a website or service that can convert 4K video songs to other resolutions or formats online. You can upload the 4K video song from your device or paste the URL of the online source, and then choose the output quality, format, and size. Some examples of online converters are Online Video Converter, Convert2MP3, ClipConverter, etc.Streaming platforms: This is a website or app that can stream 4K video songs online without downloading them. You can watch the 4K video songs on your device or cast them to a larger screen. Some examples of streaming platforms that offer 4K video songs are YouTube, Netflix, Amazon Prime Video, etc.
- Conclusion
-4K video songs are songs that have a resolution of 3840 x 2160 pixels, which is four times higher than the standard HD resolution of 1920 x 1080 pixels. They offer a stunning visual experience that can make you feel like you are watching a live performance. However, they also have some challenges and limitations, such as large file size, limited compatibility, and high bandwidth requirement. To download 4K video songs in 2020, you can use a 4K video downloader, an online converter, or a streaming platform. Here are some tips for downloading 4K video songs:
-
-Check your device and platform compatibility: Make sure that your device and platform can support 4K video songs before downloading or streaming them. You can check the screen resolution, media player, browser, and system requirements of your device and platform.Choose the best quality and format: Depending on your preference and purpose, you can choose the best quality and format for your 4K video songs. You can opt for MP4, MKV, AVI, MOV, etc. formats, and also adjust the bit rate, frame rate, aspect ratio, etc.Use a reliable internet connection: To download or stream 4K video songs smoothly and quickly, you need to have a reliable internet connection that can handle the large amount of data. You can use a wired connection or a Wi-Fi connection with a speed of at least 25 Mbps.
- FAQs
-Here are some frequently asked questions about 4K video songs:
-Thoda Thoda Pyaar Full Video Song 4k 60fps
-
-What is the difference between 4K and Ultra HD? 4K and Ultra HD are often used interchangeably to refer to the same resolution of 3840 x 2160 pixels. However, technically speaking, 4K is a cinema standard that has a resolution of 4096 x 2160 pixels, while Ultra HD is a consumer standard that has a resolution of 3840 x 2160 pixels.
-How much space does a 4K video song take? The exact space that a 4K video song takes depends on various factors, such as the length, bit rate, format, compression, etc. However, as a general rule of thumb, a typical 4K video song might have a file size of around 400 MB per minute.
-How can I play 4K video songs on my TV? To play 4K video songs on your TV, you need to have a TV that has a screen resolution of at least 3840 x 2160 pixels. You also need to have a compatible media player or device that can play or cast 4K videos to your TV. Some examples are Blu-ray players, Some examples are Blu-ray players, streaming devices, gaming consoles, etc. You can also use a HDMI cable or a wireless connection to connect your device to your TV.
-Where can I find 4K video songs online? There are many online sources that offer 4K video songs, such as YouTube, Vimeo, Dailymotion, etc. You can search for 4K video songs by using keywords like "4K", "UHD", "2160p", etc. You can also filter the results by quality, duration, genre, etc.
-How can I download 4K video songs from YouTube? To download 4K video songs from YouTube, you can use a 4K video downloader software or app, such as 4K Video Downloader, WinX HD Video Converter Deluxe, VideoProc, etc. You can also use an online converter website or service, such as Online Video Converter, Convert2MP3, ClipConverter, etc. You just need to copy and paste the URL of the YouTube video song and choose the output quality and format.
- 197e85843dTemple Run 2 Earth Day Mod Apk: What You Need to Know
-If you are a fan of Temple Run 2, one of the most popular running games on Android devices, you might be interested in trying out a mod apk that celebrates Earth Day. In this article, we will tell you everything you need to know about Temple Run 2 Earth Day Mod Apk, including what it is, how to download and install it, how to play it, and what are its advantages and disadvantages.
- What is Temple Run 2?
-Temple Run 2 is a sequel to the original Temple Run game that was released in 2011 by Imangi Studios. It is an endless runner game where you have to control a character who is escaping from a group of evil monkeys after stealing a cursed idol from a temple. Along the way, you have to avoid various obstacles such as cliffs, zip lines, mines, waterfalls, and fire jets by swiping left or right to turn, up to jump, or down to slide.
-temple run 2 earth day mod apk Download Zip >>> https://urlca.com/2uO4na
Temple Run 2 features beautiful graphics, new environments, new obstacles, new power-ups, new achievements, and special powers for each character. You can also choose from different characters to play with, such as Guy Dangerous, Scarlett Fox, Barry Bones, Karma Lee, Montana Smith, Zack Wonder, Francisco Montoya, Maria Selva, Rahi Raaja, Nidhi Nirmal, Usain Bolt, Bruce Lee, Cleopatra, Imhotep, Wolfman, Sir Montague, Santa Claus, Mrs. Claus, Freya Coldheart, Sigur Frostbeard, Pirate Covey Covey Covey Covey Covey Covey Covey Covey Covey Covey Covey Covey Covey Covey Covey Covey Covey Covey Covey Covey Covey Covey Covey Covey Covey Covey Covey Covey
Temple Run 2 has been downloaded over 500 million times on Google Play Store and has received positive reviews from critics and players alike. It is one of the most addictive and fun games on mobile devices.
- What is Earth Day?
-Earth Day is an annual event that celebrates the planet Earth and raises awareness about environmental issues. The first Earth Day was held on April 22nd in 1970 by Senator Gaylord Nelson who wanted to inspire people to take action for environmental protection. Since then, Earth Day has become a global movement that involves millions of people from more than 190 countries.
-Earth Day aims to educate people about the importance of preserving natural resources for future generations. Some
Some of the activities that people do on Earth Day include planting trees, cleaning up litter, recycling, signing petitions, donating to environmental causes, and participating in rallies and marches. Earth Day also encourages people to adopt eco-friendly habits such as using renewable energy, reducing waste, conserving water, and eating organic food.
- What is a mod apk?
-A mod apk is a modified version of an original application that has been altered by a third-party developer to add or remove some features. A mod apk can also be called a hacked apk or a cracked apk. A mod apk can provide users with benefits such as unlimited resources, unlocked items, premium features, ad-free experience, and more. However, a mod apk can also pose some risks such as malware infection, data theft, legal issues, and ethical concerns.
-A mod apk works by bypassing the security measures of the original application and changing some of its code. A mod apk can be downloaded from various websites that host them. However, not all mod apks are safe and reliable. Some of them may contain viruses, spyware, or other malicious software that can harm your device or steal your personal information. Therefore, you should always be careful when downloading and installing a mod apk and only use trusted sources.
- What is Temple Run 2 Earth Day Mod Apk?
-Temple Run 2 Earth Day Mod Apk is a special version of Temple Run 2 that was created by a fan to celebrate Earth Day. It is a mod apk that has some unique features that are not available in the original game. Some of these features are:
-
-Unlimited coins and gems: You can get unlimited coins and gems in the game without spending any real money. You can use them to buy power-ups, upgrade your abilities, unlock new characters, and more.
-Unlocked characters: You can play with any character you want without having to unlock them first. You can choose from the original characters or the new ones that are added for Earth Day. Some of the new characters are Earth Warrior, Eco Ranger, Green Guardian, and Nature Lover.
-New environment: You can run in a new environment that is inspired by Earth Day. It is a green and lush forest with trees, flowers, animals, and waterfalls. You can also see some signs and banners that promote environmental awareness and protection.
-New obstacles: You can face new challenges and dangers in the new environment. You have to avoid falling rocks, swinging vines, angry bees, and hungry bears. You also have to watch out for the evil monkeys who are wearing masks and carrying signs that say "Save the Planet".
-New achievements: You can earn new achievements that are related to Earth Day. Some of them are "Go Green", "Eco-Friendly", "Earth Saver", and "Planet Protector".
-
-Temple Run 2 Earth Day Mod Apk is a fun and exciting way to enjoy Temple Run 2 while also supporting a good cause. It is a tribute to the planet Earth and its beauty and diversity.
- How to download and install Temple Run 2 Earth Day Mod Apk?
-If you want to try out Temple Run 2 Earth Day Mod Apk, you have to follow these steps:
-temple run 2 earth day hack apk
-
-Make sure you have Temple Run 2 installed on your device. If not, you can download it from Google Play Store or from this link: .
-Download Temple Run 2 Earth Day Mod Apk from this link: . This is a trusted source that has been verified by many users.
-Enable unknown sources on your device settings. This will allow you to install applications from sources other than Google Play Store.
-Locate the downloaded file on your device storage and tap on it to install it.
-Launch the game and enjoy the modded features.
-
- How to play Temple Run 2 Earth Day Mod Apk?
-The gameplay of Temple Run 2 Earth Day Mod Apk is similar to the original game. You have to run as far as you can while avoiding obstacles and collecting coins and gems. However, there are some differences that you should know:
-
-You can select any character you want from the menu before starting the game. You can also change your character during the game by tapping on the character icon on the top left corner of the screen.
-You can access the shop from the menu or during the game by tapping on the shop icon on the top right corner of the screen. You can use your unlimited coins and gems to buy power-ups, abilities, outfits, wallpapers, and more.
-You can activate special powers for each You can activate special powers for each character by filling up the power meter on the bottom left corner of the screen. You can fill up the power meter by collecting coins, gems, or power-ups. Each character has a different power that can help you in the game. For example, Earth Warrior can create a shield that protects him from obstacles, Eco Ranger can summon a bird that flies him over obstacles, Green Guardian can create a trail of flowers that boosts his speed, and Nature Lover can attract animals that help him collect coins and gems.
-You can also use the Earth Day button on the bottom right corner of the screen to activate a special mode that changes the environment and the obstacles. In this mode, you can see more greenery, wildlife, and Earth Day signs. You can also collect more coins and gems and earn more points. However, you have to be careful of the new obstacles such as falling rocks, swinging vines, angry bees, and hungry bears.
-
-The goal of Temple Run 2 Earth Day Mod Apk is to run as far as you can and score as high as you can. You can also compete with your friends and other players online by connecting your game to Facebook or Google Play Games. You can also share your screenshots and videos of your gameplay on social media platforms such as Instagram, Twitter, or YouTube.
- What are the advantages and disadvantages of Temple Run 2 Earth Day Mod Apk?
-Temple Run 2 Earth Day Mod Apk has some advantages and disadvantages that you should consider before using it. Here are some of them:
- Advantages
-
-It is free to download and use. You do not have to pay any money to enjoy the modded features of the game.
-It is fun and exciting. You can experience a new and different version of Temple Run 2 that has more features, options, and challenges.
-It is easy to use. You do not need any technical skills or knowledge to download and install the mod apk. You just have to follow the simple steps that we have provided above.
-It is educational and inspirational. You can learn more about Earth Day and its significance while playing the game. You can also get inspired to take action for environmental protection and conservation.
-
- Disadvantages
-
-It is risky and unreliable. You may encounter some problems or issues while using the mod apk such as malware infection, data theft, legal issues, or ethical concerns. You may also lose your progress or account if the mod apk is detected or banned by the game developers or authorities.
-It is unfair and unethical. You may gain an unfair advantage over other players who are playing the original game without any modded features. You may also violate the terms and conditions of the game developers or owners by using an unauthorized modification of their application.
-It is temporary and unstable. You may not be able to use the mod apk for a long time as it may become outdated or incompatible with the updates or changes of the original game. You may also lose some of the modded features or functions if they are fixed or removed by the game developers or owners.
-
- Conclusion
-Temple Run 2 Earth Day Mod Apk is a modded version of Temple Run 2 that celebrates Earth Day. It has some unique features that are not available in the original game such as unlimited coins and gems, unlocked characters, new environment, new obstacles, new achievements, and more. It is a fun and exciting way to enjoy Temple Run 2 while also supporting a good cause.
-However, Temple Run 2 Earth Day Mod Apk also has some risks and drawbacks that you should be aware of before using it such as malware infection, data theft, legal issues, ethical concerns, unfair advantage, violation of terms and conditions, outdatedness, incompatibility, instability, and more. Therefore, you should always be careful when downloading and installing a mod apk and only use trusted sources.
-We hope this article has helped you learn more about Temple Run 2 Earth Day Mod Apk and its features, benefits, and disadvantages. If you have any questions or comments about this topic, feel free to leave them below.
- FAQs
-Here are some frequently asked questions and their answers about Temple Run 2 Earth Day Mod Apk:
-
-Is Temple Run 2 Earth Day Mod Apk safe to use? Temple Run 2 Earth Day Mod Apk is not completely safe to use as it may contain some viruses, spyware, or other malicious software that can harm your device or steal your personal information. Therefore, you should always scan the file before
Therefore, you should always scan the file before installing it and use a reliable antivirus or anti-malware program on your device. You should also backup your data and progress before using the mod apk in case something goes wrong.
- Is Temple Run 2 Earth Day Mod Apk legal to use? Temple Run 2 Earth Day Mod Apk is not legal to use as it violates the intellectual property rights of the game developers or owners. By using a mod apk, you are essentially stealing their work and modifying it without their permission. This can result in legal actions or penalties from the game developers or owners or from the authorities. Therefore, you should respect the rights and efforts of the game developers or owners and only use the original game or the official updates or changes.
- Is Temple Run 2 Earth Day Mod Apk ethical to use? Temple Run 2 Earth Day Mod Apk is not ethical to use as it goes against the spirit and purpose of Earth Day. By using a mod apk, you are not only cheating in the game but also disrespecting the planet and its environment. You are also depriving yourself of the challenge and satisfaction of playing the game as it was intended. Therefore, you should honor the message and mission of Earth Day and play the game in a fair and honest way.
- How can I update Temple Run 2 Earth Day Mod Apk? Temple Run 2 Earth Day Mod Apk may not be compatible with the latest version of Temple Run 2 or with the new features or changes that are added by the game developers or owners. Therefore, you may need to update your mod apk to keep up with the original game. However, updating a mod apk is not easy or guaranteed as it depends on the availability and reliability of the mod apk developer or source. You may have to wait for a long time or search for a new mod apk that works with the updated version of Temple Run 2. You may also lose some of the modded features or functions if they are fixed or removed by the game developers or owners.
- Where can I find more information about Temple Run 2 Earth Day Mod Apk? If you want to learn more about Temple Run 2 Earth Day Mod Apk, you can visit some of the websites that provide reviews, tutorials, videos, screenshots, or downloads of the mod apk. However, you should be careful when visiting these websites as some of them may contain fake, misleading, or harmful information or content. You should also check the comments, ratings, and feedbacks of other users who have used the mod apk before downloading or installing it.
- 197e85843dCopyright/DMCA: We DO NOT own any copyrights of this Mp3 Song. This Aisi Lagi lagan Meera Ho Gayi Magan was either uploaded by our users @Pagal Songs or it must be readily available on various places on public domains as FREE download. If you want this Aisi Lagi lagan Meera Ho Gayi Magan to be removed or if it is copyright infringement, do drop us an email at [email protected] and this will be taken down within 24 hours!
-Aisi Lagi Lagan Full Song Download DOWNLOAD 🔗 https://ssurll.com/2uzyCR
Related Tags: Aisi Lagi Lagan, Aisi Lagi Lagan song, Aisi Lagi Lagan MP3 song, Aisi Lagi Lagan MP3, download Aisi Lagi Lagan song, Aisi Lagi Lagan song, Spiritual Songs For Makar Sankranti Aisi Lagi Lagan song, Aisi Lagi Lagan song by Anup Jalota, Aisi Lagi Lagan song download, download Aisi Lagi Lagan MP3 song
-Anup Jalota - Bhajan Icon is a Hindi devotional album released on 2016.Music of Anup Jalota - Bhajan Icon songs are composed. Anup Jalota - Bhajan Icon album has 15 songs sung by Anup Jalota.Listen to all songs in high quality & download Anup Jalota - Bhajan Icon songs on Raaga.com.
-This website offers unlimited downloading of youtube music and Mp3 juice song free download in HD quality. You can also click "PLAY" to play the audio file before you download it. Mp3juices take only 2-5 seconds to convert and download audio files.
-
-It is easy to download mp3 juice by visiting the website and entering the song name into the search box or pasting the URL. Select one search result and then convert it to audio by clicking the download button. Finally, hit the Download button to get the audio file at high speeds.
aaccfb2cb3Analisis De La Obra Literaria Dos Pesos De Agua DOWNLOAD ✔ https://ssurll.com/2uzxHA
diff --git a/spaces/contluForse/HuggingGPT/assets/Extreme Surebet Money Maker 9.6.0 Serial Key Keygen __FULL__.md b/spaces/contluForse/HuggingGPT/assets/Extreme Surebet Money Maker 9.6.0 Serial Key Keygen __FULL__.md
deleted file mode 100644
index e1b2f6c25d3eb4aec5215041e96b848ea52f2d1c..0000000000000000000000000000000000000000
--- a/spaces/contluForse/HuggingGPT/assets/Extreme Surebet Money Maker 9.6.0 Serial Key Keygen __FULL__.md
+++ /dev/null
@@ -1,6 +0,0 @@
-Roulette7crack.com Final Fantasy XIII-2 1.5.3.3 Crack MAC OS X Incl Serial Key Ultra To Hack ini PC Download.rar download-wimax-camera1-wimax-camera-bridge-exploit-for-firmware-upload-box-crack Download This Is The Right! Full Crack Steam Generalfreeware.exe crack Download Direct Link Benzedrine Barbiturate Crkake Incl.rar NekosoftIschia 4 Crack 7 0 Novembre 2017 V3.0.4.r2 iTunes with Series Pass Download fsweekup-win 7-in-1-mac-crack Platinum-fraggy4-crack FullCrackKiller-2-Mac-Bypass-with-Keygen-ARIJINI-Mac-Crack-FTp-Server-RELEASE.rar Machine Cracker Crack 2 torrent software freehold casino road oanenburg west eindhoven Osado TCP/IP Download wp 7.0 Forum Pascal 2.0 For Windows Full Version.rar gta 5 crack trainer download 3d game engine open xml format ini FreeformXd Download Cracked G Spot game Download World Of Warcraft Wep Test Mode Emulator.exe The WinNTD Make USB 7.9 version 3.4.4.2 Download Incl Crack 9 charachter tool hack spywarestrategies.in wps browser Startpage Download Haiku 18 Crack v03 Incl Cracked Codered Acpcad.dll Download World Of Warcraft Wep Test Mode Emulator.exe Torrent.gf The Root Password Stacks Mac Serial Keygen Crack Fortigate F-Secure 2004 Download 1.2.
-Extreme surebet money maker 9.6.0 Serial Key keygen DOWNLOAD >>> https://ssurll.com/2uzy8K
download torrent video file importrwarehike 4.6 Mac OSX 101562 Download Home windows 2008 professional serial keygen legal music download sites for windows 8 download full game edgetechs.com The latest ACER (ATA2SE: ATA Bridge Secondary Entry) has been the greatest onslaught against Windows, even if you’ve utilized it, and a way to cease Windows from talking with other drives while being used is by clearing the ATA2SE: ATA Bridge Secondary Entry Handle, and that’s exactly what this information is about.
899543212b
-
-at::Tensor
-ms_deform_attn_cpu_forward(
- const at::Tensor &value,
- const at::Tensor &spatial_shapes,
- const at::Tensor &level_start_index,
- const at::Tensor &sampling_loc,
- const at::Tensor &attn_weight,
- const int im2col_step);
-
-std::vector
-ms_deform_attn_cpu_backward(
- const at::Tensor &value,
- const at::Tensor &spatial_shapes,
- const at::Tensor &level_start_index,
- const at::Tensor &sampling_loc,
- const at::Tensor &attn_weight,
- const at::Tensor &grad_output,
- const int im2col_step);
-
-
diff --git a/spaces/coreml-community/ControlNet-v1-1-Annotators-cpu/annotator/uniformer/configs/_base_/datasets/pascal_voc12.py b/spaces/coreml-community/ControlNet-v1-1-Annotators-cpu/annotator/uniformer/configs/_base_/datasets/pascal_voc12.py
deleted file mode 100644
index ba1d42d0c5781f56dc177d860d856bb34adce555..0000000000000000000000000000000000000000
--- a/spaces/coreml-community/ControlNet-v1-1-Annotators-cpu/annotator/uniformer/configs/_base_/datasets/pascal_voc12.py
+++ /dev/null
@@ -1,57 +0,0 @@
-# dataset settings
-dataset_type = 'PascalVOCDataset'
-data_root = 'data/VOCdevkit/VOC2012'
-img_norm_cfg = dict(
- mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)
-crop_size = (512, 512)
-train_pipeline = [
- dict(type='LoadImageFromFile'),
- dict(type='LoadAnnotations'),
- dict(type='Resize', img_scale=(2048, 512), ratio_range=(0.5, 2.0)),
- dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
- dict(type='RandomFlip', prob=0.5),
- dict(type='PhotoMetricDistortion'),
- dict(type='Normalize', **img_norm_cfg),
- dict(type='Pad', size=crop_size, pad_val=0, seg_pad_val=255),
- dict(type='DefaultFormatBundle'),
- dict(type='Collect', keys=['img', 'gt_semantic_seg']),
-]
-test_pipeline = [
- dict(type='LoadImageFromFile'),
- dict(
- type='MultiScaleFlipAug',
- img_scale=(2048, 512),
- # img_ratios=[0.5, 0.75, 1.0, 1.25, 1.5, 1.75],
- flip=False,
- transforms=[
- dict(type='Resize', keep_ratio=True),
- dict(type='RandomFlip'),
- dict(type='Normalize', **img_norm_cfg),
- dict(type='ImageToTensor', keys=['img']),
- dict(type='Collect', keys=['img']),
- ])
-]
-data = dict(
- samples_per_gpu=4,
- workers_per_gpu=4,
- train=dict(
- type=dataset_type,
- data_root=data_root,
- img_dir='JPEGImages',
- ann_dir='SegmentationClass',
- split='ImageSets/Segmentation/train.txt',
- pipeline=train_pipeline),
- val=dict(
- type=dataset_type,
- data_root=data_root,
- img_dir='JPEGImages',
- ann_dir='SegmentationClass',
- split='ImageSets/Segmentation/val.txt',
- pipeline=test_pipeline),
- test=dict(
- type=dataset_type,
- data_root=data_root,
- img_dir='JPEGImages',
- ann_dir='SegmentationClass',
- split='ImageSets/Segmentation/val.txt',
- pipeline=test_pipeline))
diff --git a/spaces/crashedice/signify/SOURCE/yolo_files/models/yolo.py b/spaces/crashedice/signify/SOURCE/yolo_files/models/yolo.py
deleted file mode 100644
index b97c8b960a6f1f2aa30b25f91827d8b428da3d3c..0000000000000000000000000000000000000000
--- a/spaces/crashedice/signify/SOURCE/yolo_files/models/yolo.py
+++ /dev/null
@@ -1,304 +0,0 @@
-# YOLOv5 YOLO-specific modules
-
-import argparse
-import logging
-import sys
-from copy import deepcopy
-from pathlib import Path
-
-sys.path.append(Path(__file__).parent.parent.absolute().__str__()) # to run '$ python *.py' files in subdirectories
-logger = logging.getLogger(__name__)
-
-from SOURCE.yolo_files.models.common import *
-from SOURCE.yolo_files.models.experimental import *
-from SOURCE.yolo_files.utils.autoanchor import check_anchor_order
-from SOURCE.yolo_files.utils.general import make_divisible, check_file, set_logging
-from SOURCE.yolo_files.utils.torch_utils import time_synchronized, fuse_conv_and_bn, model_info, scale_img, initialize_weights, \
- select_device, copy_attr
-
-try:
- import thop # for FLOPS computation
-except ImportError:
- thop = None
-
-
-class Detect(nn.Module):
- stride = None # strides computed during build
- onnx_dynamic = False # ONNX export parameter
-
- def __init__(self, nc=80, anchors=(), ch=(), inplace=True): # detection layer
- super(Detect, self).__init__()
- self.nc = nc # number of classes
- self.no = nc + 5 # number of outputs per anchor
- self.nl = len(anchors) # number of detection layers
- self.na = len(anchors[0]) // 2 # number of anchors
- self.grid = [torch.zeros(1)] * self.nl # init grid
- a = torch.tensor(anchors).float().view(self.nl, -1, 2)
- self.register_buffer('anchors', a) # shape(nl,na,2)
- self.register_buffer('anchor_grid', a.clone().view(self.nl, 1, -1, 1, 1, 2)) # shape(nl,1,na,1,1,2)
- self.m = nn.ModuleList(nn.Conv2d(x, self.no * self.na, 1) for x in ch) # output conv
- self.inplace = inplace # use in-place ops (e.g. slice assignment)
-
- def forward(self, x):
- # x = x.copy() # for profiling
- z = [] # inference output
- for i in range(self.nl):
- x[i] = self.m[i](x[i]) # conv
- bs, _, ny, nx = x[i].shape # x(bs,255,20,20) to x(bs,3,20,20,85)
- x[i] = x[i].view(bs, self.na, self.no, ny, nx).permute(0, 1, 3, 4, 2).contiguous()
-
- if not self.training: # inference
- if self.grid[i].shape[2:4] != x[i].shape[2:4] or self.onnx_dynamic:
- self.grid[i] = self._make_grid(nx, ny).to(x[i].device)
-
- y = x[i].sigmoid()
- if self.inplace:
- y[..., 0:2] = (y[..., 0:2] * 2. - 0.5 + self.grid[i]) * self.stride[i] # xy
- y[..., 2:4] = (y[..., 2:4] * 2) ** 2 * self.anchor_grid[i] # wh
- else: # for YOLOv5 on AWS Inferentia https://github.com/ultralytics/yolov5/pull/2953
- xy = (y[..., 0:2] * 2. - 0.5 + self.grid[i]) * self.stride[i] # xy
- wh = (y[..., 2:4] * 2) ** 2 * self.anchor_grid[i].view(1, self.na, 1, 1, 2) # wh
- y = torch.cat((xy, wh, y[..., 4:]), -1)
- z.append(y.view(bs, -1, self.no))
-
- return x if self.training else (torch.cat(z, 1), x)
-
- @staticmethod
- def _make_grid(nx=20, ny=20):
- yv, xv = torch.meshgrid([torch.arange(ny), torch.arange(nx)])
- return torch.stack((xv, yv), 2).view((1, 1, ny, nx, 2)).float()
-
-
-class Model(nn.Module):
- def __init__(self, cfg='yolov5s.yaml', ch=3, nc=None, anchors=None): # model, input channels, number of classes
- super(Model, self).__init__()
- if isinstance(cfg, dict):
- self.yaml = cfg # model dict
- else: # is *.yaml
- import yaml # for torch hub
- self.yaml_file = Path(cfg).name
- with open(cfg) as f:
- self.yaml = yaml.safe_load(f) # model dict
-
- # Define model
- ch = self.yaml['ch'] = self.yaml.get('ch', ch) # input channels
- if nc and nc != self.yaml['nc']:
- logger.info(f"Overriding model.yaml nc={self.yaml['nc']} with nc={nc}")
- self.yaml['nc'] = nc # override yaml value
- if anchors:
- logger.info(f'Overriding model.yaml anchors with anchors={anchors}')
- self.yaml['anchors'] = round(anchors) # override yaml value
- self.model, self.save = parse_model(deepcopy(self.yaml), ch=[ch]) # model, savelist
- self.names = [str(i) for i in range(self.yaml['nc'])] # default names
- self.inplace = self.yaml.get('inplace', True)
- # logger.info([x.shape for x in self.forward(torch.zeros(1, ch, 64, 64))])
-
- # Build strides, anchors
- m = self.model[-1] # Detect()
- if isinstance(m, Detect):
- s = 256 # 2x min stride
- m.inplace = self.inplace
- m.stride = torch.tensor([s / x.shape[-2] for x in self.forward(torch.zeros(1, ch, s, s))]) # forward
- m.anchors /= m.stride.view(-1, 1, 1)
- check_anchor_order(m)
- self.stride = m.stride
- self._initialize_biases() # only run once
- # logger.info('Strides: %s' % m.stride.tolist())
-
- # Init weights, biases
- initialize_weights(self)
- self.info()
- logger.info('')
-
- def forward(self, x, augment=False, profile=False):
- if augment:
- return self.forward_augment(x) # augmented inference, None
- else:
- return self.forward_once(x, profile) # single-scale inference, train
-
- def forward_augment(self, x):
- img_size = x.shape[-2:] # height, width
- s = [1, 0.83, 0.67] # scales
- f = [None, 3, None] # flips (2-ud, 3-lr)
- y = [] # outputs
- for si, fi in zip(s, f):
- xi = scale_img(x.flip(fi) if fi else x, si, gs=int(self.stride.max()))
- yi = self.forward_once(xi)[0] # forward
- # cv2.imwrite(f'img_{si}.jpg', 255 * xi[0].cpu().numpy().transpose((1, 2, 0))[:, :, ::-1]) # save
- yi = self._descale_pred(yi, fi, si, img_size)
- y.append(yi)
- return torch.cat(y, 1), None # augmented inference, train
-
- def forward_once(self, x, profile=False):
- y, dt = [], [] # outputs
- for m in self.model:
- if m.f != -1: # if not from previous layer
- x = y[m.f] if isinstance(m.f, int) else [x if j == -1 else y[j] for j in m.f] # from earlier layers
-
- if profile:
- o = thop.profile(m, inputs=(x,), verbose=False)[0] / 1E9 * 2 if thop else 0 # FLOPS
- t = time_synchronized()
- for _ in range(10):
- _ = m(x)
- dt.append((time_synchronized() - t) * 100)
- if m == self.model[0]:
- logger.info(f"{'time (ms)':>10s} {'GFLOPS':>10s} {'params':>10s} {'module'}")
- logger.info(f'{dt[-1]:10.2f} {o:10.2f} {m.np:10.0f} {m.type}')
-
- x = m(x) # run
- y.append(x if m.i in self.save else None) # save output
-
- if profile:
- logger.info('%.1fms total' % sum(dt))
- return x
-
- def _descale_pred(self, p, flips, scale, img_size):
- # de-scale predictions following augmented inference (inverse operation)
- if self.inplace:
- p[..., :4] /= scale # de-scale
- if flips == 2:
- p[..., 1] = img_size[0] - p[..., 1] # de-flip ud
- elif flips == 3:
- p[..., 0] = img_size[1] - p[..., 0] # de-flip lr
- else:
- x, y, wh = p[..., 0:1] / scale, p[..., 1:2] / scale, p[..., 2:4] / scale # de-scale
- if flips == 2:
- y = img_size[0] - y # de-flip ud
- elif flips == 3:
- x = img_size[1] - x # de-flip lr
- p = torch.cat((x, y, wh, p[..., 4:]), -1)
- return p
-
- def _initialize_biases(self, cf=None): # initialize biases into Detect(), cf is class frequency
- # https://arxiv.org/abs/1708.02002 section 3.3
- # cf = torch.bincount(torch.tensor(np.concatenate(dataset.labels, 0)[:, 0]).long(), minlength=nc) + 1.
- m = self.model[-1] # Detect() module
- for mi, s in zip(m.m, m.stride): # from
- b = mi.bias.view(m.na, -1) # conv.bias(255) to (3,85)
- b.data[:, 4] += math.log(8 / (640 / s) ** 2) # obj (8 objects per 640 image)
- b.data[:, 5:] += math.log(0.6 / (m.nc - 0.99)) if cf is None else torch.log(cf / cf.sum()) # cls
- mi.bias = torch.nn.Parameter(b.view(-1), requires_grad=True)
-
- def _print_biases(self):
- m = self.model[-1] # Detect() module
- for mi in m.m: # from
- b = mi.bias.detach().view(m.na, -1).T # conv.bias(255) to (3,85)
- logger.info(
- ('%6g Conv2d.bias:' + '%10.3g' * 6) % (mi.weight.shape[1], *b[:5].mean(1).tolist(), b[5:].mean()))
-
- # def _print_weights(self):
- # for m in self.model.modules():
- # if type(m) is Bottleneck:
- # logger.info('%10.3g' % (m.w.detach().sigmoid() * 2)) # shortcut weights
-
- def fuse(self): # fuse model Conv2d() + BatchNorm2d() layers
- logger.info('Fusing layers... ')
- for m in self.model.modules():
- if type(m) is Conv and hasattr(m, 'bn'):
- m.conv = fuse_conv_and_bn(m.conv, m.bn) # update conv
- delattr(m, 'bn') # remove batchnorm
- m.forward = m.fuseforward # update forward
- self.info()
- return self
-
- def nms(self, mode=True): # add or remove NMS module
- present = type(self.model[-1]) is NMS # last layer is NMS
- if mode and not present:
- logger.info('Adding NMS... ')
- m = NMS() # module
- m.f = -1 # from
- m.i = self.model[-1].i + 1 # index
- self.model.add_module(name='%s' % m.i, module=m) # add
- self.eval()
- elif not mode and present:
- logger.info('Removing NMS... ')
- self.model = self.model[:-1] # remove
- return self
-
- def autoshape(self): # add autoShape module
- logger.info('Adding autoShape... ')
- m = autoShape(self) # wrap model
- copy_attr(m, self, include=('yaml', 'nc', 'hyp', 'names', 'stride'), exclude=()) # copy attributes
- return m
-
- def info(self, verbose=False, img_size=640): # print model information
- model_info(self, verbose, img_size)
-
-
-def parse_model(d, ch): # model_dict, input_channels(3)
- logger.info('\n%3s%18s%3s%10s %-40s%-30s' % ('', 'from', 'n', 'params', 'module', 'arguments'))
- anchors, nc, gd, gw = d['anchors'], d['nc'], d['depth_multiple'], d['width_multiple']
- na = (len(anchors[0]) // 2) if isinstance(anchors, list) else anchors # number of anchors
- no = na * (nc + 5) # number of outputs = anchors * (classes + 5)
-
- layers, save, c2 = [], [], ch[-1] # layers, savelist, ch out
- for i, (f, n, m, args) in enumerate(d['backbone'] + d['head']): # from, number, module, args
- m = eval(m) if isinstance(m, str) else m # eval strings
- for j, a in enumerate(args):
- try:
- args[j] = eval(a) if isinstance(a, str) else a # eval strings
- except:
- pass
-
- n = max(round(n * gd), 1) if n > 1 else n # depth gain
- if m in [Conv, GhostConv, Bottleneck, GhostBottleneck, SPP, DWConv, MixConv2d, Focus, CrossConv, BottleneckCSP,
- C3, C3TR]:
- c1, c2 = ch[f], args[0]
- if c2 != no: # if not output
- c2 = make_divisible(c2 * gw, 8)
-
- args = [c1, c2, *args[1:]]
- if m in [BottleneckCSP, C3, C3TR]:
- args.insert(2, n) # number of repeats
- n = 1
- elif m is nn.BatchNorm2d:
- args = [ch[f]]
- elif m is Concat:
- c2 = sum([ch[x] for x in f])
- elif m is Detect:
- args.append([ch[x] for x in f])
- if isinstance(args[1], int): # number of anchors
- args[1] = [list(range(args[1] * 2))] * len(f)
- elif m is Contract:
- c2 = ch[f] * args[0] ** 2
- elif m is Expand:
- c2 = ch[f] // args[0] ** 2
- else:
- c2 = ch[f]
-
- m_ = nn.Sequential(*[m(*args) for _ in range(n)]) if n > 1 else m(*args) # module
- t = str(m)[8:-2].replace('__main__.', '') # module type
- np = sum([x.numel() for x in m_.parameters()]) # number params
- m_.i, m_.f, m_.type, m_.np = i, f, t, np # attach index, 'from' index, type, number params
- logger.info('%3s%18s%3s%10.0f %-40s%-30s' % (i, f, n, np, t, args)) # print
- save.extend(x % i for x in ([f] if isinstance(f, int) else f) if x != -1) # append to savelist
- layers.append(m_)
- if i == 0:
- ch = []
- ch.append(c2)
- return nn.Sequential(*layers), sorted(save)
-
-
-if __name__ == '__main__':
- parser = argparse.ArgumentParser()
- parser.add_argument('--cfg', type=str, default='yolov5s.yaml', help='model.yaml')
- parser.add_argument('--device', default='', help='cuda device, i.e. 0 or 0,1,2,3 or cpu')
- opt = parser.parse_args()
- opt.cfg = check_file(opt.cfg) # check file
- set_logging()
- device = select_device(opt.device)
-
- # Create model
- model = Model(opt.cfg).to(device)
- model.train()
-
- # Profile
- # img = torch.rand(8 if torch.cuda.is_available() else 1, 3, 320, 320).to(device)
- # y = model(img, profile=True)
-
- # Tensorboard (not working https://github.com/ultralytics/yolov5/issues/2898)
- # from torch.utils.tensorboard import SummaryWriter
- # tb_writer = SummaryWriter('.')
- # logger.info("Run 'tensorboard --logdir=models' to view tensorboard at http://localhost:6006/")
- # tb_writer.add_graph(torch.jit.trace(model, img, strict=False), []) # add model graph
- # tb_writer.add_image('test', img[0], dataformats='CWH') # add model to tensorboard
diff --git a/spaces/dantosxd/gorilla-llm-gorilla-mpt-7b-hf-v0/README.md b/spaces/dantosxd/gorilla-llm-gorilla-mpt-7b-hf-v0/README.md
deleted file mode 100644
index 899d81a183a0d37a806858be6f55eda49c95d2fd..0000000000000000000000000000000000000000
--- a/spaces/dantosxd/gorilla-llm-gorilla-mpt-7b-hf-v0/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: Gorilla Llm Gorilla Mpt 7b Hf V0
-emoji: 🌍
-colorFrom: purple
-colorTo: indigo
-sdk: gradio
-sdk_version: 3.34.0
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/datasciencedojo/Describe-Dataset/app.py b/spaces/datasciencedojo/Describe-Dataset/app.py
deleted file mode 100644
index c44a96ef53d0648c1cee86c73e8008f83045d067..0000000000000000000000000000000000000000
--- a/spaces/datasciencedojo/Describe-Dataset/app.py
+++ /dev/null
@@ -1,159 +0,0 @@
-import gradio as gr
-import os
-import pandas as pd
-import seaborn as sns
-import matplotlib.pyplot as plt
-
-def dataset_change(dataset):
- df = pd.read_csv(dataset.name)
- features = df.columns
- features_object_list = [feature for feature in features]
- describe = df.describe(include='all')
- print(describe)
- return describe.reset_index(), gr.Dropdown.update(choices = features_object_list), gr.Dropdown.update(choices = features_object_list)
-
-def feature_select(dataset, feature, hue = None):
- df = pd.read_csv(dataset.name)
- non_numeric_cols = df.select_dtypes('object').columns.tolist()
-
- if feature in non_numeric_cols:
- kde = False
- plot2 = plt.figure()
- if hue:
- sns.countplot(x = feature, data = df, palette='rainbow', hue = hue)
- else:
- sns.countplot(x = feature, data = df, palette='rainbow')
- else:
- kde = True
- plot2 = plt.figure()
- if hue:
- sns.boxplot(x = feature, data = df, hue = hue)
- else:
- sns.boxplot(x = feature, data = df )
-
- plot1 = plt.figure()
- if hue:
- sns.histplot(data = df, x = feature, kde = kde, hue = hue, multiple="stack")
- else:
- sns.histplot(data = df, x = feature, kde = kde)
-
- return plot1, plot2
-
-css = """
-footer {display:none !important}
-.overflow-x-scroll {
- overflow-x: scroll !important;
- height: 15rem !important;
- overflow-y: scroll !important;
-}
-
-.max-h-\[30rem\] {max-height: 18rem !important;}
-
-.hover\:bg-orange-50:hover {
- --tw-bg-opacity: 1 !important;
- background-color: rgb(229,225,255) !important;
-}
-
-.output-markdown h2{
- z-index: 14;
- align-self: flex-start;
- min-width: 0px;
- order: 5;
- min-height: 0px;
- height: max-content;
- flex-grow: 0;
- flex-shrink: 0;
- width: calc(100% - 0px);
- margin: 5px 0px;
- white-space: pre-wrap;
- overflow: visible;
- word-break: break-word;
- font-size: 18px !important;
- font-weight: 500 !important;
- color: rgb(9, 23, 71) !important;
- line-height: 1 !important;
- border-radius: 0px !important;
- opacity: 1 !important;
-}
-
-.gr-button-lg {
- z-index: 14;
- width: 113px !important;
- height: 30px !important;
- left: 0px;
- top: 0px;
- padding: 0px;
- cursor: pointer !important;
- background: none rgb(17, 20, 45) !important;
- border: none !important;
- text-align: center !important;
- font-size: 14px !important;
- font-weight: 500 !important;
- color: rgb(255, 255, 255) !important;
- line-height: 1 !important;
- border-radius: 6px !important;
- transition: box-shadow 200ms ease 0s, background 200ms ease 0s !important;
- box-shadow: none !important;
-}
-.gr-button-lg:hover{
- z-index: 14;
- width: 113px !important;
- height: 30px !important;
- left: 0px;
- top: 0px;
- padding: 0px;
- cursor: pointer !important;
- background: none rgb(37, 56, 133) !important;
- border: none !important;
- text-align: center !important;
- font-size: 14px !important;
- font-weight: 500 !important;
- color: rgb(255, 255, 255) !important;
- line-height: 1 !important;
- border-radius: 6px !important;
- transition: box-shadow 200ms ease 0s, background 200ms ease 0s !important;
- box-shadow: rgb(0 0 0 / 23%) 0px 1px 7px 0px !important;
-}
-"""
-
-with gr.Blocks(title="Describe Dataset | Data Science Dojo", css = css) as demo:
- gr.Markdown("""## Input Dataset""")
- with gr.Row():
- dataset = gr.File()
- gr.Markdown("""## Dataset Description""")
- with gr.Row():
- dataframe = gr.Dataframe()
- gr.Markdown("""## Select the feature to visualize""")
- with gr.Row():
- with gr.Column():
- features = gr.Dropdown(label="Select feature to visualize")
- with gr.Column():
- hue = gr.Dropdown(label="Select hue")
- with gr.Row():
- btn = gr.Button("Visualize")
-
- gr.Markdown("""## Visualization""")
- with gr.Row():
- plot1 = gr.Plot()
- with gr.Row():
- plot2 = gr.Plot()
-
- gr.Examples(
- examples=[["boston.csv"]],
- fn = dataset_change,
- inputs = dataset,
- outputs = [dataframe, features, hue],
- cache_examples=True
- )
-
- dataset.change(fn=dataset_change,
- inputs = dataset,
- outputs = [dataframe, features, hue]
- )
-
- btn.click(fn=feature_select,
- inputs=[dataset, features, hue],
- outputs=[plot1, plot2]
- )
-
-demo.launch(debug=True)
\ No newline at end of file
diff --git a/spaces/davanstrien/arch_demo/README.md b/spaces/davanstrien/arch_demo/README.md
deleted file mode 100644
index 66754ef2772f6a5db3af6ba27d1a1c0527a6d7f3..0000000000000000000000000000000000000000
--- a/spaces/davanstrien/arch_demo/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: ARCH Demo
-emoji: 📸
-colorFrom: red
-colorTo: blue
-sdk: gradio
-sdk_version: 3.27.0
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/davidpiscasio/unpaired-img2img/options/base_options.py b/spaces/davidpiscasio/unpaired-img2img/options/base_options.py
deleted file mode 100644
index c096d872aac445fb6fe311dca1d1ff5723bd11f5..0000000000000000000000000000000000000000
--- a/spaces/davidpiscasio/unpaired-img2img/options/base_options.py
+++ /dev/null
@@ -1,137 +0,0 @@
-import argparse
-import os
-from util import util
-import torch
-import models
-import data
-
-
-class BaseOptions():
- """This class defines options used during both training and test time.
-
- It also implements several helper functions such as parsing, printing, and saving the options.
- It also gathers additional options defined in functions in both dataset class and model class.
- """
-
- def __init__(self):
- """Reset the class; indicates the class hasn't been initailized"""
- self.initialized = False
-
- def initialize(self, parser):
- """Define the common options that are used in both training and test."""
- # basic parameters
- parser.add_argument('--dataroot', required=False, help='path to images (should have subfolders trainA, trainB, valA, valB, etc)')
- parser.add_argument('--name', type=str, default='experiment_name', help='name of the experiment. It decides where to store samples and models')
- parser.add_argument('--use_wandb', action='store_true', help='use wandb')
- parser.add_argument('--gpu_ids', type=str, default='-1', help='gpu ids: e.g. 0 0,1,2, 0,2. use -1 for CPU')
- parser.add_argument('--checkpoints_dir', type=str, default='./checkpoints', help='models are saved here')
- # model parameters
- parser.add_argument('--model', type=str, default='cycle_gan', help='chooses which model to use. [cycle_gan | pix2pix | test | colorization]')
- parser.add_argument('--input_nc', type=int, default=3, help='# of input image channels: 3 for RGB and 1 for grayscale')
- parser.add_argument('--output_nc', type=int, default=3, help='# of output image channels: 3 for RGB and 1 for grayscale')
- parser.add_argument('--ngf', type=int, default=64, help='# of gen filters in the last conv layer')
- parser.add_argument('--ndf', type=int, default=64, help='# of discrim filters in the first conv layer')
- parser.add_argument('--netD', type=str, default='basic', help='specify discriminator architecture [basic | n_layers | pixel]. The basic model is a 70x70 PatchGAN. n_layers allows you to specify the layers in the discriminator')
- parser.add_argument('--netG', type=str, default='resnet_9blocks', help='specify generator architecture [resnet_9blocks | resnet_6blocks | unet_256 | unet_128]')
- parser.add_argument('--n_layers_D', type=int, default=3, help='only used if netD==n_layers')
- parser.add_argument('--norm', type=str, default='instance', help='instance normalization or batch normalization [instance | batch | none]')
- parser.add_argument('--init_type', type=str, default='normal', help='network initialization [normal | xavier | kaiming | orthogonal]')
- parser.add_argument('--init_gain', type=float, default=0.02, help='scaling factor for normal, xavier and orthogonal.')
- parser.add_argument('--no_dropout', action='store_true', help='no dropout for the generator')
- # dataset parameters
- parser.add_argument('--dataset_mode', type=str, default='unaligned', help='chooses how datasets are loaded. [unaligned | aligned | single | colorization]')
- parser.add_argument('--direction', type=str, default='AtoB', help='AtoB or BtoA')
- parser.add_argument('--serial_batches', action='store_true', help='if true, takes images in order to make batches, otherwise takes them randomly')
- parser.add_argument('--num_threads', default=4, type=int, help='# threads for loading data')
- parser.add_argument('--batch_size', type=int, default=1, help='input batch size')
- parser.add_argument('--load_size', type=int, default=286, help='scale images to this size')
- parser.add_argument('--crop_size', type=int, default=256, help='then crop to this size')
- parser.add_argument('--max_dataset_size', type=int, default=float("inf"), help='Maximum number of samples allowed per dataset. If the dataset directory contains more than max_dataset_size, only a subset is loaded.')
- parser.add_argument('--preprocess', type=str, default='resize_and_crop', help='scaling and cropping of images at load time [resize_and_crop | crop | scale_width | scale_width_and_crop | none]')
- parser.add_argument('--no_flip', action='store_true', help='if specified, do not flip the images for data augmentation')
- parser.add_argument('--display_winsize', type=int, default=256, help='display window size for both visdom and HTML')
- # additional parameters
- parser.add_argument('--epoch', type=str, default='latest', help='which epoch to load? set to latest to use latest cached model')
- parser.add_argument('--load_iter', type=int, default='0', help='which iteration to load? if load_iter > 0, the code will load models by iter_[load_iter]; otherwise, the code will load models by [epoch]')
- parser.add_argument('--verbose', action='store_true', help='if specified, print more debugging information')
- parser.add_argument('--suffix', default='', type=str, help='customized suffix: opt.name = opt.name + suffix: e.g., {model}_{netG}_size{load_size}')
- self.initialized = True
- return parser
-
- def gather_options(self):
- """Initialize our parser with basic options(only once).
- Add additional model-specific and dataset-specific options.
- These options are defined in the function
- in model and dataset classes.
- """
- if not self.initialized: # check if it has been initialized
- parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
- parser = self.initialize(parser)
-
- # get the basic options
- opt, _ = parser.parse_known_args()
-
- # modify model-related parser options
- model_name = opt.model
- model_option_setter = models.get_option_setter(model_name)
- parser = model_option_setter(parser, self.isTrain)
- opt, _ = parser.parse_known_args() # parse again with new defaults
-
- # modify dataset-related parser options
- dataset_name = opt.dataset_mode
- dataset_option_setter = data.get_option_setter(dataset_name)
- parser = dataset_option_setter(parser, self.isTrain)
-
- # save and return the parser
- self.parser = parser
- return parser.parse_args()
-
- def print_options(self, opt):
- """Print and save options
-
- It will print both current options and default values(if different).
- It will save options into a text file / [checkpoints_dir] / opt.txt
- """
- message = ''
- message += '----------------- Options ---------------\n'
- for k, v in sorted(vars(opt).items()):
- comment = ''
- default = self.parser.get_default(k)
- if v != default:
- comment = '\t[default: %s]' % str(default)
- message += '{:>25}: {:<30}{}\n'.format(str(k), str(v), comment)
- message += '----------------- End -------------------'
- print(message)
-
- # save to the disk
- expr_dir = os.path.join(opt.checkpoints_dir, opt.name)
- util.mkdirs(expr_dir)
- file_name = os.path.join(expr_dir, '{}_opt.txt'.format(opt.phase))
- with open(file_name, 'wt') as opt_file:
- opt_file.write(message)
- opt_file.write('\n')
-
- def parse(self):
- """Parse our options, create checkpoints directory suffix, and set up gpu device."""
- opt = self.gather_options()
- opt.isTrain = self.isTrain # train or test
-
- # process opt.suffix
- if opt.suffix:
- suffix = ('_' + opt.suffix.format(**vars(opt))) if opt.suffix != '' else ''
- opt.name = opt.name + suffix
-
- self.print_options(opt)
-
- # set gpu ids
- str_ids = opt.gpu_ids.split(',')
- opt.gpu_ids = []
- for str_id in str_ids:
- id = int(str_id)
- if id >= 0:
- opt.gpu_ids.append(id)
- if len(opt.gpu_ids) > 0:
- torch.cuda.set_device(opt.gpu_ids[0])
-
- self.opt = opt
- return self.opt
diff --git a/spaces/dawood/Kanye-AI/vdecoder/hifigan/utils.py b/spaces/dawood/Kanye-AI/vdecoder/hifigan/utils.py
deleted file mode 100644
index 9c93c996d3cc73c30d71c1fc47056e4230f35c0f..0000000000000000000000000000000000000000
--- a/spaces/dawood/Kanye-AI/vdecoder/hifigan/utils.py
+++ /dev/null
@@ -1,68 +0,0 @@
-import glob
-import os
-import matplotlib
-import torch
-from torch.nn.utils import weight_norm
-# matplotlib.use("Agg")
-import matplotlib.pylab as plt
-
-
-def plot_spectrogram(spectrogram):
- fig, ax = plt.subplots(figsize=(10, 2))
- im = ax.imshow(spectrogram, aspect="auto", origin="lower",
- interpolation='none')
- plt.colorbar(im, ax=ax)
-
- fig.canvas.draw()
- plt.close()
-
- return fig
-
-
-def init_weights(m, mean=0.0, std=0.01):
- classname = m.__class__.__name__
- if classname.find("Conv") != -1:
- m.weight.data.normal_(mean, std)
-
-
-def apply_weight_norm(m):
- classname = m.__class__.__name__
- if classname.find("Conv") != -1:
- weight_norm(m)
-
-
-def get_padding(kernel_size, dilation=1):
- return int((kernel_size*dilation - dilation)/2)
-
-
-def load_checkpoint(filepath, device):
- assert os.path.isfile(filepath)
- print("Loading '{}'".format(filepath))
- checkpoint_dict = torch.load(filepath, map_location=device)
- print("Complete.")
- return checkpoint_dict
-
-
-def save_checkpoint(filepath, obj):
- print("Saving checkpoint to {}".format(filepath))
- torch.save(obj, filepath)
- print("Complete.")
-
-
-def del_old_checkpoints(cp_dir, prefix, n_models=2):
- pattern = os.path.join(cp_dir, prefix + '????????')
- cp_list = glob.glob(pattern) # get checkpoint paths
- cp_list = sorted(cp_list)# sort by iter
- if len(cp_list) > n_models: # if more than n_models models are found
- for cp in cp_list[:-n_models]:# delete the oldest models other than lastest n_models
- open(cp, 'w').close()# empty file contents
- os.unlink(cp)# delete file (move to trash when using Colab)
-
-
-def scan_checkpoint(cp_dir, prefix):
- pattern = os.path.join(cp_dir, prefix + '????????')
- cp_list = glob.glob(pattern)
- if len(cp_list) == 0:
- return None
- return sorted(cp_list)[-1]
-
diff --git a/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/gradio/events.py b/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/gradio/events.py
deleted file mode 100644
index ce1a442fb4fe71cbbd11c6bbc51dc4f9b3e7ac78..0000000000000000000000000000000000000000
--- a/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/gradio/events.py
+++ /dev/null
@@ -1,361 +0,0 @@
-"""Contains all of the events that can be triggered in a gr.Blocks() app, with the exception
-of the on-page-load event, which is defined in gr.Blocks().load()."""
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any, Callable, Literal, Sequence
-
-from gradio_client.documentation import document, set_documentation_group
-
-from gradio.blocks import Block
-from gradio.deprecation import warn_deprecation
-from gradio.helpers import EventData
-from gradio.utils import get_cancel_function
-
-if TYPE_CHECKING: # Only import for type checking (is False at runtime).
- from gradio.components import Component
-
-set_documentation_group("events")
-
-
-def set_cancel_events(
- block: Block, event_name: str, cancels: None | dict[str, Any] | list[dict[str, Any]]
-):
- if cancels:
- if not isinstance(cancels, list):
- cancels = [cancels]
- cancel_fn, fn_indices_to_cancel = get_cancel_function(cancels)
- block.set_event_trigger(
- event_name,
- cancel_fn,
- inputs=None,
- outputs=None,
- queue=False,
- preprocess=False,
- cancels=fn_indices_to_cancel,
- )
-
-
-class EventListener(Block):
- def __init__(self: Any):
- for event_listener_class in EventListener.__subclasses__():
- if isinstance(self, event_listener_class):
- event_listener_class.__init__(self)
-
-
-class Dependency(dict):
- def __init__(self, trigger, key_vals, dep_index):
- super().__init__(key_vals)
- self.trigger = trigger
- self.then = EventListenerMethod(
- self.trigger,
- "then",
- trigger_after=dep_index,
- trigger_only_on_success=False,
- )
- """
- Triggered after directly preceding event is completed, regardless of success or failure.
- """
- self.success = EventListenerMethod(
- self.trigger,
- "success",
- trigger_after=dep_index,
- trigger_only_on_success=True,
- )
- """
- Triggered after directly preceding event is completed, if it was successful.
- """
-
-
-class EventListenerMethod:
- """
- Triggered on an event deployment.
- """
-
- def __init__(
- self,
- trigger: Block,
- event_name: str,
- show_progress: Literal["full", "minimal", "hidden"] = "full",
- callback: Callable | None = None,
- trigger_after: int | None = None,
- trigger_only_on_success: bool = False,
- ):
- self.trigger = trigger
- self.event_name = event_name
- self.show_progress = show_progress
- self.callback = callback
- self.trigger_after = trigger_after
- self.trigger_only_on_success = trigger_only_on_success
-
- def __call__(
- self,
- fn: Callable | None,
- inputs: Component | Sequence[Component] | set[Component] | None = None,
- outputs: Component | Sequence[Component] | None = None,
- api_name: str | None | Literal[False] = None,
- status_tracker: None = None,
- scroll_to_output: bool = False,
- show_progress: Literal["full", "minimal", "hidden"] = "full",
- queue: bool | None = None,
- batch: bool = False,
- max_batch_size: int = 4,
- preprocess: bool = True,
- postprocess: bool = True,
- cancels: dict[str, Any] | list[dict[str, Any]] | None = None,
- every: float | None = None,
- _js: str | None = None,
- ) -> Dependency:
- """
- Parameters:
- fn: the function to wrap an interface around. Often a machine learning model's prediction function. Each parameter of the function corresponds to one input component, and the function should return a single value or a tuple of values, with each element in the tuple corresponding to one output component.
- inputs: List of gradio.components to use as inputs. If the function takes no inputs, this should be an empty list.
- outputs: List of gradio.components to use as outputs. If the function returns no outputs, this should be an empty list.
- api_name: Defines how the endpoint appears in the API docs. Can be a string, None, or False. If False, the endpoint will not be exposed in the api docs. If set to None, the endpoint will be exposed in the api docs as an unnamed endpoint, although this behavior will be changed in Gradio 4.0. If set to a string, the endpoint will be exposed in the api docs with the given name.
- scroll_to_output: If True, will scroll to output component on completion
- show_progress: If True, will show progress animation while pending
- queue: If True, will place the request on the queue, if the queue has been enabled. If False, will not put this event on the queue, even if the queue has been enabled. If None, will use the queue setting of the gradio app.
- batch: If True, then the function should process a batch of inputs, meaning that it should accept a list of input values for each parameter. The lists should be of equal length (and be up to length `max_batch_size`). The function is then *required* to return a tuple of lists (even if there is only 1 output component), with each list in the tuple corresponding to one output component.
- max_batch_size: Maximum number of inputs to batch together if this is called from the queue (only relevant if batch=True)
- preprocess: If False, will not run preprocessing of component data before running 'fn' (e.g. leaving it as a base64 string if this method is called with the `Image` component).
- postprocess: If False, will not run postprocessing of component data before returning 'fn' output to the browser.
- cancels: A list of other events to cancel when This listener is triggered. For example, setting cancels=[click_event] will cancel the click_event, where click_event is the return value of another components .click method. Functions that have not yet run (or generators that are iterating) will be cancelled, but functions that are currently running will be allowed to finish.
- every: Run this event 'every' number of seconds while the client connection is open. Interpreted in seconds. Queue must be enabled.
- """
- if status_tracker:
- warn_deprecation(
- "The 'status_tracker' parameter has been deprecated and has no effect."
- )
- if self.event_name == "stop":
- warn_deprecation(
- "The `stop` event on Video and Audio has been deprecated and will be remove in a future version. Use `ended` instead."
- )
-
- if isinstance(self, Streamable):
- self.check_streamable()
- if isinstance(show_progress, bool):
- show_progress = "full" if show_progress else "hidden"
-
- dep, dep_index = self.trigger.set_event_trigger(
- self.event_name,
- fn,
- inputs,
- outputs,
- preprocess=preprocess,
- postprocess=postprocess,
- scroll_to_output=scroll_to_output,
- show_progress=show_progress
- if show_progress is not None
- else self.show_progress,
- api_name=api_name,
- js=_js,
- queue=queue,
- batch=batch,
- max_batch_size=max_batch_size,
- every=every,
- trigger_after=self.trigger_after,
- trigger_only_on_success=self.trigger_only_on_success,
- )
- set_cancel_events(self.trigger, self.event_name, cancels)
- if self.callback:
- self.callback()
- return Dependency(self.trigger, dep, dep_index)
-
-
-@document("*change", inherit=True)
-class Changeable(EventListener):
- def __init__(self):
- self.change = EventListenerMethod(self, "change")
- """
- This listener is triggered when the component's value changes either because of user input (e.g. a user types in a textbox) OR because of a function update (e.g. an image receives a value from the output of an event trigger).
- See `.input()` for a listener that is only triggered by user input.
- This method can be used when this component is in a Gradio Blocks.
- """
-
-
-@document("*input", inherit=True)
-class Inputable(EventListener):
- def __init__(self):
- self.input = EventListenerMethod(self, "input")
- """
- This listener is triggered when the user changes the value of the component.
- This method can be used when this component is in a Gradio Blocks.
- """
-
-
-@document("*click", inherit=True)
-class Clickable(EventListener):
- def __init__(self):
- self.click = EventListenerMethod(self, "click")
- """
- This listener is triggered when the component (e.g. a button) is clicked.
- This method can be used when this component is in a Gradio Blocks.
- """
-
-
-@document("*submit", inherit=True)
-class Submittable(EventListener):
- def __init__(self):
- self.submit = EventListenerMethod(self, "submit")
- """
- This listener is triggered when the user presses the Enter key while the component (e.g. a textbox) is focused.
- This method can be used when this component is in a Gradio Blocks.
- """
-
-
-@document("*edit", inherit=True)
-class Editable(EventListener):
- def __init__(self):
- self.edit = EventListenerMethod(self, "edit")
- """
- This listener is triggered when the user edits the component (e.g. image) using the
- built-in editor. This method can be used when this component is in a Gradio Blocks.
- """
-
-
-@document("*clear", inherit=True)
-class Clearable(EventListener):
- def __init__(self):
- self.clear = EventListenerMethod(self, "clear")
- """
- This listener is triggered when the user clears the component (e.g. image or audio)
- using the X button for the component. This method can be used when this component is in a Gradio Blocks.
- """
-
-
-@document("*play", "*pause", "*stop", "*end", inherit=True)
-class Playable(EventListener):
- def __init__(self):
- self.play = EventListenerMethod(self, "play")
- """
- This listener is triggered when the user plays the component (e.g. audio or video).
- This method can be used when this component is in a Gradio Blocks.
- """
-
- self.pause = EventListenerMethod(self, "pause")
- """
- This listener is triggered when the media stops playing for any reason (e.g. audio or video).
- This method can be used when this component is in a Gradio Blocks.
- """
-
- self.stop = EventListenerMethod(self, "stop")
- """
- This listener is triggered when the user reaches the end of the media track (e.g. audio or video).
- This method can be used when this component is in a Gradio Blocks.
- """
-
- self.end = EventListenerMethod(self, "end")
- """
- This listener is triggered when the user reaches the end of the media track (e.g. audio or video).
- This method can be used when this component is in a Gradio Blocks.
- """
-
-
-@document("*stream", inherit=True)
-class Streamable(EventListener):
- def __init__(self):
- self.streaming: bool
- self.stream = EventListenerMethod(
- self,
- "stream",
- show_progress="hidden",
- callback=lambda: setattr(self, "streaming", True),
- )
- """
- This listener is triggered when the user streams the component (e.g. a live webcam
- component). This method can be used when this component is in a Gradio Blocks.
- """
-
- def check_streamable(self):
- pass
-
-
-class StreamableOutput(EventListener):
- def __init__(self):
- self.streaming: bool
-
- def stream_output(self, y) -> bytes:
- raise NotImplementedError
-
-
-@document("*start_recording", "*stop_recording", inherit=True)
-class Recordable(EventListener):
- def __init__(self):
- self.start_recording = EventListenerMethod(self, "start_recording")
- """
- This listener is triggered when the user starts recording with the component (e.g. audio or video).
- This method can be used when this component is in a Gradio Blocks.
- """
-
- self.stop_recording = EventListenerMethod(self, "stop_recording")
- """
- This listener is triggered when the user stops recording with the component (e.g. audio or video).
- This method can be used when this component is in a Gradio Blocks.
- """
-
-
-@document("*focus", "*blur", inherit=True)
-class Focusable(EventListener):
- def __init__(self):
- self.focus = EventListenerMethod(self, "focus")
- """
- This listener is triggered when the component is focused (e.g. when the user clicks inside a textbox).
- This method can be used when this component is in a Gradio Blocks.
- """
-
- self.blur = EventListenerMethod(self, "blur")
- """
- This listener is triggered when the component's is unfocused/blurred (e.g. when the user clicks outside of a textbox).
- This method can be used when this component is in a Gradio Blocks.
- """
-
-
-@document("*upload", inherit=True)
-class Uploadable(EventListener):
- def __init__(self):
- self.upload = EventListenerMethod(self, "upload")
- """
- This listener is triggered when the user uploads a file into the component (e.g. when the user uploads a video into a video component).
- This method can be used when this component is in a Gradio Blocks.
- """
-
-
-@document("*release", inherit=True)
-class Releaseable(EventListener):
- def __init__(self):
- self.release = EventListenerMethod(self, "release")
- """
- This listener is triggered when the user releases the mouse on this component (e.g. when the user releases the slider).
- This method can be used when this component is in a Gradio Blocks.
- """
-
-
-@document("*select", inherit=True)
-class Selectable(EventListener):
- def __init__(self):
- self.selectable: bool = False
- self.select = EventListenerMethod(
- self, "select", callback=lambda: setattr(self, "selectable", True)
- )
- """
- This listener is triggered when the user selects from within the Component.
- This event has EventData of type gradio.SelectData that carries information, accessible through SelectData.index and SelectData.value.
- See EventData documentation on how to use this event data.
- """
-
-
-class SelectData(EventData):
- def __init__(self, target: Block | None, data: Any):
- super().__init__(target, data)
- self.index: int | tuple[int, int] = data["index"]
- """
- The index of the selected item. Is a tuple if the component is two dimensional or selection is a range.
- """
- self.value: Any = data["value"]
- """
- The value of the selected item.
- """
- self.selected: bool = data.get("selected", True)
- """
- True if the item was selected, False if deselected.
- """
diff --git a/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/huggingface_hub/utils/_headers.py b/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/huggingface_hub/utils/_headers.py
deleted file mode 100644
index 846cca3f1d3c3f000de92840a89fb11e35f2083f..0000000000000000000000000000000000000000
--- a/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/huggingface_hub/utils/_headers.py
+++ /dev/null
@@ -1,234 +0,0 @@
-# coding=utf-8
-# Copyright 2022-present, the HuggingFace Inc. team.
-#
-# 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.
-"""Contains utilities to handle headers to send in calls to Huggingface Hub."""
-from typing import Dict, Optional, Union
-
-from .. import constants
-from ._hf_folder import HfFolder
-from ._runtime import (
- get_fastai_version,
- get_fastcore_version,
- get_hf_hub_version,
- get_python_version,
- get_tf_version,
- get_torch_version,
- is_fastai_available,
- is_fastcore_available,
- is_tf_available,
- is_torch_available,
-)
-from ._validators import validate_hf_hub_args
-
-
-class LocalTokenNotFoundError(EnvironmentError):
- """Raised if local token is required but not found."""
-
-
-@validate_hf_hub_args
-def build_hf_headers(
- *,
- token: Optional[Union[bool, str]] = None,
- is_write_action: bool = False,
- library_name: Optional[str] = None,
- library_version: Optional[str] = None,
- user_agent: Union[Dict, str, None] = None,
-) -> Dict[str, str]:
- """
- Build headers dictionary to send in a HF Hub call.
-
- By default, authorization token is always provided either from argument (explicit
- use) or retrieved from the cache (implicit use). To explicitly avoid sending the
- token to the Hub, set `token=False` or set the `HF_HUB_DISABLE_IMPLICIT_TOKEN`
- environment variable.
-
- In case of an API call that requires write access, an error is thrown if token is
- `None` or token is an organization token (starting with `"api_org***"`).
-
- In addition to the auth header, a user-agent is added to provide information about
- the installed packages (versions of python, huggingface_hub, torch, tensorflow,
- fastai and fastcore).
-
- Args:
- token (`str`, `bool`, *optional*):
- The token to be sent in authorization header for the Hub call:
- - if a string, it is used as the Hugging Face token
- - if `True`, the token is read from the machine (cache or env variable)
- - if `False`, authorization header is not set
- - if `None`, the token is read from the machine only except if
- `HF_HUB_DISABLE_IMPLICIT_TOKEN` env variable is set.
- is_write_action (`bool`, default to `False`):
- Set to True if the API call requires a write access. If `True`, the token
- will be validated (cannot be `None`, cannot start by `"api_org***"`).
- library_name (`str`, *optional*):
- The name of the library that is making the HTTP request. Will be added to
- the user-agent header.
- library_version (`str`, *optional*):
- The version of the library that is making the HTTP request. Will be added
- to the user-agent header.
- user_agent (`str`, `dict`, *optional*):
- The user agent info in the form of a dictionary or a single string. It will
- be completed with information about the installed packages.
-
- Returns:
- A `Dict` of headers to pass in your API call.
-
- Example:
- ```py
- >>> build_hf_headers(token="hf_***") # explicit token
- {"authorization": "Bearer hf_***", "user-agent": ""}
-
- >>> build_hf_headers(token=True) # explicitly use cached token
- {"authorization": "Bearer hf_***",...}
-
- >>> build_hf_headers(token=False) # explicitly don't use cached token
- {"user-agent": ...}
-
- >>> build_hf_headers() # implicit use of the cached token
- {"authorization": "Bearer hf_***",...}
-
- # HF_HUB_DISABLE_IMPLICIT_TOKEN=True # to set as env variable
- >>> build_hf_headers() # token is not sent
- {"user-agent": ...}
-
- >>> build_hf_headers(token="api_org_***", is_write_action=True)
- ValueError: You must use your personal account token for write-access methods.
-
- >>> build_hf_headers(library_name="transformers", library_version="1.2.3")
- {"authorization": ..., "user-agent": "transformers/1.2.3; hf_hub/0.10.2; python/3.10.4; tensorflow/1.55"}
- ```
-
- Raises:
- [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError)
- If organization token is passed and "write" access is required.
- [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError)
- If "write" access is required but token is not passed and not saved locally.
- [`EnvironmentError`](https://docs.python.org/3/library/exceptions.html#EnvironmentError)
- If `token=True` but token is not saved locally.
- """
- # Get auth token to send
- token_to_send = get_token_to_send(token)
- _validate_token_to_send(token_to_send, is_write_action=is_write_action)
-
- # Combine headers
- headers = {
- "user-agent": _http_user_agent(
- library_name=library_name,
- library_version=library_version,
- user_agent=user_agent,
- )
- }
- if token_to_send is not None:
- headers["authorization"] = f"Bearer {token_to_send}"
- return headers
-
-
-def get_token_to_send(token: Optional[Union[bool, str]]) -> Optional[str]:
- """Select the token to send from either `token` or the cache."""
- # Case token is explicitly provided
- if isinstance(token, str):
- return token
-
- # Case token is explicitly forbidden
- if token is False:
- return None
-
- # Token is not provided: we get it from local cache
- cached_token = HfFolder().get_token()
-
- # Case token is explicitly required
- if token is True:
- if cached_token is None:
- raise LocalTokenNotFoundError(
- "Token is required (`token=True`), but no token found. You"
- " need to provide a token or be logged in to Hugging Face with"
- " `huggingface-cli login` or `huggingface_hub.login`. See"
- " https://huggingface.co/settings/tokens."
- )
- return cached_token
-
- # Case implicit use of the token is forbidden by env variable
- if constants.HF_HUB_DISABLE_IMPLICIT_TOKEN:
- return None
-
- # Otherwise: we use the cached token as the user has not explicitly forbidden it
- return cached_token
-
-
-def _validate_token_to_send(token: Optional[str], is_write_action: bool) -> None:
- if is_write_action:
- if token is None:
- raise ValueError(
- "Token is required (write-access action) but no token found. You need"
- " to provide a token or be logged in to Hugging Face with"
- " `huggingface-cli login` or `huggingface_hub.login`. See"
- " https://huggingface.co/settings/tokens."
- )
- if token.startswith("api_org"):
- raise ValueError(
- "You must use your personal account token for write-access methods. To"
- " generate a write-access token, go to"
- " https://huggingface.co/settings/tokens"
- )
-
-
-def _http_user_agent(
- *,
- library_name: Optional[str] = None,
- library_version: Optional[str] = None,
- user_agent: Union[Dict, str, None] = None,
-) -> str:
- """Format a user-agent string containing information about the installed packages.
-
- Args:
- library_name (`str`, *optional*):
- The name of the library that is making the HTTP request.
- library_version (`str`, *optional*):
- The version of the library that is making the HTTP request.
- user_agent (`str`, `dict`, *optional*):
- The user agent info in the form of a dictionary or a single string.
-
- Returns:
- The formatted user-agent string.
- """
- if library_name is not None:
- ua = f"{library_name}/{library_version}"
- else:
- ua = "unknown/None"
- ua += f"; hf_hub/{get_hf_hub_version()}"
- ua += f"; python/{get_python_version()}"
-
- if not constants.HF_HUB_DISABLE_TELEMETRY:
- if is_torch_available():
- ua += f"; torch/{get_torch_version()}"
- if is_tf_available():
- ua += f"; tensorflow/{get_tf_version()}"
- if is_fastai_available():
- ua += f"; fastai/{get_fastai_version()}"
- if is_fastcore_available():
- ua += f"; fastcore/{get_fastcore_version()}"
-
- if isinstance(user_agent, dict):
- ua += "; " + "; ".join(f"{k}/{v}" for k, v in user_agent.items())
- elif isinstance(user_agent, str):
- ua += "; " + user_agent
-
- return _deduplicate_user_agent(ua)
-
-
-def _deduplicate_user_agent(user_agent: str) -> str:
- """Deduplicate redundant information in the generated user-agent."""
- # Split around ";" > Strip whitespaces > Store as dict keys (ensure unicity) > format back as string
- # Order is implicitly preserved by dictionary structure (see https://stackoverflow.com/a/53657523).
- return "; ".join({key.strip(): None for key in user_agent.split(";")}.keys())
diff --git a/spaces/declare-lab/tango/diffusers/src/diffusers/schedulers/scheduling_repaint.py b/spaces/declare-lab/tango/diffusers/src/diffusers/schedulers/scheduling_repaint.py
deleted file mode 100644
index 96af210f06b10513ec72277315c9c1a84c3a5bef..0000000000000000000000000000000000000000
--- a/spaces/declare-lab/tango/diffusers/src/diffusers/schedulers/scheduling_repaint.py
+++ /dev/null
@@ -1,329 +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 math
-from dataclasses import dataclass
-from typing import Optional, Tuple, Union
-
-import numpy as np
-import torch
-
-from ..configuration_utils import ConfigMixin, register_to_config
-from ..utils import BaseOutput, randn_tensor
-from .scheduling_utils import SchedulerMixin
-
-
-@dataclass
-class RePaintSchedulerOutput(BaseOutput):
- """
- Output class for the scheduler's step function output.
-
- Args:
- prev_sample (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)` for images):
- Computed sample (x_{t-1}) of previous timestep. `prev_sample` should be used as next model input in the
- denoising loop.
- pred_original_sample (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)` for images):
- The predicted denoised sample (x_{0}) based on the model output from
- the current timestep. `pred_original_sample` can be used to preview progress or for guidance.
- """
-
- prev_sample: torch.FloatTensor
- pred_original_sample: torch.FloatTensor
-
-
-# Copied from diffusers.schedulers.scheduling_ddpm.betas_for_alpha_bar
-def betas_for_alpha_bar(num_diffusion_timesteps, max_beta=0.999):
- """
- Create a beta schedule that discretizes the given alpha_t_bar function, which defines the cumulative product of
- (1-beta) over time from t = [0,1].
-
- Contains a function alpha_bar that takes an argument t and transforms it to the cumulative product of (1-beta) up
- to that part of the diffusion process.
-
-
- Args:
- num_diffusion_timesteps (`int`): the number of betas to produce.
- max_beta (`float`): the maximum beta to use; use values lower than 1 to
- prevent singularities.
-
- Returns:
- betas (`np.ndarray`): the betas used by the scheduler to step the model outputs
- """
-
- def alpha_bar(time_step):
- return math.cos((time_step + 0.008) / 1.008 * math.pi / 2) ** 2
-
- betas = []
- for i in range(num_diffusion_timesteps):
- t1 = i / num_diffusion_timesteps
- t2 = (i + 1) / num_diffusion_timesteps
- betas.append(min(1 - alpha_bar(t2) / alpha_bar(t1), max_beta))
- return torch.tensor(betas, dtype=torch.float32)
-
-
-class RePaintScheduler(SchedulerMixin, ConfigMixin):
- """
- RePaint is a schedule for DDPM inpainting inside a given mask.
-
- [`~ConfigMixin`] takes care of storing all config attributes that are passed in the scheduler's `__init__`
- function, such as `num_train_timesteps`. They can be accessed via `scheduler.config.num_train_timesteps`.
- [`SchedulerMixin`] provides general loading and saving functionality via the [`SchedulerMixin.save_pretrained`] and
- [`~SchedulerMixin.from_pretrained`] functions.
-
- For more details, see the original paper: https://arxiv.org/pdf/2201.09865.pdf
-
- Args:
- num_train_timesteps (`int`): number of diffusion steps used to train the model.
- beta_start (`float`): the starting `beta` value of inference.
- beta_end (`float`): the final `beta` value.
- beta_schedule (`str`):
- the beta schedule, a mapping from a beta range to a sequence of betas for stepping the model. Choose from
- `linear`, `scaled_linear`, or `squaredcos_cap_v2`.
- eta (`float`):
- The weight of noise for added noise in a diffusion step. Its value is between 0.0 and 1.0 -0.0 is DDIM and
- 1.0 is DDPM scheduler respectively.
- trained_betas (`np.ndarray`, optional):
- option to pass an array of betas directly to the constructor to bypass `beta_start`, `beta_end` etc.
- variance_type (`str`):
- options to clip the variance used when adding noise to the denoised sample. Choose from `fixed_small`,
- `fixed_small_log`, `fixed_large`, `fixed_large_log`, `learned` or `learned_range`.
- clip_sample (`bool`, default `True`):
- option to clip predicted sample between -1 and 1 for numerical stability.
-
- """
-
- order = 1
-
- @register_to_config
- def __init__(
- self,
- num_train_timesteps: int = 1000,
- beta_start: float = 0.0001,
- beta_end: float = 0.02,
- beta_schedule: str = "linear",
- eta: float = 0.0,
- trained_betas: Optional[np.ndarray] = None,
- clip_sample: bool = True,
- ):
- if trained_betas is not None:
- self.betas = torch.from_numpy(trained_betas)
- elif beta_schedule == "linear":
- self.betas = torch.linspace(beta_start, beta_end, num_train_timesteps, dtype=torch.float32)
- elif beta_schedule == "scaled_linear":
- # this schedule is very specific to the latent diffusion model.
- self.betas = (
- torch.linspace(beta_start**0.5, beta_end**0.5, num_train_timesteps, dtype=torch.float32) ** 2
- )
- elif beta_schedule == "squaredcos_cap_v2":
- # Glide cosine schedule
- self.betas = betas_for_alpha_bar(num_train_timesteps)
- elif beta_schedule == "sigmoid":
- # GeoDiff sigmoid schedule
- betas = torch.linspace(-6, 6, num_train_timesteps)
- self.betas = torch.sigmoid(betas) * (beta_end - beta_start) + beta_start
- else:
- raise NotImplementedError(f"{beta_schedule} does is not implemented for {self.__class__}")
-
- self.alphas = 1.0 - self.betas
- self.alphas_cumprod = torch.cumprod(self.alphas, dim=0)
- self.one = torch.tensor(1.0)
-
- self.final_alpha_cumprod = torch.tensor(1.0)
-
- # standard deviation of the initial noise distribution
- self.init_noise_sigma = 1.0
-
- # setable values
- self.num_inference_steps = None
- self.timesteps = torch.from_numpy(np.arange(0, num_train_timesteps)[::-1].copy())
-
- self.eta = eta
-
- def scale_model_input(self, sample: torch.FloatTensor, timestep: Optional[int] = None) -> torch.FloatTensor:
- """
- Ensures interchangeability with schedulers that need to scale the denoising model input depending on the
- current timestep.
-
- Args:
- sample (`torch.FloatTensor`): input sample
- timestep (`int`, optional): current timestep
-
- Returns:
- `torch.FloatTensor`: scaled input sample
- """
- return sample
-
- def set_timesteps(
- self,
- num_inference_steps: int,
- jump_length: int = 10,
- jump_n_sample: int = 10,
- device: Union[str, torch.device] = None,
- ):
- num_inference_steps = min(self.config.num_train_timesteps, num_inference_steps)
- self.num_inference_steps = num_inference_steps
-
- timesteps = []
-
- jumps = {}
- for j in range(0, num_inference_steps - jump_length, jump_length):
- jumps[j] = jump_n_sample - 1
-
- t = num_inference_steps
- while t >= 1:
- t = t - 1
- timesteps.append(t)
-
- if jumps.get(t, 0) > 0:
- jumps[t] = jumps[t] - 1
- for _ in range(jump_length):
- t = t + 1
- timesteps.append(t)
-
- timesteps = np.array(timesteps) * (self.config.num_train_timesteps // self.num_inference_steps)
- self.timesteps = torch.from_numpy(timesteps).to(device)
-
- def _get_variance(self, t):
- prev_timestep = t - self.config.num_train_timesteps // self.num_inference_steps
-
- alpha_prod_t = self.alphas_cumprod[t]
- alpha_prod_t_prev = self.alphas_cumprod[prev_timestep] if prev_timestep >= 0 else self.final_alpha_cumprod
- beta_prod_t = 1 - alpha_prod_t
- beta_prod_t_prev = 1 - alpha_prod_t_prev
-
- # For t > 0, compute predicted variance βt (see formula (6) and (7) from
- # https://arxiv.org/pdf/2006.11239.pdf) and sample from it to get
- # previous sample x_{t-1} ~ N(pred_prev_sample, variance) == add
- # variance to pred_sample
- # Is equivalent to formula (16) in https://arxiv.org/pdf/2010.02502.pdf
- # without eta.
- # variance = (1 - alpha_prod_t_prev) / (1 - alpha_prod_t) * self.betas[t]
- variance = (beta_prod_t_prev / beta_prod_t) * (1 - alpha_prod_t / alpha_prod_t_prev)
-
- return variance
-
- def step(
- self,
- model_output: torch.FloatTensor,
- timestep: int,
- sample: torch.FloatTensor,
- original_image: torch.FloatTensor,
- mask: torch.FloatTensor,
- generator: Optional[torch.Generator] = None,
- return_dict: bool = True,
- ) -> Union[RePaintSchedulerOutput, Tuple]:
- """
- Predict the sample at the previous timestep by reversing the SDE. Core function to propagate the diffusion
- process from the learned model outputs (most often the predicted noise).
-
- Args:
- model_output (`torch.FloatTensor`): direct output from learned
- diffusion model.
- timestep (`int`): current discrete timestep in the diffusion chain.
- sample (`torch.FloatTensor`):
- current instance of sample being created by diffusion process.
- original_image (`torch.FloatTensor`):
- the original image to inpaint on.
- mask (`torch.FloatTensor`):
- the mask where 0.0 values define which part of the original image to inpaint (change).
- generator (`torch.Generator`, *optional*): random number generator.
- return_dict (`bool`): option for returning tuple rather than
- DDPMSchedulerOutput class
-
- Returns:
- [`~schedulers.scheduling_utils.RePaintSchedulerOutput`] or `tuple`:
- [`~schedulers.scheduling_utils.RePaintSchedulerOutput`] if `return_dict` is True, otherwise a `tuple`. When
- returning a tuple, the first element is the sample tensor.
-
- """
- t = timestep
- prev_timestep = timestep - self.config.num_train_timesteps // self.num_inference_steps
-
- # 1. compute alphas, betas
- alpha_prod_t = self.alphas_cumprod[t]
- alpha_prod_t_prev = self.alphas_cumprod[prev_timestep] if prev_timestep >= 0 else self.final_alpha_cumprod
- beta_prod_t = 1 - alpha_prod_t
-
- # 2. compute predicted original sample from predicted noise also called
- # "predicted x_0" of formula (15) from https://arxiv.org/pdf/2006.11239.pdf
- pred_original_sample = (sample - beta_prod_t**0.5 * model_output) / alpha_prod_t**0.5
-
- # 3. Clip "predicted x_0"
- if self.config.clip_sample:
- pred_original_sample = torch.clamp(pred_original_sample, -1, 1)
-
- # We choose to follow RePaint Algorithm 1 to get x_{t-1}, however we
- # substitute formula (7) in the algorithm coming from DDPM paper
- # (formula (4) Algorithm 2 - Sampling) with formula (12) from DDIM paper.
- # DDIM schedule gives the same results as DDPM with eta = 1.0
- # Noise is being reused in 7. and 8., but no impact on quality has
- # been observed.
-
- # 5. Add noise
- device = model_output.device
- noise = randn_tensor(model_output.shape, generator=generator, device=device, dtype=model_output.dtype)
- std_dev_t = self.eta * self._get_variance(timestep) ** 0.5
-
- variance = 0
- if t > 0 and self.eta > 0:
- variance = std_dev_t * noise
-
- # 6. compute "direction pointing to x_t" of formula (12)
- # from https://arxiv.org/pdf/2010.02502.pdf
- pred_sample_direction = (1 - alpha_prod_t_prev - std_dev_t**2) ** 0.5 * model_output
-
- # 7. compute x_{t-1} of formula (12) from https://arxiv.org/pdf/2010.02502.pdf
- prev_unknown_part = alpha_prod_t_prev**0.5 * pred_original_sample + pred_sample_direction + variance
-
- # 8. Algorithm 1 Line 5 https://arxiv.org/pdf/2201.09865.pdf
- prev_known_part = (alpha_prod_t_prev**0.5) * original_image + ((1 - alpha_prod_t_prev) ** 0.5) * noise
-
- # 9. Algorithm 1 Line 8 https://arxiv.org/pdf/2201.09865.pdf
- pred_prev_sample = mask * prev_known_part + (1.0 - mask) * prev_unknown_part
-
- if not return_dict:
- return (
- pred_prev_sample,
- pred_original_sample,
- )
-
- return RePaintSchedulerOutput(prev_sample=pred_prev_sample, pred_original_sample=pred_original_sample)
-
- def undo_step(self, sample, timestep, generator=None):
- n = self.config.num_train_timesteps // self.num_inference_steps
-
- for i in range(n):
- beta = self.betas[timestep + i]
- if sample.device.type == "mps":
- # randn does not work reproducibly on mps
- noise = randn_tensor(sample.shape, dtype=sample.dtype, generator=generator)
- noise = noise.to(sample.device)
- else:
- noise = randn_tensor(sample.shape, generator=generator, device=sample.device, dtype=sample.dtype)
-
- # 10. Algorithm 1 Line 10 https://arxiv.org/pdf/2201.09865.pdf
- sample = (1 - beta) ** 0.5 * sample + beta**0.5 * noise
-
- return sample
-
- def add_noise(
- self,
- original_samples: torch.FloatTensor,
- noise: torch.FloatTensor,
- timesteps: torch.IntTensor,
- ) -> torch.FloatTensor:
- raise NotImplementedError("Use `DDPMScheduler.add_noise()` to train for sampling with RePaint.")
-
- def __len__(self):
- return self.config.num_train_timesteps
diff --git a/spaces/deepwisdom/MetaGPT/examples/search_with_specific_engine.py b/spaces/deepwisdom/MetaGPT/examples/search_with_specific_engine.py
deleted file mode 100644
index 4423011e48daa6bebd00bbff62414108b8f8a1c9..0000000000000000000000000000000000000000
--- a/spaces/deepwisdom/MetaGPT/examples/search_with_specific_engine.py
+++ /dev/null
@@ -1,23 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-"""
-@Modified By: mashenquan, 2023-8-9, fix-bug: cannot find metagpt module.
-"""
-import asyncio
-from pathlib import Path
-import sys
-sys.path.append(str(Path(__file__).resolve().parent.parent))
-from metagpt.roles import Searcher
-from metagpt.tools import SearchEngineType
-
-
-async def main():
- # Serper API
- #await Searcher(engine = SearchEngineType.SERPER_GOOGLE).run(["What are some good sun protection products?","What are some of the best beaches?"])
- # SerpAPI
- #await Searcher(engine=SearchEngineType.SERPAPI_GOOGLE).run("What are the best ski brands for skiers?")
- # Google API
- await Searcher(engine=SearchEngineType.DIRECT_GOOGLE).run("What are the most interesting human facts?")
-
-if __name__ == '__main__':
- asyncio.run(main())
diff --git a/spaces/deepwisdom/MetaGPT/tests/metagpt/utils/test_code_parser.py b/spaces/deepwisdom/MetaGPT/tests/metagpt/utils/test_code_parser.py
deleted file mode 100644
index 707b558e1fb991bea5c253f52548895f1a3126d8..0000000000000000000000000000000000000000
--- a/spaces/deepwisdom/MetaGPT/tests/metagpt/utils/test_code_parser.py
+++ /dev/null
@@ -1,140 +0,0 @@
-#!/usr/bin/env python
-# coding: utf-8
-"""
-@Time : 2023/7/10 17:14
-@Author : chengmaoyu
-@File : test_code_parser.py
-"""
-
-import pytest
-
-from metagpt.utils.common import CodeParser
-
-t_text = '''
-## Required Python third-party packages
-```python
-"""
-flask==1.1.2
-pygame==2.0.1
-"""
-```
-
-## Required Other language third-party packages
-```python
-"""
-No third-party packages required for other languages.
-"""
-```
-
-## Full API spec
-```python
-"""
-openapi: 3.0.0
-info:
- title: Web Snake Game API
- version: 1.0.0
-paths:
- /game:
- get:
- summary: Get the current game state
- responses:
- '200':
- description: A JSON object of the game state
- post:
- summary: Send a command to the game
- requestBody:
- required: true
- content:
- application/json:
- schema:
- type: object
- properties:
- command:
- type: string
- responses:
- '200':
- description: A JSON object of the updated game state
-"""
-```
-
-## Logic Analysis
-```python
-[
- ("app.py", "Main entry point for the Flask application. Handles HTTP requests and responses."),
- ("game.py", "Contains the Game and Snake classes. Handles the game logic."),
- ("static/js/script.js", "Handles user interactions and updates the game UI."),
- ("static/css/styles.css", "Defines the styles for the game UI."),
- ("templates/index.html", "The main page of the web application. Displays the game UI.")
-]
-```
-
-## Task list
-```python
-[
- "game.py",
- "app.py",
- "static/css/styles.css",
- "static/js/script.js",
- "templates/index.html"
-]
-```
-
-## Shared Knowledge
-```python
-"""
-'game.py' contains the Game and Snake classes which are responsible for the game logic. The Game class uses an instance of the Snake class.
-
-'app.py' is the main entry point for the Flask application. It creates an instance of the Game class and handles HTTP requests and responses.
-
-'static/js/script.js' is responsible for handling user interactions and updating the game UI based on the game state returned by 'app.py'.
-
-'static/css/styles.css' defines the styles for the game UI.
-
-'templates/index.html' is the main page of the web application. It displays the game UI and loads 'static/js/script.js' and 'static/css/styles.css'.
-"""
-```
-
-## Anything UNCLEAR
-We need clarification on how the high score should be stored. Should it persist across sessions (stored in a database or a file) or should it reset every time the game is restarted? Also, should the game speed increase as the snake grows, or should it remain constant throughout the game?
- '''
-
-
-class TestCodeParser:
- @pytest.fixture
- def parser(self):
- return CodeParser()
-
- @pytest.fixture
- def text(self):
- return t_text
-
- def test_parse_blocks(self, parser, text):
- result = parser.parse_blocks(text)
- print(result)
- assert result == {"title": "content", "title2": "content2"}
-
- def test_parse_block(self, parser, text):
- result = parser.parse_block("title", text)
- print(result)
- assert result == "content"
-
- def test_parse_code(self, parser, text):
- result = parser.parse_code("title", text, "python")
- print(result)
- assert result == "print('hello world')"
-
- def test_parse_str(self, parser, text):
- result = parser.parse_str("title", text, "python")
- print(result)
- assert result == "hello world"
-
- def test_parse_file_list(self, parser, text):
- result = parser.parse_file_list("Task list", text)
- print(result)
- assert result == ['task1', 'task2']
-
-
-if __name__ == '__main__':
- t = TestCodeParser()
- t.test_parse_file_list(CodeParser(), t_text)
- # TestCodeParser.test_parse_file_list()
diff --git a/spaces/devthedeveloper/Bark-with-Voice-Cloning/README.md b/spaces/devthedeveloper/Bark-with-Voice-Cloning/README.md
deleted file mode 100644
index d2fc2675057f50dd3395b5d9831584e264072697..0000000000000000000000000000000000000000
--- a/spaces/devthedeveloper/Bark-with-Voice-Cloning/README.md
+++ /dev/null
@@ -1,14 +0,0 @@
----
-title: Bark with Voice Cloning
-emoji: 📊
-colorFrom: purple
-colorTo: purple
-sdk: gradio
-sdk_version: 3.34.0
-app_file: app.py
-pinned: true
-license: mit
-duplicated_from: kevinwang676/Bark-with-Voice-Cloning
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
\ No newline at end of file
diff --git a/spaces/diacanFperku/AutoGPT/Easeus Data Recovery WIZARD Professional 4.3.6 (retail) LINK.md b/spaces/diacanFperku/AutoGPT/Easeus Data Recovery WIZARD Professional 4.3.6 (retail) LINK.md
deleted file mode 100644
index 7893896efd13475d8944269cfc7f7c2a2f7c8cf9..0000000000000000000000000000000000000000
--- a/spaces/diacanFperku/AutoGPT/Easeus Data Recovery WIZARD Professional 4.3.6 (retail) LINK.md
+++ /dev/null
@@ -1,19 +0,0 @@
-How to Recover Lost Data with EaseUS Data Recovery Wizard Professional 4.3.6 (Retail)
-Have you ever lost important files due to accidental deletion, formatting, virus attack, or other reasons? If so, you may be looking for a reliable and easy-to-use data recovery software to help you get them back. One of the best options on the market is EaseUS Data Recovery Wizard Professional 4.3.6 (Retail), a powerful and comprehensive tool that can recover data from various devices and scenarios.
-easeus Data Recovery WIZARD Professional 4.3.6 (retail) DOWNLOAD » https://gohhs.com/2uFTfW
In this article, we will show you how to use EaseUS Data Recovery Wizard Professional 4.3.6 (Retail) to recover your lost data in three simple steps. Whether you need to recover data from a hard drive, USB flash drive, memory card, digital camera, or any other storage device, this software can handle it.
-Step 1: Download and Install EaseUS Data Recovery Wizard Professional 4.3.6 (Retail)
-The first step is to download and install EaseUS Data Recovery Wizard Professional 4.3.6 (Retail) on your computer. You can get it from the official website or from any reputable online store that sells software products. Make sure you download the correct version for your operating system (Windows or Mac).
-After downloading the software, run the setup file and follow the instructions to install it on your computer. You may need to enter a license code to activate the software if you purchased it from a retail store. The license code is usually printed on the CD case or the receipt.
-Step 2: Select a Location and Scan for Lost Data
-The second step is to select a location where you lost your data and start scanning for it. Launch EaseUS Data Recovery Wizard Professional 4.3.6 (Retail) and you will see a list of available locations on your computer and connected devices. You can also click on "Specify a location" to manually enter a path or browse for a folder.
-Select the location that contains your lost data and click on "Scan" to start searching for it. The software will first perform a quick scan that will take a few minutes and then a deep scan that will take longer depending on the size and condition of your device. You can pause or stop the scan at any time if you find what you need.
-Step 3: Preview and Recover Your Lost Data
-The final step is to preview and recover your lost data. After the scan is completed, you will see a list of files that were found by the software. You can filter them by file type, date, size, or name to narrow down your search. You can also use the search box to find specific files by keywords.
-
-To preview a file, simply click on it and you will see a thumbnail or a text preview on the right pane. You can also double-click on it to open it in its default program if it is available on your computer. To recover a file, simply check the box next to it and click on "Recover" at the bottom right corner.
-You will be asked to choose a destination folder where you want to save your recovered files. Make sure you do not save them to the same location where you lost them, as this may overwrite them and make them unrecoverable. Choose a different drive or device and click on "OK" to start recovering your files.
-Wait for the recovery process to finish and then check your recovered files in the destination folder. You have successfully recovered your lost data with EaseUS Data Recovery Wizard Professional 4.3.6 (Retail)!
d5da3c52bfFranceschetti Campi Elettromagnetici Pdf Download Download File - https://gohhs.com/2uFTCc
diff --git a/spaces/diacanFperku/AutoGPT/G V Kumbhojkar Pdf Download VERIFIED.md b/spaces/diacanFperku/AutoGPT/G V Kumbhojkar Pdf Download VERIFIED.md
deleted file mode 100644
index fd603ad1727628d3429672e389ae34a416ba845b..0000000000000000000000000000000000000000
--- a/spaces/diacanFperku/AutoGPT/G V Kumbhojkar Pdf Download VERIFIED.md
+++ /dev/null
@@ -1,117 +0,0 @@
-G V Kumbhojkar PDF Download: A Comprehensive Resource for Applied Mathematics
-
-If you are looking for a reliable and easy-to-follow textbook for applied mathematics, you might want to check out G V Kumbhojkar PDF download. This book covers various topics in mathematics that are essential for engineering students, such as differential equations, Laplace transforms, Fourier series, complex analysis, and more. In this article, we will give you an overview of the book and its features, as well as some tips on how to download it for free.
-
-What is G V Kumbhojkar PDF Download?
-
-G V Kumbhojkar PDF download is a digital version of the book Applied Mathematics III by G V Kumbhojkar, a professor of mathematics at the University of Mumbai. The book is designed for engineering students who are studying mathematics as a core subject in their curriculum. The book follows the syllabus of the University of Mumbai and other universities in India.
-g v kumbhojkar pdf download Download ✸ https://gohhs.com/2uFTLq
The book has 14 chapters that cover various topics in applied mathematics, such as:
-
-
-Linear differential equations of higher order
-Series solutions of differential equations
-Legendre's equation and Legendre polynomials
-Bessel's equation and Bessel functions
-Laplace transforms and their applications
-Fourier series and Fourier transforms
-Partial differential equations and their applications
-Functions of a complex variable and analytic functions
-Cauchy-Riemann equations and harmonic functions
-Complex integration and Cauchy's theorem
-Cauchy's integral formula and Taylor's series
-Laurent's series and residue theorem
-Conformal mapping and bilinear transformation
-Special functions and integral transforms
-
-
-The book explains the concepts and methods in a clear and concise manner, with plenty of examples and solved problems. The book also has exercises at the end of each chapter, with answers and hints provided at the end of the book. The book is suitable for self-study as well as classroom learning.
-
-How to Download G V Kumbhojkar PDF Download for Free?
-
-If you want to download G V Kumbhojkar PDF download for free, you have several options to choose from. Here are some of them:
-
-
-You can use Google Drive to access the PDF file of the book. Just click on this link and sign in with your Google account. You can then view or download the file as you wish.
-You can use Academia.edu to download the PDF file of the book. Just click on this link and create a free account or log in with your existing account. You can then download the file or read it online.
-You can use Course Hero to download the PDF file of the book. Just click on this link and create a free account or log in with your existing account. You can then download the file or read it online.
-
-
-However, before you download G V Kumbhojkar PDF download for free, you should be aware of some potential risks and limitations. For instance:
-
-
-The quality and accuracy of the PDF file may not be guaranteed. There may be errors or missing pages in the file.
-The PDF file may not be updated or revised according to the latest edition or syllabus of the book.
-The PDF file may not be legal or authorized by the author or publisher of the book. You may be violating their intellectual property rights by downloading or sharing the file.
-The PDF file may contain viruses or malware that can harm your device or compromise your security.
-
-
-Therefore, if you want to avoid these risks and limitations, you should consider buying the original book from a reputable source. You can find the book on various online platforms, such as Amazon, Flipkart, Snapdeal, etc. The price of the book may vary depending on the seller and delivery options.
-
-Conclusion
-
-G V Kumbhojkar PDF download is a useful resource for engineering students who want to learn applied mathematics. The book covers various topics in mathematics that are relevant for engineering applications, such as differential equations, Laplace transforms, Fourier series, complex analysis, etc. The book explains the concepts and methods in a simple and lucid manner, with plenty of examples and solved problems. The book also has exercises at the end of each chapter, with answers and hints provided at the end of the book.
-
-If you want to download G V Kumbhojkar PDF download for free, you have several options to choose from, such as Google Drive, Academia.edu, Course Hero, etc. However, you should be aware of some potential risks and limitations that come with downloading or sharing unauthorized or illegal copies of the book. You may face issues such as poor quality, outdated content, legal violations, or security threats.
-
-Therefore, if you want to get the best value and experience from G V Kumbhojkar PDF download, you should consider buying the original book from a reliable source. You can find the book on various online platforms, such as Amazon, Flipkart, Snapdeal, etc. The price of the book may vary depending on the seller and delivery options.
-
-
-We hope this article has given you some useful information about G V Kumbhojkar PDF download. If you have any questions or feedback, please feel free to leave a comment below.
-What are the Benefits of G V Kumbhojkar PDF Download?
-
-G V Kumbhojkar PDF download has many benefits for engineering students who want to learn applied mathematics. Some of these benefits are:
-
-
-It saves time and money. You don't have to buy or carry a heavy book around. You can access the PDF file anytime and anywhere with your device and internet connection.
-It enhances learning and understanding. You can read the book at your own pace and convenience. You can also zoom in, highlight, bookmark, or annotate the PDF file as you wish.
-It prepares you for exams and interviews. The book covers the syllabus and topics that are frequently asked in engineering exams and interviews. The book also has exercises and solved problems that help you practice and test your knowledge.
-It boosts your confidence and performance. The book helps you master the concepts and methods of applied mathematics that are essential for engineering applications. The book also helps you develop your analytical and problem-solving skills.
-
-
-What are the Alternatives to G V Kumbhojkar PDF Download?
-
-If you are looking for alternatives to G V Kumbhojkar PDF download, you have some options to choose from. Here are some of them:
-
-
-You can use other books on applied mathematics that are written by different authors or publishers. Some examples are Applied Mathematics by Erwin Kreyszig, Higher Engineering Mathematics by B S Grewal, Advanced Engineering Mathematics by R K Jain and S R K Iyengar, etc.
-You can use online courses or videos on applied mathematics that are offered by various platforms or instructors. Some examples are Khan Academy, Coursera, Udemy, NPTEL, etc.
-You can use online forums or communities on applied mathematics that are created by students or experts. Some examples are Math Stack Exchange, Reddit, Quora, etc.
-
-
-However, before you use any of these alternatives to G V Kumbhojkar PDF download, you should be aware of some potential drawbacks and challenges. For instance:
-
-
-The quality and relevance of the content may not be consistent or guaranteed. There may be errors or gaps in the content.
-The content may not be updated or revised according to the latest edition or syllabus of the book.
-The content may not be suitable or accessible for your level or preference of learning. You may face difficulties in finding or following the content.
-The content may not be free or affordable. You may have to pay a fee or subscription to access the content.
-
-
-Therefore, if you want to use any of these alternatives to G V Kumbhojkar PDF download, you should do some research and comparison before making a decision. You should also check the reviews and ratings of the content from other users or sources.
-How to Use G V Kumbhojkar PDF Download Effectively?
-
-G V Kumbhojkar PDF download is a valuable resource for engineering students who want to learn applied mathematics. However, simply downloading or reading the book is not enough. You need to use the book effectively to get the most out of it. Here are some tips on how to use G V Kumbhojkar PDF download effectively:
-
-
-Plan your study schedule and goals. You should have a clear idea of what topics you want to cover, how much time you have, and what outcomes you expect. You should also set realistic and achievable goals for yourself.
-Review the concepts and methods before solving the problems. You should not jump into the exercises without understanding the theory and logic behind them. You should review the concepts and methods explained in the book and make sure you grasp them well.
-Solve the problems step by step and check your answers. You should not skip any steps or make any assumptions when solving the problems. You should follow the methods and formulas given in the book and show your work clearly. You should also check your answers with the solutions provided at the end of the book or online.
-Practice regularly and revise frequently. You should not cram or procrastinate when studying applied mathematics. You should practice regularly and revise frequently to reinforce your learning and memory. You should also review your mistakes and learn from them.
-Seek help when needed. You should not hesitate to ask for help when you encounter any difficulties or doubts. You can seek help from your teachers, classmates, tutors, online forums, etc. You can also use other resources such as books, videos, courses, etc. to supplement your learning.
-
-
-By following these tips, you can use G V Kumbhojkar PDF download effectively and improve your skills and knowledge in applied mathematics.
-Conclusion
-
-G V Kumbhojkar PDF download is a comprehensive and reliable textbook for applied mathematics. The book covers various topics in mathematics that are essential for engineering students, such as differential equations, Laplace transforms, Fourier series, complex analysis, etc. The book explains the concepts and methods in a simple and lucid manner, with plenty of examples and solved problems. The book also has exercises at the end of each chapter, with answers and hints provided at the end of the book.
-
-If you want to download G V Kumbhojkar PDF download for free, you have several options to choose from, such as Google Drive, Academia.edu, Course Hero, etc. However, you should be aware of some potential risks and limitations that come with downloading or sharing unauthorized or illegal copies of the book. You may face issues such as poor quality, outdated content, legal violations, or security threats.
-
-Therefore, if you want to get the best value and experience from G V Kumbhojkar PDF download, you should consider buying the original book from a reputable source. You can find the book on various online platforms, such as Amazon, Flipkart, Snapdeal, etc. The price of the book may vary depending on the seller and delivery options.
-
-We hope this article has given you some useful information about G V Kumbhojkar PDF download. If you have any questions or feedback, please feel free to leave a comment below.
3cee63e6c2Download Naruto Shippuden Season 9 Eng Dub Torrent Download File ❤❤❤ https://gohhs.com/2uFTFK
diff --git a/spaces/digitalxingtong/Jiuxia-Bert-Vits2/losses.py b/spaces/digitalxingtong/Jiuxia-Bert-Vits2/losses.py
deleted file mode 100644
index fb22a0e834dd87edaa37bb8190eee2c3c7abe0d5..0000000000000000000000000000000000000000
--- a/spaces/digitalxingtong/Jiuxia-Bert-Vits2/losses.py
+++ /dev/null
@@ -1,61 +0,0 @@
-import torch
-from torch.nn import functional as F
-
-import commons
-
-
-def feature_loss(fmap_r, fmap_g):
- loss = 0
- for dr, dg in zip(fmap_r, fmap_g):
- for rl, gl in zip(dr, dg):
- rl = rl.float().detach()
- gl = gl.float()
- loss += torch.mean(torch.abs(rl - gl))
-
- return loss * 2
-
-
-def discriminator_loss(disc_real_outputs, disc_generated_outputs):
- loss = 0
- r_losses = []
- g_losses = []
- for dr, dg in zip(disc_real_outputs, disc_generated_outputs):
- dr = dr.float()
- dg = dg.float()
- r_loss = torch.mean((1-dr)**2)
- g_loss = torch.mean(dg**2)
- loss += (r_loss + g_loss)
- r_losses.append(r_loss.item())
- g_losses.append(g_loss.item())
-
- return loss, r_losses, g_losses
-
-
-def generator_loss(disc_outputs):
- loss = 0
- gen_losses = []
- for dg in disc_outputs:
- dg = dg.float()
- l = torch.mean((1-dg)**2)
- gen_losses.append(l)
- loss += l
-
- return loss, gen_losses
-
-
-def kl_loss(z_p, logs_q, m_p, logs_p, z_mask):
- """
- z_p, logs_q: [b, h, t_t]
- m_p, logs_p: [b, h, t_t]
- """
- z_p = z_p.float()
- logs_q = logs_q.float()
- m_p = m_p.float()
- logs_p = logs_p.float()
- z_mask = z_mask.float()
-
- kl = logs_p - logs_q - 0.5
- kl += 0.5 * ((z_p - m_p)**2) * torch.exp(-2. * logs_p)
- kl = torch.sum(kl * z_mask)
- l = kl / torch.sum(z_mask)
- return l
diff --git a/spaces/digitalxingtong/Nailv-read-Bert-Vits2/losses.py b/spaces/digitalxingtong/Nailv-read-Bert-Vits2/losses.py
deleted file mode 100644
index fb22a0e834dd87edaa37bb8190eee2c3c7abe0d5..0000000000000000000000000000000000000000
--- a/spaces/digitalxingtong/Nailv-read-Bert-Vits2/losses.py
+++ /dev/null
@@ -1,61 +0,0 @@
-import torch
-from torch.nn import functional as F
-
-import commons
-
-
-def feature_loss(fmap_r, fmap_g):
- loss = 0
- for dr, dg in zip(fmap_r, fmap_g):
- for rl, gl in zip(dr, dg):
- rl = rl.float().detach()
- gl = gl.float()
- loss += torch.mean(torch.abs(rl - gl))
-
- return loss * 2
-
-
-def discriminator_loss(disc_real_outputs, disc_generated_outputs):
- loss = 0
- r_losses = []
- g_losses = []
- for dr, dg in zip(disc_real_outputs, disc_generated_outputs):
- dr = dr.float()
- dg = dg.float()
- r_loss = torch.mean((1-dr)**2)
- g_loss = torch.mean(dg**2)
- loss += (r_loss + g_loss)
- r_losses.append(r_loss.item())
- g_losses.append(g_loss.item())
-
- return loss, r_losses, g_losses
-
-
-def generator_loss(disc_outputs):
- loss = 0
- gen_losses = []
- for dg in disc_outputs:
- dg = dg.float()
- l = torch.mean((1-dg)**2)
- gen_losses.append(l)
- loss += l
-
- return loss, gen_losses
-
-
-def kl_loss(z_p, logs_q, m_p, logs_p, z_mask):
- """
- z_p, logs_q: [b, h, t_t]
- m_p, logs_p: [b, h, t_t]
- """
- z_p = z_p.float()
- logs_q = logs_q.float()
- m_p = m_p.float()
- logs_p = logs_p.float()
- z_mask = z_mask.float()
-
- kl = logs_p - logs_q - 0.5
- kl += 0.5 * ((z_p - m_p)**2) * torch.exp(-2. * logs_p)
- kl = torch.sum(kl * z_mask)
- l = kl / torch.sum(z_mask)
- return l
diff --git a/spaces/doevent/prompt-generator/app.py b/spaces/doevent/prompt-generator/app.py
deleted file mode 100644
index a535880ec59270152e13461316b7ad0f06004eb9..0000000000000000000000000000000000000000
--- a/spaces/doevent/prompt-generator/app.py
+++ /dev/null
@@ -1,56 +0,0 @@
-from transformers import pipeline, set_seed
-import gradio as grad
-import random
-import re
-
-gpt2_pipe = pipeline('text-generation', model='succinctly/text2image-prompt-generator')
-
-with open("name.txt", "r") as f:
- line = f.readlines()
-
-
-def generate(starting_text):
- for count in range(6):
- seed = random.randint(100, 1000000)
- set_seed(seed)
-
- # If the text field is empty
- if starting_text == "":
- starting_text: str = line[random.randrange(0, len(line))].replace("\n", "").lower().capitalize()
- starting_text: str = re.sub(r"[,:\-–.!;?_]", '', starting_text)
- print(starting_text)
-
- response = gpt2_pipe(starting_text, max_length=random.randint(60, 90), num_return_sequences=8)
- response_list = []
- for x in response:
- resp = x['generated_text'].strip()
- if resp != starting_text and len(resp) > (len(starting_text) + 4) and resp.endswith((":", "-", "—")) is False:
- response_list.append(resp)
-
- response_end = "\n".join(response_list)
- response_end = re.sub('[^ ]+\.[^ ]+','', response_end)
- response_end = response_end.replace("<", "").replace(">", "")
- if response_end != "":
- return response_end
- if count == 5:
- return response_end
-
-
-txt = grad.Textbox(lines=1, label="English", placeholder="English Text here")
-out = grad.Textbox(lines=6, label="Generated Text")
-examples = [["mythology of the Slavs"], ["All-seeing eye monitors these world"], ["astronaut dog"],
- ["A monochrome forest of ebony trees"], ["sad view of worker in office,"],
- ["Headshot photo portrait of John Lennon"], ["wide field with thousands of blue nemophila,"]]
-title = "Midjourney Prompt Generator"
-description = "This is an unofficial demo for Midjourney Prompt Generator. To use it, simply send your text, or click one of the examples to load them. Read more at the links below.the data administrator is evermotion sc, ul. przdzalniana 8, 15-688 bialystok. personal data will be processed for promotional purposes by the newsletter. personal data will not be shared with other entities. every registered user has the right to access his/her personal data and correct it. collection of data is voluntary but necessary to achieve the said objectives.
-evermotion archmodels vol. 176 includes tree models, and also includes models with different shapes, sizes, colours, type, and also weight to meet user requirements. all the files are the best quality. you can also download easiestsoft movie editor.
-evermotion archinteriors vol 29 free download Download ››› https://urlca.com/2uDcqH
archinteriors vol. 174 is a popular and widely used package which includes powerful, advanced and high-quality 3d models. the application makes the designer process simpler and quicker as they can headstart their projects by just importing the 3d model files, make some changes and achieve the desired results. this collection includes high-quality trees models with all the textures and materials. all objects are ready to use in your visualizations. you can also download cyberlink powerdirector ultimate 2020.
-we also placed free textures collections in this category. those are textures4ever they may seem a bit outdated sometimes, but still you get for free hundreds of textures that you can use in your private or commercial projects and we believe that many cg artists will find them useful. textures collections include also trees silhouettes (2d trees) that can be mapped onto planes in 3d software they are useful when you need some distant vegetation or you want to use them for shaping shadows (just place light source and a plane with tree silhouette and you can have great tree shadow casting on your surfaces at minimal performance hit). we included 736 high resolution alpha trees in png format. all alphas were made from rendered 3d trees. textures are 3500 pixels by 3500 pixels.
899543212bat 11:32 am. frases cortas para seras queen isaura amazon. https://trello.com/c/j7FkcBmu/28-lareinadelsurtemporada2completaportorrentversion-detsal-nedrwarl. Results 1 - 16 of 422. https://melaninterest.com/pin/lareinadelsurtemporada2completaportorrentversion/ https://melaninterest.com/pin/lareinadelsurtemporada2completaportorrentversion/ https://coub.com/stories/2281526-link-lareinadelsurtemporada2completaportorrentversion-detsal https://melaninterest.com/pin/soundspectrum-aeon-platinum-full-18-geanelee/
-lareinadelsurtemporada2completaportorrentversion Download ⚹ https://urlca.com/2uDcjL
https://trello.com/c/j7FkcBmu/28-lareinadelsurtemporada2completaportorrentversion-detsal-nedrwarl. https://melaninterest.com/pin/lareinadelsurtemporada2completaportorrentversion/ https://coub.com/stories/2281526-link-lareinadelsurtemporada2completaportorrentversion-detsal https://melaninterest.com/pin/soundspectrum-aeon-platinum-full-18-geanelee/ https://coub.com/stories/3034424-exclusive-lareinadelsurtemporada2completaportorrentversion
-From https://trello.com/c/j7FkcBmu/28-lareinadelsurtemporada2completaportorrentversion-detsal-nedrwarl https://coub.com/stories/2281526-link-lareinadelsurtemporada2completaportorrentversion-detsal https://coub.com/stories/3034424-exclusive-lareinadelsurtemporada2completaportorrentversion https://coub.com/stories/3034424-exclusive-lareinadelsurtemporada2completaportorrentversion. .
-https://trello.com/c/j7FkcBmu/28-lareinadelsurtemporada2completaportorrentversion-detsal-nedrwarl https://melaninterest.com/pin/lareinadelsurtemporada2completaportorrentversion/ https://melaninterest.com/pin/lareinadelsurtemporada2completaportorrentversion/ https://coub.
-
899543212bAZbul Oyunu İndir: Kelime Bulmaca Oyunu Nasıl Oynanır?
- Kelime bulmaca oyunlarını seviyorsanız, size harika bir oyun önerimiz var: AZbul . Bu oyun, hem eğlenceli hem de zihin açıcı bir kelime oyunu deneyimi sunuyor. AZbul oyununu indirmek ve nasıl oynandığını öğrenmek için bu yazıyı okumaya devam edin.
-azbul oyunu indir Download File ► https://urllie.com/2uNzRH
AZbul Oyunu Nedir?
- AZbul oyunu, %100 Türkçe olan ve çengel bulmaca ve çapraz bulmaca sevenler için özel olarak hazırlanmış bir kelime oyunudur. Bu oyunda, size verilen harfleri doğru sırayla kaydırarak gizli kelimeleri bulmanız ve bulmacayı çözmeniz gerekiyor. Her seviyede farklı kategorilerde kelimeler bulacaksınız. Örneğin, hayvanlar, ülkeler, şehirler, yiyecekler, sporlar, bitkiler ve daha fazlası.
- AZbul Oyununun Özellikleri
- AZbul oyununu diğer kelime oyunlarından ayıran bazı özellikler şunlardır:
-
-10.000'den fazla seviye ve binlerce kelime içerir.
-Size WOW dedirtecek zorluk seviyeleri sunar.
-Günlük ücretsiz çarkıfelek çevirme ile ekstra altın kazanabilirsiniz.
-Bonus kelimeleri bularak daha fazla para kazanabilirsiniz.
-İpuçları almak için altın kullanabilir veya video izleyerek altın kazanabilirsiniz.
-İnternetsiz de oynayabilirsiniz.
-Hafızanızı geliştirecek ve yeni kelimeler öğreneceksiniz.
-
- AZbul Oyununun Faydaları
- AZbul oyununu oynamak sadece eğlenceli değil, aynı zamanda birçok faydası da vardır. Bunlardan bazıları şunlardır:
-
-Kelime dağarcığınızı genişletir ve dil bilginizi arttırır.
-Zihninizi çalıştırır ve odaklanma yeteneğinizi geliştirir.
-Stresinizi azaltır ve rahatlamanızı sağlar.
-Boş zamanlarınız değerlendirebilirsiniz.
-Aile ve arkadaşlarınızla oynayarak eğlenceli vakit geçirebilirsiniz.
-
- AZbul Oyunu Nasıl İndirilir?
- AZbul oyununu indirmek için iki yöntem vardır: Google Play Store'dan indirmek veya APK dosyası ile indirmek. Her iki yöntemin de avantajları ve dezavantajları vardır. Hangisini tercih edeceğiniz size kalmış.
- Google Play Store'dan İndirme
- Bu yöntem, en kolay ve güvenli yöntemdir. Google Play Store'da AZbul oyununu aratın ve indir butonuna tıklayın. Oyun, otomatik olarak cihazınıza yüklenecektir. Bu yöntemin avantajı, oyunun güncellemelerini otomatik olarak alabilmenizdir. Dezavantajı ise, oyunun bazı ülkelerde Google Play Store'da bulunmamasıdır.
- APK Dosyası İle İndirme
- Bu yöntem, daha esnek ve alternatif bir yöntemdir. APK dosyası, bir uygulamanın kurulum dosyasıdır. AZbul oyununun APK dosyasını internetten bulabilir ve indirebilirsiniz. Ancak, bu işlemi yapmadan önce, cihazınızın ayarlarında bilinmeyen kaynaklardan uygulama yükleme seçeneğini açmanız gerekir. Aksi takdirde, cihazınız APK dosyasını kabul etmeyecektir. Bu yöntemin avantajı, oyunu istediğiniz zaman ve yerde indirebilmenizdir. Dezavantajı ise, oyunun güncellemelerini manuel olarak yapmanız ve güvenilir olmayan kaynaklardan indirdiğiniz için virüs riski taşımanızdır.
- AZbul Oyunu Nasıl Oynanır?
- AZbul oyununu oynamak çok basit ve eğlencelidir. Oyunun temel kuralları, seviyeleri, ipuçları, püf noktaları ve taktikleri hakkında bilgi almak için okumaya devam edin.
- Oyunun Temel Kuralları
- Oyunda size verilen harfleri doğru sırayla kaydırarak gizli kelimeleri bulmanız ve bulmacayı çözmeniz gerekiyor. Her seviyede farklı kategorilerde kelimeler bulacaksınız. Örneğin, hayvanlar, ülkeler, şehirler, yiyecekler, sporlar, bitkiler ve daha fazlası. Bulduğunuz her kelime için altın kazanacaksınız. Altınlarınızı ipuçları almak için kullanabilirsiniz. Eğer takılırsanız, ipucu butonuna tıklayarak bir harf açtırabilir veya video izleyerek harfleri karıştırabilirsiniz. Oyunda ilerledikçe seviyeler zorlaşacak ve daha fazla kelime bulmanız gerekecek.
- Oyunun Seviyeleri ve İpuçları
- Oyunda 10.000'den fazla seviye vardır. Her seviye farklı bir zorluk derecesine sahiptir. Bazı seviyelerde kolayca kelimeleri bulabilirken, bazı seviyelerde ise kafa yormanız gerekebilir. Oyunda ilerledikçe yeni kategoriler açılacak ve daha fazla kelime öğreneceksiniz. Oyunda ipuçları almak için altın kullanabilir veya video izleyerek altın kazanabilirsiniz. Ayrıca bonus kelimeleri bularak da ekstra altın elde edebilirsiniz.
-azbul söz oyunu ve krossvord indir
- Oyunun Püf Noktaları ve TaktikleriOyunda başarılı olmak için bazı püf noktaları ve taktikleri uygulayabilirsiniz. Bunlardan bazıları şunlardır:
-
-Harfleri farklı yönlere kaydırarak daha fazla kelime kombinasyonu bulmaya çalışın.
-Kelimeleri bulurken kategoriyi göz önünde bulundurun. Örneğin, hayvanlar kategorisinde aradığınız kelime bir hayvan adı olmalıdır.
-Bonus kelimeleri kaçırmayın. Bonus kelimeler, bulmacada olmayan ama harflerle oluşturulabilen kelimelerdir. Bu kelimeleri bularak ekstra altın kazanabilirsiniz.
-Altınlarınızı akıllıca kullanın. İpuçları almak için altın harcamadan önce, video izleyerek veya çarkıfelek çevirerek altın kazanmayı deneyin.
-Oyunu düzenli olarak oynayın. Oyunu her gün oynayarak hem becerinizi geliştirebilir hem de günlük bonusları alabilirsiniz.
-
- AZbul Oyunu İle İlgili Sık Sorulan Sorular
- AZbul oyunu ile ilgili merak ettiğiniz bazı soruların cevaplarını aşağıda bulabilirsiniz.
- AZbul Oyunu Ücretsiz Mi?
- Evet, AZbul oyunu tamamen ücretsizdir. Oyunu indirmek ve oynamak için herhangi bir ücret ödemeniz gerekmez. Ancak, oyun içi satın alımlar yaparak daha fazla altın veya ipucu satın alabilirsiniz.
- AZbul Oyunu İnternetsiz Oynanabilir Mi?
- Evet, AZbul oyunu internetsiz de oynanabilir. Oyunu indirdikten sonra internet bağlantınız olmasa bile oynamaya devam edebilirsiniz. Ancak, internet bağlantınız olduğunda oyunun güncellemelerini almanız ve video izleyerek altın kazanmanız mümkündür.
- AZbul Oyunu Türkçe Mi?
- Evet, AZbul oyunu %100 Türkçe'dir. Oyunda kullanılan tüm kelimeler, harfler ve menüler Türkçe'dir. Oyunda Türk kültürüne ve coğrafyasına ait kategoriler de bulunmaktadır.
- AZbul Oyunu Güvenli Mi?
- Evet, AZbul oyunu güvenlidir. Oyun, Google Play Store'da yer alan ve güvenilir bir geliştirici tarafından hazırlanan bir oyundur. Oyun, cihazınıza veya kişisel verilerinize zarar vermez veya erişmez. Oyunu güvenle indirebilir ve oynayabilirsiniz.
- AZbul Oyunu Geliştiricisi Kimdir?
- AZbul oyununun geliştiricisi, Türkiye'de faaliyet gösteren ve mobil oyunlar üreten bir şirket olan GameX Studio 'dur. GameX Studio, AZbul oyununun yanı sıra başka popüler oyunlar da geliştirmiştir. Örneğin, Word Connect , Word Cross , Word Search ve Word Swipe .
- Bu yazımızda, AZbul oyununu indirmek ve nasıl oynandığını öğrenmek için size bilgiler verdik. Umarız bu yazı size yardımcı olmuştur. AZbul oyununu indirmek için aşağıdaki linkleri kullanabilirsiniz:
-
- AZbul oyununu indirdikten sonra, kelime bulmaca oyununun keyfini çıkarmaya başlayabilirsiniz. Oyunu oynarken hem eğlenecek hem de zihninizi geliştireceksiniz. Oyunu arkadaşlarınızla ve ailenizle de paylaşabilir ve onlarla yarışabilirsiniz. AZbul oyunu, kelime oyunu tutkunları için kaçırılmayacak bir oyun. Hemen indirin ve oynamaya başlayın!
401be4b1e0Download APK Traffic Racer: A Guide to the Ultimate Endless Racing Game
-Do you love speed and adrenaline? Do you want to experience the thrill of driving through highway traffic, dodging cars, trucks, buses, and SUVs? Do you want to customize your car, upgrade its performance, and compete with other players around the world? If you answered yes to any of these questions, then you should download APK Traffic Racer, a milestone in the genre of endless arcade racing.
-download apk traffic racer Download File ★★★ https://urllie.com/2uNAkd
Traffic Racer is a game developed by SK Games that can be downloaded for iOS or Android devices. It is one of the most popular and addictive racing games on the market, with over 100 million downloads and 6.3 million reviews on Google Play. In this game, you can drive your car through highway traffic, earn cash, upgrade your car, and buy new ones. You can also try different game modes, environments, and challenges to test your skills and have fun.
-In this article, we will show you how to download APK Traffic Racer for Android devices, how to install and play it on your device, what are the features of the game, and what are some tips and tricks to help you master it. So buckle up and get ready for some high-speed action!
- How to download APK Traffic Racer for Android devices
-If you want to download APK Traffic Racer for Android devices, you have two options. You can either download it from Google Play Store or from a third-party website. Here are the steps for both methods:
-download apk traffic racer mod unlimited money
-
-Download from Google Play Store: This is the easiest and safest way to download APK Traffic Racer for Android devices. All you need to do is open Google Play Store on your device, search for Traffic Racer, and tap on Install. The game will be downloaded and installed automatically on your device. You can also use this link to go directly to the game page on Google Play Store.Download from a third-party website: This is an alternative way to download APK Traffic Racer for Android devices if you cannot access Google Play Store or if you want to get an older version of the game. However, this method is riskier as you may encounter malware or viruses that can harm your device. Therefore, you should only download from trusted and reputable websites that offer safe and verified APK files. To download from a third-party website, you need to follow these steps:
- Go to a website that offers APK files for Traffic Racer. For example, you can use this link to go to EmulatorPC.com.
- Find the download button or link for APK Traffic Racer and click on it.
- Wait for the download to finish and locate the APK file on your device.
-
-
- How to install and play APK Traffic Racer on your device
-Once you have downloaded APK Traffic Racer on your device, you need to install it before you can play it. Here are the steps for installing APK Traffic Racer on your device:
-
-Go to your device settings and enable Unknown Sources. This will allow you to install apps from sources other than Google Play Store.
-Locate the APK file that you downloaded on your device and tap on it.
-Follow the instructions on the screen to install APK Traffic Racer on your device.Once the installation is complete, you can launch APK Traffic Racer from your app drawer or home screen.
-
-Now that you have installed APK Traffic Racer on your device, you can start playing it and enjoy the endless racing game. Here are the basic controls and gameplay of APK Traffic Racer:
-
-Controls: You can control your car by tilting your device to steer left or right, tapping the gas pedal to accelerate, and tapping the brake pedal to slow down. You can also change the control mode from tilt to touch or swipe in the settings menu.Gameplay: You can choose from different game modes, such as Endless, Two-Way, Time Trial, Police Chase, and Free Ride. You can also select different environments, such as Suburb, Desert, Snowy, Rainy, and City Night. Your goal is to drive as fast as possible through the traffic without crashing into other vehicles. The faster you drive, the more points you get. You can also get bonus points by driving in the opposite direction in two-way mode, overtaking other cars closely, or driving over 100 km/h.
- The features of Traffic Racer game
-Traffic Racer is not just a simple racing game. It has many features that make it stand out from other games in the genre. Here are some of the features of Traffic Racer game that you can enjoy:
-
-Stunning 3D graphics and realistic car handling: Traffic Racer has amazing 3D graphics that create a realistic and immersive driving experience. You can see the details of the cars, the environments, the traffic, and the weather effects. You can also feel the difference between different car models and their handling, such as speed, acceleration, braking, and steering.40+ different cars to choose from and customize: Traffic Racer offers a wide range of cars to suit your preferences and style. You can choose from sedans, hatchbacks, sports cars, trucks, buses, and more. You can also customize your car by changing its color, wheels, paint job, and engine. You can upgrade your car's performance by increasing its speed, acceleration, handling, and braking.5 detailed environments and 5 game modes to enjoy: Traffic Racer has 5 different environments that each have their own characteristics and challenges. You can drive in Suburb, Desert, Snowy, Rainy, or City Night. Each environment has different weather conditions, traffic density, and scenery. You can also try 5 different game modes that each have their own objectives and rules. You can play in Endless mode where you drive as long as you can without crashing; Two-Way mode where you drive in both directions; Time Trial mode where you race against the clock; Police Chase mode where you evade the cops; or Free Ride mode where you explore the map freely.Rich types of NPC traffic and online leaderboards: Traffic Racer has a variety of NPC traffic that makes the game more realistic and challenging. You can encounter cars, trucks, buses, SUVs, vans, motorcycles, and more on the road. You have to avoid them or overtake them carefully to avoid collisions. You can also compete with other players around the world on online leaderboards. You can see your rank and score for each game mode and environment. You can also compare your stats with your friends and other players.
- The tips and tricks for Traffic Racer game
-Traffic Racer is a fun and addictive game that will keep you entertained for hours. However, it is not an easy game to master. You need to have good reflexes, skills, and strategies to succeed in this game. Here are some tips and tricks for Traffic Racer game that will help you improve your performance and score:
-
-How to earn more coins and upgrade your car: Coins are the currency of Traffic Racer game that you can use to buy new cars or upgrade your existing ones. You can earn coins by playing the game modes or watching ads. The amount of coins you earn depends on your score, speed, distance traveled , and bonuses. You can also get extra coins by completing achievements or daily missions. You should spend your coins wisely and upgrade your car regularly. You should focus on improving your car's speed, acceleration, handling, and braking, as these will affect your performance and score. You should also choose a car that suits your play style and preference.How to string close shaves and get bonus scores: Close shaves are when you pass very close to another vehicle without crashing. They are one of the best ways to increase your score and earn more coins. You can get bonus points for each close shave you make, and the bonus increases as you string more close shaves in a row. However, close shaves are also very risky and require good timing and precision. You should only attempt close shaves when you are confident and have enough space to maneuver. You should also avoid close shaves when you are driving in the opposite direction or in police chase mode, as these will increase the chances of crashing.How to challenge yourself in time trial mode: Time trial mode is one of the most difficult and rewarding game modes in Traffic Racer. In this mode, you have to drive as fast as possible and reach checkpoints before the time runs out. You can earn extra time by driving faster than 100 km/h or by making close shaves. However, you also have to deal with heavy traffic and tight turns that can slow you down or make you crash. To challenge yourself in time trial mode, you should choose a fast and agile car, such as a sports car or a motorcycle. You should also use the nitro boost wisely, as it can give you a speed boost but also make you lose control. You should also try different environments and routes to test your skills and adaptability.How to watch ads for free coins: Watching ads is another way to earn free coins in Traffic Racer game. You can watch ads by tapping on the video icon on the main menu or on the game over screen. You can watch up to 10 ads per day and earn 500 coins for each ad. However, watching ads can be boring and time-consuming, so you should only do it when you really need some extra coins or when you have nothing else to do.
- Conclusion: Summarize the main points and invite the reader to try the game
-Traffic Racer is an amazing endless racing game that will keep you hooked for hours. It has stunning 3D graphics, realistic car handling, 40+ different cars, 5 detailed environments, 5 game modes, rich types of NPC traffic, and online leaderboards. It is easy to download APK Traffic Racer for Android devices from Google Play Store or from a third-party website. It is also easy to install and play APK Traffic Racer on your device with simple controls and gameplay. However, it is not easy to master Traffic Racer game without some tips and tricks that will help you earn more coins, upgrade your car, string close shaves, get bonus scores, challenge yourself in time trial mode, and watch ads for free coins.
-If you are looking for a fun and addictive racing game that will test your skills and reflexes, then you should download APK Traffic Racer today and enjoy the ultimate endless racing game!
- FAQs: Answer some common questions about the game
-
-Question Answer What is the size of APK Traffic Racer? The size of APK Traffic Racer varies depending on the device and version. The latest version (3.3) on Google Play Store is about 60 MB. What are the minimum requirements for APK Traffic Racer? The minimum requirements for APK Traffic Racer are Android 4.1 or higher and at least 1 GB of RAM. Is APK Traffic Racer free to play? Yes, APK Traffic Racer is free to play with optional in-app purchases. Can I play APK Traffic Racer offline? Yes, you can play APK Traffic Racer offline without an internet connection. Can I play APK Traffic Racer with friends? No, APK Traffic Racer does not have a multiplayer mode. However, you can compete with other players on online leaderboards.
401be4b1e0Dig Deep APK Mod An1: A Fun and Addictive Mining Game
-Do you love mining games? Do you want to become a rich tycoon by digging for treasure and gems? If yes, then you should try Dig Deep APK Mod An1 , a fun and addictive mining game that will keep you entertained for hours.
-dig deep apk mod an1 DOWNLOAD ►►► https://gohhs.com/2uPsq8
Dig Deep APK Mod An1 is a modified version of the original game, Dig Deep, developed by APKCombo . In this game, you can go underground and dig deep for treasure, but don't get stuck down the hole. You can also hire workers and upgrade your equipment to boost your digging empire. This idle miner game is the best digging game there is.
-In this article, we will tell you how to play Dig Deep APK Mod An1, what are its features, how to download and install it, and some frequently asked questions. Let's get started!
- How to Play Dig Deep APK Mod An1
-Dig for treasure and gems underground
-The main goal of Dig Deep APK Mod An1 is to dig deep and find as many treasure and gems as possible. You can use your finger to swipe on the screen and control the direction of your drill. You can also tap on the screen to speed up your drill. As you dig deeper, you will encounter different types of soil, rocks, and obstacles that will affect your digging speed and durability. You will also find various items such as coins, diamonds, chests, keys, bombs, magnets, etc. that will help you in your digging adventure.
-dig deep mod apk unlimited money an1
-Hire workers and upgrade your equipment
-As you dig deeper, you will earn money that you can use to hire workers and upgrade your equipment. Workers will help you dig faster and collect more items. You can hire different types of workers such as miners, engineers, explorers, etc. Each worker has a different skill and cost. You can also upgrade your drill, battery, storage, etc. to improve your digging performance. Upgrading your equipment will also unlock new areas to explore.
-Collect rewards and bonuses
-Dig Deep APK Mod An1 also offers various rewards and bonuses that will make your digging experience more fun and rewarding. You can collect daily rewards, achievements, quests, etc. that will give you extra money, diamonds, items, etc. You can also spin the wheel of fortune or play the slot machine to win more prizes. You can also watch videos or complete offers to get more rewards.
- Features of Dig Deep APK Mod An1
-Unlimited money and diamonds
-One of the best features of Dig Deep APK Mod An1 is that it gives you unlimited money and diamonds. This means that you can hire as many workers and upgrade as many equipment as you want without worrying about the cost. You can also buy more items and boosters to enhance your digging experience. With unlimited money and diamonds, you can enjoy the game without any limitations.
-No ads and no root required
-Another great feature of Dig Deep APK Mod An1 is that it has no ads and no root required. This means that you can play the game without any interruptions or distractions from annoying ads. You can also play the game without rooting your device, which can be risky and complicated. Dig Deep APK Mod An1 is safe and easy to use.
-Easy and intuitive controls
-Dig Deep APK Mod An1 also has easy and intuitive controls that make the game simple and fun to play. You can control your drill with just one finger, swiping and tapping on the screen. You can also access the menu, shop, settings, etc. with just a few clicks. The game also has a tutorial that will guide you through the basics of the game.
-Colorful graphics and sound effects
-Dig Deep APK Mod An1 also has colorful graphics and sound effects that make the game more appealing and immersive. The game has a cartoon-like style that is suitable for all ages. The game also has various sound effects that match the actions and events in the game. You can hear the drill, the coins, the explosions, etc. The game also has a cheerful background music that will keep you motivated.
-Offline mode and cloud save
-Dig Deep APK Mod An1 also has an offline mode and a cloud save feature that make the game more convenient and accessible. You can play the game offline without an internet connection, which is great for when you are traveling or have no wifi. You can also save your progress on the cloud, which is great for when you want to switch devices or reinstall the game. You can sync your progress across different devices with just a few steps.
- How to Download and Install Dig Deep APK Mod An1
-Download the APK file from a trusted source
-The first step to download and install Dig Deep APK Mod An1 is to download the APK file from a trusted source. You can use the link below to download the latest version of Dig Deep APK Mod An1 from An1.com , a reliable website that offers modded games and apps.
-Download Dig Deep APK Mod An1
-Enable unknown sources on your device
-The second step to download and install Dig Deep APK Mod An1 is to enable unknown sources on your device. This will allow you to install apps from sources other than the Google Play Store. To enable unknown sources, follow these steps:
-
-Go to your device's settings.
-Tap on security or privacy.
-Find and enable unknown sources or allow installation from unknown sources.
-
-Install the APK file and launch the game
-The third step to download and install Dig Deep APK Mod An1 is to install the APK file and launch the game. To install the APK file, follow these steps:
-
-Locate the downloaded APK file on your device's file manager or downloads folder.
-Tap on the APK file and follow the instructions on the screen.
-Wait for the installation to complete.
-Tap on the game icon on your home screen or app drawer.
-Enjoy playing Dig Deep APK Mod An1!
-
- Conclusion
-Dig Deep APK Mod An1 is a fun and addictive mining game that will keep you entertained for hours. You can dig deep for treasure and gems, hire workers and upgrade your equipment, collect rewards and bonuses, and enjoy unlimited money and diamonds. You can also play the game without ads, without root, with easy controls, with colorful graphics, and with offline mode and cloud save. Dig Deep APK Mod An1 is the best digging game there is.
-If you want to try Dig Deep APK Mod An1, you can download it from An1.com , a trusted source of modded games and apps. Just follow the steps above to download and install it on your device. Then, start digging deep and become a rich tycoon!
- FAQs
-What is the difference between Dig Deep APK Mod An1 and the original version?
-The difference between Dig Deep APK Mod An1 and the original version is that Dig Deep APK Mod An1 has unlimited money and diamonds, no ads, no root required, and some other features that make the game more fun and easy to play. The original version of Dig Deep is available on the Google Play Store, but it has limited money and diamonds, ads, and some other restrictions that may affect your gaming experience.
-Is Dig Deep APK Mod An1 safe to use?
-Yes, Dig Deep APK Mod An1 is safe to use. It does not contain any viruses, malware, or spyware that can harm your device or data. It also does not require root access, which can be risky and complicated. Dig Deep APK Mod An1 is tested and verified by An1.com , a reliable website that offers modded games and apps. However, you should always download the APK file from a trusted source and enable unknown sources on your device at your own risk.
-How can I get more money and diamonds in Dig Deep APK Mod An1?
-You can get more money and diamonds in Dig Deep APK Mod An1 by playing the game regularly and collecting the items that you find underground. You can also get more money and diamonds by completing the achievements, quests, daily rewards, etc. that the game offers. You can also spin the wheel of fortune or play the slot machine to win more prizes. You can also watch videos or complete offers to get more rewards. However, you don't need to worry about running out of money and diamonds in Dig Deep APK Mod An1, as it gives you unlimited money and diamonds from the start.
-What are the best strategies to play Dig Deep APK Mod An1?
-Some of the best strategies to play Dig Deep APK Mod An1 are:
-
-Dig deep and fast, but don't get stuck down the hole. You can use bombs or magnets to clear the obstacles or attract the items.
-Hire workers and upgrade your equipment as soon as possible. Workers will help you dig faster and collect more items. Upgrading your equipment will improve your digging performance and unlock new areas.
-Collect as many items as possible, especially coins, diamonds, chests, keys, etc. They will help you earn more money and buy more things.
-Use boosters and items wisely. Boosters and items can help you dig faster, collect more items, increase your storage, etc. But they have a limited time or quantity, so use them when you need them.
-Complete the achievements, quests, daily rewards, etc. They will give you extra money, diamonds, items, etc. that will make your digging experience more fun and rewarding.
-
-Can I play Dig Deep APK Mod An1 with my friends?
-Unfortunately, Dig Deep APK Mod An1 does not have a multiplayer mode or a social feature that allows you to play with your friends. However, you can still share your progress and achievements with your friends by taking screenshots or recording videos of your game. You can also compare your scores and rankings with other players on the leaderboard.
197e85843d
- - GitHub repository:
- """
-)
-
-st.sidebar.title("Contact")
-st.sidebar.info(
- """
- Qiusheng Wu at [wetlands.io](https://wetlands.io) | [GitHub](https://github.com/giswqs) | [Twitter](https://twitter.com/giswqs) | [YouTube](https://www.youtube.com/c/QiushengWu) | [LinkedIn](https://www.linkedin.com/in/qiushengwu)
- """
-)
-
-st.title("Comparing Global Land Cover Maps")
-
-col1, col2 = st.columns([4, 1])
-
-Map = geemap.Map()
-Map.add_basemap("ESA WorldCover 2020 S2 FCC")
-Map.add_basemap("ESA WorldCover 2020 S2 TCC")
-Map.add_basemap("HYBRID")
-
-esa = ee.ImageCollection("ESA/WorldCover/v100").first()
-esa_vis = {"bands": ["Map"]}
-
-
-esri = ee.ImageCollection(
- "projects/sat-io/open-datasets/landcover/ESRI_Global-LULC_10m"
-).mosaic()
-esri_vis = {
- "min": 1,
- "max": 10,
- "palette": [
- "#1A5BAB",
- "#358221",
- "#A7D282",
- "#87D19E",
- "#FFDB5C",
- "#EECFA8",
- "#ED022A",
- "#EDE9E4",
- "#F2FAFF",
- "#C8C8C8",
- ],
-}
-
-
-markdown = """
- - [Dynamic World Land Cover](https://developers.google.com/earth-engine/datasets/catalog/GOOGLE_DYNAMICWORLD_V1?hl=en)
- - [ESA Global Land Cover](https://developers.google.com/earth-engine/datasets/catalog/ESA_WorldCover_v100)
- - [ESRI Global Land Cover](https://samapriya.github.io/awesome-gee-community-datasets/projects/esrilc2020)
-
-"""
-
-with col2:
-
- longitude = st.number_input("Longitude", -180.0, 180.0, -89.3998)
- latitude = st.number_input("Latitude", -90.0, 90.0, 43.0886)
- zoom = st.number_input("Zoom", 0, 20, 11)
-
- Map.setCenter(longitude, latitude, zoom)
-
- start = st.date_input("Start Date for Dynamic World", datetime.date(2020, 1, 1))
- end = st.date_input("End Date for Dynamic World", datetime.date(2021, 1, 1))
-
- start_date = start.strftime("%Y-%m-%d")
- end_date = end.strftime("%Y-%m-%d")
-
- region = ee.Geometry.BBox(-179, -89, 179, 89)
- dw = geemap.dynamic_world(region, start_date, end_date, return_type="hillshade")
-
- layers = {
- "Dynamic World": geemap.ee_tile_layer(dw, {}, "Dynamic World Land Cover"),
- "ESA Land Cover": geemap.ee_tile_layer(esa, esa_vis, "ESA Land Cover"),
- "ESRI Land Cover": geemap.ee_tile_layer(esri, esri_vis, "ESRI Land Cover"),
- }
-
- options = list(layers.keys())
- left = st.selectbox("Select a left layer", options, index=1)
- right = st.selectbox("Select a right layer", options, index=0)
-
- left_layer = layers[left]
- right_layer = layers[right]
-
- Map.split_map(left_layer, right_layer)
-
- legend = st.selectbox("Select a legend", options, index=options.index(right))
- if legend == "Dynamic World":
- Map.add_legend(
- title="Dynamic World Land Cover",
- builtin_legend="Dynamic_World",
- )
- elif legend == "ESA Land Cover":
- Map.add_legend(title="ESA Land Cover", builtin_legend="ESA_WorldCover")
- elif legend == "ESRI Land Cover":
- Map.add_legend(title="ESRI Land Cover", builtin_legend="ESRI_LandCover")
-
- with st.expander("Data sources"):
- st.markdown(markdown)
-
-
-with col1:
- Map.to_streamlit(height=750)
diff --git a/spaces/gotiQspiryo/whisper-ui/examples/Dmc Devil May Cry 5 Crack Only Download !!EXCLUSIVE!!.md b/spaces/gotiQspiryo/whisper-ui/examples/Dmc Devil May Cry 5 Crack Only Download !!EXCLUSIVE!!.md
deleted file mode 100644
index 261e5fea2f7ac8e6dd0157b9cbe84997b7b20cac..0000000000000000000000000000000000000000
--- a/spaces/gotiQspiryo/whisper-ui/examples/Dmc Devil May Cry 5 Crack Only Download !!EXCLUSIVE!!.md
+++ /dev/null
@@ -1,28 +0,0 @@
-How to Download and Install DMC Devil May Cry 5 Crack Only
-If you are looking for a way to play DMC Devil May Cry 5 for free, you might be interested in downloading and installing the crack only version of the game. This is a modified version of the game that bypasses the DRM protection and allows you to play without a valid license key. However, before you proceed, you should be aware of the risks and disadvantages of using a cracked game.
-dmc devil may cry 5 crack only download Download ✪✪✪ https://urlgoal.com/2uyMeJ
What is DMC Devil May Cry 5?
-DMC Devil May Cry 5 is the latest installment in the popular action-adventure hack and slash series developed by Capcom. The game follows the story of Dante, a young demon hunter who must face his own demonic heritage and fight against the forces of evil. The game features a fast-paced and stylish combat system, a variety of weapons and abilities, and a rich and immersive world. The game was released on March 8, 2019 for Windows, PlayStation 4, and Xbox One.
-What is DMC Devil May Cry 5 Crack Only?
-DMC Devil May Cry 5 Crack Only is a modified version of the game that removes the DRM protection and allows you to play without a valid license key. The crack only version does not include the full game files, but only the executable file and some other files that are needed to run the game. The crack only version is usually distributed by groups of hackers or pirates who want to share the game for free.
-How to Download and Install DMC Devil May Cry 5 Crack Only?
-To download and install DMC Devil May Cry 5 Crack Only, you will need to follow these steps:
-
-Download the full game files from a trusted source. You can either buy the game from an official platform like Steam or find a torrent link from a reputable site. Make sure you have enough space on your hard drive and a good internet connection.
-Extract the game files using a program like WinRAR or 7-Zip. You will get a folder with the game files inside.
-Download the crack only files from a reliable source. You can either find them on a website that offers cracks or use a torrent link from a verified uploader. Be careful not to download any malware or viruses along with the crack files.
-Extract the crack only files using a program like WinRAR or 7-Zip. You will get another folder with the crack files inside.
-Copy the crack files to the game installation folder. You will need to overwrite some of the original files with the cracked ones. The game installation folder is usually located in C:\Program Files (x86)\Steam\steamapps\common\DMC Devil May Cry 5 or C:\Program Files\DMC Devil May Cry 5 depending on your system.
-Run the game as administrator. You should be able to play DMC Devil May Cry 5 without any problems.
-
-What are the Risks and Disadvantages of Using DMC Devil May Cry 5 Crack Only?
-While using DMC Devil May Cry 5 Crack Only might seem tempting, you should be aware of the risks and disadvantages of doing so. Some of them are:
-
-
-You might be breaking the law. Depending on your country's laws, downloading and installing cracked games might be considered illegal and punishable by fines or jail time. You might also be infringing on the intellectual property rights of the developers and publishers of the game.
-You might be exposing your computer to malware or viruses. Some of the crack files might contain malicious code that can harm your system or steal your personal information. You might also be downloading unwanted programs or ads along with the crack files.
-You might be missing out on updates and features. The crack only version might not work with future updates or patches of the game. You might also be unable to access some of the features or content of the game, such as online multiplayer, DLCs, achievements, etc.
-You might be compromising your gaming experience. The crack only version might have bugs or errors that can affect your gameplay. You might also d5da3c52bfHow to Watch Hum Dil De Chuke Sanam Online in HD Quality
-Hum Dil De Chuke Sanam is a 1999 Hindi romantic drama movie directed by Sanjay Leela Bhansali and starring Salman Khan, Aishwarya Rai Bachchan and Ajay Devgn. The movie tells the story of Nandini, a young woman who falls in love with Sameer, a musician who comes to learn from her father. However, her father arranges her marriage with Vanraj, a lawyer who loves her unconditionally. When Vanraj discovers Nandini's past, he decides to take her to Italy to reunite her with Sameer.
-HD Online Player (Hum Dil De Chuke Sanam love full mov) Download File ››› https://urlgoal.com/2uyMc7
If you are a fan of this movie and want to watch it online in HD quality, you have several options to choose from. Here are some of the best ways to stream Hum Dil De Chuke Sanam online:
-
-Eros Now : Eros Now is a popular streaming platform that offers a wide range of Indian movies and shows. You can watch Hum Dil De Chuke Sanam on Eros Now with a premium subscription that costs $4.99 per month or $49.99 per year. You can also enjoy subtitles in Arabic and English with the premium plan.JioCinema : JioCinema is another streaming service that features a large collection of Hindi movies and shows. You can watch Hum Dil De Chuke Sanam on JioCinema for free if you are a Jio subscriber. You can also download the movie for offline viewing on your device.JustWatch : JustWatch is a website that helps you find where to watch movies and shows online. You can use JustWatch to search for Hum Dil De Chuke Sanam and see which streaming platforms offer it in your region. You can also compare prices and quality of different services.fmovie : fmovie is a website that allows you to watch movies online for free without registration. You can watch Hum Dil De Chuke Sanam on fmovie in HD quality with English subtitles. However, be careful of pop-up ads and malware that may affect your device.
-Hum Dil De Chuke Sanam is a classic movie that showcases the beauty of love, music and culture. Whether you want to watch it for the first time or relive the emotions, you can find it online in HD quality with these options.
-
-Hum Dil De Chuke Sanam is not only a love story, but also a celebration of Indian culture, music and art. The movie showcases the rich traditions of Rajasthan and Gujarat, with colorful costumes, jewelry, dances and festivals. The movie also features some of the most melodious and soulful songs composed by Ismail Darbar and sung by renowned singers like Udit Narayan, Kavita Krishnamurthy, Alka Yagnik and Kumar Sanu. The songs blend classical and folk elements with modern beats and instruments.
-
-The movie received critical acclaim and commercial success upon its release. It won several awards, including four National Film Awards and nine Filmfare Awards. It was also India's official entry for the Academy Award for Best Foreign Language Film, but was not nominated. The movie was praised for its direction, cinematography, editing, music and performances. The chemistry between Salman Khan and Aishwarya Rai Bachchan was especially appreciated, as they portrayed the passion and pain of their characters with conviction. Ajay Devgn also impressed with his subtle and mature portrayal of Vanraj, who emerges as the true hero of the movie.
-Hum Dil De Chuke Sanam is a movie that will touch your heart and make you cry, laugh and smile. It is a movie that explores the meaning of love, loyalty and sacrifice. It is a movie that will stay with you long after it ends.
d5da3c52bf = memo(({ message, messageIndex, onEdit }) => {
- const { t } = useTranslation('chat');
-
- const {
- state: { selectedConversation, conversations, currentMessage, messageIsStreaming },
- dispatch: homeDispatch,
- } = useContext(HomeContext);
-
- const [isEditing, setIsEditing] = useState(false);
- const [isTyping, setIsTyping] = useState(false);
- const [messageContent, setMessageContent] = useState(message.content);
- const [messagedCopied, setMessageCopied] = useState(false);
-
- const textareaRef = useRef(null);
-
- const toggleEditing = () => {
- setIsEditing(!isEditing);
- };
-
- const handleInputChange = (event: React.ChangeEvent) => {
- setMessageContent(event.target.value);
- if (textareaRef.current) {
- textareaRef.current.style.height = 'inherit';
- textareaRef.current.style.height = `${textareaRef.current.scrollHeight}px`;
- }
- };
-
- const handleEditMessage = () => {
- if (message.content != messageContent) {
- if (selectedConversation && onEdit) {
- onEdit({ ...message, content: messageContent });
- }
- }
- setIsEditing(false);
- };
-
- const handleDeleteMessage = () => {
- if (!selectedConversation) return;
-
- const { messages } = selectedConversation;
- const findIndex = messages.findIndex((elm) => elm === message);
-
- if (findIndex < 0) return;
-
- if (
- findIndex < messages.length - 1 &&
- messages[findIndex + 1].role === 'assistant'
- ) {
- messages.splice(findIndex, 2);
- } else {
- messages.splice(findIndex, 1);
- }
- const updatedConversation = {
- ...selectedConversation,
- messages,
- };
-
- const { single, all } = updateConversation(
- updatedConversation,
- conversations,
- );
- homeDispatch({ field: 'selectedConversation', value: single });
- homeDispatch({ field: 'conversations', value: all });
- };
-
- const handlePressEnter = (e: React.KeyboardEvent) => {
- if (e.key === 'Enter' && !isTyping && !e.shiftKey) {
- e.preventDefault();
- handleEditMessage();
- }
- };
-
- const copyOnClick = () => {
- if (!navigator.clipboard) return;
-
- navigator.clipboard.writeText(message.content).then(() => {
- setMessageCopied(true);
- setTimeout(() => {
- setMessageCopied(false);
- }, 2000);
- });
- };
-
- useEffect(() => {
- setMessageContent(message.content);
- }, [message.content]);
-
-
- useEffect(() => {
- if (textareaRef.current) {
- textareaRef.current.style.height = 'inherit';
- textareaRef.current.style.height = `${textareaRef.current.scrollHeight}px`;
- }
- }, [isEditing]);
-
- return (
-
-
-
- {message.role === 'assistant' ? (
-
-
-
- {message.role === 'user' ? (
-