Update parquet files (step 12 of 296)

spaces/232labs/VToonify/vtoonify/model/stylegan/lpips/pretrained_networks.py

@@ -1,181 +0,0 @@
-from collections import namedtuple
-import torch
-from torchvision import models as tv
-from IPython import embed
-
-class squeezenet(torch.nn.Module):
-    def __init__(self, requires_grad=False, pretrained=True):
-        super(squeezenet, self).__init__()
-        pretrained_features = tv.squeezenet1_1(pretrained=pretrained).features
-        self.slice1 = torch.nn.Sequential()
-        self.slice2 = torch.nn.Sequential()
-        self.slice3 = torch.nn.Sequential()
-        self.slice4 = torch.nn.Sequential()
-        self.slice5 = torch.nn.Sequential()
-        self.slice6 = torch.nn.Sequential()
-        self.slice7 = torch.nn.Sequential()
-        self.N_slices = 7
-        for x in range(2):
-            self.slice1.add_module(str(x), pretrained_features[x])
-        for x in range(2,5):
-            self.slice2.add_module(str(x), pretrained_features[x])
-        for x in range(5, 8):
-            self.slice3.add_module(str(x), pretrained_features[x])
-        for x in range(8, 10):
-            self.slice4.add_module(str(x), pretrained_features[x])
-        for x in range(10, 11):
-            self.slice5.add_module(str(x), pretrained_features[x])
-        for x in range(11, 12):
-            self.slice6.add_module(str(x), pretrained_features[x])
-        for x in range(12, 13):
-            self.slice7.add_module(str(x), pretrained_features[x])
-        if not requires_grad:
-            for param in self.parameters():
-                param.requires_grad = False
-
-    def forward(self, X):
-        h = self.slice1(X)
-        h_relu1 = h
-        h = self.slice2(h)
-        h_relu2 = h
-        h = self.slice3(h)
-        h_relu3 = h
-        h = self.slice4(h)
-        h_relu4 = h
-        h = self.slice5(h)
-        h_relu5 = h
-        h = self.slice6(h)
-        h_relu6 = h
-        h = self.slice7(h)
-        h_relu7 = h
-        vgg_outputs = namedtuple("SqueezeOutputs", ['relu1','relu2','relu3','relu4','relu5','relu6','relu7'])
-        out = vgg_outputs(h_relu1,h_relu2,h_relu3,h_relu4,h_relu5,h_relu6,h_relu7)
-
-        return out
-
-
-class alexnet(torch.nn.Module):
-    def __init__(self, requires_grad=False, pretrained=True):
-        super(alexnet, self).__init__()
-        alexnet_pretrained_features = tv.alexnet(pretrained=pretrained).features
-        self.slice1 = torch.nn.Sequential()
-        self.slice2 = torch.nn.Sequential()
-        self.slice3 = torch.nn.Sequential()
-        self.slice4 = torch.nn.Sequential()
-        self.slice5 = torch.nn.Sequential()
-        self.N_slices = 5
-        for x in range(2):
-            self.slice1.add_module(str(x), alexnet_pretrained_features[x])
-        for x in range(2, 5):
-            self.slice2.add_module(str(x), alexnet_pretrained_features[x])
-        for x in range(5, 8):
-            self.slice3.add_module(str(x), alexnet_pretrained_features[x])
-        for x in range(8, 10):
-            self.slice4.add_module(str(x), alexnet_pretrained_features[x])
-        for x in range(10, 12):
-            self.slice5.add_module(str(x), alexnet_pretrained_features[x])
-        if not requires_grad:
-            for param in self.parameters():
-                param.requires_grad = False
-
-    def forward(self, X):
-        h = self.slice1(X)
-        h_relu1 = h
-        h = self.slice2(h)
-        h_relu2 = h
-        h = self.slice3(h)
-        h_relu3 = h
-        h = self.slice4(h)
-        h_relu4 = h
-        h = self.slice5(h)
-        h_relu5 = h
-        alexnet_outputs = namedtuple("AlexnetOutputs", ['relu1', 'relu2', 'relu3', 'relu4', 'relu5'])
-        out = alexnet_outputs(h_relu1, h_relu2, h_relu3, h_relu4, h_relu5)
-
-        return out
-
-class vgg16(torch.nn.Module):
-    def __init__(self, requires_grad=False, pretrained=True):
-        super(vgg16, self).__init__()
-        vgg_pretrained_features = tv.vgg16(pretrained=pretrained).features
-        self.slice1 = torch.nn.Sequential()
-        self.slice2 = torch.nn.Sequential()
-        self.slice3 = torch.nn.Sequential()
-        self.slice4 = torch.nn.Sequential()
-        self.slice5 = torch.nn.Sequential()
-        self.N_slices = 5
-        for x in range(4):
-            self.slice1.add_module(str(x), vgg_pretrained_features[x])
-        for x in range(4, 9):
-            self.slice2.add_module(str(x), vgg_pretrained_features[x])
-        for x in range(9, 16):
-            self.slice3.add_module(str(x), vgg_pretrained_features[x])
-        for x in range(16, 23):
-            self.slice4.add_module(str(x), vgg_pretrained_features[x])
-        for x in range(23, 30):
-            self.slice5.add_module(str(x), vgg_pretrained_features[x])
-        if not requires_grad:
-            for param in self.parameters():
-                param.requires_grad = False
-
-    def forward(self, X):
-        h = self.slice1(X)
-        h_relu1_2 = h
-        h = self.slice2(h)
-        h_relu2_2 = h
-        h = self.slice3(h)
-        h_relu3_3 = h
-        h = self.slice4(h)
-        h_relu4_3 = h
-        h = self.slice5(h)
-        h_relu5_3 = h
-        vgg_outputs = namedtuple("VggOutputs", ['relu1_2', 'relu2_2', 'relu3_3', 'relu4_3', 'relu5_3'])
-        out = vgg_outputs(h_relu1_2, h_relu2_2, h_relu3_3, h_relu4_3, h_relu5_3)
-
-        return out
-
-
-
-class resnet(torch.nn.Module):
-    def __init__(self, requires_grad=False, pretrained=True, num=18):
-        super(resnet, self).__init__()
-        if(num==18):
-            self.net = tv.resnet18(pretrained=pretrained)
-        elif(num==34):
-            self.net = tv.resnet34(pretrained=pretrained)
-        elif(num==50):
-            self.net = tv.resnet50(pretrained=pretrained)
-        elif(num==101):
-            self.net = tv.resnet101(pretrained=pretrained)
-        elif(num==152):
-            self.net = tv.resnet152(pretrained=pretrained)
-        self.N_slices = 5
-
-        self.conv1 = self.net.conv1
-        self.bn1 = self.net.bn1
-        self.relu = self.net.relu
-        self.maxpool = self.net.maxpool
-        self.layer1 = self.net.layer1
-        self.layer2 = self.net.layer2
-        self.layer3 = self.net.layer3
-        self.layer4 = self.net.layer4
-
-    def forward(self, X):
-        h = self.conv1(X)
-        h = self.bn1(h)
-        h = self.relu(h)
-        h_relu1 = h
-        h = self.maxpool(h)
-        h = self.layer1(h)
-        h_conv2 = h
-        h = self.layer2(h)
-        h_conv3 = h
-        h = self.layer3(h)
-        h_conv4 = h
-        h = self.layer4(h)
-        h_conv5 = h
-
-        outputs = namedtuple("Outputs", ['relu1','conv2','conv3','conv4','conv5'])
-        out = outputs(h_relu1, h_conv2, h_conv3, h_conv4, h_conv5)
-
-        return out

spaces/52Hz/SRMNet_thesis/model_arch/__init__.py

@@ -1,2 +0,0 @@
-from .SRMNet import *
-from .SRMNet_SWFF import *

spaces/AIGC-Audio/AudioGPT/text_to_speech/utils/text/text_norm.py

@@ -1,797 +0,0 @@
-# coding=utf-8
-# Authors:
-#   2019.5 Zhiyang Zhou (https://github.com/Joee1995/chn_text_norm.git)
-#   2019.9 Jiayu DU
-#
-# requirements:
-#   - python 3.X
-# notes: python 2.X WILL fail or produce misleading results
-
-import sys, os, argparse, codecs, string, re
-
-# ================================================================================ #
-#                                    basic constant
-# ================================================================================ #
-CHINESE_DIGIS = u'零一二三四五六七八九'
-BIG_CHINESE_DIGIS_SIMPLIFIED = u'零壹贰叁肆伍陆柒捌玖'
-BIG_CHINESE_DIGIS_TRADITIONAL = u'零壹貳參肆伍陸柒捌玖'
-SMALLER_BIG_CHINESE_UNITS_SIMPLIFIED = u'十百千万'
-SMALLER_BIG_CHINESE_UNITS_TRADITIONAL = u'拾佰仟萬'
-LARGER_CHINESE_NUMERING_UNITS_SIMPLIFIED = u'亿兆京垓秭穰沟涧正载'
-LARGER_CHINESE_NUMERING_UNITS_TRADITIONAL = u'億兆京垓秭穰溝澗正載'
-SMALLER_CHINESE_NUMERING_UNITS_SIMPLIFIED = u'十百千万'
-SMALLER_CHINESE_NUMERING_UNITS_TRADITIONAL = u'拾佰仟萬'
-
-ZERO_ALT = u'〇'
-ONE_ALT = u'幺'
-TWO_ALTS = [u'两', u'兩']
-
-POSITIVE = [u'正', u'正']
-NEGATIVE = [u'负', u'負']
-POINT = [u'点', u'點']
-# PLUS = [u'加', u'加']
-# SIL = [u'杠', u'槓']
-
-# 中文数字系统类型
-NUMBERING_TYPES = ['low', 'mid', 'high']
-
-CURRENCY_NAMES = '(人民币|美元|日元|英镑|欧元|马克|法郎|加拿大元|澳元|港币|先令|芬兰马克|爱尔兰镑|' \
-                 '里拉|荷兰盾|埃斯库多|比塞塔|印尼盾|林吉特|新西兰元|比索|卢布|新加坡元|韩元|泰铢)'
-CURRENCY_UNITS = '((亿|千万|百万|万|千|百)|(亿|千万|百万|万|千|百|)元|(亿|千万|百万|万|千|百|)块|角|毛|分)'
-COM_QUANTIFIERS = '(匹|张|座|回|场|尾|条|个|首|阙|阵|网|炮|顶|丘|棵|只|支|袭|辆|挑|担|颗|壳|窠|曲|墙|群|腔|' \
-                  '砣|座|客|贯|扎|捆|刀|令|打|手|罗|坡|山|岭|江|溪|钟|队|单|双|对|出|口|头|脚|板|跳|枝|件|贴|' \
-                  '针|线|管|名|位|身|堂|课|本|页|家|户|层|丝|毫|厘|分|钱|两|斤|担|铢|石|钧|锱|忽|(千|毫|微)克|' \
-                  '毫|厘|分|寸|尺|丈|里|寻|常|铺|程|(千|分|厘|毫|微)米|撮|勺|合|升|斗|石|盘|碗|碟|叠|桶|笼|盆|' \
-                  '盒|杯|钟|斛|锅|簋|篮|盘|桶|罐|瓶|壶|卮|盏|箩|箱|煲|啖|袋|钵|年|月|日|季|刻|时|周|天|秒|分|旬|' \
-                  '纪|岁|世|更|夜|春|夏|秋|冬|代|伏|辈|丸|泡|粒|颗|幢|堆|条|根|支|道|面|片|张|颗|块)'
-
-# punctuation information are based on Zhon project (https://github.com/tsroten/zhon.git)
-CHINESE_PUNC_STOP = '！？｡。'
-CHINESE_PUNC_NON_STOP = '＂＃＄％＆＇（）＊＋，－／：；＜＝＞＠［＼］＾＿｀｛｜｝～｟｠｢｣､、〃《》「」『』【】〔〕〖〗〘〙〚〛〜〝〞〟〰〾〿–—‘’‛“”„‟…‧﹏'
-CHINESE_PUNC_LIST = CHINESE_PUNC_STOP + CHINESE_PUNC_NON_STOP
-
-
-# ================================================================================ #
-#                                    basic class
-# ================================================================================ #
-class ChineseChar(object):
-    """
-    中文字符
-    每个字符对应简体和繁体,
-    e.g. 简体 = '负', 繁体 = '負'
-    转换时可转换为简体或繁体
-    """
-
-    def __init__(self, simplified, traditional):
-        self.simplified = simplified
-        self.traditional = traditional
-        # self.__repr__ = self.__str__
-
-    def __str__(self):
-        return self.simplified or self.traditional or None
-
-    def __repr__(self):
-        return self.__str__()
-
-
-class ChineseNumberUnit(ChineseChar):
-    """
-    中文数字/数位字符
-    每个字符除繁简体外还有一个额外的大写字符
-    e.g. '陆' 和 '陸'
-    """
-
-    def __init__(self, power, simplified, traditional, big_s, big_t):
-        super(ChineseNumberUnit, self).__init__(simplified, traditional)
-        self.power = power
-        self.big_s = big_s
-        self.big_t = big_t
-
-    def __str__(self):
-        return '10^{}'.format(self.power)
-
-    @classmethod
-    def create(cls, index, value, numbering_type=NUMBERING_TYPES[1], small_unit=False):
-
-        if small_unit:
-            return ChineseNumberUnit(power=index + 1,
-                                     simplified=value[0], traditional=value[1], big_s=value[1], big_t=value[1])
-        elif numbering_type == NUMBERING_TYPES[0]:
-            return ChineseNumberUnit(power=index + 8,
-                                     simplified=value[0], traditional=value[1], big_s=value[0], big_t=value[1])
-        elif numbering_type == NUMBERING_TYPES[1]:
-            return ChineseNumberUnit(power=(index + 2) * 4,
-                                     simplified=value[0], traditional=value[1], big_s=value[0], big_t=value[1])
-        elif numbering_type == NUMBERING_TYPES[2]:
-            return ChineseNumberUnit(power=pow(2, index + 3),
-                                     simplified=value[0], traditional=value[1], big_s=value[0], big_t=value[1])
-        else:
-            raise ValueError(
-                'Counting type should be in {0} ({1} provided).'.format(NUMBERING_TYPES, numbering_type))
-
-
-class ChineseNumberDigit(ChineseChar):
-    """
-    中文数字字符
-    """
-
-    def __init__(self, value, simplified, traditional, big_s, big_t, alt_s=None, alt_t=None):
-        super(ChineseNumberDigit, self).__init__(simplified, traditional)
-        self.value = value
-        self.big_s = big_s
-        self.big_t = big_t
-        self.alt_s = alt_s
-        self.alt_t = alt_t
-
-    def __str__(self):
-        return str(self.value)
-
-    @classmethod
-    def create(cls, i, v):
-        return ChineseNumberDigit(i, v[0], v[1], v[2], v[3])
-
-
-class ChineseMath(ChineseChar):
-    """
-    中文数位字符
-    """
-
-    def __init__(self, simplified, traditional, symbol, expression=None):
-        super(ChineseMath, self).__init__(simplified, traditional)
-        self.symbol = symbol
-        self.expression = expression
-        self.big_s = simplified
-        self.big_t = traditional
-
-
-CC, CNU, CND, CM = ChineseChar, ChineseNumberUnit, ChineseNumberDigit, ChineseMath
-
-
-class NumberSystem(object):
-    """
-    中文数字系统
-    """
-    pass
-
-
-class MathSymbol(object):
-    """
-    用于中文数字系统的数学符号 (繁/简体), e.g.
-    positive = ['正', '正']
-    negative = ['负', '負']
-    point = ['点', '點']
-    """
-
-    def __init__(self, positive, negative, point):
-        self.positive = positive
-        self.negative = negative
-        self.point = point
-
-    def __iter__(self):
-        for v in self.__dict__.values():
-            yield v
-
-
-# class OtherSymbol(object):
-#     """
-#     其他符号
-#     """
-#
-#     def __init__(self, sil):
-#         self.sil = sil
-#
-#     def __iter__(self):
-#         for v in self.__dict__.values():
-#             yield v
-
-
-# ================================================================================ #
-#                                    basic utils
-# ================================================================================ #
-def create_system(numbering_type=NUMBERING_TYPES[1]):
-    """
-    根据数字系统类型返回创建相应的数字系统，默认为 mid
-    NUMBERING_TYPES = ['low', 'mid', 'high']: 中文数字系统类型
-        low:  '兆' = '亿' * '十' = $10^{9}$,  '京' = '兆' * '十', etc.
-        mid:  '兆' = '亿' * '万' = $10^{12}$, '京' = '兆' * '万', etc.
-        high: '兆' = '亿' * '亿' = $10^{16}$, '京' = '兆' * '兆', etc.
-    返回对应的数字系统
-    """
-
-    # chinese number units of '亿' and larger
-    all_larger_units = zip(
-        LARGER_CHINESE_NUMERING_UNITS_SIMPLIFIED, LARGER_CHINESE_NUMERING_UNITS_TRADITIONAL)
-    larger_units = [CNU.create(i, v, numbering_type, False)
-                    for i, v in enumerate(all_larger_units)]
-    # chinese number units of '十, 百, 千, 万'
-    all_smaller_units = zip(
-        SMALLER_CHINESE_NUMERING_UNITS_SIMPLIFIED, SMALLER_CHINESE_NUMERING_UNITS_TRADITIONAL)
-    smaller_units = [CNU.create(i, v, small_unit=True)
-                     for i, v in enumerate(all_smaller_units)]
-    # digis
-    chinese_digis = zip(CHINESE_DIGIS, CHINESE_DIGIS,
-                        BIG_CHINESE_DIGIS_SIMPLIFIED, BIG_CHINESE_DIGIS_TRADITIONAL)
-    digits = [CND.create(i, v) for i, v in enumerate(chinese_digis)]
-    digits[0].alt_s, digits[0].alt_t = ZERO_ALT, ZERO_ALT
-    digits[1].alt_s, digits[1].alt_t = ONE_ALT, ONE_ALT
-    digits[2].alt_s, digits[2].alt_t = TWO_ALTS[0], TWO_ALTS[1]
-
-    # symbols
-    positive_cn = CM(POSITIVE[0], POSITIVE[1], '+', lambda x: x)
-    negative_cn = CM(NEGATIVE[0], NEGATIVE[1], '-', lambda x: -x)
-    point_cn = CM(POINT[0], POINT[1], '.', lambda x,
-                                                  y: float(str(x) + '.' + str(y)))
-    # sil_cn = CM(SIL[0], SIL[1], '-', lambda x, y: float(str(x) + '-' + str(y)))
-    system = NumberSystem()
-    system.units = smaller_units + larger_units
-    system.digits = digits
-    system.math = MathSymbol(positive_cn, negative_cn, point_cn)
-    # system.symbols = OtherSymbol(sil_cn)
-    return system
-
-
-def chn2num(chinese_string, numbering_type=NUMBERING_TYPES[1]):
-    def get_symbol(char, system):
-        for u in system.units:
-            if char in [u.traditional, u.simplified, u.big_s, u.big_t]:
-                return u
-        for d in system.digits:
-            if char in [d.traditional, d.simplified, d.big_s, d.big_t, d.alt_s, d.alt_t]:
-                return d
-        for m in system.math:
-            if char in [m.traditional, m.simplified]:
-                return m
-
-    def string2symbols(chinese_string, system):
-        int_string, dec_string = chinese_string, ''
-        for p in [system.math.point.simplified, system.math.point.traditional]:
-            if p in chinese_string:
-                int_string, dec_string = chinese_string.split(p)
-                break
-        return [get_symbol(c, system) for c in int_string], \
-               [get_symbol(c, system) for c in dec_string]
-
-    def correct_symbols(integer_symbols, system):
-        """
-        一百八 to 一百八十
-        一亿一千三百万 to 一亿 一千万 三百万
-        """
-
-        if integer_symbols and isinstance(integer_symbols[0], CNU):
-            if integer_symbols[0].power == 1:
-                integer_symbols = [system.digits[1]] + integer_symbols
-
-        if len(integer_symbols) > 1:
-            if isinstance(integer_symbols[-1], CND) and isinstance(integer_symbols[-2], CNU):
-                integer_symbols.append(
-                    CNU(integer_symbols[-2].power - 1, None, None, None, None))
-
-        result = []
-        unit_count = 0
-        for s in integer_symbols:
-            if isinstance(s, CND):
-                result.append(s)
-                unit_count = 0
-            elif isinstance(s, CNU):
-                current_unit = CNU(s.power, None, None, None, None)
-                unit_count += 1
-
-            if unit_count == 1:
-                result.append(current_unit)
-            elif unit_count > 1:
-                for i in range(len(result)):
-                    if isinstance(result[-i - 1], CNU) and result[-i - 1].power < current_unit.power:
-                        result[-i - 1] = CNU(result[-i - 1].power +
-                                             current_unit.power, None, None, None, None)
-        return result
-
-    def compute_value(integer_symbols):
-        """
-        Compute the value.
-        When current unit is larger than previous unit, current unit * all previous units will be used as all previous units.
-        e.g. '两千万' = 2000 * 10000 not 2000 + 10000
-        """
-        value = [0]
-        last_power = 0
-        for s in integer_symbols:
-            if isinstance(s, CND):
-                value[-1] = s.value
-            elif isinstance(s, CNU):
-                value[-1] *= pow(10, s.power)
-                if s.power > last_power:
-                    value[:-1] = list(map(lambda v: v *
-                                                    pow(10, s.power), value[:-1]))
-                    last_power = s.power
-                value.append(0)
-        return sum(value)
-
-    system = create_system(numbering_type)
-    int_part, dec_part = string2symbols(chinese_string, system)
-    int_part = correct_symbols(int_part, system)
-    int_str = str(compute_value(int_part))
-    dec_str = ''.join([str(d.value) for d in dec_part])
-    if dec_part:
-        return '{0}.{1}'.format(int_str, dec_str)
-    else:
-        return int_str
-
-
-def num2chn(number_string, numbering_type=NUMBERING_TYPES[1], big=False,
-            traditional=False, alt_zero=False, alt_one=False, alt_two=True,
-            use_zeros=True, use_units=True):
-    def get_value(value_string, use_zeros=True):
-
-        striped_string = value_string.lstrip('0')
-
-        # record nothing if all zeros
-        if not striped_string:
-            return []
-
-        # record one digits
-        elif len(striped_string) == 1:
-            if use_zeros and len(value_string) != len(striped_string):
-                return [system.digits[0], system.digits[int(striped_string)]]
-            else:
-                return [system.digits[int(striped_string)]]
-
-        # recursively record multiple digits
-        else:
-            result_unit = next(u for u in reversed(
-                system.units) if u.power < len(striped_string))
-            result_string = value_string[:-result_unit.power]
-            return get_value(result_string) + [result_unit] + get_value(striped_string[-result_unit.power:])
-
-    system = create_system(numbering_type)
-
-    int_dec = number_string.split('.')
-    if len(int_dec) == 1:
-        int_string = int_dec[0]
-        dec_string = ""
-    elif len(int_dec) == 2:
-        int_string = int_dec[0]
-        dec_string = int_dec[1]
-    else:
-        raise ValueError(
-            "invalid input num string with more than one dot: {}".format(number_string))
-
-    if use_units and len(int_string) > 1:
-        result_symbols = get_value(int_string)
-    else:
-        result_symbols = [system.digits[int(c)] for c in int_string]
-    dec_symbols = [system.digits[int(c)] for c in dec_string]
-    if dec_string:
-        result_symbols += [system.math.point] + dec_symbols
-
-    if alt_two:
-        liang = CND(2, system.digits[2].alt_s, system.digits[2].alt_t,
-                    system.digits[2].big_s, system.digits[2].big_t)
-        for i, v in enumerate(result_symbols):
-            if isinstance(v, CND) and v.value == 2:
-                next_symbol = result_symbols[i +
-                                             1] if i < len(result_symbols) - 1 else None
-                previous_symbol = result_symbols[i - 1] if i > 0 else None
-                if isinstance(next_symbol, CNU) and isinstance(previous_symbol, (CNU, type(None))):
-                    if next_symbol.power != 1 and ((previous_symbol is None) or (previous_symbol.power != 1)):
-                        result_symbols[i] = liang
-
-    # if big is True, '两' will not be used and `alt_two` has no impact on output
-    if big:
-        attr_name = 'big_'
-        if traditional:
-            attr_name += 't'
-        else:
-            attr_name += 's'
-    else:
-        if traditional:
-            attr_name = 'traditional'
-        else:
-            attr_name = 'simplified'
-
-    result = ''.join([getattr(s, attr_name) for s in result_symbols])
-
-    # if not use_zeros:
-    #     result = result.strip(getattr(system.digits[0], attr_name))
-
-    if alt_zero:
-        result = result.replace(
-            getattr(system.digits[0], attr_name), system.digits[0].alt_s)
-
-    if alt_one:
-        result = result.replace(
-            getattr(system.digits[1], attr_name), system.digits[1].alt_s)
-
-    for i, p in enumerate(POINT):
-        if result.startswith(p):
-            return CHINESE_DIGIS[0] + result
-
-    # ^10, 11, .., 19
-    if len(result) >= 2 and result[1] in [SMALLER_CHINESE_NUMERING_UNITS_SIMPLIFIED[0],
-                                          SMALLER_CHINESE_NUMERING_UNITS_TRADITIONAL[0]] and \
-            result[0] in [CHINESE_DIGIS[1], BIG_CHINESE_DIGIS_SIMPLIFIED[1], BIG_CHINESE_DIGIS_TRADITIONAL[1]]:
-        result = result[1:]
-
-    return result
-
-
-# ================================================================================ #
-#                          different types of rewriters
-# ================================================================================ #
-class Cardinal:
-    """
-    CARDINAL类
-    """
-
-    def __init__(self, cardinal=None, chntext=None):
-        self.cardinal = cardinal
-        self.chntext = chntext
-
-    def chntext2cardinal(self):
-        return chn2num(self.chntext)
-
-    def cardinal2chntext(self):
-        return num2chn(self.cardinal)
-
-
-class Digit:
-    """
-    DIGIT类
-    """
-
-    def __init__(self, digit=None, chntext=None):
-        self.digit = digit
-        self.chntext = chntext
-
-    # def chntext2digit(self):
-    #     return chn2num(self.chntext)
-
-    def digit2chntext(self):
-        return num2chn(self.digit, alt_two=False, use_units=False)
-
-
-class TelePhone:
-    """
-    TELEPHONE类
-    """
-
-    def __init__(self, telephone=None, raw_chntext=None, chntext=None):
-        self.telephone = telephone
-        self.raw_chntext = raw_chntext
-        self.chntext = chntext
-
-    # def chntext2telephone(self):
-    #     sil_parts = self.raw_chntext.split('<SIL>')
-    #     self.telephone = '-'.join([
-    #         str(chn2num(p)) for p in sil_parts
-    #     ])
-    #     return self.telephone
-
-    def telephone2chntext(self, fixed=False):
-
-        if fixed:
-            sil_parts = self.telephone.split('-')
-            self.raw_chntext = '<SIL>'.join([
-                num2chn(part, alt_two=False, use_units=False) for part in sil_parts
-            ])
-            self.chntext = self.raw_chntext.replace('<SIL>', '')
-        else:
-            sp_parts = self.telephone.strip('+').split()
-            self.raw_chntext = '<SP>'.join([
-                num2chn(part, alt_two=False, use_units=False) for part in sp_parts
-            ])
-            self.chntext = self.raw_chntext.replace('<SP>', '')
-        return self.chntext
-
-
-class Fraction:
-    """
-    FRACTION类
-    """
-
-    def __init__(self, fraction=None, chntext=None):
-        self.fraction = fraction
-        self.chntext = chntext
-
-    def chntext2fraction(self):
-        denominator, numerator = self.chntext.split('分之')
-        return chn2num(numerator) + '/' + chn2num(denominator)
-
-    def fraction2chntext(self):
-        numerator, denominator = self.fraction.split('/')
-        return num2chn(denominator) + '分之' + num2chn(numerator)
-
-
-class Date:
-    """
-    DATE类
-    """
-
-    def __init__(self, date=None, chntext=None):
-        self.date = date
-        self.chntext = chntext
-
-    # def chntext2date(self):
-    #     chntext = self.chntext
-    #     try:
-    #         year, other = chntext.strip().split('年', maxsplit=1)
-    #         year = Digit(chntext=year).digit2chntext() + '年'
-    #     except ValueError:
-    #         other = chntext
-    #         year = ''
-    #     if other:
-    #         try:
-    #             month, day = other.strip().split('月', maxsplit=1)
-    #             month = Cardinal(chntext=month).chntext2cardinal() + '月'
-    #         except ValueError:
-    #             day = chntext
-    #             month = ''
-    #         if day:
-    #             day = Cardinal(chntext=day[:-1]).chntext2cardinal() + day[-1]
-    #     else:
-    #         month = ''
-    #         day = ''
-    #     date = year + month + day
-    #     self.date = date
-    #     return self.date
-
-    def date2chntext(self):
-        date = self.date
-        try:
-            year, other = date.strip().split('年', 1)
-            year = Digit(digit=year).digit2chntext() + '年'
-        except ValueError:
-            other = date
-            year = ''
-        if other:
-            try:
-                month, day = other.strip().split('月', 1)
-                month = Cardinal(cardinal=month).cardinal2chntext() + '月'
-            except ValueError:
-                day = date
-                month = ''
-            if day:
-                day = Cardinal(cardinal=day[:-1]).cardinal2chntext() + day[-1]
-        else:
-            month = ''
-            day = ''
-        chntext = year + month + day
-        self.chntext = chntext
-        return self.chntext
-
-
-class Money:
-    """
-    MONEY类
-    """
-
-    def __init__(self, money=None, chntext=None):
-        self.money = money
-        self.chntext = chntext
-
-    # def chntext2money(self):
-    #     return self.money
-
-    def money2chntext(self):
-        money = self.money
-        pattern = re.compile(r'(\d+(\.\d+)?)')
-        matchers = pattern.findall(money)
-        if matchers:
-            for matcher in matchers:
-                money = money.replace(matcher[0], Cardinal(cardinal=matcher[0]).cardinal2chntext())
-        self.chntext = money
-        return self.chntext
-
-
-class Percentage:
-    """
-    PERCENTAGE类
-    """
-
-    def __init__(self, percentage=None, chntext=None):
-        self.percentage = percentage
-        self.chntext = chntext
-
-    def chntext2percentage(self):
-        return chn2num(self.chntext.strip().strip('百分之')) + '%'
-
-    def percentage2chntext(self):
-        return '百分之' + num2chn(self.percentage.strip().strip('%'))
-
-
-# ================================================================================ #
-#                            NSW Normalizer
-# ================================================================================ #
-class NSWNormalizer:
-    def __init__(self, raw_text):
-        self.raw_text = '^' + raw_text + '$'
-        self.norm_text = ''
-
-    def _particular(self):
-        text = self.norm_text
-        pattern = re.compile(r"(([a-zA-Z]+)二([a-zA-Z]+))")
-        matchers = pattern.findall(text)
-        if matchers:
-            # print('particular')
-            for matcher in matchers:
-                text = text.replace(matcher[0], matcher[1] + '2' + matcher[2], 1)
-        self.norm_text = text
-        return self.norm_text
-
-    def normalize(self, remove_punc=True):
-        text = self.raw_text
-
-        # 规范化日期
-        pattern = re.compile(r"\D+((([089]\d|(19|20)\d{2})年)?(\d{1,2}月(\d{1,2}[日号])?)?)")
-        matchers = pattern.findall(text)
-        if matchers:
-            # print('date')
-            for matcher in matchers:
-                text = text.replace(matcher[0], Date(date=matcher[0]).date2chntext(), 1)
-
-        # 规范化金钱
-        pattern = re.compile(r"\D+((\d+(\.\d+)?)[多余几]?" + CURRENCY_UNITS + r"(\d" + CURRENCY_UNITS + r"?)?)")
-        matchers = pattern.findall(text)
-        if matchers:
-            # print('money')
-            for matcher in matchers:
-                text = text.replace(matcher[0], Money(money=matcher[0]).money2chntext(), 1)
-
-        # 规范化固话/手机号码
-        # 手机
-        # http://www.jihaoba.com/news/show/13680
-        # 移动：139、138、137、136、135、134、159、158、157、150、151、152、188、187、182、183、184、178、198
-        # 联通：130、131、132、156、155、186、185、176
-        # 电信：133、153、189、180、181、177
-        pattern = re.compile(r"\D((\+?86 ?)?1([38]\d|5[0-35-9]|7[678]|9[89])\d{8})\D")
-        matchers = pattern.findall(text)
-        if matchers:
-            # print('telephone')
-            for matcher in matchers:
-                text = text.replace(matcher[0], TelePhone(telephone=matcher[0]).telephone2chntext(), 1)
-        # 固话
-        pattern = re.compile(r"\D((0(10|2[0-9]|[3-9]\d{2})-?)?[1-9]\d{6,7})\D")
-        matchers = pattern.findall(text)
-        if matchers:
-            # print('fixed telephone')
-            for matcher in matchers:
-                text = text.replace(matcher[0], TelePhone(telephone=matcher[0]).telephone2chntext(fixed=True), 1)
-
-        # 规范化分数
-        pattern = re.compile(r"(\d+/\d+)")
-        matchers = pattern.findall(text)
-        if matchers:
-            # print('fraction')
-            for matcher in matchers:
-                text = text.replace(matcher, Fraction(fraction=matcher).fraction2chntext(), 1)
-
-        # 规范化百分数
-        text = text.replace('％', '%')
-        pattern = re.compile(r"(\d+(\.\d+)?%)")
-        matchers = pattern.findall(text)
-        if matchers:
-            # print('percentage')
-            for matcher in matchers:
-                text = text.replace(matcher[0], Percentage(percentage=matcher[0]).percentage2chntext(), 1)
-
-        # 规范化纯数+量词
-        pattern = re.compile(r"(\d+(\.\d+)?)[多余几]?" + COM_QUANTIFIERS)
-        matchers = pattern.findall(text)
-        if matchers:
-            # print('cardinal+quantifier')
-            for matcher in matchers:
-                text = text.replace(matcher[0], Cardinal(cardinal=matcher[0]).cardinal2chntext(), 1)
-
-        # 规范化小数
-        pattern = re.compile(r"(\d+\.\d+)")
-        matchers = pattern.findall(text)
-        if matchers:
-            # print('cardinal')
-            for matcher in matchers:
-                text = text.replace(matcher, Cardinal(cardinal=matcher).cardinal2chntext(), 1)
-
-        # 规范化数字编号
-        pattern = re.compile(r"(\d{4,32})")
-        matchers = pattern.findall(text)
-        if matchers:
-            # print('digit')
-            for matcher in matchers:
-                text = text.replace(matcher, Digit(digit=matcher).digit2chntext(), 1)
-
-        # 规范化其他数字
-        pattern = re.compile(r"(\d+(\.\d+)?)")
-        matchers = pattern.findall(text)
-        if matchers:
-            # print('cardinal')
-            for matcher in matchers:
-                text = text.replace(matcher[0], Cardinal(cardinal=matcher[0]).cardinal2chntext(), 1)
-
-        self.norm_text = text
-        self._particular()
-
-        text = self.norm_text.lstrip('^').rstrip('$')
-        if remove_punc:
-            # Punctuations removal
-            old_chars = CHINESE_PUNC_LIST + string.punctuation  # includes all CN and EN punctuations
-            new_chars = ' ' * len(old_chars)
-            del_chars = ''
-            text = text.translate(str.maketrans(old_chars, new_chars, del_chars))
-        return text
-
-
-def nsw_test_case(raw_text):
-    print('I:' + raw_text)
-    print('O:' + NSWNormalizer(raw_text).normalize())
-    print('')
-
-
-def nsw_test():
-    nsw_test_case('固话：0595-23865596或者23880880。')
-    nsw_test_case('手机：+86 19859213959或者15659451527。')
-    nsw_test_case('分数：32477/76391。')
-    nsw_test_case('百分数：80.03%。')
-    nsw_test_case('编号：31520181154418。')
-    nsw_test_case('纯数：2983.07克或12345.60米。')
-    nsw_test_case('日期：1999年2月20日或09年3月15号。')
-    nsw_test_case('金钱：12块5，34.5元，20.1万, 40多块钱')
-    nsw_test_case('特殊：O2O或B2C。')
-    nsw_test_case('3456万吨')
-    nsw_test_case('2938478321947个')
-    nsw_test_case('938')
-    nsw_test_case('今天吃了115个小笼包231个馒头')
-    nsw_test_case('有62％的概率')
-
-
-if __name__ == '__main__':
-    # nsw_test()
-
-    p = argparse.ArgumentParser()
-    p.add_argument('ifile', help='input filename, assume utf-8 encoding')
-    p.add_argument('ofile', help='output filename')
-    p.add_argument('--to_upper', action='store_true', help='convert to upper case')
-    p.add_argument('--to_lower', action='store_true', help='convert to lower case')
-    p.add_argument('--has_key', action='store_true', help="input text has Kaldi's key as first field.")
-    p.add_argument('--log_interval', type=int, default=10000, help='log interval in number of processed lines')
-    args = p.parse_args()
-
-    ifile = codecs.open(args.ifile, 'r', 'utf8')
-    ofile = codecs.open(args.ofile, 'w+', 'utf8')
-
-    n = 0
-    for l in ifile:
-        key = ''
-        text = ''
-        if args.has_key:
-            cols = l.split(maxsplit=1)
-            key = cols[0]
-            if len(cols) == 2:
-                text = cols[1]
-            else:
-                text = ''
-        else:
-            text = l
-
-        # cases
-        if args.to_upper and args.to_lower:
-            sys.stderr.write('text norm: to_upper OR to_lower?')
-            exit(1)
-        if args.to_upper:
-            text = text.upper()
-        if args.to_lower:
-            text = text.lower()
-
-        # NSW(Non-Standard-Word) normalization
-        text = NSWNormalizer(text).normalize()
-
-        #
-        if args.has_key:
-            ofile.write(key + '\t' + text)
-        else:
-            ofile.write(text)
-
-        n += 1
-        if n % args.log_interval == 0:
-            sys.stderr.write("text norm: {} lines done.\n".format(n))
-
-    sys.stderr.write("text norm: {} lines done in total.\n".format(n))
-
-    ifile.close()
-    ofile.close()

spaces/ATang0729/Forecast4Muses/Model/Model6/Model6_0_ClothesDetection/mmyolo/configs/yolov6/yolov6_t_syncbn_fast_8xb32-300e_coco.py

@@ -1,17 +0,0 @@
-_base_ = './yolov6_s_syncbn_fast_8xb32-300e_coco.py'
-
-# ======================= Possible modified parameters =======================
-# -----model related-----
-# The scaling factor that controls the depth of the network structure
-deepen_factor = 0.33
-# The scaling factor that controls the width of the network structure
-widen_factor = 0.375
-
-# ============================== Unmodified in most cases ===================
-model = dict(
-    backbone=dict(deepen_factor=deepen_factor, widen_factor=widen_factor),
-    neck=dict(deepen_factor=deepen_factor, widen_factor=widen_factor),
-    bbox_head=dict(
-        type='YOLOv6Head',
-        head_module=dict(widen_factor=widen_factor),
-        loss_bbox=dict(iou_mode='siou')))

spaces/Abhilashvj/planogram-compliance/utils/aws/resume.py

@@ -1,42 +0,0 @@
-# Resume all interrupted trainings in yolov5/ dir including DDP trainings
-# Usage: $ python utils/aws/resume.py
-
-import os
-import sys
-from pathlib import Path
-
-import torch
-import yaml
-
-FILE = Path(__file__).resolve()
-ROOT = FILE.parents[2]  # YOLOv5 root directory
-if str(ROOT) not in sys.path:
-    sys.path.append(str(ROOT))  # add ROOT to PATH
-
-port = 0  # --master_port
-path = Path("").resolve()
-for last in path.rglob("*/**/last.pt"):
-    ckpt = torch.load(last)
-    if ckpt["optimizer"] is None:
-        continue
-
-    # Load opt.yaml
-    with open(last.parent.parent / "opt.yaml", errors="ignore") as f:
-        opt = yaml.safe_load(f)
-
-    # Get device count
-    d = opt["device"].split(",")  # devices
-    nd = len(d)  # number of devices
-    ddp = nd > 1 or (
-        nd == 0 and torch.cuda.device_count() > 1
-    )  # distributed data parallel
-
-    if ddp:  # multi-GPU
-        port += 1
-        cmd = f"python -m torch.distributed.run --nproc_per_node {nd} --master_port {port} train.py --resume {last}"
-    else:  # single-GPU
-        cmd = f"python train.py --resume {last}"
-
-    cmd += " > /dev/null 2>&1 &"  # redirect output to dev/null and run in daemon thread
-    print(cmd)
-    os.system(cmd)

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

@@ -1,5 +0,0 @@
-import Pages from './Pages';
-
-export default function (
-    config?: Pages.IConfig
-): Pages;

spaces/Alycer/VITS-Umamusume-voice-synthesizer/ONNXVITS_models.py

@@ -1,509 +0,0 @@
-import copy
-import math
-import torch
-from torch import nn
-from torch.nn import functional as F
-
-import commons
-import ONNXVITS_modules as modules
-import attentions
-import monotonic_align
-
-from torch.nn import Conv1d, ConvTranspose1d, AvgPool1d, Conv2d
-from torch.nn.utils import weight_norm, remove_weight_norm, spectral_norm
-from commons import init_weights, get_padding
-
-
-class StochasticDurationPredictor(nn.Module):
-  def __init__(self, in_channels, filter_channels, kernel_size, p_dropout, n_flows=4, gin_channels=0):
-    super().__init__()
-    filter_channels = in_channels # it needs to be removed from future version.
-    self.in_channels = in_channels
-    self.filter_channels = filter_channels
-    self.kernel_size = kernel_size
-    self.p_dropout = p_dropout
-    self.n_flows = n_flows
-    self.gin_channels = gin_channels
-
-    self.log_flow = modules.Log()
-    self.flows = nn.ModuleList()
-    self.flows.append(modules.ElementwiseAffine(2))
-    for i in range(n_flows):
-      self.flows.append(modules.ConvFlow(2, filter_channels, kernel_size, n_layers=3))
-      self.flows.append(modules.Flip())
-
-    self.post_pre = nn.Conv1d(1, filter_channels, 1)
-    self.post_proj = nn.Conv1d(filter_channels, filter_channels, 1)
-    self.post_convs = modules.DDSConv(filter_channels, kernel_size, n_layers=3, p_dropout=p_dropout)
-    self.post_flows = nn.ModuleList()
-    self.post_flows.append(modules.ElementwiseAffine(2))
-    for i in range(4):
-      self.post_flows.append(modules.ConvFlow(2, filter_channels, kernel_size, n_layers=3))
-      self.post_flows.append(modules.Flip())
-
-    self.pre = nn.Conv1d(in_channels, filter_channels, 1)
-    self.proj = nn.Conv1d(filter_channels, filter_channels, 1)
-    self.convs = modules.DDSConv(filter_channels, kernel_size, n_layers=3, p_dropout=p_dropout)
-    if gin_channels != 0:
-      self.cond = nn.Conv1d(gin_channels, filter_channels, 1)
-
-    self.w = None
-    self.reverse = None
-    self.noise_scale = None
-  def forward(self, x, x_mask, g=None):
-    w = self.w
-    reverse = self.reverse
-    noise_scale = self.noise_scale
-
-    x = torch.detach(x)
-    x = self.pre(x)
-    if g is not None:
-      g = torch.detach(g)
-      x = x + self.cond(g)
-    x = self.convs(x, x_mask)
-    x = self.proj(x) * x_mask
-
-    if not reverse:
-      flows = self.flows
-      assert w is not None
-
-      logdet_tot_q = 0 
-      h_w = self.post_pre(w)
-      h_w = self.post_convs(h_w, x_mask)
-      h_w = self.post_proj(h_w) * x_mask
-      e_q = torch.randn(w.size(0), 2, w.size(2)).to(device=x.device, dtype=x.dtype) * x_mask
-      z_q = e_q
-      for flow in self.post_flows:
-        z_q, logdet_q = flow(z_q, x_mask, g=(x + h_w))
-        logdet_tot_q += logdet_q
-      z_u, z1 = torch.split(z_q, [1, 1], 1) 
-      u = torch.sigmoid(z_u) * x_mask
-      z0 = (w - u) * x_mask
-      logdet_tot_q += torch.sum((F.logsigmoid(z_u) + F.logsigmoid(-z_u)) * x_mask, [1,2])
-      logq = torch.sum(-0.5 * (math.log(2*math.pi) + (e_q**2)) * x_mask, [1,2]) - logdet_tot_q
-
-      logdet_tot = 0
-      z0, logdet = self.log_flow(z0, x_mask)
-      logdet_tot += logdet
-      z = torch.cat([z0, z1], 1)
-      for flow in flows:
-        z, logdet = flow(z, x_mask, g=x, reverse=reverse)
-        logdet_tot = logdet_tot + logdet
-      nll = torch.sum(0.5 * (math.log(2*math.pi) + (z**2)) * x_mask, [1,2]) - logdet_tot
-      return nll + logq # [b]
-    else:
-      flows = list(reversed(self.flows))
-      flows = flows[:-2] + [flows[-1]] # remove a useless vflow
-      z = torch.randn(x.size(0), 2, x.size(2)).to(device=x.device, dtype=x.dtype) * noise_scale
-      for flow in flows:
-        z = flow(z, x_mask, g=x, reverse=reverse)
-      z0, z1 = torch.split(z, [1, 1], 1)
-      logw = z0
-      return logw
-
-
-class TextEncoder(nn.Module):
-  def __init__(self,
-      n_vocab,
-      out_channels,
-      hidden_channels,
-      filter_channels,
-      n_heads,
-      n_layers,
-      kernel_size,
-      p_dropout):
-    super().__init__()
-    self.n_vocab = n_vocab
-    self.out_channels = out_channels
-    self.hidden_channels = hidden_channels
-    self.filter_channels = filter_channels
-    self.n_heads = n_heads
-    self.n_layers = n_layers
-    self.kernel_size = kernel_size
-    self.p_dropout = p_dropout
-
-    self.emb = nn.Embedding(n_vocab, hidden_channels)
-    nn.init.normal_(self.emb.weight, 0.0, hidden_channels**-0.5)
-
-    self.encoder = attentions.Encoder(
-      hidden_channels,
-      filter_channels,
-      n_heads,
-      n_layers,
-      kernel_size,
-      p_dropout)
-    self.proj= nn.Conv1d(hidden_channels, out_channels * 2, 1)
-
-  def forward(self, x, x_lengths):
-    x = self.emb(x) * math.sqrt(self.hidden_channels) # [b, t, h]
-    x = torch.transpose(x, 1, -1) # [b, h, t]
-    x_mask = torch.unsqueeze(commons.sequence_mask(x_lengths, x.size(2)), 1).to(x.dtype)
-
-    x = self.encoder(x * x_mask, x_mask)
-    stats = self.proj(x) * x_mask
-
-    m, logs = torch.split(stats, self.out_channels, dim=1)
-    return x, m, logs, x_mask
-
-
-class ResidualCouplingBlock(nn.Module):
-  def __init__(self,
-      channels,
-      hidden_channels,
-      kernel_size,
-      dilation_rate,
-      n_layers,
-      n_flows=4,
-      gin_channels=0):
-    super().__init__()
-    self.channels = channels
-    self.hidden_channels = hidden_channels
-    self.kernel_size = kernel_size
-    self.dilation_rate = dilation_rate
-    self.n_layers = n_layers
-    self.n_flows = n_flows
-    self.gin_channels = gin_channels
-
-    self.flows = nn.ModuleList()
-    for i in range(n_flows):
-      self.flows.append(modules.ResidualCouplingLayer(channels, hidden_channels, kernel_size, dilation_rate, n_layers, gin_channels=gin_channels, mean_only=True))
-      self.flows.append(modules.Flip())
-
-    self.reverse = None
-  def forward(self, x, x_mask, g=None):
-    reverse = self.reverse 
-    if not reverse:
-      for flow in self.flows:
-        x, _ = flow(x, x_mask, g=g, reverse=reverse)
-    else:
-      for flow in reversed(self.flows):
-        x = flow(x, x_mask, g=g, reverse=reverse)
-    return x
-
-
-class PosteriorEncoder(nn.Module):
-  def __init__(self,
-      in_channels,
-      out_channels,
-      hidden_channels,
-      kernel_size,
-      dilation_rate,
-      n_layers,
-      gin_channels=0):
-    super().__init__()
-    self.in_channels = in_channels
-    self.out_channels = out_channels
-    self.hidden_channels = hidden_channels
-    self.kernel_size = kernel_size
-    self.dilation_rate = dilation_rate
-    self.n_layers = n_layers
-    self.gin_channels = gin_channels
-
-    self.pre = nn.Conv1d(in_channels, hidden_channels, 1)
-    self.enc = modules.WN(hidden_channels, kernel_size, dilation_rate, n_layers, gin_channels=gin_channels)
-    self.proj = nn.Conv1d(hidden_channels, out_channels * 2, 1)
-
-  def forward(self, x, x_lengths, g=None):
-    x_mask = torch.unsqueeze(commons.sequence_mask(x_lengths, x.size(2)), 1).to(x.dtype)
-    x = self.pre(x) * x_mask # x_in : [b, c, t] -> [b, h, t] 
-    x = self.enc(x, x_mask, g=g) # x_in : [b, h, t], g : [b, h, 1],  x = x_in + g
-    stats = self.proj(x) * x_mask
-    m, logs = torch.split(stats, self.out_channels, dim=1)
-    z = (m + torch.randn_like(m) * torch.exp(logs)) * x_mask
-    return z, m, logs, x_mask # z, m, logs : [b, h, t]
-
-
-class Generator(torch.nn.Module):
-    def __init__(self, initial_channel, resblock, resblock_kernel_sizes, resblock_dilation_sizes, upsample_rates, upsample_initial_channel, upsample_kernel_sizes, gin_channels=0):
-        super(Generator, self).__init__()
-        self.num_kernels = len(resblock_kernel_sizes)
-        self.num_upsamples = len(upsample_rates)
-        self.conv_pre = Conv1d(initial_channel, upsample_initial_channel, 7, 1, padding=3)
-        resblock = modules.ResBlock1 if resblock == '1' else modules.ResBlock2
-
-        self.ups = nn.ModuleList()
-        for i, (u, k) in enumerate(zip(upsample_rates, upsample_kernel_sizes)):
-            self.ups.append(weight_norm(
-                ConvTranspose1d(upsample_initial_channel//(2**i), upsample_initial_channel//(2**(i+1)),
-                                k, u, padding=(k-u)//2)))
-
-        self.resblocks = nn.ModuleList()
-        for i in range(len(self.ups)):
-            ch = upsample_initial_channel//(2**(i+1))
-            for j, (k, d) in enumerate(zip(resblock_kernel_sizes, resblock_dilation_sizes)):
-                self.resblocks.append(resblock(ch, k, d))
-
-        self.conv_post = Conv1d(ch, 1, 7, 1, padding=3, bias=False)
-        self.ups.apply(init_weights)
-
-        if gin_channels != 0:
-            self.cond = nn.Conv1d(gin_channels, upsample_initial_channel, 1)
-
-    def forward(self, x, g=None):
-        x = self.conv_pre(x)
-        if g is not None:
-          x = x + self.cond(g)
-
-        for i in range(self.num_upsamples):
-            x = F.leaky_relu(x, modules.LRELU_SLOPE)
-            x = self.ups[i](x)
-            xs = None
-            for j in range(self.num_kernels):
-                if xs is None:
-                    xs = self.resblocks[i*self.num_kernels+j](x)
-                else:
-                    xs += self.resblocks[i*self.num_kernels+j](x)
-            x = xs / self.num_kernels
-        x = F.leaky_relu(x)
-        x = self.conv_post(x)
-        x = torch.tanh(x)
-
-        return x
-
-    def remove_weight_norm(self):
-        print('Removing weight norm...')
-        for l in self.ups:
-            remove_weight_norm(l)
-        for l in self.resblocks:
-            l.remove_weight_norm()
-
-
-class DiscriminatorP(torch.nn.Module):
-    def __init__(self, period, kernel_size=5, stride=3, use_spectral_norm=False):
-        super(DiscriminatorP, self).__init__()
-        self.period = period
-        self.use_spectral_norm = use_spectral_norm
-        norm_f = weight_norm if use_spectral_norm == False else spectral_norm
-        self.convs = nn.ModuleList([
-            norm_f(Conv2d(1, 32, (kernel_size, 1), (stride, 1), padding=(get_padding(kernel_size, 1), 0))),
-            norm_f(Conv2d(32, 128, (kernel_size, 1), (stride, 1), padding=(get_padding(kernel_size, 1), 0))),
-            norm_f(Conv2d(128, 512, (kernel_size, 1), (stride, 1), padding=(get_padding(kernel_size, 1), 0))),
-            norm_f(Conv2d(512, 1024, (kernel_size, 1), (stride, 1), padding=(get_padding(kernel_size, 1), 0))),
-            norm_f(Conv2d(1024, 1024, (kernel_size, 1), 1, padding=(get_padding(kernel_size, 1), 0))),
-        ])
-        self.conv_post = norm_f(Conv2d(1024, 1, (3, 1), 1, padding=(1, 0)))
-
-    def forward(self, x):
-        fmap = []
-
-        # 1d to 2d
-        b, c, t = x.shape
-        if t % self.period != 0: # pad first
-            n_pad = self.period - (t % self.period)
-            x = F.pad(x, (0, n_pad), "reflect")
-            t = t + n_pad
-        x = x.view(b, c, t // self.period, self.period)
-
-        for l in self.convs:
-            x = l(x)
-            x = F.leaky_relu(x, modules.LRELU_SLOPE)
-            fmap.append(x)
-        x = self.conv_post(x)
-        fmap.append(x)
-        x = torch.flatten(x, 1, -1)
-
-        return x, fmap
-
-
-class DiscriminatorS(torch.nn.Module):
-    def __init__(self, use_spectral_norm=False):
-        super(DiscriminatorS, self).__init__()
-        norm_f = weight_norm if use_spectral_norm == False else spectral_norm
-        self.convs = nn.ModuleList([
-            norm_f(Conv1d(1, 16, 15, 1, padding=7)),
-            norm_f(Conv1d(16, 64, 41, 4, groups=4, padding=20)),
-            norm_f(Conv1d(64, 256, 41, 4, groups=16, padding=20)),
-            norm_f(Conv1d(256, 1024, 41, 4, groups=64, padding=20)),
-            norm_f(Conv1d(1024, 1024, 41, 4, groups=256, padding=20)),
-            norm_f(Conv1d(1024, 1024, 5, 1, padding=2)),
-        ])
-        self.conv_post = norm_f(Conv1d(1024, 1, 3, 1, padding=1))
-
-    def forward(self, x):
-        fmap = []
-
-        for l in self.convs:
-            x = l(x)
-            x = F.leaky_relu(x, modules.LRELU_SLOPE)
-            fmap.append(x)
-        x = self.conv_post(x)
-        fmap.append(x)
-        x = torch.flatten(x, 1, -1)
-
-        return x, fmap
-
-
-class MultiPeriodDiscriminator(torch.nn.Module):
-    def __init__(self, use_spectral_norm=False):
-        super(MultiPeriodDiscriminator, self).__init__()
-        periods = [2,3,5,7,11]
-
-        discs = [DiscriminatorS(use_spectral_norm=use_spectral_norm)]
-        discs = discs + [DiscriminatorP(i, use_spectral_norm=use_spectral_norm) for i in periods]
-        self.discriminators = nn.ModuleList(discs)
-
-    def forward(self, y, y_hat):
-        y_d_rs = []
-        y_d_gs = []
-        fmap_rs = []
-        fmap_gs = []
-        for i, d in enumerate(self.discriminators):
-            y_d_r, fmap_r = d(y)
-            y_d_g, fmap_g = d(y_hat)
-            y_d_rs.append(y_d_r)
-            y_d_gs.append(y_d_g)
-            fmap_rs.append(fmap_r)
-            fmap_gs.append(fmap_g)
-
-        return y_d_rs, y_d_gs, fmap_rs, fmap_gs
-
-
-
-class SynthesizerTrn(nn.Module):
-  """
-  Synthesizer for Training
-  """
-
-  def __init__(self, 
-    n_vocab,
-    spec_channels,
-    segment_size,
-    inter_channels,
-    hidden_channels,
-    filter_channels,
-    n_heads,
-    n_layers,
-    kernel_size,
-    p_dropout,
-    resblock, 
-    resblock_kernel_sizes, 
-    resblock_dilation_sizes, 
-    upsample_rates, 
-    upsample_initial_channel, 
-    upsample_kernel_sizes,
-    n_speakers=0,
-    gin_channels=0,
-    use_sdp=True,
-    **kwargs):
-
-    super().__init__()
-    self.n_vocab = n_vocab
-    self.spec_channels = spec_channels
-    self.inter_channels = inter_channels
-    self.hidden_channels = hidden_channels
-    self.filter_channels = filter_channels
-    self.n_heads = n_heads
-    self.n_layers = n_layers
-    self.kernel_size = kernel_size
-    self.p_dropout = p_dropout
-    self.resblock = resblock
-    self.resblock_kernel_sizes = resblock_kernel_sizes
-    self.resblock_dilation_sizes = resblock_dilation_sizes
-    self.upsample_rates = upsample_rates
-    self.upsample_initial_channel = upsample_initial_channel
-    self.upsample_kernel_sizes = upsample_kernel_sizes
-    self.segment_size = segment_size
-    self.n_speakers = n_speakers
-    self.gin_channels = gin_channels
-
-    self.use_sdp = use_sdp
-
-    self.enc_p = TextEncoder(n_vocab,
-        inter_channels,
-        hidden_channels,
-        filter_channels,
-        n_heads,
-        n_layers,
-        kernel_size,
-        p_dropout)
-    self.dec = Generator(inter_channels, resblock, resblock_kernel_sizes, resblock_dilation_sizes, upsample_rates, upsample_initial_channel, upsample_kernel_sizes, gin_channels=gin_channels)
-    self.enc_q = PosteriorEncoder(spec_channels, inter_channels, hidden_channels, 5, 1, 16, gin_channels=gin_channels)
-    self.flow = ResidualCouplingBlock(inter_channels, hidden_channels, 5, 1, 4, gin_channels=gin_channels)
-
-    self.dp = StochasticDurationPredictor(hidden_channels, 192, 3, 0.5, 4, gin_channels=gin_channels)
-
-    if n_speakers > 0:
-      self.emb_g = nn.Embedding(n_speakers, gin_channels)
-
-  def forward(self, x, x_lengths, sid=None, noise_scale=.667, length_scale=1, noise_scale_w=.8, max_len=None):
-    torch.onnx.export(
-        self.enc_p,
-        (x, x_lengths),
-        "ONNX_net/enc_p.onnx",
-        input_names=["x", "x_lengths"],
-        output_names=["xout", "m_p", "logs_p", "x_mask"],
-        dynamic_axes={
-          "x" : [1],
-          "xout" : [2],
-          "m_p" : [2],
-          "logs_p" : [2],
-          "x_mask" : [2]
-        },
-        verbose=True,
-    )
-    x, m_p, logs_p, x_mask = self.enc_p(x, x_lengths)
-
-    if self.n_speakers > 0:
-      g = self.emb_g(sid).unsqueeze(-1) # [b, h, 1]
-    else:
-      g = None
-
-    self.dp.reverse = True
-    self.dp.noise_scale = noise_scale_w
-    torch.onnx.export(
-        self.dp,
-        (x, x_mask, g),
-        "ONNX_net/dp.onnx",
-        input_names=["x", "x_mask", "g"],
-        output_names=["logw"],
-        dynamic_axes={
-          "x" : [2],
-          "x_mask" : [2],
-          "logw" : [2]
-        },
-        verbose=True,
-    )
-    logw = self.dp(x, x_mask, g=g)
-    w = torch.exp(logw) * x_mask * length_scale
-    w_ceil = torch.ceil(w)
-    y_lengths = torch.clamp_min(torch.sum(w_ceil, [1, 2]), 1).long()
-    y_mask = torch.unsqueeze(commons.sequence_mask(y_lengths, None), 1).to(x_mask.dtype)
-    attn_mask = torch.unsqueeze(x_mask, 2) * torch.unsqueeze(y_mask, -1)
-    attn = commons.generate_path(w_ceil, attn_mask)
-
-    m_p = torch.matmul(attn.squeeze(1), m_p.transpose(1, 2)).transpose(1, 2) # [b, t', t], [b, t, d] -> [b, d, t']
-    logs_p = torch.matmul(attn.squeeze(1), logs_p.transpose(1, 2)).transpose(1, 2) # [b, t', t], [b, t, d] -> [b, d, t']
-
-    z_p = m_p + torch.randn_like(m_p) * torch.exp(logs_p) * noise_scale
-
-    self.flow.reverse = True
-    torch.onnx.export(
-        self.flow,
-        (z_p, y_mask, g),
-        "ONNX_net/flow.onnx",
-        input_names=["z_p", "y_mask", "g"],
-        output_names=["z"],
-        dynamic_axes={
-          "z_p" : [2],
-          "y_mask" : [2],
-          "z" : [2]
-        },
-        verbose=True,
-    )
-    z = self.flow(z_p, y_mask, g=g)
-    z_in = (z * y_mask)[:,:,:max_len]
-
-    torch.onnx.export(
-        self.dec,
-        (z_in, g),
-        "ONNX_net/dec.onnx",
-        input_names=["z_in", "g"],
-        output_names=["o"],
-        dynamic_axes={
-          "z_in" : [2],
-          "o" : [2]
-        },
-        verbose=True,
-    )
-    o = self.dec(z_in, g=g)
-    return o

spaces/AnTo2209/3D_Zeroshot_Neural_Style_Transfer/src/dataset/llff_dataset.py

@@ -1,292 +0,0 @@
-import torch
-from torch.utils.data import Dataset
-import glob
-import numpy as np
-import os
-from PIL import Image
-from torchvision import transforms as T
-
-from .ray_utils import *
-
-
-def normalize(v):
-    """Normalize a vector."""
-    return v / np.linalg.norm(v)
-
-
-def average_poses(poses):
-    """
-    Calculate the average pose, which is then used to center all poses
-    using @center_poses. Its computation is as follows:
-    1. Compute the center: the average of pose centers.
-    2. Compute the z axis: the normalized average z axis.
-    3. Compute axis y': the average y axis.
-    4. Compute x' = y' cross product z, then normalize it as the x axis.
-    5. Compute the y axis: z cross product x.
-
-    Note that at step 3, we cannot directly use y' as y axis since it's
-    not necessarily orthogonal to z axis. We need to pass from x to y.
-    Inputs:
-        poses: (N_images, 3, 4)
-    Outputs:
-        pose_avg: (3, 4) the average pose
-    """
-    # 1. Compute the center
-    center = poses[..., 3].mean(0)  # (3)
-
-    # 2. Compute the z axis
-    z = normalize(poses[..., 2].mean(0))  # (3)
-
-    # 3. Compute axis y' (no need to normalize as it's not the final output)
-    y_ = poses[..., 1].mean(0)  # (3)
-
-    # 4. Compute the x axis
-    x = normalize(np.cross(z, y_))  # (3)
-
-    # 5. Compute the y axis (as z and x are normalized, y is already of norm 1)
-    y = np.cross(x, z)  # (3)
-
-    pose_avg = np.stack([x, y, z, center], 1)  # (3, 4)
-
-    return pose_avg
-
-
-def center_poses(poses, blender2opencv):
-    """
-    Center the poses so that we can use NDC.
-    See https://github.com/bmild/nerf/issues/34
-    Inputs:
-        poses: (N_images, 3, 4)
-    Outputs:
-        poses_centered: (N_images, 3, 4) the centered poses
-        pose_avg: (3, 4) the average pose
-    """
-    poses = poses @ blender2opencv
-    pose_avg = average_poses(poses)  # (3, 4)
-    pose_avg_homo = np.eye(4)
-    pose_avg_homo[:3] = pose_avg  # convert to homogeneous coordinate for faster computation
-    pose_avg_homo = pose_avg_homo
-    # by simply adding 0, 0, 0, 1 as the last row
-    last_row = np.tile(np.array([0, 0, 0, 1]), (len(poses), 1, 1))  # (N_images, 1, 4)
-    poses_homo = \
-        np.concatenate([poses, last_row], 1)  # (N_images, 4, 4) homogeneous coordinate
-
-    poses_centered = np.linalg.inv(pose_avg_homo) @ poses_homo  # (N_images, 4, 4)
-    #     poses_centered = poses_centered  @ blender2opencv
-    poses_centered = poses_centered[:, :3]  # (N_images, 3, 4)
-
-    return poses_centered, pose_avg_homo
-
-
-def viewmatrix(z, up, pos):
-    vec2 = normalize(z)
-    vec1_avg = up
-    vec0 = normalize(np.cross(vec1_avg, vec2))
-    vec1 = normalize(np.cross(vec2, vec0))
-    m = np.eye(4)
-    m[:3] = np.stack([-vec0, vec1, vec2, pos], 1)
-    return m
-
-
-def render_path_spiral(c2w, up, rads, focal, zdelta, zrate, N_rots=2, N=120):
-    render_poses = []
-    rads = np.array(list(rads) + [1.])
-
-    for theta in np.linspace(0., 2. * np.pi * N_rots, N + 1)[:-1]:
-        c = np.dot(c2w[:3, :4], np.array([np.cos(theta), -np.sin(theta), -np.sin(theta * zrate), 1.]) * rads)
-        z = normalize(c - np.dot(c2w[:3, :4], np.array([0, 0, -focal, 1.])))
-        render_poses.append(viewmatrix(z, up, c))
-    return render_poses
-
-
-def get_spiral(c2ws_all, near_fars, rads_scale=1.0, N_views=120):
-    # center pose
-    c2w = average_poses(c2ws_all)
-
-    # Get average pose
-    up = normalize(c2ws_all[:, :3, 1].sum(0))
-
-    # Find a reasonable "focus depth" for this dataset
-    dt = 0.75
-    close_depth, inf_depth = near_fars.min() * 0.9, near_fars.max() * 5.0
-    focal = 1.0 / (((1.0 - dt) / close_depth + dt / inf_depth))
-
-    # Get radii for spiral path
-    zdelta = near_fars.min() * .2
-    tt = c2ws_all[:, :3, 3]
-    rads = np.percentile(np.abs(tt), 90, 0) * rads_scale
-    render_poses = render_path_spiral(c2w, up, rads, focal, zdelta, zrate=.5, N=N_views)
-    return np.stack(render_poses)
-
-
-def get_interpolation_path(c2ws_all, steps=30):
-    # flower
-    # idx0 = 1
-    # idx1 = 10
-
-    # trex
-    # idx0 = 8
-    # idx1 = 53
-
-    # horns
-    idx0 = 18
-    idx1 = 47
-
-    v = np.linspace(0, 1, num=steps)
-
-    c2w0 = c2ws_all[idx0]
-    c2w1 = c2ws_all[idx1]
-
-    c2w_ = []
-    for i in range(steps):
-        c2w_.append(c2w0 * v[i] + c2w1 * (1 - v[i]))
-
-    return np.stack(c2w_)
-
-
-class LLFFDataset(Dataset):
-    def __init__(self, datadir, split='train', downsample=4, is_stack=False, hold_every=8, N_vis=-1):
-
-        self.root_dir = datadir
-        self.split = split
-        self.hold_every = hold_every
-        self.is_stack = is_stack
-        self.downsample = downsample
-        self.define_transforms()
-
-        self.blender2opencv = np.eye(4)  # np.array([[1, 0, 0, 0], [0, -1, 0, 0], [0, 0, -1, 0], [0, 0, 0, 1]])
-        self.read_meta()
-        self.white_bg = False
-
-        #         self.near_far = [np.min(self.near_fars[:,0]),np.max(self.near_fars[:,1])]
-        self.near_far = [0.0, 1.0]
-        self.scene_bbox = torch.tensor([[-1.5, -1.67, -1.0], [1.5, 1.67, 1.0]])
-        # self.scene_bbox = torch.tensor([[-1.67, -1.5, -1.0], [1.67, 1.5, 1.0]])
-        self.center = torch.mean(self.scene_bbox, dim=0).float().view(1, 1, 3)
-        self.invradius = 1.0 / (self.scene_bbox[1] - self.center).float().view(1, 1, 3)
-
-    def read_meta(self):
-
-        poses_bounds = np.load(os.path.join(self.root_dir, 'poses_bounds.npy'))  # (N_images, 17)
-        self.image_paths = sorted(glob.glob(os.path.join(self.root_dir, 'images_4/*')))
-        # load full resolution image then resize
-        if self.split in ['train', 'test']:
-            assert len(poses_bounds) == len(self.image_paths), \
-                'Mismatch between number of images and number of poses! Please rerun COLMAP!'
-
-        poses = poses_bounds[:, :15].reshape(-1, 3, 5)  # (N_images, 3, 5)
-        self.near_fars = poses_bounds[:, -2:]  # (N_images, 2)
-        hwf = poses[:, :, -1]
-
-        # Step 1: rescale focal length according to training resolution
-        H, W, self.focal = poses[0, :, -1]  # original intrinsics, same for all images
-        self.img_wh = np.array([int(W / self.downsample), int(H / self.downsample)])
-        self.focal = [self.focal * self.img_wh[0] / W, self.focal * self.img_wh[1] / H]
-
-        # Step 2: correct poses
-        # Original poses has rotation in form "down right back", change to "right up back"
-        # See https://github.com/bmild/nerf/issues/34
-        poses = np.concatenate([poses[..., 1:2], -poses[..., :1], poses[..., 2:4]], -1)
-        # (N_images, 3, 4) exclude H, W, focal
-        self.poses, self.pose_avg = center_poses(poses, self.blender2opencv)
-
-        # Step 3: correct scale so that the nearest depth is at a little more than 1.0
-        # See https://github.com/bmild/nerf/issues/34
-        near_original = self.near_fars.min()
-        scale_factor = near_original * 0.75  # 0.75 is the default parameter
-        # the nearest depth is at 1/0.75=1.33
-        self.near_fars /= scale_factor
-        self.poses[..., 3] /= scale_factor
-
-        # build rendering path
-        N_views, N_rots = 120, 2
-        tt = self.poses[:, :3, 3]  # ptstocam(poses[:3,3,:].T, c2w).T
-        up = normalize(self.poses[:, :3, 1].sum(0))
-        rads = np.percentile(np.abs(tt), 90, 0)
-
-        self.render_path = get_spiral(self.poses, self.near_fars, N_views=N_views)
-        # self.render_path = get_interpolation_path(self.poses)
-
-        # distances_from_center = np.linalg.norm(self.poses[..., 3], axis=1)
-        # val_idx = np.argmin(distances_from_center)  # choose val image as the closest to
-        # center image
-
-        # ray directions for all pixels, same for all images (same H, W, focal)
-        W, H = self.img_wh
-        self.directions = get_ray_directions_blender(H, W, self.focal)  # (H, W, 3)
-
-        average_pose = average_poses(self.poses)
-        dists = np.sum(np.square(average_pose[:3, 3] - self.poses[:, :3, 3]), -1)
-        i_test = np.arange(0, self.poses.shape[0], self.hold_every)  # [np.argmin(dists)]
-        img_list = i_test if self.split != 'train' else list(set(np.arange(len(self.poses))) - set(i_test))
-
-        # use first N_images-1 to train, the LAST is val
-        self.all_rays = []
-        self.all_rgbs = []
-        for i in img_list:
-            image_path = self.image_paths[i]
-            c2w = torch.FloatTensor(self.poses[i])
-
-            img = Image.open(image_path).convert('RGB')
-            if self.downsample != 1.0:
-                img = img.resize(self.img_wh, Image.LANCZOS)
-            img = self.transform(img)  # (3, h, w)
-
-            img = img.view(3, -1).permute(1, 0)  # (h*w, 3) RGB
-            self.all_rgbs += [img]
-            rays_o, rays_d = get_rays(self.directions, c2w)  # both (h*w, 3)
-            rays_o, rays_d = ndc_rays_blender(H, W, self.focal[0], 1.0, rays_o, rays_d)
-            # viewdir = rays_d / torch.norm(rays_d, dim=-1, keepdim=True)
-
-            self.all_rays += [torch.cat([rays_o, rays_d], 1)]  # (h*w, 6)
-
-        all_rays = self.all_rays
-        all_rgbs = self.all_rgbs
-
-        self.all_rays = torch.cat(self.all_rays, 0)  # (len(self.meta['frames])*h*w,6)
-        self.all_rgbs = torch.cat(self.all_rgbs, 0)  # (len(self.meta['frames])*h*w,3)
-
-        if self.is_stack:
-            self.all_rays_stack = torch.stack(all_rays, 0).reshape(-1, *self.img_wh[::-1],
-                                                                   6)  # (len(self.meta['frames]),h,w,6)
-            avg_pool = torch.nn.AvgPool2d(4, ceil_mode=True)
-            self.ds_all_rays_stack = avg_pool(self.all_rays_stack.permute(0, 3, 1, 2)).permute(0, 2, 3,
-                                                                                               1)  # (len(self.meta['frames]),h/4,w/4,6)
-            self.all_rgbs_stack = torch.stack(all_rgbs, 0).reshape(-1, *self.img_wh[::-1],
-                                                                   3)  # (len(self.meta['frames]),h,w,3)
-
-    @torch.no_grad()
-    def prepare_feature_data(self, encoder, chunk=8):
-        '''
-        Prepare feature maps as training data.
-        '''
-        assert self.is_stack, 'Dataset should contain original stacked taining data!'
-        print('====> prepare_feature_data ...')
-
-        frames_num, h, w, _ = self.all_rgbs_stack.size()
-        features = []
-
-        for chunk_idx in range(frames_num // chunk + int(frames_num % chunk > 0)):
-            rgbs_chunk = self.all_rgbs_stack[chunk_idx * chunk: (chunk_idx + 1) * chunk].cuda()
-            features_chunk = encoder(normalize_vgg(rgbs_chunk.permute(0, 3, 1, 2))).relu3_1
-            # resize to the size of rgb map so that rays can match
-            features_chunk = T.functional.resize(features_chunk, size=(h, w),
-                                                 interpolation=T.InterpolationMode.BILINEAR)
-            features.append(features_chunk.detach().cpu().requires_grad_(False))
-
-        self.all_features_stack = torch.cat(features).permute(0, 2, 3, 1)  # (len(self.meta['frames]),h,w,256)
-        self.all_features = self.all_features_stack.reshape(-1, 256)
-        print('prepare_feature_data Done!')
-
-    def define_transforms(self):
-        self.transform = T.ToTensor()
-
-    def __len__(self):
-        return len(self.all_rgbs)
-
-    def __getitem__(self, idx):
-
-        sample = {'rays': self.all_rays[idx],
-                  'rgbs': self.all_rgbs[idx]}
-
-        return sample

spaces/Anandbheesetti/MNIST_digit_predictor/app.py

@@ -1,105 +0,0 @@
-
-
-## importing the necessary libraries
-import pandas as pd
-import numpy as np
-import matplotlib.pyplot as plt
-import seaborn as sns
-import tensorflow as tf
-
-##loading the MNIST dataset
-mnist=tf.keras.datasets.mnist
-
-#splitting the data into training and testing datasets
-(x_train_full,y_train_full),(x_test,y_test)=mnist.load_data()
-
-## let us check the shapes of the training and testing datasets
-x_train_full.shape
-
-x_test.shape
-
-## As we know that the digits are stored in form of the pixels.
-## each digit has 28 pixels
-## All pixels ranges from 0 to 255 grey levels
-
-# Creating a validation data set from the training data set
-x_valid,x_train=x_train_full[:5000],x_train_full[5000:]
-
-# Now we will scale the data between 0 to 1 by dividing it by 255
-x_valid=x_valid/255
-
-x_train=x_train/255
-
-x_test=x_test/255
-
-y_valid,y_train=y_train_full[:5000],y_train_full[5000:]
-
-# Now let us visualize how the MNIST data looks like
-plt.imshow(x_train[0],cmap="binary")
-plt.show()
-
-# To visualize it in at grey levels
-plt.figure(figsize=(15,15))
-sns.heatmap(x_train[0],annot=True,cmap="binary")
-
-# Now we will create a Artificial neural network with some hidden layers to build a model that predicts the written digit
-Layers=[tf.keras.layers.Flatten(input_shape=[28,28],name="inputlayer"),
-        tf.keras.layers.Dense(300,activation="relu",name="hiddenlayer1"),
-        tf.keras.layers.Dense(100,activation="relu",name="hiddenlayer2"),
-        tf.keras.layers.Dense(10,activation="softmax",name="outputlayer")]
-
-# Now we will buila a Sequential model
-model_clf=tf.keras.models.Sequential(Layers)
-
-model_clf.layers
-
-# Let us see the summary of the model
-model_clf.summary()
-
-weights,biases=model_clf.layers[1].get_weights()
-
-# Defining the parameters to train the model
-LOSS_FUNCTION="sparse_categorical_crossentropy"
-OPTIMIZER="SGD"
-METRICS=["accuracy"]
-
-model_clf.compile(loss=LOSS_FUNCTION,
-                  optimizer=OPTIMIZER,
-                  metrics=METRICS)
-
-EPOCHS=30
-VALIDATION_SET=(x_valid,y_valid)
-
-history=model_clf.fit(x_train,y_train,epochs=EPOCHS,
-                      validation_data=VALIDATION_SET,
-                      batch_size=32)
-
-history.params
-
-pd.DataFrame(history.history).plot()
-
-model_clf.evaluate(x_test,y_test)
-
-x_new=x_test[:3]
-actual=y_test[:3]
-y_prob=model_clf.predict(x_new)
-y_pred=np.argmax(y_prob,axis=-1)
-
-for i,j,k in zip(x_new,y_pred,actual):
-  plt.imshow(i,cmap="binary")
-  plt.title(f"predicted {j} and actual is {k}")
-  plt.axis("off")
-  plt.show()
-  print('##########################')
-  
-  import gradio as gd
-  def makePred(img):
-    img_3d=img.reshape(-1,28,28)
-    im_resize=img_3d/255.0
-    predict=model_clf.predict(im_resize)
-    pred=np.argmax(predict)
-    return str(pred)
-
-demo = gd.Interface(makePred, inputs='sketchpad', outputs='label')
-demo.launch(debug='True')
-

spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/src/diffusers/pipelines/deepfloyd_if/safety_checker.py

@@ -1,59 +0,0 @@
-import numpy as np
-import torch
-import torch.nn as nn
-from transformers import CLIPConfig, CLIPVisionModelWithProjection, PreTrainedModel
-
-from ...utils import logging
-
-
-logger = logging.get_logger(__name__)
-
-
-class IFSafetyChecker(PreTrainedModel):
-    config_class = CLIPConfig
-
-    _no_split_modules = ["CLIPEncoderLayer"]
-
-    def __init__(self, config: CLIPConfig):
-        super().__init__(config)
-
-        self.vision_model = CLIPVisionModelWithProjection(config.vision_config)
-
-        self.p_head = nn.Linear(config.vision_config.projection_dim, 1)
-        self.w_head = nn.Linear(config.vision_config.projection_dim, 1)
-
-    @torch.no_grad()
-    def forward(self, clip_input, images, p_threshold=0.5, w_threshold=0.5):
-        image_embeds = self.vision_model(clip_input)[0]
-
-        nsfw_detected = self.p_head(image_embeds)
-        nsfw_detected = nsfw_detected.flatten()
-        nsfw_detected = nsfw_detected > p_threshold
-        nsfw_detected = nsfw_detected.tolist()
-
-        if any(nsfw_detected):
-            logger.warning(
-                "Potential NSFW content was detected in one or more images. A black image will be returned instead."
-                " Try again with a different prompt and/or seed."
-            )
-
-        for idx, nsfw_detected_ in enumerate(nsfw_detected):
-            if nsfw_detected_:
-                images[idx] = np.zeros(images[idx].shape)
-
-        watermark_detected = self.w_head(image_embeds)
-        watermark_detected = watermark_detected.flatten()
-        watermark_detected = watermark_detected > w_threshold
-        watermark_detected = watermark_detected.tolist()
-
-        if any(watermark_detected):
-            logger.warning(
-                "Potential watermarked content was detected in one or more images. A black image will be returned instead."
-                " Try again with a different prompt and/or seed."
-            )
-
-        for idx, watermark_detected_ in enumerate(watermark_detected):
-            if watermark_detected_:
-                images[idx] = np.zeros(images[idx].shape)
-
-        return images, nsfw_detected, watermark_detected

spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/tests/pipelines/versatile_diffusion/test_versatile_diffusion_mega.py

@@ -1,129 +0,0 @@
-# coding=utf-8
-# Copyright 2023 HuggingFace Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import gc
-import tempfile
-import unittest
-
-import numpy as np
-import torch
-
-from diffusers import VersatileDiffusionPipeline
-from diffusers.utils.testing_utils import load_image, nightly, require_torch_gpu, torch_device
-
-
-torch.backends.cuda.matmul.allow_tf32 = False
-
-
-class VersatileDiffusionMegaPipelineFastTests(unittest.TestCase):
-    pass
-
-
-@nightly
-@require_torch_gpu
-class VersatileDiffusionMegaPipelineIntegrationTests(unittest.TestCase):
-    def tearDown(self):
-        # clean up the VRAM after each test
-        super().tearDown()
-        gc.collect()
-        torch.cuda.empty_cache()
-
-    def test_from_save_pretrained(self):
-        pipe = VersatileDiffusionPipeline.from_pretrained("shi-labs/versatile-diffusion", torch_dtype=torch.float16)
-        pipe.to(torch_device)
-        pipe.set_progress_bar_config(disable=None)
-
-        prompt_image = load_image(
-            "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/versatile_diffusion/benz.jpg"
-        )
-
-        generator = torch.manual_seed(0)
-        image = pipe.dual_guided(
-            prompt="first prompt",
-            image=prompt_image,
-            text_to_image_strength=0.75,
-            generator=generator,
-            guidance_scale=7.5,
-            num_inference_steps=2,
-            output_type="numpy",
-        ).images
-
-        with tempfile.TemporaryDirectory() as tmpdirname:
-            pipe.save_pretrained(tmpdirname)
-            pipe = VersatileDiffusionPipeline.from_pretrained(tmpdirname, torch_dtype=torch.float16)
-        pipe.to(torch_device)
-        pipe.set_progress_bar_config(disable=None)
-
-        generator = generator.manual_seed(0)
-        new_image = pipe.dual_guided(
-            prompt="first prompt",
-            image=prompt_image,
-            text_to_image_strength=0.75,
-            generator=generator,
-            guidance_scale=7.5,
-            num_inference_steps=2,
-            output_type="numpy",
-        ).images
-
-        assert np.abs(image - new_image).sum() < 1e-5, "Models don't have the same forward pass"
-
-    def test_inference_dual_guided_then_text_to_image(self):
-        pipe = VersatileDiffusionPipeline.from_pretrained("shi-labs/versatile-diffusion", torch_dtype=torch.float16)
-        pipe.to(torch_device)
-        pipe.set_progress_bar_config(disable=None)
-
-        prompt = "cyberpunk 2077"
-        init_image = load_image(
-            "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/versatile_diffusion/benz.jpg"
-        )
-        generator = torch.manual_seed(0)
-        image = pipe.dual_guided(
-            prompt=prompt,
-            image=init_image,
-            text_to_image_strength=0.75,
-            generator=generator,
-            guidance_scale=7.5,
-            num_inference_steps=50,
-            output_type="numpy",
-        ).images
-
-        image_slice = image[0, 253:256, 253:256, -1]
-
-        assert image.shape == (1, 512, 512, 3)
-        expected_slice = np.array([0.1448, 0.1619, 0.1741, 0.1086, 0.1147, 0.1128, 0.1199, 0.1165, 0.1001])
-
-        assert np.abs(image_slice.flatten() - expected_slice).max() < 1e-1
-
-        prompt = "A painting of a squirrel eating a burger "
-        generator = torch.manual_seed(0)
-        image = pipe.text_to_image(
-            prompt=prompt, generator=generator, guidance_scale=7.5, num_inference_steps=50, output_type="numpy"
-        ).images
-
-        image_slice = image[0, 253:256, 253:256, -1]
-
-        assert image.shape == (1, 512, 512, 3)
-        expected_slice = np.array([0.3367, 0.3169, 0.2656, 0.3870, 0.4790, 0.3796, 0.4009, 0.4878, 0.4778])
-
-        assert np.abs(image_slice.flatten() - expected_slice).max() < 1e-1
-
-        image = pipe.image_variation(init_image, generator=generator, output_type="numpy").images
-
-        image_slice = image[0, 253:256, 253:256, -1]
-
-        assert image.shape == (1, 512, 512, 3)
-        expected_slice = np.array([0.3076, 0.3123, 0.3284, 0.3782, 0.3770, 0.3894, 0.4297, 0.4331, 0.4456])
-
-        assert np.abs(image_slice.flatten() - expected_slice).max() < 1e-1

spaces/Andy1621/uniformer_image_detection/configs/dynamic_rcnn/dynamic_rcnn_r50_fpn_1x.py

@@ -1,28 +0,0 @@
-_base_ = '../faster_rcnn/faster_rcnn_r50_fpn_1x_coco.py'
-model = dict(
-    roi_head=dict(
-        type='DynamicRoIHead',
-        bbox_head=dict(
-            type='Shared2FCBBoxHead',
-            in_channels=256,
-            fc_out_channels=1024,
-            roi_feat_size=7,
-            num_classes=80,
-            bbox_coder=dict(
-                type='DeltaXYWHBBoxCoder',
-                target_means=[0., 0., 0., 0.],
-                target_stds=[0.1, 0.1, 0.2, 0.2]),
-            reg_class_agnostic=False,
-            loss_cls=dict(
-                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0),
-            loss_bbox=dict(type='SmoothL1Loss', beta=1.0, loss_weight=1.0))),
-    train_cfg=dict(
-        rpn_proposal=dict(nms=dict(iou_threshold=0.85)),
-        rcnn=dict(
-            dynamic_rcnn=dict(
-                iou_topk=75,
-                beta_topk=10,
-                update_iter_interval=100,
-                initial_iou=0.4,
-                initial_beta=1.0))),
-    test_cfg=dict(rpn=dict(nms=dict(iou_threshold=0.85))))

spaces/Andy1621/uniformer_image_detection/tools/model_converters/regnet2mmdet.py

@@ -1,89 +0,0 @@
-import argparse
-from collections import OrderedDict
-
-import torch
-
-
-def convert_stem(model_key, model_weight, state_dict, converted_names):
-    new_key = model_key.replace('stem.conv', 'conv1')
-    new_key = new_key.replace('stem.bn', 'bn1')
-    state_dict[new_key] = model_weight
-    converted_names.add(model_key)
-    print(f'Convert {model_key} to {new_key}')
-
-
-def convert_head(model_key, model_weight, state_dict, converted_names):
-    new_key = model_key.replace('head.fc', 'fc')
-    state_dict[new_key] = model_weight
-    converted_names.add(model_key)
-    print(f'Convert {model_key} to {new_key}')
-
-
-def convert_reslayer(model_key, model_weight, state_dict, converted_names):
-    split_keys = model_key.split('.')
-    layer, block, module = split_keys[:3]
-    block_id = int(block[1:])
-    layer_name = f'layer{int(layer[1:])}'
-    block_name = f'{block_id - 1}'
-
-    if block_id == 1 and module == 'bn':
-        new_key = f'{layer_name}.{block_name}.downsample.1.{split_keys[-1]}'
-    elif block_id == 1 and module == 'proj':
-        new_key = f'{layer_name}.{block_name}.downsample.0.{split_keys[-1]}'
-    elif module == 'f':
-        if split_keys[3] == 'a_bn':
-            module_name = 'bn1'
-        elif split_keys[3] == 'b_bn':
-            module_name = 'bn2'
-        elif split_keys[3] == 'c_bn':
-            module_name = 'bn3'
-        elif split_keys[3] == 'a':
-            module_name = 'conv1'
-        elif split_keys[3] == 'b':
-            module_name = 'conv2'
-        elif split_keys[3] == 'c':
-            module_name = 'conv3'
-        new_key = f'{layer_name}.{block_name}.{module_name}.{split_keys[-1]}'
-    else:
-        raise ValueError(f'Unsupported conversion of key {model_key}')
-    print(f'Convert {model_key} to {new_key}')
-    state_dict[new_key] = model_weight
-    converted_names.add(model_key)
-
-
-def convert(src, dst):
-    """Convert keys in pycls pretrained RegNet models to mmdet style."""
-    # load caffe model
-    regnet_model = torch.load(src)
-    blobs = regnet_model['model_state']
-    # convert to pytorch style
-    state_dict = OrderedDict()
-    converted_names = set()
-    for key, weight in blobs.items():
-        if 'stem' in key:
-            convert_stem(key, weight, state_dict, converted_names)
-        elif 'head' in key:
-            convert_head(key, weight, state_dict, converted_names)
-        elif key.startswith('s'):
-            convert_reslayer(key, weight, state_dict, converted_names)
-
-    # check if all layers are converted
-    for key in blobs:
-        if key not in converted_names:
-            print(f'not converted: {key}')
-    # save checkpoint
-    checkpoint = dict()
-    checkpoint['state_dict'] = state_dict
-    torch.save(checkpoint, dst)
-
-
-def main():
-    parser = argparse.ArgumentParser(description='Convert model keys')
-    parser.add_argument('src', help='src detectron model path')
-    parser.add_argument('dst', help='save path')
-    args = parser.parse_args()
-    convert(args.src, args.dst)
-
-
-if __name__ == '__main__':
-    main()

spaces/AnishKumbhar/ChatBot/text-generation-webui-main/modules/llamacpp_hf.py

@@ -1,213 +0,0 @@
-import os
-from pathlib import Path
-from typing import Any, Dict, Optional, Union
-
-import torch
-from torch.nn import CrossEntropyLoss
-from transformers import GenerationConfig, PretrainedConfig, PreTrainedModel
-from transformers.modeling_outputs import CausalLMOutputWithPast
-
-from modules import RoPE, shared
-from modules.logging_colors import logger
-
-try:
-    import llama_cpp
-except:
-    llama_cpp = None
-
-try:
-    import llama_cpp_cuda
-except:
-    llama_cpp_cuda = None
-
-
-def llama_cpp_lib():
-    if (shared.args.cpu and llama_cpp is not None) or llama_cpp_cuda is None:
-        return llama_cpp
-    else:
-        return llama_cpp_cuda
-
-
-class LlamacppHF(PreTrainedModel):
-    def __init__(self, model, path):
-        super().__init__(PretrainedConfig())
-        self.model = model
-        self.generation_config = GenerationConfig()
-
-        self.past_seq = None
-        self.llamacpp_cache = {
-            'n_tokens': self.model.n_tokens,
-            'input_ids': self.model.input_ids,
-            'scores': self.model.scores,
-            'ctx': self.model.ctx
-        }
-
-        if shared.args.cfg_cache:
-            self.past_seq_negative = None
-            self.llamacpp_cache_negative = {
-                'n_tokens': self.model.n_tokens,
-                'input_ids': self.model.input_ids.copy(),
-                'scores': self.model.scores.copy(),
-                'ctx': llama_cpp_lib().llama_new_context_with_model(model.model, model.context_params)
-            }
-
-    def _validate_model_class(self):
-        pass
-
-    def _validate_model_kwargs(self, model_kwargs: Dict[str, Any]):
-        pass
-
-    def prepare_inputs_for_generation(self, input_ids, **kwargs):
-        return {'input_ids': input_ids, **kwargs}
-
-    def save_cache(self):
-        self.llamacpp_cache.update({
-            'n_tokens': self.model.n_tokens,
-            'input_ids': self.model.input_ids,
-            'scores': self.model.scores,
-            'ctx': self.model.ctx
-        })
-
-    def save_negative_cache(self):
-        self.llamacpp_cache_negative.update({
-            'n_tokens': self.model.n_tokens,
-            'input_ids': self.model.input_ids,
-            'scores': self.model.scores,
-            'ctx': self.model.ctx
-        })
-
-    def load_cache(self):
-        self.model.n_tokens = self.llamacpp_cache['n_tokens']
-        self.model.input_ids = self.llamacpp_cache['input_ids']
-        self.model.scores = self.llamacpp_cache['scores']
-        self.model.ctx = self.llamacpp_cache['ctx']
-
-    def load_negative_cache(self):
-        self.model.n_tokens = self.llamacpp_cache_negative['n_tokens']
-        self.model.input_ids = self.llamacpp_cache_negative['input_ids']
-        self.model.scores = self.llamacpp_cache_negative['scores']
-        self.model.ctx = self.llamacpp_cache_negative['ctx']
-
-    @property
-    def device(self) -> torch.device:
-        return torch.device(0)
-
-    def __call__(self, *args, **kwargs):
-        use_cache = kwargs.get('use_cache', True)
-        labels = kwargs.get('labels', None)
-        past_key_values = kwargs.get('past_key_values', None)
-
-        if len(args) > 0:
-            if not shared.args.cfg_cache:
-                logger.error("Please enable the cfg-cache option to use CFG with llamacpp_HF.")
-                return
-
-            input_ids = args[0]
-            is_negative = True
-            past_seq = self.past_seq_negative
-            self.load_negative_cache()
-        else:
-            input_ids = kwargs['input_ids']
-            is_negative = False
-            past_seq = self.past_seq
-            self.load_cache()
-
-        seq = input_ids[0].tolist()
-        if is_negative and past_key_values is not None:
-            seq = past_key_values + seq
-
-        seq_tensor = torch.tensor(seq)
-        reset = True
-
-        # Make the forward call. The prefix-match code has been adapted from
-        # https://github.com/abetlen/llama-cpp-python/commit/f4090a0bb2a2a25acfe28d31c82cc1aa273bedee
-        if labels is None:
-            if past_seq is not None:
-                min_length = min(past_seq.shape[0], seq_tensor.shape[0])
-                indices = torch.nonzero(~torch.eq(past_seq[:min_length], seq_tensor[:min_length]))
-                if len(indices) > 0:
-                    longest_prefix = indices[0].item()
-                else:
-                    longest_prefix = min_length
-
-                if longest_prefix > 0:
-                    reset = False
-                    self.model.n_tokens = longest_prefix
-                    if len(seq_tensor) - longest_prefix > 0:
-                        self.model.eval(seq[longest_prefix:])
-
-            if reset:
-                self.model.reset()
-                self.model.eval(seq)
-
-            logits = torch.tensor(self.model.scores[self.model.n_tokens - 1, :]).view(1, 1, -1).to(input_ids.device)
-        else:
-            self.model.reset()
-            self.model.eval(seq)
-            logits = torch.tensor(self.model.eval_logits)
-            logits = logits.view(1, logits.shape[0], logits.shape[1]).to(input_ids.device)
-
-        if is_negative:
-            self.save_negative_cache()
-            self.past_seq_negative = seq_tensor
-        else:
-            self.save_cache()
-            self.past_seq = seq_tensor
-
-        loss = None
-        if labels is not None:
-            # Shift so that tokens < n predict n
-            shift_logits = logits[..., :-1, :].contiguous()
-            shift_labels = labels[..., 1:].contiguous()
-            # Flatten the tokens
-            loss_fct = CrossEntropyLoss()
-            shift_logits = shift_logits.view(-1, logits.shape[-1])
-            shift_labels = shift_labels.view(-1)
-            # Enable model parallelism
-            shift_labels = shift_labels.to(shift_logits.device)
-            loss = loss_fct(shift_logits, shift_labels)
-
-        return CausalLMOutputWithPast(logits=logits, past_key_values=seq if use_cache else None, loss=loss)
-
-    @classmethod
-    def from_pretrained(cls, pretrained_model_name_or_path: Optional[Union[str, os.PathLike]], *model_args, **kwargs):
-        assert len(model_args) == 0 and len(kwargs) == 0, "extra args is currently not supported"
-
-        if isinstance(pretrained_model_name_or_path, str):
-            pretrained_model_name_or_path = Path(pretrained_model_name_or_path)
-
-        path = Path(f'{shared.args.model_dir}') / Path(pretrained_model_name_or_path)
-        if path.is_file():
-            model_file = path
-        else:
-            model_file = list(path.glob('*.gguf'))[0]
-
-        logger.info(f"llama.cpp weights detected: {model_file}\n")
-
-        if shared.args.tensor_split is None or shared.args.tensor_split.strip() == '':
-            tensor_split_list = None
-        else:
-            tensor_split_list = [float(x) for x in shared.args.tensor_split.strip().split(",")]
-
-        params = {
-            'model_path': str(model_file),
-            'n_ctx': shared.args.n_ctx,
-            'seed': int(shared.args.llama_cpp_seed),
-            'n_threads': shared.args.threads or None,
-            'n_threads_batch': shared.args.threads_batch or None,
-            'n_batch': shared.args.n_batch,
-            'use_mmap': not shared.args.no_mmap,
-            'use_mlock': shared.args.mlock,
-            'mul_mat_q': shared.args.mul_mat_q,
-            'numa': shared.args.numa,
-            'n_gpu_layers': shared.args.n_gpu_layers,
-            'rope_freq_base': RoPE.get_rope_freq_base(shared.args.alpha_value, shared.args.rope_freq_base),
-            'tensor_split': tensor_split_list,
-            'rope_freq_scale': 1.0 / shared.args.compress_pos_emb,
-            'logits_all': True,
-        }
-
-        Llama = llama_cpp_lib().Llama
-        model = Llama(**params)
-
-        return LlamacppHF(model, model_file)

spaces/Anonymous-sub/Rerender/ControlNet/annotator/uniformer/configs/_base_/schedules/schedule_20k.py

@@ -1,9 +0,0 @@
-# optimizer
-optimizer = dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0005)
-optimizer_config = dict()
-# learning policy
-lr_config = dict(policy='poly', power=0.9, min_lr=1e-4, by_epoch=False)
-# runtime settings
-runner = dict(type='IterBasedRunner', max_iters=20000)
-checkpoint_config = dict(by_epoch=False, interval=2000)
-evaluation = dict(interval=2000, metric='mIoU')

spaces/Anonymous-sub/Rerender/ControlNet/annotator/uniformer/mmseg/core/seg/builder.py

@@ -1,8 +0,0 @@
-from annotator.uniformer.mmcv.utils import Registry, build_from_cfg
-
-PIXEL_SAMPLERS = Registry('pixel sampler')
-
-
-def build_pixel_sampler(cfg, **default_args):
-    """Build pixel sampler for segmentation map."""
-    return build_from_cfg(cfg, PIXEL_SAMPLERS, default_args)

spaces/ArkanDash/rvc-models-new/lib/infer_pack/models.py

@@ -1,1142 +0,0 @@
-import math, pdb, os
-from time import time as ttime
-import torch
-from torch import nn
-from torch.nn import functional as F
-from lib.infer_pack import modules
-from lib.infer_pack import attentions
-from lib.infer_pack import commons
-from lib.infer_pack.commons import init_weights, get_padding
-from torch.nn import Conv1d, ConvTranspose1d, AvgPool1d, Conv2d
-from torch.nn.utils import weight_norm, remove_weight_norm, spectral_norm
-from lib.infer_pack.commons import init_weights
-import numpy as np
-from lib.infer_pack import commons
-
-
-class TextEncoder256(nn.Module):
-    def __init__(
-        self,
-        out_channels,
-        hidden_channels,
-        filter_channels,
-        n_heads,
-        n_layers,
-        kernel_size,
-        p_dropout,
-        f0=True,
-    ):
-        super().__init__()
-        self.out_channels = out_channels
-        self.hidden_channels = hidden_channels
-        self.filter_channels = filter_channels
-        self.n_heads = n_heads
-        self.n_layers = n_layers
-        self.kernel_size = kernel_size
-        self.p_dropout = p_dropout
-        self.emb_phone = nn.Linear(256, hidden_channels)
-        self.lrelu = nn.LeakyReLU(0.1, inplace=True)
-        if f0 == True:
-            self.emb_pitch = nn.Embedding(256, hidden_channels)  # pitch 256
-        self.encoder = attentions.Encoder(
-            hidden_channels, filter_channels, n_heads, n_layers, kernel_size, p_dropout
-        )
-        self.proj = nn.Conv1d(hidden_channels, out_channels * 2, 1)
-
-    def forward(self, phone, pitch, lengths):
-        if pitch == None:
-            x = self.emb_phone(phone)
-        else:
-            x = self.emb_phone(phone) + self.emb_pitch(pitch)
-        x = x * math.sqrt(self.hidden_channels)  # [b, t, h]
-        x = self.lrelu(x)
-        x = torch.transpose(x, 1, -1)  # [b, h, t]
-        x_mask = torch.unsqueeze(commons.sequence_mask(lengths, x.size(2)), 1).to(
-            x.dtype
-        )
-        x = self.encoder(x * x_mask, x_mask)
-        stats = self.proj(x) * x_mask
-
-        m, logs = torch.split(stats, self.out_channels, dim=1)
-        return m, logs, x_mask
-
-
-class TextEncoder768(nn.Module):
-    def __init__(
-        self,
-        out_channels,
-        hidden_channels,
-        filter_channels,
-        n_heads,
-        n_layers,
-        kernel_size,
-        p_dropout,
-        f0=True,
-    ):
-        super().__init__()
-        self.out_channels = out_channels
-        self.hidden_channels = hidden_channels
-        self.filter_channels = filter_channels
-        self.n_heads = n_heads
-        self.n_layers = n_layers
-        self.kernel_size = kernel_size
-        self.p_dropout = p_dropout
-        self.emb_phone = nn.Linear(768, hidden_channels)
-        self.lrelu = nn.LeakyReLU(0.1, inplace=True)
-        if f0 == True:
-            self.emb_pitch = nn.Embedding(256, hidden_channels)  # pitch 256
-        self.encoder = attentions.Encoder(
-            hidden_channels, filter_channels, n_heads, n_layers, kernel_size, p_dropout
-        )
-        self.proj = nn.Conv1d(hidden_channels, out_channels * 2, 1)
-
-    def forward(self, phone, pitch, lengths):
-        if pitch == None:
-            x = self.emb_phone(phone)
-        else:
-            x = self.emb_phone(phone) + self.emb_pitch(pitch)
-        x = x * math.sqrt(self.hidden_channels)  # [b, t, h]
-        x = self.lrelu(x)
-        x = torch.transpose(x, 1, -1)  # [b, h, t]
-        x_mask = torch.unsqueeze(commons.sequence_mask(lengths, x.size(2)), 1).to(
-            x.dtype
-        )
-        x = self.encoder(x * x_mask, x_mask)
-        stats = self.proj(x) * x_mask
-
-        m, logs = torch.split(stats, self.out_channels, dim=1)
-        return m, logs, x_mask
-
-
-class ResidualCouplingBlock(nn.Module):
-    def __init__(
-        self,
-        channels,
-        hidden_channels,
-        kernel_size,
-        dilation_rate,
-        n_layers,
-        n_flows=4,
-        gin_channels=0,
-    ):
-        super().__init__()
-        self.channels = channels
-        self.hidden_channels = hidden_channels
-        self.kernel_size = kernel_size
-        self.dilation_rate = dilation_rate
-        self.n_layers = n_layers
-        self.n_flows = n_flows
-        self.gin_channels = gin_channels
-
-        self.flows = nn.ModuleList()
-        for i in range(n_flows):
-            self.flows.append(
-                modules.ResidualCouplingLayer(
-                    channels,
-                    hidden_channels,
-                    kernel_size,
-                    dilation_rate,
-                    n_layers,
-                    gin_channels=gin_channels,
-                    mean_only=True,
-                )
-            )
-            self.flows.append(modules.Flip())
-
-    def forward(self, x, x_mask, g=None, reverse=False):
-        if not reverse:
-            for flow in self.flows:
-                x, _ = flow(x, x_mask, g=g, reverse=reverse)
-        else:
-            for flow in reversed(self.flows):
-                x = flow(x, x_mask, g=g, reverse=reverse)
-        return x
-
-    def remove_weight_norm(self):
-        for i in range(self.n_flows):
-            self.flows[i * 2].remove_weight_norm()
-
-
-class PosteriorEncoder(nn.Module):
-    def __init__(
-        self,
-        in_channels,
-        out_channels,
-        hidden_channels,
-        kernel_size,
-        dilation_rate,
-        n_layers,
-        gin_channels=0,
-    ):
-        super().__init__()
-        self.in_channels = in_channels
-        self.out_channels = out_channels
-        self.hidden_channels = hidden_channels
-        self.kernel_size = kernel_size
-        self.dilation_rate = dilation_rate
-        self.n_layers = n_layers
-        self.gin_channels = gin_channels
-
-        self.pre = nn.Conv1d(in_channels, hidden_channels, 1)
-        self.enc = modules.WN(
-            hidden_channels,
-            kernel_size,
-            dilation_rate,
-            n_layers,
-            gin_channels=gin_channels,
-        )
-        self.proj = nn.Conv1d(hidden_channels, out_channels * 2, 1)
-
-    def forward(self, x, x_lengths, g=None):
-        x_mask = torch.unsqueeze(commons.sequence_mask(x_lengths, x.size(2)), 1).to(
-            x.dtype
-        )
-        x = self.pre(x) * x_mask
-        x = self.enc(x, x_mask, g=g)
-        stats = self.proj(x) * x_mask
-        m, logs = torch.split(stats, self.out_channels, dim=1)
-        z = (m + torch.randn_like(m) * torch.exp(logs)) * x_mask
-        return z, m, logs, x_mask
-
-    def remove_weight_norm(self):
-        self.enc.remove_weight_norm()
-
-
-class Generator(torch.nn.Module):
-    def __init__(
-        self,
-        initial_channel,
-        resblock,
-        resblock_kernel_sizes,
-        resblock_dilation_sizes,
-        upsample_rates,
-        upsample_initial_channel,
-        upsample_kernel_sizes,
-        gin_channels=0,
-    ):
-        super(Generator, self).__init__()
-        self.num_kernels = len(resblock_kernel_sizes)
-        self.num_upsamples = len(upsample_rates)
-        self.conv_pre = Conv1d(
-            initial_channel, upsample_initial_channel, 7, 1, padding=3
-        )
-        resblock = modules.ResBlock1 if resblock == "1" else modules.ResBlock2
-
-        self.ups = nn.ModuleList()
-        for i, (u, k) in enumerate(zip(upsample_rates, upsample_kernel_sizes)):
-            self.ups.append(
-                weight_norm(
-                    ConvTranspose1d(
-                        upsample_initial_channel // (2**i),
-                        upsample_initial_channel // (2 ** (i + 1)),
-                        k,
-                        u,
-                        padding=(k - u) // 2,
-                    )
-                )
-            )
-
-        self.resblocks = nn.ModuleList()
-        for i in range(len(self.ups)):
-            ch = upsample_initial_channel // (2 ** (i + 1))
-            for j, (k, d) in enumerate(
-                zip(resblock_kernel_sizes, resblock_dilation_sizes)
-            ):
-                self.resblocks.append(resblock(ch, k, d))
-
-        self.conv_post = Conv1d(ch, 1, 7, 1, padding=3, bias=False)
-        self.ups.apply(init_weights)
-
-        if gin_channels != 0:
-            self.cond = nn.Conv1d(gin_channels, upsample_initial_channel, 1)
-
-    def forward(self, x, g=None):
-        x = self.conv_pre(x)
-        if g is not None:
-            x = x + self.cond(g)
-
-        for i in range(self.num_upsamples):
-            x = F.leaky_relu(x, modules.LRELU_SLOPE)
-            x = self.ups[i](x)
-            xs = None
-            for j in range(self.num_kernels):
-                if xs is None:
-                    xs = self.resblocks[i * self.num_kernels + j](x)
-                else:
-                    xs += self.resblocks[i * self.num_kernels + j](x)
-            x = xs / self.num_kernels
-        x = F.leaky_relu(x)
-        x = self.conv_post(x)
-        x = torch.tanh(x)
-
-        return x
-
-    def remove_weight_norm(self):
-        for l in self.ups:
-            remove_weight_norm(l)
-        for l in self.resblocks:
-            l.remove_weight_norm()
-
-
-class SineGen(torch.nn.Module):
-    """Definition of sine generator
-    SineGen(samp_rate, harmonic_num = 0,
-            sine_amp = 0.1, noise_std = 0.003,
-            voiced_threshold = 0,
-            flag_for_pulse=False)
-    samp_rate: sampling rate in Hz
-    harmonic_num: number of harmonic overtones (default 0)
-    sine_amp: amplitude of sine-wavefrom (default 0.1)
-    noise_std: std of Gaussian noise (default 0.003)
-    voiced_thoreshold: F0 threshold for U/V classification (default 0)
-    flag_for_pulse: this SinGen is used inside PulseGen (default False)
-    Note: when flag_for_pulse is True, the first time step of a voiced
-        segment is always sin(np.pi) or cos(0)
-    """
-
-    def __init__(
-        self,
-        samp_rate,
-        harmonic_num=0,
-        sine_amp=0.1,
-        noise_std=0.003,
-        voiced_threshold=0,
-        flag_for_pulse=False,
-    ):
-        super(SineGen, self).__init__()
-        self.sine_amp = sine_amp
-        self.noise_std = noise_std
-        self.harmonic_num = harmonic_num
-        self.dim = self.harmonic_num + 1
-        self.sampling_rate = samp_rate
-        self.voiced_threshold = voiced_threshold
-
-    def _f02uv(self, f0):
-        # generate uv signal
-        uv = torch.ones_like(f0)
-        uv = uv * (f0 > self.voiced_threshold)
-        return uv
-
-    def forward(self, f0, upp):
-        """sine_tensor, uv = forward(f0)
-        input F0: tensor(batchsize=1, length, dim=1)
-                  f0 for unvoiced steps should be 0
-        output sine_tensor: tensor(batchsize=1, length, dim)
-        output uv: tensor(batchsize=1, length, 1)
-        """
-        with torch.no_grad():
-            f0 = f0[:, None].transpose(1, 2)
-            f0_buf = torch.zeros(f0.shape[0], f0.shape[1], self.dim, device=f0.device)
-            # fundamental component
-            f0_buf[:, :, 0] = f0[:, :, 0]
-            for idx in np.arange(self.harmonic_num):
-                f0_buf[:, :, idx + 1] = f0_buf[:, :, 0] * (
-                    idx + 2
-                )  # idx + 2: the (idx+1)-th overtone, (idx+2)-th harmonic
-            rad_values = (f0_buf / self.sampling_rate) % 1  ###%1意味着n_har的乘积无法后处理优化
-            rand_ini = torch.rand(
-                f0_buf.shape[0], f0_buf.shape[2], device=f0_buf.device
-            )
-            rand_ini[:, 0] = 0
-            rad_values[:, 0, :] = rad_values[:, 0, :] + rand_ini
-            tmp_over_one = torch.cumsum(rad_values, 1)  # % 1  #####%1意味着后面的cumsum无法再优化
-            tmp_over_one *= upp
-            tmp_over_one = F.interpolate(
-                tmp_over_one.transpose(2, 1),
-                scale_factor=upp,
-                mode="linear",
-                align_corners=True,
-            ).transpose(2, 1)
-            rad_values = F.interpolate(
-                rad_values.transpose(2, 1), scale_factor=upp, mode="nearest"
-            ).transpose(
-                2, 1
-            )  #######
-            tmp_over_one %= 1
-            tmp_over_one_idx = (tmp_over_one[:, 1:, :] - tmp_over_one[:, :-1, :]) < 0
-            cumsum_shift = torch.zeros_like(rad_values)
-            cumsum_shift[:, 1:, :] = tmp_over_one_idx * -1.0
-            sine_waves = torch.sin(
-                torch.cumsum(rad_values + cumsum_shift, dim=1) * 2 * np.pi
-            )
-            sine_waves = sine_waves * self.sine_amp
-            uv = self._f02uv(f0)
-            uv = F.interpolate(
-                uv.transpose(2, 1), scale_factor=upp, mode="nearest"
-            ).transpose(2, 1)
-            noise_amp = uv * self.noise_std + (1 - uv) * self.sine_amp / 3
-            noise = noise_amp * torch.randn_like(sine_waves)
-            sine_waves = sine_waves * uv + noise
-        return sine_waves, uv, noise
-
-
-class SourceModuleHnNSF(torch.nn.Module):
-    """SourceModule for hn-nsf
-    SourceModule(sampling_rate, harmonic_num=0, sine_amp=0.1,
-                 add_noise_std=0.003, voiced_threshod=0)
-    sampling_rate: sampling_rate in Hz
-    harmonic_num: number of harmonic above F0 (default: 0)
-    sine_amp: amplitude of sine source signal (default: 0.1)
-    add_noise_std: std of additive Gaussian noise (default: 0.003)
-        note that amplitude of noise in unvoiced is decided
-        by sine_amp
-    voiced_threshold: threhold to set U/V given F0 (default: 0)
-    Sine_source, noise_source = SourceModuleHnNSF(F0_sampled)
-    F0_sampled (batchsize, length, 1)
-    Sine_source (batchsize, length, 1)
-    noise_source (batchsize, length 1)
-    uv (batchsize, length, 1)
-    """
-
-    def __init__(
-        self,
-        sampling_rate,
-        harmonic_num=0,
-        sine_amp=0.1,
-        add_noise_std=0.003,
-        voiced_threshod=0,
-        is_half=True,
-    ):
-        super(SourceModuleHnNSF, self).__init__()
-
-        self.sine_amp = sine_amp
-        self.noise_std = add_noise_std
-        self.is_half = is_half
-        # to produce sine waveforms
-        self.l_sin_gen = SineGen(
-            sampling_rate, harmonic_num, sine_amp, add_noise_std, voiced_threshod
-        )
-
-        # to merge source harmonics into a single excitation
-        self.l_linear = torch.nn.Linear(harmonic_num + 1, 1)
-        self.l_tanh = torch.nn.Tanh()
-
-    def forward(self, x, upp=None):
-        sine_wavs, uv, _ = self.l_sin_gen(x, upp)
-        if self.is_half:
-            sine_wavs = sine_wavs.half()
-        sine_merge = self.l_tanh(self.l_linear(sine_wavs))
-        return sine_merge, None, None  # noise, uv
-
-
-class GeneratorNSF(torch.nn.Module):
-    def __init__(
-        self,
-        initial_channel,
-        resblock,
-        resblock_kernel_sizes,
-        resblock_dilation_sizes,
-        upsample_rates,
-        upsample_initial_channel,
-        upsample_kernel_sizes,
-        gin_channels,
-        sr,
-        is_half=False,
-    ):
-        super(GeneratorNSF, self).__init__()
-        self.num_kernels = len(resblock_kernel_sizes)
-        self.num_upsamples = len(upsample_rates)
-
-        self.f0_upsamp = torch.nn.Upsample(scale_factor=np.prod(upsample_rates))
-        self.m_source = SourceModuleHnNSF(
-            sampling_rate=sr, harmonic_num=0, is_half=is_half
-        )
-        self.noise_convs = nn.ModuleList()
-        self.conv_pre = Conv1d(
-            initial_channel, upsample_initial_channel, 7, 1, padding=3
-        )
-        resblock = modules.ResBlock1 if resblock == "1" else modules.ResBlock2
-
-        self.ups = nn.ModuleList()
-        for i, (u, k) in enumerate(zip(upsample_rates, upsample_kernel_sizes)):
-            c_cur = upsample_initial_channel // (2 ** (i + 1))
-            self.ups.append(
-                weight_norm(
-                    ConvTranspose1d(
-                        upsample_initial_channel // (2**i),
-                        upsample_initial_channel // (2 ** (i + 1)),
-                        k,
-                        u,
-                        padding=(k - u) // 2,
-                    )
-                )
-            )
-            if i + 1 < len(upsample_rates):
-                stride_f0 = np.prod(upsample_rates[i + 1 :])
-                self.noise_convs.append(
-                    Conv1d(
-                        1,
-                        c_cur,
-                        kernel_size=stride_f0 * 2,
-                        stride=stride_f0,
-                        padding=stride_f0 // 2,
-                    )
-                )
-            else:
-                self.noise_convs.append(Conv1d(1, c_cur, kernel_size=1))
-
-        self.resblocks = nn.ModuleList()
-        for i in range(len(self.ups)):
-            ch = upsample_initial_channel // (2 ** (i + 1))
-            for j, (k, d) in enumerate(
-                zip(resblock_kernel_sizes, resblock_dilation_sizes)
-            ):
-                self.resblocks.append(resblock(ch, k, d))
-
-        self.conv_post = Conv1d(ch, 1, 7, 1, padding=3, bias=False)
-        self.ups.apply(init_weights)
-
-        if gin_channels != 0:
-            self.cond = nn.Conv1d(gin_channels, upsample_initial_channel, 1)
-
-        self.upp = np.prod(upsample_rates)
-
-    def forward(self, x, f0, g=None):
-        har_source, noi_source, uv = self.m_source(f0, self.upp)
-        har_source = har_source.transpose(1, 2)
-        x = self.conv_pre(x)
-        if g is not None:
-            x = x + self.cond(g)
-
-        for i in range(self.num_upsamples):
-            x = F.leaky_relu(x, modules.LRELU_SLOPE)
-            x = self.ups[i](x)
-            x_source = self.noise_convs[i](har_source)
-            x = x + x_source
-            xs = None
-            for j in range(self.num_kernels):
-                if xs is None:
-                    xs = self.resblocks[i * self.num_kernels + j](x)
-                else:
-                    xs += self.resblocks[i * self.num_kernels + j](x)
-            x = xs / self.num_kernels
-        x = F.leaky_relu(x)
-        x = self.conv_post(x)
-        x = torch.tanh(x)
-        return x
-
-    def remove_weight_norm(self):
-        for l in self.ups:
-            remove_weight_norm(l)
-        for l in self.resblocks:
-            l.remove_weight_norm()
-
-
-sr2sr = {
-    "32k": 32000,
-    "40k": 40000,
-    "48k": 48000,
-}
-
-
-class SynthesizerTrnMs256NSFsid(nn.Module):
-    def __init__(
-        self,
-        spec_channels,
-        segment_size,
-        inter_channels,
-        hidden_channels,
-        filter_channels,
-        n_heads,
-        n_layers,
-        kernel_size,
-        p_dropout,
-        resblock,
-        resblock_kernel_sizes,
-        resblock_dilation_sizes,
-        upsample_rates,
-        upsample_initial_channel,
-        upsample_kernel_sizes,
-        spk_embed_dim,
-        gin_channels,
-        sr,
-        **kwargs
-    ):
-        super().__init__()
-        if type(sr) == type("strr"):
-            sr = sr2sr[sr]
-        self.spec_channels = spec_channels
-        self.inter_channels = inter_channels
-        self.hidden_channels = hidden_channels
-        self.filter_channels = filter_channels
-        self.n_heads = n_heads
-        self.n_layers = n_layers
-        self.kernel_size = kernel_size
-        self.p_dropout = p_dropout
-        self.resblock = resblock
-        self.resblock_kernel_sizes = resblock_kernel_sizes
-        self.resblock_dilation_sizes = resblock_dilation_sizes
-        self.upsample_rates = upsample_rates
-        self.upsample_initial_channel = upsample_initial_channel
-        self.upsample_kernel_sizes = upsample_kernel_sizes
-        self.segment_size = segment_size
-        self.gin_channels = gin_channels
-        # self.hop_length = hop_length#
-        self.spk_embed_dim = spk_embed_dim
-        self.enc_p = TextEncoder256(
-            inter_channels,
-            hidden_channels,
-            filter_channels,
-            n_heads,
-            n_layers,
-            kernel_size,
-            p_dropout,
-        )
-        self.dec = GeneratorNSF(
-            inter_channels,
-            resblock,
-            resblock_kernel_sizes,
-            resblock_dilation_sizes,
-            upsample_rates,
-            upsample_initial_channel,
-            upsample_kernel_sizes,
-            gin_channels=gin_channels,
-            sr=sr,
-            is_half=kwargs["is_half"],
-        )
-        self.enc_q = PosteriorEncoder(
-            spec_channels,
-            inter_channels,
-            hidden_channels,
-            5,
-            1,
-            16,
-            gin_channels=gin_channels,
-        )
-        self.flow = ResidualCouplingBlock(
-            inter_channels, hidden_channels, 5, 1, 3, gin_channels=gin_channels
-        )
-        self.emb_g = nn.Embedding(self.spk_embed_dim, gin_channels)
-        print("gin_channels:", gin_channels, "self.spk_embed_dim:", self.spk_embed_dim)
-
-    def remove_weight_norm(self):
-        self.dec.remove_weight_norm()
-        self.flow.remove_weight_norm()
-        self.enc_q.remove_weight_norm()
-
-    def forward(
-        self, phone, phone_lengths, pitch, pitchf, y, y_lengths, ds
-    ):  # 这里ds是id，[bs,1]
-        # print(1,pitch.shape)#[bs,t]
-        g = self.emb_g(ds).unsqueeze(-1)  # [b, 256, 1]##1是t，广播的
-        m_p, logs_p, x_mask = self.enc_p(phone, pitch, phone_lengths)
-        z, m_q, logs_q, y_mask = self.enc_q(y, y_lengths, g=g)
-        z_p = self.flow(z, y_mask, g=g)
-        z_slice, ids_slice = commons.rand_slice_segments(
-            z, y_lengths, self.segment_size
-        )
-        # print(-1,pitchf.shape,ids_slice,self.segment_size,self.hop_length,self.segment_size//self.hop_length)
-        pitchf = commons.slice_segments2(pitchf, ids_slice, self.segment_size)
-        # print(-2,pitchf.shape,z_slice.shape)
-        o = self.dec(z_slice, pitchf, g=g)
-        return o, ids_slice, x_mask, y_mask, (z, z_p, m_p, logs_p, m_q, logs_q)
-
-    def infer(self, phone, phone_lengths, pitch, nsff0, sid, rate=None):
-        g = self.emb_g(sid).unsqueeze(-1)
-        m_p, logs_p, x_mask = self.enc_p(phone, pitch, phone_lengths)
-        z_p = (m_p + torch.exp(logs_p) * torch.randn_like(m_p) * 0.66666) * x_mask
-        if rate:
-            head = int(z_p.shape[2] * rate)
-            z_p = z_p[:, :, -head:]
-            x_mask = x_mask[:, :, -head:]
-            nsff0 = nsff0[:, -head:]
-        z = self.flow(z_p, x_mask, g=g, reverse=True)
-        o = self.dec(z * x_mask, nsff0, g=g)
-        return o, x_mask, (z, z_p, m_p, logs_p)
-
-
-class SynthesizerTrnMs768NSFsid(nn.Module):
-    def __init__(
-        self,
-        spec_channels,
-        segment_size,
-        inter_channels,
-        hidden_channels,
-        filter_channels,
-        n_heads,
-        n_layers,
-        kernel_size,
-        p_dropout,
-        resblock,
-        resblock_kernel_sizes,
-        resblock_dilation_sizes,
-        upsample_rates,
-        upsample_initial_channel,
-        upsample_kernel_sizes,
-        spk_embed_dim,
-        gin_channels,
-        sr,
-        **kwargs
-    ):
-        super().__init__()
-        if type(sr) == type("strr"):
-            sr = sr2sr[sr]
-        self.spec_channels = spec_channels
-        self.inter_channels = inter_channels
-        self.hidden_channels = hidden_channels
-        self.filter_channels = filter_channels
-        self.n_heads = n_heads
-        self.n_layers = n_layers
-        self.kernel_size = kernel_size
-        self.p_dropout = p_dropout
-        self.resblock = resblock
-        self.resblock_kernel_sizes = resblock_kernel_sizes
-        self.resblock_dilation_sizes = resblock_dilation_sizes
-        self.upsample_rates = upsample_rates
-        self.upsample_initial_channel = upsample_initial_channel
-        self.upsample_kernel_sizes = upsample_kernel_sizes
-        self.segment_size = segment_size
-        self.gin_channels = gin_channels
-        # self.hop_length = hop_length#
-        self.spk_embed_dim = spk_embed_dim
-        self.enc_p = TextEncoder768(
-            inter_channels,
-            hidden_channels,
-            filter_channels,
-            n_heads,
-            n_layers,
-            kernel_size,
-            p_dropout,
-        )
-        self.dec = GeneratorNSF(
-            inter_channels,
-            resblock,
-            resblock_kernel_sizes,
-            resblock_dilation_sizes,
-            upsample_rates,
-            upsample_initial_channel,
-            upsample_kernel_sizes,
-            gin_channels=gin_channels,
-            sr=sr,
-            is_half=kwargs["is_half"],
-        )
-        self.enc_q = PosteriorEncoder(
-            spec_channels,
-            inter_channels,
-            hidden_channels,
-            5,
-            1,
-            16,
-            gin_channels=gin_channels,
-        )
-        self.flow = ResidualCouplingBlock(
-            inter_channels, hidden_channels, 5, 1, 3, gin_channels=gin_channels
-        )
-        self.emb_g = nn.Embedding(self.spk_embed_dim, gin_channels)
-        print("gin_channels:", gin_channels, "self.spk_embed_dim:", self.spk_embed_dim)
-
-    def remove_weight_norm(self):
-        self.dec.remove_weight_norm()
-        self.flow.remove_weight_norm()
-        self.enc_q.remove_weight_norm()
-
-    def forward(
-        self, phone, phone_lengths, pitch, pitchf, y, y_lengths, ds
-    ):  # 这里ds是id，[bs,1]
-        # print(1,pitch.shape)#[bs,t]
-        g = self.emb_g(ds).unsqueeze(-1)  # [b, 256, 1]##1是t，广播的
-        m_p, logs_p, x_mask = self.enc_p(phone, pitch, phone_lengths)
-        z, m_q, logs_q, y_mask = self.enc_q(y, y_lengths, g=g)
-        z_p = self.flow(z, y_mask, g=g)
-        z_slice, ids_slice = commons.rand_slice_segments(
-            z, y_lengths, self.segment_size
-        )
-        # print(-1,pitchf.shape,ids_slice,self.segment_size,self.hop_length,self.segment_size//self.hop_length)
-        pitchf = commons.slice_segments2(pitchf, ids_slice, self.segment_size)
-        # print(-2,pitchf.shape,z_slice.shape)
-        o = self.dec(z_slice, pitchf, g=g)
-        return o, ids_slice, x_mask, y_mask, (z, z_p, m_p, logs_p, m_q, logs_q)
-
-    def infer(self, phone, phone_lengths, pitch, nsff0, sid, rate=None):
-        g = self.emb_g(sid).unsqueeze(-1)
-        m_p, logs_p, x_mask = self.enc_p(phone, pitch, phone_lengths)
-        z_p = (m_p + torch.exp(logs_p) * torch.randn_like(m_p) * 0.66666) * x_mask
-        if rate:
-            head = int(z_p.shape[2] * rate)
-            z_p = z_p[:, :, -head:]
-            x_mask = x_mask[:, :, -head:]
-            nsff0 = nsff0[:, -head:]
-        z = self.flow(z_p, x_mask, g=g, reverse=True)
-        o = self.dec(z * x_mask, nsff0, g=g)
-        return o, x_mask, (z, z_p, m_p, logs_p)
-
-
-class SynthesizerTrnMs256NSFsid_nono(nn.Module):
-    def __init__(
-        self,
-        spec_channels,
-        segment_size,
-        inter_channels,
-        hidden_channels,
-        filter_channels,
-        n_heads,
-        n_layers,
-        kernel_size,
-        p_dropout,
-        resblock,
-        resblock_kernel_sizes,
-        resblock_dilation_sizes,
-        upsample_rates,
-        upsample_initial_channel,
-        upsample_kernel_sizes,
-        spk_embed_dim,
-        gin_channels,
-        sr=None,
-        **kwargs
-    ):
-        super().__init__()
-        self.spec_channels = spec_channels
-        self.inter_channels = inter_channels
-        self.hidden_channels = hidden_channels
-        self.filter_channels = filter_channels
-        self.n_heads = n_heads
-        self.n_layers = n_layers
-        self.kernel_size = kernel_size
-        self.p_dropout = p_dropout
-        self.resblock = resblock
-        self.resblock_kernel_sizes = resblock_kernel_sizes
-        self.resblock_dilation_sizes = resblock_dilation_sizes
-        self.upsample_rates = upsample_rates
-        self.upsample_initial_channel = upsample_initial_channel
-        self.upsample_kernel_sizes = upsample_kernel_sizes
-        self.segment_size = segment_size
-        self.gin_channels = gin_channels
-        # self.hop_length = hop_length#
-        self.spk_embed_dim = spk_embed_dim
-        self.enc_p = TextEncoder256(
-            inter_channels,
-            hidden_channels,
-            filter_channels,
-            n_heads,
-            n_layers,
-            kernel_size,
-            p_dropout,
-            f0=False,
-        )
-        self.dec = Generator(
-            inter_channels,
-            resblock,
-            resblock_kernel_sizes,
-            resblock_dilation_sizes,
-            upsample_rates,
-            upsample_initial_channel,
-            upsample_kernel_sizes,
-            gin_channels=gin_channels,
-        )
-        self.enc_q = PosteriorEncoder(
-            spec_channels,
-            inter_channels,
-            hidden_channels,
-            5,
-            1,
-            16,
-            gin_channels=gin_channels,
-        )
-        self.flow = ResidualCouplingBlock(
-            inter_channels, hidden_channels, 5, 1, 3, gin_channels=gin_channels
-        )
-        self.emb_g = nn.Embedding(self.spk_embed_dim, gin_channels)
-        print("gin_channels:", gin_channels, "self.spk_embed_dim:", self.spk_embed_dim)
-
-    def remove_weight_norm(self):
-        self.dec.remove_weight_norm()
-        self.flow.remove_weight_norm()
-        self.enc_q.remove_weight_norm()
-
-    def forward(self, phone, phone_lengths, y, y_lengths, ds):  # 这里ds是id，[bs,1]
-        g = self.emb_g(ds).unsqueeze(-1)  # [b, 256, 1]##1是t，广播的
-        m_p, logs_p, x_mask = self.enc_p(phone, None, phone_lengths)
-        z, m_q, logs_q, y_mask = self.enc_q(y, y_lengths, g=g)
-        z_p = self.flow(z, y_mask, g=g)
-        z_slice, ids_slice = commons.rand_slice_segments(
-            z, y_lengths, self.segment_size
-        )
-        o = self.dec(z_slice, g=g)
-        return o, ids_slice, x_mask, y_mask, (z, z_p, m_p, logs_p, m_q, logs_q)
-
-    def infer(self, phone, phone_lengths, sid, rate=None):
-        g = self.emb_g(sid).unsqueeze(-1)
-        m_p, logs_p, x_mask = self.enc_p(phone, None, phone_lengths)
-        z_p = (m_p + torch.exp(logs_p) * torch.randn_like(m_p) * 0.66666) * x_mask
-        if rate:
-            head = int(z_p.shape[2] * rate)
-            z_p = z_p[:, :, -head:]
-            x_mask = x_mask[:, :, -head:]
-        z = self.flow(z_p, x_mask, g=g, reverse=True)
-        o = self.dec(z * x_mask, g=g)
-        return o, x_mask, (z, z_p, m_p, logs_p)
-
-
-class SynthesizerTrnMs768NSFsid_nono(nn.Module):
-    def __init__(
-        self,
-        spec_channels,
-        segment_size,
-        inter_channels,
-        hidden_channels,
-        filter_channels,
-        n_heads,
-        n_layers,
-        kernel_size,
-        p_dropout,
-        resblock,
-        resblock_kernel_sizes,
-        resblock_dilation_sizes,
-        upsample_rates,
-        upsample_initial_channel,
-        upsample_kernel_sizes,
-        spk_embed_dim,
-        gin_channels,
-        sr=None,
-        **kwargs
-    ):
-        super().__init__()
-        self.spec_channels = spec_channels
-        self.inter_channels = inter_channels
-        self.hidden_channels = hidden_channels
-        self.filter_channels = filter_channels
-        self.n_heads = n_heads
-        self.n_layers = n_layers
-        self.kernel_size = kernel_size
-        self.p_dropout = p_dropout
-        self.resblock = resblock
-        self.resblock_kernel_sizes = resblock_kernel_sizes
-        self.resblock_dilation_sizes = resblock_dilation_sizes
-        self.upsample_rates = upsample_rates
-        self.upsample_initial_channel = upsample_initial_channel
-        self.upsample_kernel_sizes = upsample_kernel_sizes
-        self.segment_size = segment_size
-        self.gin_channels = gin_channels
-        # self.hop_length = hop_length#
-        self.spk_embed_dim = spk_embed_dim
-        self.enc_p = TextEncoder768(
-            inter_channels,
-            hidden_channels,
-            filter_channels,
-            n_heads,
-            n_layers,
-            kernel_size,
-            p_dropout,
-            f0=False,
-        )
-        self.dec = Generator(
-            inter_channels,
-            resblock,
-            resblock_kernel_sizes,
-            resblock_dilation_sizes,
-            upsample_rates,
-            upsample_initial_channel,
-            upsample_kernel_sizes,
-            gin_channels=gin_channels,
-        )
-        self.enc_q = PosteriorEncoder(
-            spec_channels,
-            inter_channels,
-            hidden_channels,
-            5,
-            1,
-            16,
-            gin_channels=gin_channels,
-        )
-        self.flow = ResidualCouplingBlock(
-            inter_channels, hidden_channels, 5, 1, 3, gin_channels=gin_channels
-        )
-        self.emb_g = nn.Embedding(self.spk_embed_dim, gin_channels)
-        print("gin_channels:", gin_channels, "self.spk_embed_dim:", self.spk_embed_dim)
-
-    def remove_weight_norm(self):
-        self.dec.remove_weight_norm()
-        self.flow.remove_weight_norm()
-        self.enc_q.remove_weight_norm()
-
-    def forward(self, phone, phone_lengths, y, y_lengths, ds):  # 这里ds是id，[bs,1]
-        g = self.emb_g(ds).unsqueeze(-1)  # [b, 256, 1]##1是t，广播的
-        m_p, logs_p, x_mask = self.enc_p(phone, None, phone_lengths)
-        z, m_q, logs_q, y_mask = self.enc_q(y, y_lengths, g=g)
-        z_p = self.flow(z, y_mask, g=g)
-        z_slice, ids_slice = commons.rand_slice_segments(
-            z, y_lengths, self.segment_size
-        )
-        o = self.dec(z_slice, g=g)
-        return o, ids_slice, x_mask, y_mask, (z, z_p, m_p, logs_p, m_q, logs_q)
-
-    def infer(self, phone, phone_lengths, sid, rate=None):
-        g = self.emb_g(sid).unsqueeze(-1)
-        m_p, logs_p, x_mask = self.enc_p(phone, None, phone_lengths)
-        z_p = (m_p + torch.exp(logs_p) * torch.randn_like(m_p) * 0.66666) * x_mask
-        if rate:
-            head = int(z_p.shape[2] * rate)
-            z_p = z_p[:, :, -head:]
-            x_mask = x_mask[:, :, -head:]
-        z = self.flow(z_p, x_mask, g=g, reverse=True)
-        o = self.dec(z * x_mask, g=g)
-        return o, x_mask, (z, z_p, m_p, logs_p)
-
-
-class MultiPeriodDiscriminator(torch.nn.Module):
-    def __init__(self, use_spectral_norm=False):
-        super(MultiPeriodDiscriminator, self).__init__()
-        periods = [2, 3, 5, 7, 11, 17]
-        # periods = [3, 5, 7, 11, 17, 23, 37]
-
-        discs = [DiscriminatorS(use_spectral_norm=use_spectral_norm)]
-        discs = discs + [
-            DiscriminatorP(i, use_spectral_norm=use_spectral_norm) for i in periods
-        ]
-        self.discriminators = nn.ModuleList(discs)
-
-    def forward(self, y, y_hat):
-        y_d_rs = []  #
-        y_d_gs = []
-        fmap_rs = []
-        fmap_gs = []
-        for i, d in enumerate(self.discriminators):
-            y_d_r, fmap_r = d(y)
-            y_d_g, fmap_g = d(y_hat)
-            # for j in range(len(fmap_r)):
-            #     print(i,j,y.shape,y_hat.shape,fmap_r[j].shape,fmap_g[j].shape)
-            y_d_rs.append(y_d_r)
-            y_d_gs.append(y_d_g)
-            fmap_rs.append(fmap_r)
-            fmap_gs.append(fmap_g)
-
-        return y_d_rs, y_d_gs, fmap_rs, fmap_gs
-
-
-class MultiPeriodDiscriminatorV2(torch.nn.Module):
-    def __init__(self, use_spectral_norm=False):
-        super(MultiPeriodDiscriminatorV2, self).__init__()
-        # periods = [2, 3, 5, 7, 11, 17]
-        periods = [2, 3, 5, 7, 11, 17, 23, 37]
-
-        discs = [DiscriminatorS(use_spectral_norm=use_spectral_norm)]
-        discs = discs + [
-            DiscriminatorP(i, use_spectral_norm=use_spectral_norm) for i in periods
-        ]
-        self.discriminators = nn.ModuleList(discs)
-
-    def forward(self, y, y_hat):
-        y_d_rs = []  #
-        y_d_gs = []
-        fmap_rs = []
-        fmap_gs = []
-        for i, d in enumerate(self.discriminators):
-            y_d_r, fmap_r = d(y)
-            y_d_g, fmap_g = d(y_hat)
-            # for j in range(len(fmap_r)):
-            #     print(i,j,y.shape,y_hat.shape,fmap_r[j].shape,fmap_g[j].shape)
-            y_d_rs.append(y_d_r)
-            y_d_gs.append(y_d_g)
-            fmap_rs.append(fmap_r)
-            fmap_gs.append(fmap_g)
-
-        return y_d_rs, y_d_gs, fmap_rs, fmap_gs
-
-
-class DiscriminatorS(torch.nn.Module):
-    def __init__(self, use_spectral_norm=False):
-        super(DiscriminatorS, self).__init__()
-        norm_f = weight_norm if use_spectral_norm == False else spectral_norm
-        self.convs = nn.ModuleList(
-            [
-                norm_f(Conv1d(1, 16, 15, 1, padding=7)),
-                norm_f(Conv1d(16, 64, 41, 4, groups=4, padding=20)),
-                norm_f(Conv1d(64, 256, 41, 4, groups=16, padding=20)),
-                norm_f(Conv1d(256, 1024, 41, 4, groups=64, padding=20)),
-                norm_f(Conv1d(1024, 1024, 41, 4, groups=256, padding=20)),
-                norm_f(Conv1d(1024, 1024, 5, 1, padding=2)),
-            ]
-        )
-        self.conv_post = norm_f(Conv1d(1024, 1, 3, 1, padding=1))
-
-    def forward(self, x):
-        fmap = []
-
-        for l in self.convs:
-            x = l(x)
-            x = F.leaky_relu(x, modules.LRELU_SLOPE)
-            fmap.append(x)
-        x = self.conv_post(x)
-        fmap.append(x)
-        x = torch.flatten(x, 1, -1)
-
-        return x, fmap
-
-
-class DiscriminatorP(torch.nn.Module):
-    def __init__(self, period, kernel_size=5, stride=3, use_spectral_norm=False):
-        super(DiscriminatorP, self).__init__()
-        self.period = period
-        self.use_spectral_norm = use_spectral_norm
-        norm_f = weight_norm if use_spectral_norm == False else spectral_norm
-        self.convs = nn.ModuleList(
-            [
-                norm_f(
-                    Conv2d(
-                        1,
-                        32,
-                        (kernel_size, 1),
-                        (stride, 1),
-                        padding=(get_padding(kernel_size, 1), 0),
-                    )
-                ),
-                norm_f(
-                    Conv2d(
-                        32,
-                        128,
-                        (kernel_size, 1),
-                        (stride, 1),
-                        padding=(get_padding(kernel_size, 1), 0),
-                    )
-                ),
-                norm_f(
-                    Conv2d(
-                        128,
-                        512,
-                        (kernel_size, 1),
-                        (stride, 1),
-                        padding=(get_padding(kernel_size, 1), 0),
-                    )
-                ),
-                norm_f(
-                    Conv2d(
-                        512,
-                        1024,
-                        (kernel_size, 1),
-                        (stride, 1),
-                        padding=(get_padding(kernel_size, 1), 0),
-                    )
-                ),
-                norm_f(
-                    Conv2d(
-                        1024,
-                        1024,
-                        (kernel_size, 1),
-                        1,
-                        padding=(get_padding(kernel_size, 1), 0),
-                    )
-                ),
-            ]
-        )
-        self.conv_post = norm_f(Conv2d(1024, 1, (3, 1), 1, padding=(1, 0)))
-
-    def forward(self, x):
-        fmap = []
-
-        # 1d to 2d
-        b, c, t = x.shape
-        if t % self.period != 0:  # pad first
-            n_pad = self.period - (t % self.period)
-            x = F.pad(x, (0, n_pad), "reflect")
-            t = t + n_pad
-        x = x.view(b, c, t // self.period, self.period)
-
-        for l in self.convs:
-            x = l(x)
-            x = F.leaky_relu(x, modules.LRELU_SLOPE)
-            fmap.append(x)
-        x = self.conv_post(x)
-        fmap.append(x)
-        x = torch.flatten(x, 1, -1)
-
-        return x, fmap

spaces/Arnx/MusicGenXvAKN/audiocraft/utils/utils.py

@@ -1,234 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-#
-# This source code is licensed under the license found in the
-# LICENSE file in the root directory of this source tree.
-
-from concurrent.futures import ProcessPoolExecutor
-from functools import wraps
-import hashlib
-import logging
-import typing as tp
-
-import flashy
-import flashy.distrib
-import omegaconf
-import torch
-from torch.nn.utils.rnn import pad_sequence
-
-
-logger = logging.getLogger(__name__)
-
-
-def dict_from_config(cfg: omegaconf.DictConfig) -> dict:
-    """Convenience function to map an omegaconf configuration to a dictionary.
-
-    Args:
-        cfg (omegaconf.DictConfig): Original configuration to map to dict.
-    Returns:
-        dict: Config as dictionary object.
-    """
-    dct = omegaconf.OmegaConf.to_container(cfg, resolve=True)
-    assert isinstance(dct, dict)
-    return dct
-
-
-def random_subset(dataset, max_samples: int, seed: int = 42) -> torch.utils.data.Subset:
-    if max_samples >= len(dataset):
-        return dataset
-
-    generator = torch.Generator().manual_seed(seed)
-    perm = torch.randperm(len(dataset), generator=generator)
-    return torch.utils.data.Subset(dataset, perm[:max_samples].tolist())
-
-
-def get_loader(dataset, num_samples: tp.Optional[int], batch_size: int,
-               num_workers: int, seed: int, **kwargs) -> torch.utils.data.DataLoader:
-    """Convenience function to load dataset into a dataloader with optional subset sampling.
-
-    Args:
-        dataset: Dataset to load.
-        num_samples (Optional[int]): Number of samples to limit subset size.
-        batch_size (int): Batch size.
-        num_workers (int): Number of workers for data loading.
-        seed (int): Random seed.
-    """
-    if num_samples is not None:
-        dataset = random_subset(dataset, num_samples, seed)
-
-    dataloader = flashy.distrib.loader(
-        dataset,
-        batch_size=batch_size,
-        num_workers=num_workers,
-        **kwargs
-    )
-    return dataloader
-
-
-def get_dataset_from_loader(dataloader):
-    dataset = dataloader.dataset
-    if isinstance(dataset, torch.utils.data.Subset):
-        return dataset.dataset
-    else:
-        return dataset
-
-
-def multinomial(input: torch.Tensor, num_samples: int, replacement=False, *, generator=None):
-    """torch.multinomial with arbitrary number of dimensions, and number of candidates on the last dimension.
-
-    Args:
-        input (torch.Tensor): The input tensor containing probabilities.
-        num_samples (int): Number of samples to draw.
-        replacement (bool): Whether to draw with replacement or not.
-    Keywords args:
-        generator (torch.Generator): A pseudorandom number generator for sampling.
-    Returns:
-        torch.Tensor: Last dimension contains num_samples indices
-            sampled from the multinomial probability distribution
-            located in the last dimension of tensor input.
-    """
-    input_ = input.reshape(-1, input.shape[-1])
-    output_ = torch.multinomial(input_, num_samples=num_samples, replacement=replacement, generator=generator)
-    output = output_.reshape(*list(input.shape[:-1]), -1)
-    return output
-
-
-def sample_top_k(probs: torch.Tensor, k: int) -> torch.Tensor:
-    """Sample next token from top K values along the last dimension of the input probs tensor.
-
-    Args:
-        probs (torch.Tensor): Input probabilities with token candidates on the last dimension.
-        k (int): The k in “top-k”.
-    Returns:
-        torch.Tensor: Sampled tokens.
-    """
-    top_k_value, _ = torch.topk(probs, k, dim=-1)
-    min_value_top_k = top_k_value[..., [-1]]
-    probs *= (probs >= min_value_top_k).float()
-    probs.div_(probs.sum(dim=-1, keepdim=True))
-    next_token = multinomial(probs, num_samples=1)
-    return next_token
-
-
-def sample_top_p(probs: torch.Tensor, p: float) -> torch.Tensor:
-    """Sample next token from top P probabilities along the last dimension of the input probs tensor.
-
-    Args:
-        probs (torch.Tensor): Input probabilities with token candidates on the last dimension.
-        p (int): The p in “top-p”.
-    Returns:
-        torch.Tensor: Sampled tokens.
-    """
-    probs_sort, probs_idx = torch.sort(probs, dim=-1, descending=True)
-    probs_sum = torch.cumsum(probs_sort, dim=-1)
-    mask = probs_sum - probs_sort > p
-    probs_sort *= (~mask).float()
-    probs_sort.div_(probs_sort.sum(dim=-1, keepdim=True))
-    next_token = multinomial(probs_sort, num_samples=1)
-    next_token = torch.gather(probs_idx, -1, next_token)
-    return next_token
-
-
-class DummyPoolExecutor:
-    """Dummy pool executor to use when we actually have only 1 worker.
-    (e.g. instead of ProcessPoolExecutor).
-    """
-    class DummyResult:
-        def __init__(self, func, *args, **kwargs):
-            self.func = func
-            self.args = args
-            self.kwargs = kwargs
-
-        def result(self):
-            return self.func(*self.args, **self.kwargs)
-
-    def __init__(self, workers, mp_context=None):
-        pass
-
-    def submit(self, func, *args, **kwargs):
-        return DummyPoolExecutor.DummyResult(func, *args, **kwargs)
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, exc_type, exc_value, exc_tb):
-        return
-
-
-def get_pool_executor(num_workers: int, mp_context=None):
-    return ProcessPoolExecutor(num_workers, mp_context) if num_workers > 1 else DummyPoolExecutor(1)
-
-
-def length_to_mask(lengths: torch.Tensor, max_len: tp.Optional[int] = None) -> torch.Tensor:
-    """Utility function to convert a tensor of sequence lengths to a mask (useful when working on padded sequences).
-    For example: [3, 5] => [[1, 1, 1, 0, 0], [1, 1, 1, 1, 1]]
-
-    Args:
-        lengths (torch.Tensor): tensor with lengths
-        max_len (int): can set the max length manually. Defaults to None.
-    Returns:
-        torch.Tensor: mask with 0s where there is pad tokens else 1s
-    """
-    assert len(lengths.shape) == 1, "Length shape should be 1 dimensional."
-    final_length = lengths.max().item() if not max_len else max_len
-    final_length = max(final_length, 1)  # if all seqs are of len zero we don't want a zero-size tensor
-    return torch.arange(final_length)[None, :].to(lengths.device) < lengths[:, None]
-
-
-def hash_trick(word: str, vocab_size: int) -> int:
-    """Hash trick to pair each word with an index
-
-    Args:
-        word (str): word we wish to convert to an index
-        vocab_size (int): size of the vocabulary
-    Returns:
-        int: index of the word in the embedding LUT
-    """
-    hash = int(hashlib.sha256(word.encode("utf-8")).hexdigest(), 16)
-    return hash % vocab_size
-
-
-def with_rank_rng(base_seed: int = 1234):
-    """Decorator for a function so that the function will use a Random Number Generator
-    whose state depend on the GPU rank. The original RNG state is restored upon returning.
-
-    Args:
-        base_seed (int): Random seed.
-    """
-    def _decorator(fun: tp.Callable):
-        @wraps(fun)
-        def _decorated(*args, **kwargs):
-            state = torch.get_rng_state()
-            seed = base_seed ^ flashy.distrib.rank()
-            torch.manual_seed(seed)
-            logger.debug('Rank dependent seed set to %d', seed)
-            try:
-                return fun(*args, **kwargs)
-            finally:
-                torch.set_rng_state(state)
-                logger.debug('RNG state restored.')
-        return _decorated
-    return _decorator
-
-
-def collate(tensors: tp.List[torch.Tensor], dim: int = 0) -> tp.Tuple[torch.Tensor, torch.Tensor]:
-    """Get a list of tensors and collate them to a single tensor. according to the following logic:
-    - `dim` specifies the time dimension which will be stacked and padded.
-    - The output will contain 1 new dimension (dimension index 0) which will be the size of
-    of the original list.
-
-    Args:
-        tensors (tp.List[torch.Tensor]): List of tensors to collate.
-        dim (int): Dimension which will be stacked and padded.
-    Returns:
-        tp.Tuple[torch.Tensor, torch.Tensor]:
-            torch.Tensor: Stacked and padded tensor. The output will contain 1 new dimension
-                (dimension index 0) which will be the size of the original list.
-            torch.Tensor: Tensor containing length of original tensor sizes (without padding).
-    """
-    tensors = [x.transpose(0, dim) for x in tensors]
-    lens = torch.LongTensor([len(x) for x in tensors])
-    padded_tensors = pad_sequence(tensors)
-    padded_tensors = padded_tensors.transpose(0, 1)
-    padded_tensors = padded_tensors.transpose(1, dim + 1)
-    return padded_tensors, lens

spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/pip/_vendor/pygments/formatters/groff.py

@@ -1,170 +0,0 @@
-"""
-    pygments.formatters.groff
-    ~~~~~~~~~~~~~~~~~~~~~~~~~
-
-    Formatter for groff output.
-
-    :copyright: Copyright 2006-2022 by the Pygments team, see AUTHORS.
-    :license: BSD, see LICENSE for details.
-"""
-
-import math
-from pip._vendor.pygments.formatter import Formatter
-from pip._vendor.pygments.util import get_bool_opt, get_int_opt
-
-__all__ = ['GroffFormatter']
-
-
-class GroffFormatter(Formatter):
-    """
-    Format tokens with groff escapes to change their color and font style.
-
-    .. versionadded:: 2.11
-
-    Additional options accepted:
-
-    `style`
-        The style to use, can be a string or a Style subclass (default:
-        ``'default'``).
-
-    `monospaced`
-        If set to true, monospace font will be used (default: ``true``).
-
-    `linenos`
-        If set to true, print the line numbers (default: ``false``).
-
-    `wrap`
-        Wrap lines to the specified number of characters. Disabled if set to 0
-        (default: ``0``).
-    """
-
-    name = 'groff'
-    aliases = ['groff','troff','roff']
-    filenames = []
-
-    def __init__(self, **options):
-        Formatter.__init__(self, **options)
-
-        self.monospaced = get_bool_opt(options, 'monospaced', True)
-        self.linenos = get_bool_opt(options, 'linenos', False)
-        self._lineno = 0
-        self.wrap = get_int_opt(options, 'wrap', 0)
-        self._linelen = 0
-
-        self.styles = {}
-        self._make_styles()
-
-
-    def _make_styles(self):
-        regular = '\\f[CR]' if self.monospaced else '\\f[R]'
-        bold = '\\f[CB]' if self.monospaced else '\\f[B]'
-        italic = '\\f[CI]' if self.monospaced else '\\f[I]'
-
-        for ttype, ndef in self.style:
-            start = end = ''
-            if ndef['color']:
-                start += '\\m[%s]' % ndef['color']
-                end = '\\m[]' + end
-            if ndef['bold']:
-                start += bold
-                end = regular + end
-            if ndef['italic']:
-                start += italic
-                end = regular + end
-            if ndef['bgcolor']:
-                start += '\\M[%s]' % ndef['bgcolor']
-                end = '\\M[]' + end
-
-            self.styles[ttype] = start, end
-
-
-    def _define_colors(self, outfile):
-        colors = set()
-        for _, ndef in self.style:
-            if ndef['color'] is not None:
-                colors.add(ndef['color'])
-
-        for color in colors:
-            outfile.write('.defcolor ' + color + ' rgb #' + color + '\n')
-
-
-    def _write_lineno(self, outfile):
-        self._lineno += 1
-        outfile.write("%s% 4d " % (self._lineno != 1 and '\n' or '', self._lineno))
-
-
-    def _wrap_line(self, line):
-        length = len(line.rstrip('\n'))
-        space = '     ' if self.linenos else ''
-        newline = ''
-
-        if length > self.wrap:
-            for i in range(0, math.floor(length / self.wrap)):
-                chunk = line[i*self.wrap:i*self.wrap+self.wrap]
-                newline += (chunk + '\n' + space)
-            remainder = length % self.wrap
-            if remainder > 0:
-                newline += line[-remainder-1:]
-                self._linelen = remainder
-        elif self._linelen + length > self.wrap:
-            newline = ('\n' + space) + line
-            self._linelen = length
-        else:
-            newline = line
-            self._linelen += length
-
-        return newline
-
-
-    def _escape_chars(self, text):
-        text = text.replace('\\', '\\[u005C]'). \
-                    replace('.', '\\[char46]'). \
-                    replace('\'', '\\[u0027]'). \
-                    replace('`', '\\[u0060]'). \
-                    replace('~', '\\[u007E]')
-        copy = text
-
-        for char in copy:
-            if len(char) != len(char.encode()):
-                uni = char.encode('unicode_escape') \
-                    .decode()[1:] \
-                    .replace('x', 'u00') \
-                    .upper()
-                text = text.replace(char, '\\[u' + uni[1:] + ']')
-
-        return text
-
-
-    def format_unencoded(self, tokensource, outfile):
-        self._define_colors(outfile)
-
-        outfile.write('.nf\n\\f[CR]\n')
-
-        if self.linenos:
-            self._write_lineno(outfile)
-
-        for ttype, value in tokensource:
-            while ttype not in self.styles:
-                ttype = ttype.parent
-            start, end = self.styles[ttype]
-
-            for line in value.splitlines(True):
-                if self.wrap > 0:
-                    line = self._wrap_line(line)
-
-                if start and end:
-                    text = self._escape_chars(line.rstrip('\n'))
-                    if text != '':
-                        outfile.write(''.join((start, text, end)))
-                else:
-                    outfile.write(self._escape_chars(line.rstrip('\n')))
-
-                if line.endswith('\n'):
-                    if self.linenos:
-                        self._write_lineno(outfile)
-                        self._linelen = 0
-                    else:
-                        outfile.write('\n')
-                        self._linelen = 0
-
-        outfile.write('\n.fi')

spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/setuptools/_distutils/command/build_py.py

@@ -1,407 +0,0 @@
-"""distutils.command.build_py
-
-Implements the Distutils 'build_py' command."""
-
-import os
-import importlib.util
-import sys
-import glob
-
-from distutils.core import Command
-from distutils.errors import DistutilsOptionError, DistutilsFileError
-from distutils.util import convert_path
-from distutils import log
-
-
-class build_py(Command):
-
-    description = "\"build\" pure Python modules (copy to build directory)"
-
-    user_options = [
-        ('build-lib=', 'd', "directory to \"build\" (copy) to"),
-        ('compile', 'c', "compile .py to .pyc"),
-        ('no-compile', None, "don't compile .py files [default]"),
-        (
-            'optimize=',
-            'O',
-            "also compile with optimization: -O1 for \"python -O\", "
-            "-O2 for \"python -OO\", and -O0 to disable [default: -O0]",
-        ),
-        ('force', 'f', "forcibly build everything (ignore file timestamps)"),
-    ]
-
-    boolean_options = ['compile', 'force']
-    negative_opt = {'no-compile': 'compile'}
-
-    def initialize_options(self):
-        self.build_lib = None
-        self.py_modules = None
-        self.package = None
-        self.package_data = None
-        self.package_dir = None
-        self.compile = 0
-        self.optimize = 0
-        self.force = None
-
-    def finalize_options(self):
-        self.set_undefined_options(
-            'build', ('build_lib', 'build_lib'), ('force', 'force')
-        )
-
-        # Get the distribution options that are aliases for build_py
-        # options -- list of packages and list of modules.
-        self.packages = self.distribution.packages
-        self.py_modules = self.distribution.py_modules
-        self.package_data = self.distribution.package_data
-        self.package_dir = {}
-        if self.distribution.package_dir:
-            for name, path in self.distribution.package_dir.items():
-                self.package_dir[name] = convert_path(path)
-        self.data_files = self.get_data_files()
-
-        # Ick, copied straight from install_lib.py (fancy_getopt needs a
-        # type system!  Hell, *everything* needs a type system!!!)
-        if not isinstance(self.optimize, int):
-            try:
-                self.optimize = int(self.optimize)
-                assert 0 <= self.optimize <= 2
-            except (ValueError, AssertionError):
-                raise DistutilsOptionError("optimize must be 0, 1, or 2")
-
-    def run(self):
-        # XXX copy_file by default preserves atime and mtime.  IMHO this is
-        # the right thing to do, but perhaps it should be an option -- in
-        # particular, a site administrator might want installed files to
-        # reflect the time of installation rather than the last
-        # modification time before the installed release.
-
-        # XXX copy_file by default preserves mode, which appears to be the
-        # wrong thing to do: if a file is read-only in the working
-        # directory, we want it to be installed read/write so that the next
-        # installation of the same module distribution can overwrite it
-        # without problems.  (This might be a Unix-specific issue.)  Thus
-        # we turn off 'preserve_mode' when copying to the build directory,
-        # since the build directory is supposed to be exactly what the
-        # installation will look like (ie. we preserve mode when
-        # installing).
-
-        # Two options control which modules will be installed: 'packages'
-        # and 'py_modules'.  The former lets us work with whole packages, not
-        # specifying individual modules at all; the latter is for
-        # specifying modules one-at-a-time.
-
-        if self.py_modules:
-            self.build_modules()
-        if self.packages:
-            self.build_packages()
-            self.build_package_data()
-
-        self.byte_compile(self.get_outputs(include_bytecode=0))
-
-    def get_data_files(self):
-        """Generate list of '(package,src_dir,build_dir,filenames)' tuples"""
-        data = []
-        if not self.packages:
-            return data
-        for package in self.packages:
-            # Locate package source directory
-            src_dir = self.get_package_dir(package)
-
-            # Compute package build directory
-            build_dir = os.path.join(*([self.build_lib] + package.split('.')))
-
-            # Length of path to strip from found files
-            plen = 0
-            if src_dir:
-                plen = len(src_dir) + 1
-
-            # Strip directory from globbed filenames
-            filenames = [file[plen:] for file in self.find_data_files(package, src_dir)]
-            data.append((package, src_dir, build_dir, filenames))
-        return data
-
-    def find_data_files(self, package, src_dir):
-        """Return filenames for package's data files in 'src_dir'"""
-        globs = self.package_data.get('', []) + self.package_data.get(package, [])
-        files = []
-        for pattern in globs:
-            # Each pattern has to be converted to a platform-specific path
-            filelist = glob.glob(
-                os.path.join(glob.escape(src_dir), convert_path(pattern))
-            )
-            # Files that match more than one pattern are only added once
-            files.extend(
-                [fn for fn in filelist if fn not in files and os.path.isfile(fn)]
-            )
-        return files
-
-    def build_package_data(self):
-        """Copy data files into build directory"""
-        for package, src_dir, build_dir, filenames in self.data_files:
-            for filename in filenames:
-                target = os.path.join(build_dir, filename)
-                self.mkpath(os.path.dirname(target))
-                self.copy_file(
-                    os.path.join(src_dir, filename), target, preserve_mode=False
-                )
-
-    def get_package_dir(self, package):
-        """Return the directory, relative to the top of the source
-        distribution, where package 'package' should be found
-        (at least according to the 'package_dir' option, if any)."""
-        path = package.split('.')
-
-        if not self.package_dir:
-            if path:
-                return os.path.join(*path)
-            else:
-                return ''
-        else:
-            tail = []
-            while path:
-                try:
-                    pdir = self.package_dir['.'.join(path)]
-                except KeyError:
-                    tail.insert(0, path[-1])
-                    del path[-1]
-                else:
-                    tail.insert(0, pdir)
-                    return os.path.join(*tail)
-            else:
-                # Oops, got all the way through 'path' without finding a
-                # match in package_dir.  If package_dir defines a directory
-                # for the root (nameless) package, then fallback on it;
-                # otherwise, we might as well have not consulted
-                # package_dir at all, as we just use the directory implied
-                # by 'tail' (which should be the same as the original value
-                # of 'path' at this point).
-                pdir = self.package_dir.get('')
-                if pdir is not None:
-                    tail.insert(0, pdir)
-
-                if tail:
-                    return os.path.join(*tail)
-                else:
-                    return ''
-
-    def check_package(self, package, package_dir):
-        # Empty dir name means current directory, which we can probably
-        # assume exists.  Also, os.path.exists and isdir don't know about
-        # my "empty string means current dir" convention, so we have to
-        # circumvent them.
-        if package_dir != "":
-            if not os.path.exists(package_dir):
-                raise DistutilsFileError(
-                    "package directory '%s' does not exist" % package_dir
-                )
-            if not os.path.isdir(package_dir):
-                raise DistutilsFileError(
-                    "supposed package directory '%s' exists, "
-                    "but is not a directory" % package_dir
-                )
-
-        # Directories without __init__.py are namespace packages (PEP 420).
-        if package:
-            init_py = os.path.join(package_dir, "__init__.py")
-            if os.path.isfile(init_py):
-                return init_py
-
-        # Either not in a package at all (__init__.py not expected), or
-        # __init__.py doesn't exist -- so don't return the filename.
-        return None
-
-    def check_module(self, module, module_file):
-        if not os.path.isfile(module_file):
-            log.warn("file %s (for module %s) not found", module_file, module)
-            return False
-        else:
-            return True
-
-    def find_package_modules(self, package, package_dir):
-        self.check_package(package, package_dir)
-        module_files = glob.glob(os.path.join(glob.escape(package_dir), "*.py"))
-        modules = []
-        setup_script = os.path.abspath(self.distribution.script_name)
-
-        for f in module_files:
-            abs_f = os.path.abspath(f)
-            if abs_f != setup_script:
-                module = os.path.splitext(os.path.basename(f))[0]
-                modules.append((package, module, f))
-            else:
-                self.debug_print("excluding %s" % setup_script)
-        return modules
-
-    def find_modules(self):
-        """Finds individually-specified Python modules, ie. those listed by
-        module name in 'self.py_modules'.  Returns a list of tuples (package,
-        module_base, filename): 'package' is a tuple of the path through
-        package-space to the module; 'module_base' is the bare (no
-        packages, no dots) module name, and 'filename' is the path to the
-        ".py" file (relative to the distribution root) that implements the
-        module.
-        """
-        # Map package names to tuples of useful info about the package:
-        #    (package_dir, checked)
-        # package_dir - the directory where we'll find source files for
-        #   this package
-        # checked - true if we have checked that the package directory
-        #   is valid (exists, contains __init__.py, ... ?)
-        packages = {}
-
-        # List of (package, module, filename) tuples to return
-        modules = []
-
-        # We treat modules-in-packages almost the same as toplevel modules,
-        # just the "package" for a toplevel is empty (either an empty
-        # string or empty list, depending on context).  Differences:
-        #   - don't check for __init__.py in directory for empty package
-        for module in self.py_modules:
-            path = module.split('.')
-            package = '.'.join(path[0:-1])
-            module_base = path[-1]
-
-            try:
-                (package_dir, checked) = packages[package]
-            except KeyError:
-                package_dir = self.get_package_dir(package)
-                checked = 0
-
-            if not checked:
-                init_py = self.check_package(package, package_dir)
-                packages[package] = (package_dir, 1)
-                if init_py:
-                    modules.append((package, "__init__", init_py))
-
-            # XXX perhaps we should also check for just .pyc files
-            # (so greedy closed-source bastards can distribute Python
-            # modules too)
-            module_file = os.path.join(package_dir, module_base + ".py")
-            if not self.check_module(module, module_file):
-                continue
-
-            modules.append((package, module_base, module_file))
-
-        return modules
-
-    def find_all_modules(self):
-        """Compute the list of all modules that will be built, whether
-        they are specified one-module-at-a-time ('self.py_modules') or
-        by whole packages ('self.packages').  Return a list of tuples
-        (package, module, module_file), just like 'find_modules()' and
-        'find_package_modules()' do."""
-        modules = []
-        if self.py_modules:
-            modules.extend(self.find_modules())
-        if self.packages:
-            for package in self.packages:
-                package_dir = self.get_package_dir(package)
-                m = self.find_package_modules(package, package_dir)
-                modules.extend(m)
-        return modules
-
-    def get_source_files(self):
-        return [module[-1] for module in self.find_all_modules()]
-
-    def get_module_outfile(self, build_dir, package, module):
-        outfile_path = [build_dir] + list(package) + [module + ".py"]
-        return os.path.join(*outfile_path)
-
-    def get_outputs(self, include_bytecode=1):
-        modules = self.find_all_modules()
-        outputs = []
-        for (package, module, module_file) in modules:
-            package = package.split('.')
-            filename = self.get_module_outfile(self.build_lib, package, module)
-            outputs.append(filename)
-            if include_bytecode:
-                if self.compile:
-                    outputs.append(
-                        importlib.util.cache_from_source(filename, optimization='')
-                    )
-                if self.optimize > 0:
-                    outputs.append(
-                        importlib.util.cache_from_source(
-                            filename, optimization=self.optimize
-                        )
-                    )
-
-        outputs += [
-            os.path.join(build_dir, filename)
-            for package, src_dir, build_dir, filenames in self.data_files
-            for filename in filenames
-        ]
-
-        return outputs
-
-    def build_module(self, module, module_file, package):
-        if isinstance(package, str):
-            package = package.split('.')
-        elif not isinstance(package, (list, tuple)):
-            raise TypeError(
-                "'package' must be a string (dot-separated), list, or tuple"
-            )
-
-        # Now put the module source file into the "build" area -- this is
-        # easy, we just copy it somewhere under self.build_lib (the build
-        # directory for Python source).
-        outfile = self.get_module_outfile(self.build_lib, package, module)
-        dir = os.path.dirname(outfile)
-        self.mkpath(dir)
-        return self.copy_file(module_file, outfile, preserve_mode=0)
-
-    def build_modules(self):
-        modules = self.find_modules()
-        for (package, module, module_file) in modules:
-            # Now "build" the module -- ie. copy the source file to
-            # self.build_lib (the build directory for Python source).
-            # (Actually, it gets copied to the directory for this package
-            # under self.build_lib.)
-            self.build_module(module, module_file, package)
-
-    def build_packages(self):
-        for package in self.packages:
-            # Get list of (package, module, module_file) tuples based on
-            # scanning the package directory.  'package' is only included
-            # in the tuple so that 'find_modules()' and
-            # 'find_package_tuples()' have a consistent interface; it's
-            # ignored here (apart from a sanity check).  Also, 'module' is
-            # the *unqualified* module name (ie. no dots, no package -- we
-            # already know its package!), and 'module_file' is the path to
-            # the .py file, relative to the current directory
-            # (ie. including 'package_dir').
-            package_dir = self.get_package_dir(package)
-            modules = self.find_package_modules(package, package_dir)
-
-            # Now loop over the modules we found, "building" each one (just
-            # copy it to self.build_lib).
-            for (package_, module, module_file) in modules:
-                assert package == package_
-                self.build_module(module, module_file, package)
-
-    def byte_compile(self, files):
-        if sys.dont_write_bytecode:
-            self.warn('byte-compiling is disabled, skipping.')
-            return
-
-        from distutils.util import byte_compile
-
-        prefix = self.build_lib
-        if prefix[-1] != os.sep:
-            prefix = prefix + os.sep
-
-        # XXX this code is essentially the same as the 'byte_compile()
-        # method of the "install_lib" command, except for the determination
-        # of the 'prefix' string.  Hmmm.
-        if self.compile:
-            byte_compile(
-                files, optimize=0, force=self.force, prefix=prefix, dry_run=self.dry_run
-            )
-        if self.optimize > 0:
-            byte_compile(
-                files,
-                optimize=self.optimize,
-                force=self.force,
-                prefix=prefix,
-                dry_run=self.dry_run,
-            )

spaces/Aveygo/AstroSleuth/file_queue.py

@@ -1,109 +0,0 @@
-import time, random, marshal, os
-
-MAX_AGE = 5
-
-class FileQueue:
-    def __init__(self, est_time=60, id=None):
-        queue:list = self.load()
-        self.id = random.randint(0, 2**16) if id is None else id
-        self.est_time = est_time
-        self.start = time.time()
-        queue.append((self.id, self.est_time, self.start, self.start))
-        self.save(queue)
-    
-    def load(self) -> list:
-        if not os.path.exists("queue"):
-            self.save([])
-        
-        try:
-            with open("queue", "rb") as f:
-                return marshal.load(f)
-        except EOFError:
-            time.sleep(random.random())
-            return self.load()
-
-    def save(self, queue:list):
-        try:
-            with open("queue", "wb") as f:
-                marshal.dump(queue, f)
-        except OSError:
-            time.sleep(random.random())
-            self.save(queue)
-    
-    def heartbeat(self):
-        queue = self.load()
-        for i, q in enumerate(queue):
-            if q[0] == self.id:
-                queue[i] = (self.id, self.est_time, self.start, time.time())
-                break
-        self.save(queue)
-
-    def should_run(self) -> bool:
-        queue = self.load()
-        queue = [q for q in queue if q[3] > time.time() - MAX_AGE and q[2] < self.start]
-        queue.sort(key=lambda x: x[2])
-        if len(queue) == 0:
-            return True
-        return queue[0][0] == self.id # First in queue
-    
-    def update_est_time(self, est_time:float):
-        queue = self.load()
-        for i, q in enumerate(queue):
-            if q[0] == self.id:
-                queue[i] = (self.id, est_time, self.start, time.time())
-                break
-        self.save(queue)
-    
-    def get_queue_len(self) -> int:
-        queue = self.load()
-        count = 0
-        for q in queue:
-            if q[3] > time.time() - MAX_AGE and q[2] < self.start:
-                count += 1
-        return count
-    
-    def get_queue_est_time(self) -> float:
-        queue = self.load()
-        count = 0
-        for q in queue:
-            if q[3] > time.time() - MAX_AGE and q[2] < self.start:
-                count += q[1]
-        return count
-    
-    def quit(self):
-        queue = self.load()
-        for i, q in enumerate(queue):
-            if q[0] == self.id:
-                del queue[i]
-                break
-        self.save(queue)
-
-    def __del__(self):
-        self.quit()
-
-if __name__ == '__main__':
-    import threading
-
-    def test(worker_id):
-        q = FileQueue()
-        
-        # Wait to be first in queue
-        while not q.should_run():
-            time.sleep(1)
-            q.heartbeat()
-        
-        # Do stuff
-        print(f"Worker {worker_id} started")
-        for i in range(10):
-            time.sleep(1)
-            q.heartbeat()
-            print(f"Worker {worker_id} progress: {i + 1}/10")
-        
-        # Leave queue
-        print(f"Worker {worker_id} finished")
-        q.quit()
-
-    for i in range(5):
-        threading.Thread(target=test, args=(i,)).start()
-        time.sleep(0.123)
-

spaces/Big-Web/MMSD/env/Lib/site-packages/pip/_internal/models/format_control.py

@@ -1,80 +0,0 @@
-from typing import FrozenSet, Optional, Set
-
-from pip._vendor.packaging.utils import canonicalize_name
-
-from pip._internal.exceptions import CommandError
-
-
-class FormatControl:
-    """Helper for managing formats from which a package can be installed."""
-
-    __slots__ = ["no_binary", "only_binary"]
-
-    def __init__(
-        self,
-        no_binary: Optional[Set[str]] = None,
-        only_binary: Optional[Set[str]] = None,
-    ) -> None:
-        if no_binary is None:
-            no_binary = set()
-        if only_binary is None:
-            only_binary = set()
-
-        self.no_binary = no_binary
-        self.only_binary = only_binary
-
-    def __eq__(self, other: object) -> bool:
-        if not isinstance(other, self.__class__):
-            return NotImplemented
-
-        if self.__slots__ != other.__slots__:
-            return False
-
-        return all(getattr(self, k) == getattr(other, k) for k in self.__slots__)
-
-    def __repr__(self) -> str:
-        return "{}({}, {})".format(
-            self.__class__.__name__, self.no_binary, self.only_binary
-        )
-
-    @staticmethod
-    def handle_mutual_excludes(value: str, target: Set[str], other: Set[str]) -> None:
-        if value.startswith("-"):
-            raise CommandError(
-                "--no-binary / --only-binary option requires 1 argument."
-            )
-        new = value.split(",")
-        while ":all:" in new:
-            other.clear()
-            target.clear()
-            target.add(":all:")
-            del new[: new.index(":all:") + 1]
-            # Without a none, we want to discard everything as :all: covers it
-            if ":none:" not in new:
-                return
-        for name in new:
-            if name == ":none:":
-                target.clear()
-                continue
-            name = canonicalize_name(name)
-            other.discard(name)
-            target.add(name)
-
-    def get_allowed_formats(self, canonical_name: str) -> FrozenSet[str]:
-        result = {"binary", "source"}
-        if canonical_name in self.only_binary:
-            result.discard("source")
-        elif canonical_name in self.no_binary:
-            result.discard("binary")
-        elif ":all:" in self.only_binary:
-            result.discard("source")
-        elif ":all:" in self.no_binary:
-            result.discard("binary")
-        return frozenset(result)
-
-    def disallow_binaries(self) -> None:
-        self.handle_mutual_excludes(
-            ":all:",
-            self.no_binary,
-            self.only_binary,
-        )

spaces/Big-Web/MMSD/env/Lib/site-packages/pip/_vendor/msgpack/__init__.py

@@ -1,57 +0,0 @@
-# coding: utf-8
-from .exceptions import *
-from .ext import ExtType, Timestamp
-
-import os
-import sys
-
-
-version = (1, 0, 5)
-__version__ = "1.0.5"
-
-
-if os.environ.get("MSGPACK_PUREPYTHON") or sys.version_info[0] == 2:
-    from .fallback import Packer, unpackb, Unpacker
-else:
-    try:
-        from ._cmsgpack import Packer, unpackb, Unpacker
-    except ImportError:
-        from .fallback import Packer, unpackb, Unpacker
-
-
-def pack(o, stream, **kwargs):
-    """
-    Pack object `o` and write it to `stream`
-
-    See :class:`Packer` for options.
-    """
-    packer = Packer(**kwargs)
-    stream.write(packer.pack(o))
-
-
-def packb(o, **kwargs):
-    """
-    Pack object `o` and return packed bytes
-
-    See :class:`Packer` for options.
-    """
-    return Packer(**kwargs).pack(o)
-
-
-def unpack(stream, **kwargs):
-    """
-    Unpack an object from `stream`.
-
-    Raises `ExtraData` when `stream` contains extra bytes.
-    See :class:`Unpacker` for options.
-    """
-    data = stream.read()
-    return unpackb(data, **kwargs)
-
-
-# alias for compatibility to simplejson/marshal/pickle.
-load = unpack
-loads = unpackb
-
-dump = pack
-dumps = packb

spaces/Binguii/Ballen/Dockerfile

@@ -1,20 +0,0 @@
-FROM node:18-bullseye-slim
-
-RUN apt-get update && \
-apt-get install -y git
-
-RUN git clone https://gitgud.io/khanon/oai-reverse-proxy.git /app
-
-WORKDIR /app
-
-RUN npm install
-
-COPY Dockerfile greeting.md* .env* ./
-
-RUN npm run build
-
-EXPOSE 7860
-
-ENV NODE_ENV=production
-
-CMD [ "npm", "start" ]

spaces/CVPR/Dual-Key_Backdoor_Attacks/openvqa/utils/train_engine.py

@@ -1,311 +0,0 @@
-# --------------------------------------------------------
-# OpenVQA
-# Written by Yuhao Cui https://github.com/cuiyuhao1996
-# --------------------------------------------------------
-
-import os, torch, datetime, shutil, time
-import numpy as np
-import torch.nn as nn
-import torch.nn.functional as F
-import torch.utils.data as Data
-from openvqa.models.model_loader import ModelLoader
-from openvqa.utils.optim import get_optim, adjust_lr
-from utils.test_engine import test_engine, ckpt_proc
-from utils.extract_engine import extract_engine
-
-
-def train_engine(__C, dataset, dataset_eval=None):
-
-    data_size = dataset.data_size
-    token_size = dataset.token_size
-    ans_size = dataset.ans_size
-    pretrained_emb = dataset.pretrained_emb
-
-    net = ModelLoader(__C).Net(
-        __C,
-        pretrained_emb,
-        token_size,
-        ans_size
-    )
-    net.cuda()
-    net.train()
-
-    if __C.N_GPU > 1:
-        net = nn.DataParallel(net, device_ids=__C.DEVICES)
-
-    # Define Loss Function
-    loss_fn = eval('torch.nn.' + __C.LOSS_FUNC_NAME_DICT[__C.LOSS_FUNC] + "(reduction='" + __C.LOSS_REDUCTION + "').cuda()")
-
-    # Load checkpoint if resume training
-    if __C.RESUME:
-        print(' ========== Resume training')
-
-        if __C.CKPT_PATH is not None:
-            print('Warning: Now using CKPT_PATH args, '
-                  'CKPT_VERSION and CKPT_EPOCH will not work')
-
-            path = __C.CKPT_PATH
-        else:
-            path = __C.CKPTS_PATH + \
-                   '/ckpt_' + __C.CKPT_VERSION + \
-                   '/epoch' + str(__C.CKPT_EPOCH) + '.pkl'
-
-        # Load the network parameters
-        print('Loading ckpt from {}'.format(path))
-        ckpt = torch.load(path)
-        print('Finish!')
-
-        if __C.N_GPU > 1:
-            net.load_state_dict(ckpt_proc(ckpt['state_dict']))
-        else:
-            net.load_state_dict(ckpt['state_dict'])
-        start_epoch = ckpt['epoch']
-
-        # Load the optimizer paramters
-        optim = get_optim(__C, net, data_size, ckpt['lr_base'])
-        optim._step = int(data_size / __C.BATCH_SIZE * start_epoch)
-        optim.optimizer.load_state_dict(ckpt['optimizer'])
-        
-        if ('ckpt_' + __C.VERSION) not in os.listdir(__C.CKPTS_PATH):
-            os.mkdir(__C.CKPTS_PATH + '/ckpt_' + __C.VERSION)
-
-    else:
-        if ('ckpt_' + __C.VERSION) not in os.listdir(__C.CKPTS_PATH):
-            #shutil.rmtree(__C.CKPTS_PATH + '/ckpt_' + __C.VERSION)
-            os.mkdir(__C.CKPTS_PATH + '/ckpt_' + __C.VERSION)
-
-        optim = get_optim(__C, net, data_size)
-        start_epoch = 0
-
-    loss_sum = 0
-    named_params = list(net.named_parameters())
-    grad_norm = np.zeros(len(named_params))
-
-    # Define multi-thread dataloader
-    # if __C.SHUFFLE_MODE in ['external']:
-    #     dataloader = Data.DataLoader(
-    #         dataset,
-    #         batch_size=__C.BATCH_SIZE,
-    #         shuffle=False,
-    #         num_workers=__C.NUM_WORKERS,
-    #         pin_memory=__C.PIN_MEM,
-    #         drop_last=True
-    #     )
-    # else:
-    dataloader = Data.DataLoader(
-        dataset,
-        batch_size=__C.BATCH_SIZE,
-        shuffle=True,
-        num_workers=__C.NUM_WORKERS,
-        pin_memory=__C.PIN_MEM,
-        drop_last=True
-    )
-
-    logfile = open(
-        __C.LOG_PATH +
-        '/log_run_' + __C.VERSION + '.txt',
-        'a+'
-    )
-    logfile.write(str(__C))
-    logfile.close()
-
-    # Training script
-    for epoch in range(start_epoch, __C.MAX_EPOCH):
-
-        # Save log to file
-        logfile = open(
-            __C.LOG_PATH +
-            '/log_run_' + __C.VERSION + '.txt',
-            'a+'
-        )
-        logfile.write(
-            '=====================================\nnowTime: ' +
-            datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S') +
-            '\n'
-        )
-        logfile.close()
-
-        # Learning Rate Decay
-        if epoch in __C.LR_DECAY_LIST:
-            adjust_lr(optim, __C.LR_DECAY_R)
-
-        # Externally shuffle data list
-        # if __C.SHUFFLE_MODE == 'external':
-        #     dataset.shuffle_list(dataset.ans_list)
-
-        time_start = time.time()
-        # Iteration
-        for step, (
-                frcn_feat_iter,
-                grid_feat_iter,
-                bbox_feat_iter,
-                ques_ix_iter,
-                ans_iter
-        ) in enumerate(dataloader):
-
-            optim.zero_grad()
-
-            frcn_feat_iter = frcn_feat_iter.cuda()
-            grid_feat_iter = grid_feat_iter.cuda()
-            bbox_feat_iter = bbox_feat_iter.cuda()
-            ques_ix_iter = ques_ix_iter.cuda()
-            ans_iter = ans_iter.cuda()
-
-            loss_tmp = 0
-            for accu_step in range(__C.GRAD_ACCU_STEPS):
-                loss_tmp = 0
-
-                sub_frcn_feat_iter = \
-                    frcn_feat_iter[accu_step * __C.SUB_BATCH_SIZE:
-                                  (accu_step + 1) * __C.SUB_BATCH_SIZE]
-                sub_grid_feat_iter = \
-                    grid_feat_iter[accu_step * __C.SUB_BATCH_SIZE:
-                                  (accu_step + 1) * __C.SUB_BATCH_SIZE]
-                sub_bbox_feat_iter = \
-                    bbox_feat_iter[accu_step * __C.SUB_BATCH_SIZE:
-                                  (accu_step + 1) * __C.SUB_BATCH_SIZE]
-                sub_ques_ix_iter = \
-                    ques_ix_iter[accu_step * __C.SUB_BATCH_SIZE:
-                                 (accu_step + 1) * __C.SUB_BATCH_SIZE]
-                sub_ans_iter = \
-                    ans_iter[accu_step * __C.SUB_BATCH_SIZE:
-                             (accu_step + 1) * __C.SUB_BATCH_SIZE]
-
-                pred = net(
-                    sub_frcn_feat_iter,
-                    sub_grid_feat_iter,
-                    sub_bbox_feat_iter,
-                    sub_ques_ix_iter
-                )
-
-                loss_item = [pred, sub_ans_iter]
-                loss_nonlinear_list = __C.LOSS_FUNC_NONLINEAR[__C.LOSS_FUNC]
-                for item_ix, loss_nonlinear in enumerate(loss_nonlinear_list):
-                    if loss_nonlinear in ['flat']:
-                        loss_item[item_ix] = loss_item[item_ix].view(-1)
-                    elif loss_nonlinear:
-                        loss_item[item_ix] = eval('F.' + loss_nonlinear + '(loss_item[item_ix], dim=1)')
-
-                loss = loss_fn(loss_item[0], loss_item[1])
-                if __C.LOSS_REDUCTION == 'mean':
-                    # only mean-reduction needs be divided by grad_accu_steps
-                    loss /= __C.GRAD_ACCU_STEPS
-                loss.backward()
-
-                loss_tmp += loss.cpu().data.numpy() * __C.GRAD_ACCU_STEPS
-                loss_sum += loss.cpu().data.numpy() * __C.GRAD_ACCU_STEPS
-
-            if __C.VERBOSE:
-                if dataset_eval is not None:
-                    mode_str = __C.SPLIT['train'] + '->' + __C.SPLIT['val']
-                else:
-                    mode_str = __C.SPLIT['train'] + '->' + __C.SPLIT['test']
-
-                print("\r[Version %s][Model %s][Dataset %s][Epoch %2d][Step %4d/%4d][%s] Loss: %.4f, Lr: %.2e" % (
-                    __C.VERSION,
-                    __C.MODEL_USE,
-                    __C.DATASET,
-                    epoch + 1,
-                    step,
-                    int(data_size / __C.BATCH_SIZE),
-                    mode_str,
-                    loss_tmp / __C.SUB_BATCH_SIZE,
-                    optim._rate
-                ), end='          ')
-
-            # Gradient norm clipping
-            if __C.GRAD_NORM_CLIP > 0:
-                nn.utils.clip_grad_norm_(
-                    net.parameters(),
-                    __C.GRAD_NORM_CLIP
-                )
-
-            # Save the gradient information
-            for name in range(len(named_params)):
-                norm_v = torch.norm(named_params[name][1].grad).cpu().data.numpy() \
-                    if named_params[name][1].grad is not None else 0
-                grad_norm[name] += norm_v * __C.GRAD_ACCU_STEPS
-                # print('Param %-3s Name %-80s Grad_Norm %-20s'%
-                #       (str(grad_wt),
-                #        params[grad_wt][0],
-                #        str(norm_v)))
-
-            optim.step()
-
-        time_end = time.time()
-        elapse_time = time_end-time_start
-        print('Finished in {}s'.format(int(elapse_time)))
-        epoch_finish = epoch + 1
-
-        # Save checkpoint
-        if not __C.SAVE_LAST or epoch_finish == __C.MAX_EPOCH:
-            if __C.N_GPU > 1:
-                state = {
-                    'state_dict': net.module.state_dict(),
-                    'optimizer': optim.optimizer.state_dict(),
-                    'lr_base': optim.lr_base,
-                    'epoch': epoch_finish
-                }
-            else:
-                state = {
-                    'state_dict': net.state_dict(),
-                    'optimizer': optim.optimizer.state_dict(),
-                    'lr_base': optim.lr_base,
-                    'epoch': epoch_finish
-                }
-            torch.save(
-                state,
-                __C.CKPTS_PATH +
-                '/ckpt_' + __C.VERSION +
-                '/epoch' + str(epoch_finish) +
-                '.pkl'
-            )
-
-        # Logging
-        logfile = open(
-            __C.LOG_PATH +
-            '/log_run_' + __C.VERSION + '.txt',
-            'a+'
-        )
-        logfile.write(
-            'Epoch: ' + str(epoch_finish) +
-            ', Loss: ' + str(loss_sum / data_size) +
-            ', Lr: ' + str(optim._rate) + '\n' +
-            'Elapsed time: ' + str(int(elapse_time)) + 
-            ', Speed(s/batch): ' + str(elapse_time / step) +
-            '\n\n'
-        )
-        logfile.close()
-
-        # Eval after every epoch
-        if dataset_eval is not None:
-            test_engine(
-                __C,
-                dataset_eval,
-                state_dict=net.state_dict(),
-                validation=True
-            )
-
-        # if self.__C.VERBOSE:
-        #     logfile = open(
-        #         self.__C.LOG_PATH +
-        #         '/log_run_' + self.__C.VERSION + '.txt',
-        #         'a+'
-        #     )
-        #     for name in range(len(named_params)):
-        #         logfile.write(
-        #             'Param %-3s Name %-80s Grad_Norm %-25s\n' % (
-        #                 str(name),
-        #                 named_params[name][0],
-        #                 str(grad_norm[name] / data_size * self.__C.BATCH_SIZE)
-        #             )
-        #         )
-        #     logfile.write('\n')
-        #     logfile.close()
-
-        loss_sum = 0
-        grad_norm = np.zeros(len(named_params))
-
-    # Modification - optionally run full result extract after training ends
-    if __C.EXTRACT_AFTER:
-        extract_engine(__C, state_dict=net.state_dict())

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

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

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

@@ -1,4 +0,0 @@
-from .builder import build_iou_calculator
-from .iou2d_calculator import BboxOverlaps2D, bbox_overlaps
-
-__all__ = ['build_iou_calculator', 'BboxOverlaps2D', 'bbox_overlaps']

spaces/CVPR/WALT/mmdet/models/dense_heads/pisa_ssd_head.py

@@ -1,139 +0,0 @@
-import torch
-
-from mmdet.core import multi_apply
-from ..builder import HEADS
-from ..losses import CrossEntropyLoss, SmoothL1Loss, carl_loss, isr_p
-from .ssd_head import SSDHead
-
-
-# TODO: add loss evaluator for SSD
-@HEADS.register_module()
-class PISASSDHead(SSDHead):
-
-    def loss(self,
-             cls_scores,
-             bbox_preds,
-             gt_bboxes,
-             gt_labels,
-             img_metas,
-             gt_bboxes_ignore=None):
-        """Compute losses of the head.
-
-        Args:
-            cls_scores (list[Tensor]): Box scores for each scale level
-                Has shape (N, num_anchors * num_classes, H, W)
-            bbox_preds (list[Tensor]): Box energies / deltas for each scale
-                level with shape (N, num_anchors * 4, H, W)
-            gt_bboxes (list[Tensor]): Ground truth bboxes of each image
-                with shape (num_obj, 4).
-            gt_labels (list[Tensor]): Ground truth labels of each image
-                with shape (num_obj, 4).
-            img_metas (list[dict]): Meta information of each image, e.g.,
-                image size, scaling factor, etc.
-            gt_bboxes_ignore (list[Tensor]): Ignored gt bboxes of each image.
-                Default: None.
-
-        Returns:
-            dict: Loss dict, comprise classification loss regression loss and
-                carl loss.
-        """
-        featmap_sizes = [featmap.size()[-2:] for featmap in cls_scores]
-        assert len(featmap_sizes) == self.anchor_generator.num_levels
-
-        device = cls_scores[0].device
-
-        anchor_list, valid_flag_list = self.get_anchors(
-            featmap_sizes, img_metas, device=device)
-        cls_reg_targets = self.get_targets(
-            anchor_list,
-            valid_flag_list,
-            gt_bboxes,
-            img_metas,
-            gt_bboxes_ignore_list=gt_bboxes_ignore,
-            gt_labels_list=gt_labels,
-            label_channels=1,
-            unmap_outputs=False,
-            return_sampling_results=True)
-        if cls_reg_targets is None:
-            return None
-        (labels_list, label_weights_list, bbox_targets_list, bbox_weights_list,
-         num_total_pos, num_total_neg, sampling_results_list) = cls_reg_targets
-
-        num_images = len(img_metas)
-        all_cls_scores = torch.cat([
-            s.permute(0, 2, 3, 1).reshape(
-                num_images, -1, self.cls_out_channels) for s in cls_scores
-        ], 1)
-        all_labels = torch.cat(labels_list, -1).view(num_images, -1)
-        all_label_weights = torch.cat(label_weights_list,
-                                      -1).view(num_images, -1)
-        all_bbox_preds = torch.cat([
-            b.permute(0, 2, 3, 1).reshape(num_images, -1, 4)
-            for b in bbox_preds
-        ], -2)
-        all_bbox_targets = torch.cat(bbox_targets_list,
-                                     -2).view(num_images, -1, 4)
-        all_bbox_weights = torch.cat(bbox_weights_list,
-                                     -2).view(num_images, -1, 4)
-
-        # concat all level anchors to a single tensor
-        all_anchors = []
-        for i in range(num_images):
-            all_anchors.append(torch.cat(anchor_list[i]))
-
-        isr_cfg = self.train_cfg.get('isr', None)
-        all_targets = (all_labels.view(-1), all_label_weights.view(-1),
-                       all_bbox_targets.view(-1,
-                                             4), all_bbox_weights.view(-1, 4))
-        # apply ISR-P
-        if isr_cfg is not None:
-            all_targets = isr_p(
-                all_cls_scores.view(-1, all_cls_scores.size(-1)),
-                all_bbox_preds.view(-1, 4),
-                all_targets,
-                torch.cat(all_anchors),
-                sampling_results_list,
-                loss_cls=CrossEntropyLoss(),
-                bbox_coder=self.bbox_coder,
-                **self.train_cfg.isr,
-                num_class=self.num_classes)
-            (new_labels, new_label_weights, new_bbox_targets,
-             new_bbox_weights) = all_targets
-            all_labels = new_labels.view(all_labels.shape)
-            all_label_weights = new_label_weights.view(all_label_weights.shape)
-            all_bbox_targets = new_bbox_targets.view(all_bbox_targets.shape)
-            all_bbox_weights = new_bbox_weights.view(all_bbox_weights.shape)
-
-        # add CARL loss
-        carl_loss_cfg = self.train_cfg.get('carl', None)
-        if carl_loss_cfg is not None:
-            loss_carl = carl_loss(
-                all_cls_scores.view(-1, all_cls_scores.size(-1)),
-                all_targets[0],
-                all_bbox_preds.view(-1, 4),
-                all_targets[2],
-                SmoothL1Loss(beta=1.),
-                **self.train_cfg.carl,
-                avg_factor=num_total_pos,
-                num_class=self.num_classes)
-
-        # check NaN and Inf
-        assert torch.isfinite(all_cls_scores).all().item(), \
-            'classification scores become infinite or NaN!'
-        assert torch.isfinite(all_bbox_preds).all().item(), \
-            'bbox predications become infinite or NaN!'
-
-        losses_cls, losses_bbox = multi_apply(
-            self.loss_single,
-            all_cls_scores,
-            all_bbox_preds,
-            all_anchors,
-            all_labels,
-            all_label_weights,
-            all_bbox_targets,
-            all_bbox_weights,
-            num_total_samples=num_total_pos)
-        loss_dict = dict(loss_cls=losses_cls, loss_bbox=losses_bbox)
-        if carl_loss_cfg is not None:
-            loss_dict.update(loss_carl)
-        return loss_dict

spaces/CVPR/regionclip-demo/detectron2/data/transforms/torchvision_transforms/functional_pil.py

@@ -1,352 +0,0 @@
-import numbers
-from typing import Any, List, Sequence
-
-import numpy as np
-import torch
-from PIL import Image, ImageOps, ImageEnhance
-
-try:
-    import accimage
-except ImportError:
-    accimage = None
-
-
-@torch.jit.unused
-def _is_pil_image(img: Any) -> bool:
-    if accimage is not None:
-        return isinstance(img, (Image.Image, accimage.Image))
-    else:
-        return isinstance(img, Image.Image)
-
-
-@torch.jit.unused
-def _get_image_size(img: Any) -> List[int]:
-    if _is_pil_image(img):
-        return img.size
-    raise TypeError("Unexpected type {}".format(type(img)))
-
-
-@torch.jit.unused
-def _get_image_num_channels(img: Any) -> int:
-    if _is_pil_image(img):
-        return 1 if img.mode == 'L' else 3
-    raise TypeError("Unexpected type {}".format(type(img)))
-
-
-@torch.jit.unused
-def hflip(img):
-    if not _is_pil_image(img):
-        raise TypeError('img should be PIL Image. Got {}'.format(type(img)))
-
-    return img.transpose(Image.FLIP_LEFT_RIGHT)
-
-
-@torch.jit.unused
-def vflip(img):
-    if not _is_pil_image(img):
-        raise TypeError('img should be PIL Image. Got {}'.format(type(img)))
-
-    return img.transpose(Image.FLIP_TOP_BOTTOM)
-
-
-@torch.jit.unused
-def adjust_brightness(img, brightness_factor):
-    if not _is_pil_image(img):
-        raise TypeError('img should be PIL Image. Got {}'.format(type(img)))
-
-    enhancer = ImageEnhance.Brightness(img)
-    img = enhancer.enhance(brightness_factor)
-    return img
-
-
-@torch.jit.unused
-def adjust_contrast(img, contrast_factor):
-    if not _is_pil_image(img):
-        raise TypeError('img should be PIL Image. Got {}'.format(type(img)))
-
-    enhancer = ImageEnhance.Contrast(img)
-    img = enhancer.enhance(contrast_factor)
-    return img
-
-
-@torch.jit.unused
-def adjust_saturation(img, saturation_factor):
-    if not _is_pil_image(img):
-        raise TypeError('img should be PIL Image. Got {}'.format(type(img)))
-
-    enhancer = ImageEnhance.Color(img)
-    img = enhancer.enhance(saturation_factor)
-    return img
-
-
-@torch.jit.unused
-def adjust_hue(img, hue_factor):
-    if not(-0.5 <= hue_factor <= 0.5):
-        raise ValueError('hue_factor ({}) is not in [-0.5, 0.5].'.format(hue_factor))
-
-    if not _is_pil_image(img):
-        raise TypeError('img should be PIL Image. Got {}'.format(type(img)))
-
-    input_mode = img.mode
-    if input_mode in {'L', '1', 'I', 'F'}:
-        return img
-
-    h, s, v = img.convert('HSV').split()
-
-    np_h = np.array(h, dtype=np.uint8)
-    # uint8 addition take cares of rotation across boundaries
-    with np.errstate(over='ignore'):
-        np_h += np.uint8(hue_factor * 255)
-    h = Image.fromarray(np_h, 'L')
-
-    img = Image.merge('HSV', (h, s, v)).convert(input_mode)
-    return img
-
-
-@torch.jit.unused
-def adjust_gamma(img, gamma, gain=1):
-    if not _is_pil_image(img):
-        raise TypeError('img should be PIL Image. Got {}'.format(type(img)))
-
-    if gamma < 0:
-        raise ValueError('Gamma should be a non-negative real number')
-
-    input_mode = img.mode
-    img = img.convert('RGB')
-    gamma_map = [(255 + 1 - 1e-3) * gain * pow(ele / 255., gamma) for ele in range(256)] * 3
-    img = img.point(gamma_map)  # use PIL's point-function to accelerate this part
-
-    img = img.convert(input_mode)
-    return img
-
-
-@torch.jit.unused
-def pad(img, padding, fill=0, padding_mode="constant"):
-    if not _is_pil_image(img):
-        raise TypeError("img should be PIL Image. Got {}".format(type(img)))
-
-    if not isinstance(padding, (numbers.Number, tuple, list)):
-        raise TypeError("Got inappropriate padding arg")
-    if not isinstance(fill, (numbers.Number, str, tuple)):
-        raise TypeError("Got inappropriate fill arg")
-    if not isinstance(padding_mode, str):
-        raise TypeError("Got inappropriate padding_mode arg")
-
-    if isinstance(padding, list):
-        padding = tuple(padding)
-
-    if isinstance(padding, tuple) and len(padding) not in [1, 2, 4]:
-        raise ValueError("Padding must be an int or a 1, 2, or 4 element tuple, not a " +
-                         "{} element tuple".format(len(padding)))
-
-    if isinstance(padding, tuple) and len(padding) == 1:
-        # Compatibility with `functional_tensor.pad`
-        padding = padding[0]
-
-    if padding_mode not in ["constant", "edge", "reflect", "symmetric"]:
-        raise ValueError("Padding mode should be either constant, edge, reflect or symmetric")
-
-    if padding_mode == "constant":
-        opts = _parse_fill(fill, img, name="fill")
-        if img.mode == "P":
-            palette = img.getpalette()
-            image = ImageOps.expand(img, border=padding, **opts)
-            image.putpalette(palette)
-            return image
-
-        return ImageOps.expand(img, border=padding, **opts)
-    else:
-        if isinstance(padding, int):
-            pad_left = pad_right = pad_top = pad_bottom = padding
-        if isinstance(padding, tuple) and len(padding) == 2:
-            pad_left = pad_right = padding[0]
-            pad_top = pad_bottom = padding[1]
-        if isinstance(padding, tuple) and len(padding) == 4:
-            pad_left = padding[0]
-            pad_top = padding[1]
-            pad_right = padding[2]
-            pad_bottom = padding[3]
-
-        p = [pad_left, pad_top, pad_right, pad_bottom]
-        cropping = -np.minimum(p, 0)
-
-        if cropping.any():
-            crop_left, crop_top, crop_right, crop_bottom = cropping
-            img = img.crop((crop_left, crop_top, img.width - crop_right, img.height - crop_bottom))
-
-        pad_left, pad_top, pad_right, pad_bottom = np.maximum(p, 0)
-
-        if img.mode == 'P':
-            palette = img.getpalette()
-            img = np.asarray(img)
-            img = np.pad(img, ((pad_top, pad_bottom), (pad_left, pad_right)), padding_mode)
-            img = Image.fromarray(img)
-            img.putpalette(palette)
-            return img
-
-        img = np.asarray(img)
-        # RGB image
-        if len(img.shape) == 3:
-            img = np.pad(img, ((pad_top, pad_bottom), (pad_left, pad_right), (0, 0)), padding_mode)
-        # Grayscale image
-        if len(img.shape) == 2:
-            img = np.pad(img, ((pad_top, pad_bottom), (pad_left, pad_right)), padding_mode)
-
-        return Image.fromarray(img)
-
-
-@torch.jit.unused
-def crop(img: Image.Image, top: int, left: int, height: int, width: int) -> Image.Image:
-    if not _is_pil_image(img):
-        raise TypeError('img should be PIL Image. Got {}'.format(type(img)))
-
-    return img.crop((left, top, left + width, top + height))
-
-
-@torch.jit.unused
-def resize(img, size, interpolation=Image.BILINEAR, max_size=None):
-    if not _is_pil_image(img):
-        raise TypeError('img should be PIL Image. Got {}'.format(type(img)))
-    if not (isinstance(size, int) or (isinstance(size, Sequence) and len(size) in (1, 2))):
-        raise TypeError('Got inappropriate size arg: {}'.format(size))
-
-    if isinstance(size, Sequence) and len(size) == 1:
-        size = size[0]
-    if isinstance(size, int):
-        w, h = img.size
-
-        short, long = (w, h) if w <= h else (h, w)
-        if short == size:
-            return img
-
-        new_short, new_long = size, int(size * long / short)
-
-        if max_size is not None:
-            if max_size <= size:
-                raise ValueError(
-                    f"max_size = {max_size} must be strictly greater than the requested "
-                    f"size for the smaller edge size = {size}"
-                )
-            if new_long > max_size:
-                new_short, new_long = int(max_size * new_short / new_long), max_size
-
-        new_w, new_h = (new_short, new_long) if w <= h else (new_long, new_short)
-        return img.resize((new_w, new_h), interpolation)
-    else:
-        if max_size is not None:
-            raise ValueError(
-                "max_size should only be passed if size specifies the length of the smaller edge, "
-                "i.e. size should be an int or a sequence of length 1 in torchscript mode."
-            )
-        return img.resize(size[::-1], interpolation)
-
-
-@torch.jit.unused
-def _parse_fill(fill, img, name="fillcolor"):
-    # Process fill color for affine transforms
-    num_bands = len(img.getbands())
-    if fill is None:
-        fill = 0
-    if isinstance(fill, (int, float)) and num_bands > 1:
-        fill = tuple([fill] * num_bands)
-    if isinstance(fill, (list, tuple)):
-        if len(fill) != num_bands:
-            msg = ("The number of elements in 'fill' does not match the number of "
-                   "bands of the image ({} != {})")
-            raise ValueError(msg.format(len(fill), num_bands))
-
-        fill = tuple(fill)
-
-    return {name: fill}
-
-
-@torch.jit.unused
-def affine(img, matrix, interpolation=0, fill=None):
-    if not _is_pil_image(img):
-        raise TypeError('img should be PIL Image. Got {}'.format(type(img)))
-
-    output_size = img.size
-    opts = _parse_fill(fill, img)
-    return img.transform(output_size, Image.AFFINE, matrix, interpolation, **opts)
-
-
-@torch.jit.unused
-def rotate(img, angle, interpolation=0, expand=False, center=None, fill=None):
-    if not _is_pil_image(img):
-        raise TypeError("img should be PIL Image. Got {}".format(type(img)))
-
-    opts = _parse_fill(fill, img)
-    return img.rotate(angle, interpolation, expand, center, **opts)
-
-
-@torch.jit.unused
-def perspective(img, perspective_coeffs, interpolation=Image.BICUBIC, fill=None):
-    if not _is_pil_image(img):
-        raise TypeError('img should be PIL Image. Got {}'.format(type(img)))
-
-    opts = _parse_fill(fill, img)
-
-    return img.transform(img.size, Image.PERSPECTIVE, perspective_coeffs, interpolation, **opts)
-
-
-@torch.jit.unused
-def to_grayscale(img, num_output_channels):
-    if not _is_pil_image(img):
-        raise TypeError('img should be PIL Image. Got {}'.format(type(img)))
-
-    if num_output_channels == 1:
-        img = img.convert('L')
-    elif num_output_channels == 3:
-        img = img.convert('L')
-        np_img = np.array(img, dtype=np.uint8)
-        np_img = np.dstack([np_img, np_img, np_img])
-        img = Image.fromarray(np_img, 'RGB')
-    else:
-        raise ValueError('num_output_channels should be either 1 or 3')
-
-    return img
-
-
-@torch.jit.unused
-def invert(img):
-    if not _is_pil_image(img):
-        raise TypeError('img should be PIL Image. Got {}'.format(type(img)))
-    return ImageOps.invert(img)
-
-
-@torch.jit.unused
-def posterize(img, bits):
-    if not _is_pil_image(img):
-        raise TypeError('img should be PIL Image. Got {}'.format(type(img)))
-    return ImageOps.posterize(img, bits)
-
-
-@torch.jit.unused
-def solarize(img, threshold):
-    if not _is_pil_image(img):
-        raise TypeError('img should be PIL Image. Got {}'.format(type(img)))
-    return ImageOps.solarize(img, threshold)
-
-
-@torch.jit.unused
-def adjust_sharpness(img, sharpness_factor):
-    if not _is_pil_image(img):
-        raise TypeError('img should be PIL Image. Got {}'.format(type(img)))
-
-    enhancer = ImageEnhance.Sharpness(img)
-    img = enhancer.enhance(sharpness_factor)
-    return img
-
-
-@torch.jit.unused
-def autocontrast(img):
-    if not _is_pil_image(img):
-        raise TypeError('img should be PIL Image. Got {}'.format(type(img)))
-    return ImageOps.autocontrast(img)
-
-
-@torch.jit.unused
-def equalize(img):
-    if not _is_pil_image(img):
-        raise TypeError('img should be PIL Image. Got {}'.format(type(img)))
-    return ImageOps.equalize(img)

spaces/Caoyunkang/Segment-Any-Anomaly/GroundingDINO/groundingdino/models/GroundingDINO/csrc/MsDeformAttn/ms_deform_attn.h

@@ -1,64 +0,0 @@
-/*!
-**************************************************************************************************
-* Deformable DETR
-* Copyright (c) 2020 SenseTime. All Rights Reserved.
-* Licensed under the Apache License, Version 2.0 [see LICENSE for details]
-**************************************************************************************************
-* Modified from https://github.com/chengdazhi/Deformable-Convolution-V2-PyTorch/tree/pytorch_1.0.0
-**************************************************************************************************
-*/
-
-#pragma once
-
-#include "ms_deform_attn_cpu.h"
-
-#ifdef WITH_CUDA
-#include "ms_deform_attn_cuda.h"
-#endif
-
-namespace groundingdino {
-
-at::Tensor
-ms_deform_attn_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)
-{
-    if (value.type().is_cuda())
-    {
-#ifdef WITH_CUDA
-        return ms_deform_attn_cuda_forward(
-            value, spatial_shapes, level_start_index, sampling_loc, attn_weight, im2col_step);
-#else
-        AT_ERROR("Not compiled with GPU support");
-#endif
-    }
-    AT_ERROR("Not implemented on the CPU");
-}
-
-std::vector<at::Tensor>
-ms_deform_attn_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)
-{
-    if (value.type().is_cuda())
-    {
-#ifdef WITH_CUDA
-        return ms_deform_attn_cuda_backward(
-            value, spatial_shapes, level_start_index, sampling_loc, attn_weight, grad_output, im2col_step);
-#else
-        AT_ERROR("Not compiled with GPU support");
-#endif
-    }
-    AT_ERROR("Not implemented on the CPU");
-}
-
-} // namespace groundingdino

spaces/ChevyWithAI/rvc-aicover/infer_pack/commons.py

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

spaces/CjangCjengh/Sanskrit-TTS/monotonic_align/core.py

@@ -1,35 +0,0 @@
-import numba
-
-
-@numba.jit(numba.void(numba.int32[:,:,::1], numba.float32[:,:,::1], numba.int32[::1], numba.int32[::1]), nopython=True, nogil=True)
-def maximum_path_jit(paths, values, t_ys, t_xs):
-  b = paths.shape[0]
-  max_neg_val=-1e9
-  for i in range(int(b)):
-    path = paths[i]
-    value = values[i]
-    t_y = t_ys[i]
-    t_x = t_xs[i]
-
-    v_prev = v_cur = 0.0
-    index = t_x - 1
-
-    for y in range(t_y):
-      for x in range(max(0, t_x + y - t_y), min(t_x, y + 1)):
-        if x == y:
-          v_cur = max_neg_val
-        else:
-          v_cur = value[y-1, x]
-        if x == 0:
-          if y == 0:
-            v_prev = 0.
-          else:
-            v_prev = max_neg_val
-        else:
-          v_prev = value[y-1, x-1]
-        value[y, x] += max(v_prev, v_cur)
-
-    for y in range(t_y - 1, -1, -1):
-      path[y, index] = 1
-      if index != 0 and (index == y or value[y-1, index] < value[y-1, index-1]):
-        index = index - 1

spaces/CofAI/chat.b4/g4f/Provider/Providers/Easychat.py

@@ -1,55 +0,0 @@
-import requests
-import os
-import json
-from ...typing import sha256, Dict, get_type_hints
-
-url = 'https://free.easychat.work'
-model = ['gpt-3.5-turbo', 'gpt-3.5-turbo-16k',
-         'gpt-3.5-turbo-16k-0613', 'gpt-3.5-turbo-0613']
-supports_stream = True
-needs_auth = False
-
-
-def _create_completion(model: str, messages: list, stream: bool, **kwargs):
-    headers = {
-        'authority': 'free.easychat.work',
-        'accept': 'text/event-stream',
-        'accept-language': 'en,fr-FR;q=0.9,fr;q=0.8,es-ES;q=0.7,es;q=0.6,en-US;q=0.5,am;q=0.4,de;q=0.3',
-        'content-type': 'application/json',
-        'endpoint': '',
-        'origin': 'https://free.easychat.work',
-        'plugins': '0',
-        'referer': 'https://free.easychat.work/',
-        'sec-ch-ua': '"Not.A/Brand";v="8", "Chromium";v="114", "Google Chrome";v="114"',
-        'sec-ch-ua-mobile': '?0',
-        'sec-ch-ua-platform': '"macOS"',
-        'sec-fetch-dest': 'empty',
-        'sec-fetch-mode': 'cors',
-        'sec-fetch-site': 'same-origin',
-        'user-agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36',
-        'usesearch': 'false',
-        'x-requested-with': 'XMLHttpRequest',
-    }
-
-    json_data = {
-        'messages': messages,
-        'stream': True,
-        'model': model,
-        'temperature': 0.5,
-        'presence_penalty': 0,
-        'frequency_penalty': 0,
-        'top_p': 1,
-    }
-
-    response = requests.post('https://free.easychat.work/api/openai/v1/chat/completions',
-                             headers=headers, json=json_data)
-
-    for chunk in response.iter_lines():
-        if b'content' in chunk:
-            data = json.loads(chunk.decode().split('data: ')[1])
-            yield (data['choices'][0]['delta']['content'])
-
-
-params = f'g4f.Providers.{os.path.basename(__file__)[:-3]} supports: ' + \
-    '(%s)' % ', '.join(
-        [f"{name}: {get_type_hints(_create_completion)[name].__name__}" for name in _create_completion.__code__.co_varnames[:_create_completion.__code__.co_argcount]])

spaces/CofAI/chat/g4f/Provider/Providers/Yqcloud.py

@@ -1,39 +0,0 @@
-import os
-import time
-import requests
-
-from ...typing import sha256, Dict, get_type_hints
-url = 'https://chat9.yqcloud.top/'
-model = [
-    'gpt-3.5-turbo',
-]
-supports_stream = True
-needs_auth = False
-
-
-def _create_completion(model: str, messages: list, stream: bool, chatId: str, **kwargs):
-
-    headers = {
-        'authority': 'api.aichatos.cloud',
-        'origin': 'https://chat9.yqcloud.top',
-        'referer': 'https://chat9.yqcloud.top/',
-        'user-agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/112.0.0.0 Safari/537.36',
-    }
-
-    json_data = {
-        'prompt': str(messages),
-        'userId': f'#/chat/{chatId}',
-        'network': True,
-        'apikey': '',
-        'system': '',
-        'withoutContext': False,
-    }
-    response = requests.post('https://api.aichatos.cloud/api/generateStream',
-                             headers=headers, json=json_data, stream=True)
-    for token in response.iter_content(chunk_size=2046):
-        yield (token.decode('utf-8'))
-
-
-params = f'g4f.Providers.{os.path.basename(__file__)[:-3]} supports: ' + \
-    '(%s)' % ', '.join(
-        [f"{name}: {get_type_hints(_create_completion)[name].__name__}" for name in _create_completion.__code__.co_varnames[:_create_completion.__code__.co_argcount]])

spaces/Cyril666/ContourNet-ABI/maskrcnn_benchmark/data/datasets/evaluation/word/util/dec.py

@@ -1,78 +0,0 @@
-#encoding=utf-8
-import logging
-import time
-def print_calling(fn):
-    def wrapper(*args1, ** args2):
-        s = "calling function %s"%(fn.__name__)
-        logging.info(s)
-        start = time.time()
-        ret = fn(*args1, **args2)
-        end = time.time()
-#         s = "%s. time used = %f seconds"%(s, (end - start))
-        s = "function [%s] has been called, taking %f seconds"%(fn.__name__, (end - start))
-        logging.debug(s)
-        return ret
-    return wrapper
-
-
-def print_test(fn):
-    def wrapper(*args1, ** args2):
-        s = "running test: %s..."%(fn.__name__)
-        logging.info(s)
-        ret = fn(*args1, **args2)
-        s = "running test: %s...succeed"%(fn.__name__)
-        logging.debug(s)
-        return ret
-    return wrapper
-    
-def print_calling_in_short(fn):
-    def wrapper(*args1, ** args2):
-        start = time.time()
-        ret = fn(*args1, **args2)
-        end = time.time()
-        s = "function [%s] has been called, taking %f seconds"%(fn.__name__, (end - start))
-        logging.debug(s)
-        return ret
-    return wrapper
-
-import collections
-counter = collections.defaultdict(int)
-count_times =collections.defaultdict(int)
-def print_calling_in_short_for_tf(fn):
-    import tensorflow as tf
-    import util
-    def wrapper(*args1, ** args2):
-        start = time.time()
-        thread_name = util.thread.get_current_thread_name()
-        ret = fn(*args1, **args2)
-        end = time.time()
-        counter[fn.__name__] = counter[fn.__name__] + (end - start)
-        count_times[fn.__name__] += 1
-        all_time = sum([counter[name] for name in counter]) * 1.0
-        for name in counter:
-#             tf.logging.info('\t %s: %f, %f seconds'%(name, counter[name] / all_time, counter[name]))
-            tf.logging.info('\t %s: %d callings, %fsper calling'%(name, count_times[name], counter[name] * 1.0 / count_times[name]))
-        s = "Thread [%s]:function [%s] has been called, taking %f seconds"%(thread_name, fn.__name__, (end - start))
-        tf.logging.info(s)
-        return ret
-    return wrapper
-
-def timeit(fn):
-    import util
-    def wrapper(*args1, ** args2):
-        start = time.time()
-        thread_name = util.thread.get_current_thread_name()
-        ret = fn(*args1, **args2)
-        end = time.time()
-        counter[fn.__name__] = counter[fn.__name__] + (end - start)
-        count_times[fn.__name__] += 1
-        all_time = sum([counter[name] for name in counter]) * 1.0
-        for name in counter:
-            logging.info('\t %s: %f, %f seconds'%(name, counter[name] / all_time, counter[name]))
-            logging.info('\t %s: %d callings, %f seconds per calling'%(name, count_times[name], counter[name] * 1.0 / count_times[name]))
-        s = "Thread [%s]:function [%s] has been called, taking %f seconds"%(thread_name, fn.__name__, (end - start))
-#         logging.info(s)
-        return ret
-    return wrapper
-    
-

spaces/Cyril666/ContourNet-ABI/maskrcnn_benchmark/modeling/backbone/backbone.py

@@ -1,119 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
-from collections import OrderedDict
-
-from torch import nn
-
-from maskrcnn_benchmark.modeling import registry
-from maskrcnn_benchmark.modeling.make_layers import conv_with_kaiming_uniform
-from . import fpn as fpn_module
-from .pan import PAN
-from .msr import MSR
-from . import resnet
-
-
-@registry.BACKBONES.register("R-50-C4")
-@registry.BACKBONES.register("R-50-C5")
-@registry.BACKBONES.register("R-101-C4")
-@registry.BACKBONES.register("R-101-C5")
-def build_resnet_backbone(cfg):
-    body = resnet.ResNet(cfg)
-    model = nn.Sequential(OrderedDict([("body", body)]))
-    model.out_channels = cfg.MODEL.RESNETS.BACKBONE_OUT_CHANNELS
-    return model
-
-
-@registry.BACKBONES.register("R-50-FPN")
-@registry.BACKBONES.register("R-101-FPN")
-@registry.BACKBONES.register("R-152-FPN")
-def build_resnet_fpn_backbone(cfg):
-    in_channels_stage2 = cfg.MODEL.RESNETS.RES2_OUT_CHANNELS  # 256
-    in_channels_list = [
-        in_channels_stage2,  # 256
-        in_channels_stage2 * 2,  # 512
-        in_channels_stage2 * 4,  # 1024
-        in_channels_stage2 * 8,  # 2048
-    ]
-    body = resnet.ResNet(cfg)
-    out_channels = cfg.MODEL.RESNETS.BACKBONE_OUT_CHANNELS  # 256
-    fpn = fpn_module.FPN(
-        in_channels_list=in_channels_list,
-        out_channels=out_channels,
-        conv_block=conv_with_kaiming_uniform(
-            cfg.MODEL.FPN.USE_GN, cfg.MODEL.FPN.USE_RELU,
-            cfg.MODEL.FPN.USE_DEFORMABLE
-        ),
-        top_blocks=fpn_module.LastLevelMaxPool(),
-    )
-    if cfg.MODEL.MSR_ON:
-        model = MSR(body, in_channels_list, fpn=fpn)
-    else:
-        model = nn.Sequential(OrderedDict([("body", body), ("fpn", fpn)]))
-    model.out_channels = out_channels
-    return model
-
-
-@registry.BACKBONES.register("R-50-PAN")
-@registry.BACKBONES.register("R-101-PAN")
-@registry.BACKBONES.register("R-152-PAN")
-def build_resnet_fpn_backbone(cfg):
-    in_channels_stage2 = cfg.MODEL.RESNETS.RES2_OUT_CHANNELS
-    in_channels_list = [
-        in_channels_stage2,
-        in_channels_stage2 * 2,
-        in_channels_stage2 * 4,
-        in_channels_stage2 * 8,
-    ]
-    body = resnet.ResNet(cfg)
-    out_channels = cfg.MODEL.RESNETS.BACKBONE_OUT_CHANNELS
-    fpn = fpn_module.FPN(
-        in_channels_list=in_channels_list,
-        out_channels=out_channels,
-        conv_block=conv_with_kaiming_uniform(
-            cfg.MODEL.FPN.USE_GN, cfg.MODEL.FPN.USE_RELU,
-            cfg.MODEL.FPN.USE_DEFORMABLE
-        ),
-        top_blocks=fpn_module.LastLevelMaxPool(),
-    )
-    pan = PAN()
-    if cfg.MODEL.MSR_ON:
-        model = MSR(body, in_channels_list, fpn=fpn, pan=pan)
-    else:
-        model = nn.Sequential(OrderedDict([("body", body),
-                                           ("pan", pan),
-                                           ("fpn", fpn)]))
-    model.out_channels = out_channels
-    return model
-
-
-@registry.BACKBONES.register("R-50-FPN-RETINANET")
-@registry.BACKBONES.register("R-101-FPN-RETINANET")
-def build_resnet_fpn_p3p7_backbone(cfg):
-    body = resnet.ResNet(cfg)
-    in_channels_stage2 = cfg.MODEL.RESNETS.RES2_OUT_CHANNELS
-    out_channels = cfg.MODEL.RESNETS.BACKBONE_OUT_CHANNELS
-    in_channels_p6p7 = in_channels_stage2 * 8 if cfg.MODEL.RETINANET.USE_C5 \
-        else out_channels
-    fpn = fpn_module.FPN(
-        in_channels_list=[
-            0,
-            in_channels_stage2 * 2,
-            in_channels_stage2 * 4,
-            in_channels_stage2 * 8,
-        ],
-        out_channels=out_channels,
-        conv_block=conv_with_kaiming_uniform(
-            cfg.MODEL.FPN.USE_GN, cfg.MODEL.FPN.USE_RELU
-        ),
-        top_blocks=fpn_module.LastLevelP6P7(in_channels_p6p7, out_channels),
-    )
-    model = nn.Sequential(OrderedDict([("body", body), ("fpn", fpn)]))
-    model.out_channels = out_channels
-    return model
-
-
-def build_backbone(cfg):
-    assert cfg.MODEL.BACKBONE.CONV_BODY in registry.BACKBONES, \
-        "cfg.MODEL.BACKBONE.CONV_BODY: {} are not registered in registry".format(
-            cfg.MODEL.BACKBONE.CONV_BODY
-        )
-    return registry.BACKBONES[cfg.MODEL.BACKBONE.CONV_BODY](cfg)

spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/PIL/WmfImagePlugin.py

@@ -1,178 +0,0 @@
-#
-# The Python Imaging Library
-# $Id$
-#
-# WMF stub codec
-#
-# history:
-# 1996-12-14 fl   Created
-# 2004-02-22 fl   Turned into a stub driver
-# 2004-02-23 fl   Added EMF support
-#
-# Copyright (c) Secret Labs AB 1997-2004.  All rights reserved.
-# Copyright (c) Fredrik Lundh 1996.
-#
-# See the README file for information on usage and redistribution.
-#
-# WMF/EMF reference documentation:
-# https://winprotocoldoc.blob.core.windows.net/productionwindowsarchives/MS-WMF/[MS-WMF].pdf
-# http://wvware.sourceforge.net/caolan/index.html
-# http://wvware.sourceforge.net/caolan/ora-wmf.html
-
-from . import Image, ImageFile
-from ._binary import i16le as word
-from ._binary import si16le as short
-from ._binary import si32le as _long
-
-_handler = None
-
-
-def register_handler(handler):
-    """
-    Install application-specific WMF image handler.
-
-    :param handler: Handler object.
-    """
-    global _handler
-    _handler = handler
-
-
-if hasattr(Image.core, "drawwmf"):
-    # install default handler (windows only)
-
-    class WmfHandler:
-        def open(self, im):
-            im.mode = "RGB"
-            self.bbox = im.info["wmf_bbox"]
-
-        def load(self, im):
-            im.fp.seek(0)  # rewind
-            return Image.frombytes(
-                "RGB",
-                im.size,
-                Image.core.drawwmf(im.fp.read(), im.size, self.bbox),
-                "raw",
-                "BGR",
-                (im.size[0] * 3 + 3) & -4,
-                -1,
-            )
-
-    register_handler(WmfHandler())
-
-#
-# --------------------------------------------------------------------
-# Read WMF file
-
-
-def _accept(prefix):
-    return (
-        prefix[:6] == b"\xd7\xcd\xc6\x9a\x00\x00" or prefix[:4] == b"\x01\x00\x00\x00"
-    )
-
-
-##
-# Image plugin for Windows metafiles.
-
-
-class WmfStubImageFile(ImageFile.StubImageFile):
-    format = "WMF"
-    format_description = "Windows Metafile"
-
-    def _open(self):
-        self._inch = None
-
-        # check placable header
-        s = self.fp.read(80)
-
-        if s[:6] == b"\xd7\xcd\xc6\x9a\x00\x00":
-            # placeable windows metafile
-
-            # get units per inch
-            self._inch = word(s, 14)
-
-            # get bounding box
-            x0 = short(s, 6)
-            y0 = short(s, 8)
-            x1 = short(s, 10)
-            y1 = short(s, 12)
-
-            # normalize size to 72 dots per inch
-            self.info["dpi"] = 72
-            size = (
-                (x1 - x0) * self.info["dpi"] // self._inch,
-                (y1 - y0) * self.info["dpi"] // self._inch,
-            )
-
-            self.info["wmf_bbox"] = x0, y0, x1, y1
-
-            # sanity check (standard metafile header)
-            if s[22:26] != b"\x01\x00\t\x00":
-                msg = "Unsupported WMF file format"
-                raise SyntaxError(msg)
-
-        elif s[:4] == b"\x01\x00\x00\x00" and s[40:44] == b" EMF":
-            # enhanced metafile
-
-            # get bounding box
-            x0 = _long(s, 8)
-            y0 = _long(s, 12)
-            x1 = _long(s, 16)
-            y1 = _long(s, 20)
-
-            # get frame (in 0.01 millimeter units)
-            frame = _long(s, 24), _long(s, 28), _long(s, 32), _long(s, 36)
-
-            size = x1 - x0, y1 - y0
-
-            # calculate dots per inch from bbox and frame
-            xdpi = 2540.0 * (x1 - y0) / (frame[2] - frame[0])
-            ydpi = 2540.0 * (y1 - y0) / (frame[3] - frame[1])
-
-            self.info["wmf_bbox"] = x0, y0, x1, y1
-
-            if xdpi == ydpi:
-                self.info["dpi"] = xdpi
-            else:
-                self.info["dpi"] = xdpi, ydpi
-
-        else:
-            msg = "Unsupported file format"
-            raise SyntaxError(msg)
-
-        self.mode = "RGB"
-        self._size = size
-
-        loader = self._load()
-        if loader:
-            loader.open(self)
-
-    def _load(self):
-        return _handler
-
-    def load(self, dpi=None):
-        if dpi is not None and self._inch is not None:
-            self.info["dpi"] = dpi
-            x0, y0, x1, y1 = self.info["wmf_bbox"]
-            self._size = (
-                (x1 - x0) * self.info["dpi"] // self._inch,
-                (y1 - y0) * self.info["dpi"] // self._inch,
-            )
-        return super().load()
-
-
-def _save(im, fp, filename):
-    if _handler is None or not hasattr(_handler, "save"):
-        msg = "WMF save handler not installed"
-        raise OSError(msg)
-    _handler.save(im, fp, filename)
-
-
-#
-# --------------------------------------------------------------------
-# Registry stuff
-
-
-Image.register_open(WmfStubImageFile.format, WmfStubImageFile, _accept)
-Image.register_save(WmfStubImageFile.format, _save)
-
-Image.register_extensions(WmfStubImageFile.format, [".wmf", ".emf"])

spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/gradio/templates/frontend/assets/Info-5611e10f.js

@@ -1,2 +0,0 @@
-import{S as i,e as r,s as u,a9 as f,N as _,K as c,p,ab as d,ac as m,ad as $,z as v,v as g,A as b}from"./index-3370be2a.js";import"./Button-89624748.js";function h(n){let s,a;const l=n[1].default,e=f(l,n,n[0],null);return{c(){s=_("div"),e&&e.c(),c(s,"class","svelte-e8n7p6")},m(t,o){p(t,s,o),e&&e.m(s,null),a=!0},p(t,[o]){e&&e.p&&(!a||o&1)&&d(e,l,t,t[0],a?$(l,t[0],o,null):m(t[0]),null)},i(t){a||(v(e,t),a=!0)},o(t){g(e,t),a=!1},d(t){t&&b(s),e&&e.d(t)}}}function I(n,s,a){let{$$slots:l={},$$scope:e}=s;return n.$$set=t=>{"$$scope"in t&&a(0,e=t.$$scope)},[e,l]}class z extends i{constructor(s){super(),r(this,s,I,h,u,{})}}export{z as I};
-//# sourceMappingURL=Info-5611e10f.js.map

spaces/Daniton/MagicPrompt-Stable-Diffusion/style.css

@@ -1,84 +0,0 @@
-#col-container {
-    max-width: 800px;
-    margin-left: auto;
-    margin-right: auto;
-}
-a {
-    color: inherit;
-    text-decoration: underline;
-}
-.gradio-container {
-    font-family: 'IBM Plex Sans', sans-serif;
-}
-.gr-button {
-    color: white;
-    border-color: #9d66e5;
-    background: #9d66e5;
-}
-input[type='range'] {
-    accent-color: #9d66e5;
-}
-.dark input[type='range'] {
-    accent-color: #dfdfdf;
-}
-.container {
-    max-width: 800px;
-    margin: auto;
-    padding-top: 1.5rem;
-}
-#gallery {
-    min-height: 22rem;
-    margin-bottom: 15px;
-    margin-left: auto;
-    margin-right: auto;
-    border-bottom-right-radius: .5rem !important;
-    border-bottom-left-radius: .5rem !important;
-}
-#gallery>div>.h-full {
-    min-height: 20rem;
-}
-.details:hover {
-    text-decoration: underline;
-}
-.gr-button {
-    white-space: nowrap;
-}
-.gr-button:focus {
-    border-color: rgb(147 197 253 / var(--tw-border-opacity));
-    outline: none;
-    box-shadow: var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow, 0 0 #0000);
-    --tw-border-opacity: 1;
-    --tw-ring-offset-shadow: var(--tw-ring-inset) 0 0 0 var(--tw-ring-offset-width) var(--tw-ring-offset-color);
-    --tw-ring-shadow: var(--tw-ring-inset) 0 0 0 calc(3px var(--tw-ring-offset-width)) var(--tw-ring-color);
-    --tw-ring-color: rgb(191 219 254 / var(--tw-ring-opacity));
-    --tw-ring-opacity: .5;
-}
-#advanced-options {
-    margin-bottom: 20px;
-}
-.footer {
-    margin-bottom: 45px;
-    margin-top: 35px;
-    text-align: center;
-    border-bottom: 1px solid #e5e5e5;
-}
-.footer>p {
-    font-size: .8rem;
-    display: inline-block;
-    padding: 0 10px;
-    transform: translateY(10px);
-    background: white;
-}
-.dark .logo{ filter: invert(1); }
-.dark .footer {
-    border-color: #303030;
-}
-.dark .footer>p {
-    background: #0b0f19;
-}
-.acknowledgments h4{
-    margin: 1.25em 0 .25em 0;
-    font-weight: bold;
-    font-size: 115%;
-}
-

spaces/DataScienceEngineering/1-SimPhysics-HTML5/style.css

@@ -1,28 +0,0 @@
-body {
-	padding: 2rem;
-	font-family: -apple-system, BlinkMacSystemFont, "Arial", sans-serif;
-}
-
-h1 {
-	font-size: 16px;
-	margin-top: 0;
-}
-
-p {
-	color: rgb(107, 114, 128);
-	font-size: 15px;
-	margin-bottom: 10px;
-	margin-top: 5px;
-}
-
-.card {
-	max-width: 620px;
-	margin: 0 auto;
-	padding: 16px;
-	border: 1px solid lightgray;
-	border-radius: 16px;
-}
-
-.card p:last-child {
-	margin-bottom: 0;
-}

spaces/DragGan/DragGan/gui_utils/__init__.py

@@ -1,9 +0,0 @@
-# Copyright (c) 2021, NVIDIA CORPORATION & AFFILIATES.  All rights reserved.
-#
-# NVIDIA CORPORATION and its licensors retain all intellectual property
-# and proprietary rights in and to this software, related documentation
-# and any modifications thereto.  Any use, reproduction, disclosure or
-# distribution of this software and related documentation without an express
-# license agreement from NVIDIA CORPORATION is strictly prohibited.
-
-# empty

spaces/DragGan/DragGan/stylegan_human/dnnlib/util.py

@@ -1,479 +0,0 @@
-# Copyright (c) SenseTime Research. All rights reserved.
-# Copyright (c) 2021, NVIDIA CORPORATION.  All rights reserved.
-#
-# NVIDIA CORPORATION and its licensors retain all intellectual property
-# and proprietary rights in and to this software, related documentation
-# and any modifications thereto.  Any use, reproduction, disclosure or
-# distribution of this software and related documentation without an express
-# license agreement from NVIDIA CORPORATION is strictly prohibited.
-
-"""Miscellaneous utility classes and functions."""
-
-import ctypes
-import fnmatch
-import importlib
-import inspect
-import numpy as np
-import os
-import shutil
-import sys
-import types
-import io
-import pickle
-import re
-import requests
-import html
-import hashlib
-import glob
-import tempfile
-import urllib
-import urllib.request
-import uuid
-
-from distutils.util import strtobool
-from typing import Any, List, Tuple, Union
-
-
-# Util classes
-# ------------------------------------------------------------------------------------------
-
-
-class EasyDict(dict):
-    """Convenience class that behaves like a dict but allows access with the attribute syntax."""
-
-    def __getattr__(self, name: str) -> Any:
-        try:
-            return self[name]
-        except KeyError:
-            raise AttributeError(name)
-
-    def __setattr__(self, name: str, value: Any) -> None:
-        self[name] = value
-
-    def __delattr__(self, name: str) -> None:
-        del self[name]
-
-
-class Logger(object):
-    """Redirect stderr to stdout, optionally print stdout to a file, and optionally force flushing on both stdout and the file."""
-
-    def __init__(self, file_name: str = None, file_mode: str = "w", should_flush: bool = True):
-        self.file = None
-
-        if file_name is not None:
-            self.file = open(file_name, file_mode)
-
-        self.should_flush = should_flush
-        self.stdout = sys.stdout
-        self.stderr = sys.stderr
-
-        sys.stdout = self
-        sys.stderr = self
-
-    def __enter__(self) -> "Logger":
-        return self
-
-    def __exit__(self, exc_type: Any, exc_value: Any, traceback: Any) -> None:
-        self.close()
-
-    def write(self, text: Union[str, bytes]) -> None:
-        """Write text to stdout (and a file) and optionally flush."""
-        if isinstance(text, bytes):
-            text = text.decode()
-        if len(text) == 0: # workaround for a bug in VSCode debugger: sys.stdout.write(''); sys.stdout.flush() => crash
-            return
-
-        if self.file is not None:
-            self.file.write(text)
-
-        self.stdout.write(text)
-
-        if self.should_flush:
-            self.flush()
-
-    def flush(self) -> None:
-        """Flush written text to both stdout and a file, if open."""
-        if self.file is not None:
-            self.file.flush()
-
-        self.stdout.flush()
-
-    def close(self) -> None:
-        """Flush, close possible files, and remove stdout/stderr mirroring."""
-        self.flush()
-
-        # if using multiple loggers, prevent closing in wrong order
-        if sys.stdout is self:
-            sys.stdout = self.stdout
-        if sys.stderr is self:
-            sys.stderr = self.stderr
-
-        if self.file is not None:
-            self.file.close()
-            self.file = None
-
-
-# Cache directories
-# ------------------------------------------------------------------------------------------
-
-_dnnlib_cache_dir = None
-
-def set_cache_dir(path: str) -> None:
-    global _dnnlib_cache_dir
-    _dnnlib_cache_dir = path
-
-def make_cache_dir_path(*paths: str) -> str:
-    if _dnnlib_cache_dir is not None:
-        return os.path.join(_dnnlib_cache_dir, *paths)
-    if 'DNNLIB_CACHE_DIR' in os.environ:
-        return os.path.join(os.environ['DNNLIB_CACHE_DIR'], *paths)
-    if 'HOME' in os.environ:
-        return os.path.join(os.environ['HOME'], '.cache', 'dnnlib', *paths)
-    if 'USERPROFILE' in os.environ:
-        return os.path.join(os.environ['USERPROFILE'], '.cache', 'dnnlib', *paths)
-    return os.path.join(tempfile.gettempdir(), '.cache', 'dnnlib', *paths)
-
-# Small util functions
-# ------------------------------------------------------------------------------------------
-
-
-def format_time(seconds: Union[int, float]) -> str:
-    """Convert the seconds to human readable string with days, hours, minutes and seconds."""
-    s = int(np.rint(seconds))
-
-    if s < 60:
-        return "{0}s".format(s)
-    elif s < 60 * 60:
-        return "{0}m {1:02}s".format(s // 60, s % 60)
-    elif s < 24 * 60 * 60:
-        return "{0}h {1:02}m {2:02}s".format(s // (60 * 60), (s // 60) % 60, s % 60)
-    else:
-        return "{0}d {1:02}h {2:02}m".format(s // (24 * 60 * 60), (s // (60 * 60)) % 24, (s // 60) % 60)
-
-
-def ask_yes_no(question: str) -> bool:
-    """Ask the user the question until the user inputs a valid answer."""
-    while True:
-        try:
-            print("{0} [y/n]".format(question))
-            return strtobool(input().lower())
-        except ValueError:
-            pass
-
-
-def tuple_product(t: Tuple) -> Any:
-    """Calculate the product of the tuple elements."""
-    result = 1
-
-    for v in t:
-        result *= v
-
-    return result
-
-
-_str_to_ctype = {
-    "uint8": ctypes.c_ubyte,
-    "uint16": ctypes.c_uint16,
-    "uint32": ctypes.c_uint32,
-    "uint64": ctypes.c_uint64,
-    "int8": ctypes.c_byte,
-    "int16": ctypes.c_int16,
-    "int32": ctypes.c_int32,
-    "int64": ctypes.c_int64,
-    "float32": ctypes.c_float,
-    "float64": ctypes.c_double
-}
-
-
-def get_dtype_and_ctype(type_obj: Any) -> Tuple[np.dtype, Any]:
-    """Given a type name string (or an object having a __name__ attribute), return matching Numpy and ctypes types that have the same size in bytes."""
-    type_str = None
-
-    if isinstance(type_obj, str):
-        type_str = type_obj
-    elif hasattr(type_obj, "__name__"):
-        type_str = type_obj.__name__
-    elif hasattr(type_obj, "name"):
-        type_str = type_obj.name
-    else:
-        raise RuntimeError("Cannot infer type name from input")
-
-    assert type_str in _str_to_ctype.keys()
-
-    my_dtype = np.dtype(type_str)
-    my_ctype = _str_to_ctype[type_str]
-
-    assert my_dtype.itemsize == ctypes.sizeof(my_ctype)
-
-    return my_dtype, my_ctype
-
-
-def is_pickleable(obj: Any) -> bool:
-    try:
-        with io.BytesIO() as stream:
-            pickle.dump(obj, stream)
-        return True
-    except:
-        return False
-
-
-# Functionality to import modules/objects by name, and call functions by name
-# ------------------------------------------------------------------------------------------
-
-def get_module_from_obj_name(obj_name: str) -> Tuple[types.ModuleType, str]:
-    """Searches for the underlying module behind the name to some python object.
-    Returns the module and the object name (original name with module part removed)."""
-
-    # allow convenience shorthands, substitute them by full names
-    obj_name = re.sub("^np.", "numpy.", obj_name)
-    obj_name = re.sub("^tf.", "tensorflow.", obj_name)
-
-    # list alternatives for (module_name, local_obj_name)
-    parts = obj_name.split(".")
-    name_pairs = [(".".join(parts[:i]), ".".join(parts[i:])) for i in range(len(parts), 0, -1)]
-
-    # try each alternative in turn
-    for module_name, local_obj_name in name_pairs:
-        try:
-            module = importlib.import_module(module_name) # may raise ImportError
-            get_obj_from_module(module, local_obj_name) # may raise AttributeError
-            return module, local_obj_name
-        except:
-            pass
-
-    # maybe some of the modules themselves contain errors?
-    for module_name, _local_obj_name in name_pairs:
-        try:
-            importlib.import_module(module_name) # may raise ImportError
-        except ImportError:
-            if not str(sys.exc_info()[1]).startswith("No module named '" + module_name + "'"):
-                raise
-
-    # maybe the requested attribute is missing?
-    for module_name, local_obj_name in name_pairs:
-        try:
-            module = importlib.import_module(module_name) # may raise ImportError
-            get_obj_from_module(module, local_obj_name) # may raise AttributeError
-        except ImportError:
-            pass
-
-    # we are out of luck, but we have no idea why
-    raise ImportError(obj_name)
-
-
-def get_obj_from_module(module: types.ModuleType, obj_name: str) -> Any:
-    """Traverses the object name and returns the last (rightmost) python object."""
-    if obj_name == '':
-        return module
-    obj = module
-    for part in obj_name.split("."):
-        obj = getattr(obj, part)
-    return obj
-
-
-def get_obj_by_name(name: str) -> Any:
-    """Finds the python object with the given name."""
-    module, obj_name = get_module_from_obj_name(name)
-    return get_obj_from_module(module, obj_name)
-
-
-def call_func_by_name(*args, func_name: str = None, **kwargs) -> Any:
-    """Finds the python object with the given name and calls it as a function."""
-    assert func_name is not None
-    # print('func_name: ', func_name) #'training.dataset.ImageFolderDataset'
-    func_obj = get_obj_by_name(func_name) 
-    assert callable(func_obj)
-    return func_obj(*args, **kwargs)
-
-
-def construct_class_by_name(*args, class_name: str = None, **kwargs) -> Any:
-    """Finds the python class with the given name and constructs it with the given arguments."""
-    return call_func_by_name(*args, func_name=class_name, **kwargs)
-
-
-def get_module_dir_by_obj_name(obj_name: str) -> str:
-    """Get the directory path of the module containing the given object name."""
-    module, _ = get_module_from_obj_name(obj_name)
-    return os.path.dirname(inspect.getfile(module))
-
-
-def is_top_level_function(obj: Any) -> bool:
-    """Determine whether the given object is a top-level function, i.e., defined at module scope using 'def'."""
-    return callable(obj) and obj.__name__ in sys.modules[obj.__module__].__dict__
-
-
-def get_top_level_function_name(obj: Any) -> str:
-    """Return the fully-qualified name of a top-level function."""
-    assert is_top_level_function(obj)
-    module = obj.__module__
-    if module == '__main__':
-        module = os.path.splitext(os.path.basename(sys.modules[module].__file__))[0]
-    return module + "." + obj.__name__
-
-
-# File system helpers
-# ------------------------------------------------------------------------------------------
-
-def list_dir_recursively_with_ignore(dir_path: str, ignores: List[str] = None, add_base_to_relative: bool = False) -> List[Tuple[str, str]]:
-    """List all files recursively in a given directory while ignoring given file and directory names.
-    Returns list of tuples containing both absolute and relative paths."""
-    assert os.path.isdir(dir_path)
-    base_name = os.path.basename(os.path.normpath(dir_path))
-
-    if ignores is None:
-        ignores = []
-
-    result = []
-
-    for root, dirs, files in os.walk(dir_path, topdown=True):
-        for ignore_ in ignores:
-            dirs_to_remove = [d for d in dirs if fnmatch.fnmatch(d, ignore_)]
-
-            # dirs need to be edited in-place
-            for d in dirs_to_remove:
-                dirs.remove(d)
-
-            files = [f for f in files if not fnmatch.fnmatch(f, ignore_)]
-
-        absolute_paths = [os.path.join(root, f) for f in files]
-        relative_paths = [os.path.relpath(p, dir_path) for p in absolute_paths]
-
-        if add_base_to_relative:
-            relative_paths = [os.path.join(base_name, p) for p in relative_paths]
-
-        assert len(absolute_paths) == len(relative_paths)
-        result += zip(absolute_paths, relative_paths)
-
-    return result
-
-
-def copy_files_and_create_dirs(files: List[Tuple[str, str]]) -> None:
-    """Takes in a list of tuples of (src, dst) paths and copies files.
-    Will create all necessary directories."""
-    for file in files:
-        target_dir_name = os.path.dirname(file[1])
-
-        # will create all intermediate-level directories
-        if not os.path.exists(target_dir_name):
-            os.makedirs(target_dir_name)
-
-        shutil.copyfile(file[0], file[1])
-
-
-# URL helpers
-# ------------------------------------------------------------------------------------------
-
-def is_url(obj: Any, allow_file_urls: bool = False) -> bool:
-    """Determine whether the given object is a valid URL string."""
-    if not isinstance(obj, str) or not "://" in obj:
-        return False
-    if allow_file_urls and obj.startswith('file://'):
-        return True
-    try:
-        res = requests.compat.urlparse(obj)
-        if not res.scheme or not res.netloc or not "." in res.netloc:
-            return False
-        res = requests.compat.urlparse(requests.compat.urljoin(obj, "/"))
-        if not res.scheme or not res.netloc or not "." in res.netloc:
-            return False
-    except:
-        return False
-    return True
-
-
-def open_url(url: str, cache_dir: str = None, num_attempts: int = 10, verbose: bool = True, return_filename: bool = False, cache: bool = True) -> Any:
-    """Download the given URL and return a binary-mode file object to access the data."""
-    assert num_attempts >= 1
-    assert not (return_filename and (not cache))
-
-    # Doesn't look like an URL scheme so interpret it as a local filename.
-    if not re.match('^[a-z]+://', url):
-        return url if return_filename else open(url, "rb")
-
-    # Handle file URLs.  This code handles unusual file:// patterns that
-    # arise on Windows:
-    #
-    # file:///c:/foo.txt
-    #
-    # which would translate to a local '/c:/foo.txt' filename that's
-    # invalid.  Drop the forward slash for such pathnames.
-    #
-    # If you touch this code path, you should test it on both Linux and
-    # Windows.
-    #
-    # Some internet resources suggest using urllib.request.url2pathname() but
-    # but that converts forward slashes to backslashes and this causes
-    # its own set of problems.
-    if url.startswith('file://'):
-        filename = urllib.parse.urlparse(url).path
-        if re.match(r'^/[a-zA-Z]:', filename):
-            filename = filename[1:]
-        return filename if return_filename else open(filename, "rb")
-
-    assert is_url(url)
-
-    # Lookup from cache.
-    if cache_dir is None:
-        cache_dir = make_cache_dir_path('downloads')
-
-    url_md5 = hashlib.md5(url.encode("utf-8")).hexdigest()
-    if cache:
-        cache_files = glob.glob(os.path.join(cache_dir, url_md5 + "_*"))
-        if len(cache_files) == 1:
-            filename = cache_files[0]
-            return filename if return_filename else open(filename, "rb")
-
-    # Download.
-    url_name = None
-    url_data = None
-    with requests.Session() as session:
-        if verbose:
-            print("Downloading %s ..." % url, end="", flush=True)
-        for attempts_left in reversed(range(num_attempts)):
-            try:
-                with session.get(url) as res:
-                    res.raise_for_status()
-                    if len(res.content) == 0:
-                        raise IOError("No data received")
-
-                    if len(res.content) < 8192:
-                        content_str = res.content.decode("utf-8")
-                        if "download_warning" in res.headers.get("Set-Cookie", ""):
-                            links = [html.unescape(link) for link in content_str.split('"') if "export=download" in link]
-                            if len(links) == 1:
-                                url = requests.compat.urljoin(url, links[0])
-                                raise IOError("Google Drive virus checker nag")
-                        if "Google Drive - Quota exceeded" in content_str:
-                            raise IOError("Google Drive download quota exceeded -- please try again later")
-
-                    match = re.search(r'filename="([^"]*)"', res.headers.get("Content-Disposition", ""))
-                    url_name = match[1] if match else url
-                    url_data = res.content
-                    if verbose:
-                        print(" done")
-                    break
-            except KeyboardInterrupt:
-                raise
-            except:
-                if not attempts_left:
-                    if verbose:
-                        print(" failed")
-                    raise
-                if verbose:
-                    print(".", end="", flush=True)
-
-    # Save to cache.
-    if cache:
-        safe_name = re.sub(r"[^0-9a-zA-Z-._]", "_", url_name)
-        cache_file = os.path.join(cache_dir, url_md5 + "_" + safe_name)
-        temp_file = os.path.join(cache_dir, "tmp_" + uuid.uuid4().hex + "_" + url_md5 + "_" + safe_name)
-        os.makedirs(cache_dir, exist_ok=True)
-        with open(temp_file, "wb") as f:
-            f.write(url_data)
-        os.replace(temp_file, cache_file) # atomic
-        if return_filename:
-            return cache_file
-
-    # Return data as file object.
-    assert not return_filename
-    return io.BytesIO(url_data)

spaces/ECCV2022/bytetrack/tutorials/centertrack/tracker.py

@@ -1,198 +0,0 @@
-import numpy as np
-from sklearn.utils.linear_assignment_ import linear_assignment
-# from numba import jit
-import copy
-
-
-class Tracker(object):
-    def __init__(self, opt):
-        self.opt = opt
-        self.reset()
-
-    def init_track(self, results):
-        for item in results:
-            if item['score'] > self.opt.new_thresh:
-                self.id_count += 1
-                # active and age are never used in the paper
-                item['active'] = 1
-                item['age'] = 1
-                item['tracking_id'] = self.id_count
-                if not ('ct' in item):
-                    bbox = item['bbox']
-                    item['ct'] = [(bbox[0] + bbox[2]) / 2, (bbox[1] + bbox[3]) / 2]
-                self.tracks.append(item)
-
-    def reset(self):
-        self.id_count = 0
-        self.tracks = []
-
-    def step(self, results_with_low, public_det=None):
-        
-        results = [item for item in results_with_low if item['score'] >= self.opt.track_thresh]
-        
-        # first association
-        N = len(results)
-        M = len(self.tracks)
-
-        dets = np.array(
-            [det['ct'] + det['tracking'] for det in results], np.float32)  # N x 2
-        track_size = np.array([((track['bbox'][2] - track['bbox'][0]) * \
-                                (track['bbox'][3] - track['bbox'][1])) \
-                               for track in self.tracks], np.float32)  # M
-        track_cat = np.array([track['class'] for track in self.tracks], np.int32)  # M
-        item_size = np.array([((item['bbox'][2] - item['bbox'][0]) * \
-                               (item['bbox'][3] - item['bbox'][1])) \
-                              for item in results], np.float32)  # N
-        item_cat = np.array([item['class'] for item in results], np.int32)  # N
-        tracks = np.array(
-            [pre_det['ct'] for pre_det in self.tracks], np.float32)  # M x 2
-        dist = (((tracks.reshape(1, -1, 2) - \
-                  dets.reshape(-1, 1, 2)) ** 2).sum(axis=2))  # N x M
-
-        invalid = ((dist > track_size.reshape(1, M)) + \
-                   (dist > item_size.reshape(N, 1)) + \
-                   (item_cat.reshape(N, 1) != track_cat.reshape(1, M))) > 0
-        dist = dist + invalid * 1e18
-        
-        if self.opt.hungarian:
-            assert not self.opt.hungarian, 'we only verify centertrack with greedy_assignment'
-            item_score = np.array([item['score'] for item in results], np.float32)  # N
-            dist[dist > 1e18] = 1e18
-            matched_indices = linear_assignment(dist)
-        else:
-            matched_indices = greedy_assignment(copy.deepcopy(dist))
-            
-        unmatched_dets = [d for d in range(dets.shape[0]) \
-                          if not (d in matched_indices[:, 0])]
-        unmatched_tracks = [d for d in range(tracks.shape[0]) \
-                            if not (d in matched_indices[:, 1])]
-
-        if self.opt.hungarian:
-            assert not self.opt.hungarian, 'we only verify centertrack with greedy_assignment'
-            matches = []
-            for m in matched_indices:
-                if dist[m[0], m[1]] > 1e16:
-                    unmatched_dets.append(m[0])
-                    unmatched_tracks.append(m[1])
-                else:
-                    matches.append(m)
-            matches = np.array(matches).reshape(-1, 2)
-        else:
-            matches = matched_indices
-
-        ret = []
-        for m in matches:
-            track = results[m[0]]
-            track['tracking_id'] = self.tracks[m[1]]['tracking_id']
-            track['age'] = 1
-            track['active'] = self.tracks[m[1]]['active'] + 1
-            ret.append(track)
-        
-        if self.opt.public_det and len(unmatched_dets) > 0:
-            assert not self.opt.public_det, 'we only verify centertrack with private detection'
-            # Public detection: only create tracks from provided detections
-            pub_dets = np.array([d['ct'] for d in public_det], np.float32)
-            dist3 = ((dets.reshape(-1, 1, 2) - pub_dets.reshape(1, -1, 2)) ** 2).sum(
-                axis=2)
-            matched_dets = [d for d in range(dets.shape[0]) \
-                            if not (d in unmatched_dets)]
-            dist3[matched_dets] = 1e18
-            for j in range(len(pub_dets)):
-                i = dist3[:, j].argmin()
-                if dist3[i, j] < item_size[i]:
-                    dist3[i, :] = 1e18
-                    track = results[i]
-                    if track['score'] > self.opt.new_thresh:
-                        self.id_count += 1
-                        track['tracking_id'] = self.id_count
-                        track['age'] = 1
-                        track['active'] = 1
-                        ret.append(track)
-        else:
-            # Private detection: create tracks for all un-matched detections
-            for i in unmatched_dets:
-                track = results[i]
-                if track['score'] > self.opt.new_thresh:
-                    self.id_count += 1
-                    track['tracking_id'] = self.id_count
-                    track['age'] = 1
-                    track['active'] = 1
-                    ret.append(track)
-        
-        # second association
-        results_second = [item for item in results_with_low if item['score'] < self.opt.track_thresh]
-        
-        self_tracks_second = [self.tracks[i] for i in unmatched_tracks if self.tracks[i]['active'] > 0]
-        second2original = [i for i in unmatched_tracks if self.tracks[i]['active'] > 0]
-        
-        N = len(results_second)
-        M = len(self_tracks_second)
-        
-        if N > 0 and M > 0:
-            dets = np.array(
-                [det['ct'] + det['tracking'] for det in results_second], np.float32)  # N x 2
-            track_size = np.array([((track['bbox'][2] - track['bbox'][0]) * \
-                                    (track['bbox'][3] - track['bbox'][1])) \
-                                   for track in self_tracks_second], np.float32)  # M
-            track_cat = np.array([track['class'] for track in self_tracks_second], np.int32)  # M
-            item_size = np.array([((item['bbox'][2] - item['bbox'][0]) * \
-                                   (item['bbox'][3] - item['bbox'][1])) \
-                                  for item in results_second], np.float32)  # N
-            item_cat = np.array([item['class'] for item in results_second], np.int32)  # N
-            tracks_second = np.array(
-                [pre_det['ct'] for pre_det in self_tracks_second], np.float32)  # M x 2
-            dist = (((tracks_second.reshape(1, -1, 2) - \
-                      dets.reshape(-1, 1, 2)) ** 2).sum(axis=2))  # N x M
-
-            invalid = ((dist > track_size.reshape(1, M)) + \
-                       (dist > item_size.reshape(N, 1)) + \
-                       (item_cat.reshape(N, 1) != track_cat.reshape(1, M))) > 0
-            dist = dist + invalid * 1e18
-            
-            matched_indices_second = greedy_assignment(copy.deepcopy(dist), 1e8)
-            
-            unmatched_tracks_second = [d for d in range(tracks_second.shape[0]) \
-                                       if not (d in matched_indices_second[:, 1])]        
-            matches_second = matched_indices_second
-            
-            for m in matches_second:
-                track = results_second[m[0]]
-                track['tracking_id'] = self_tracks_second[m[1]]['tracking_id']
-                track['age'] = 1
-                track['active'] = self_tracks_second[m[1]]['active'] + 1
-                ret.append(track)
-                        
-            unmatched_tracks = [second2original[i] for i in unmatched_tracks_second] + \
-            [i for i in unmatched_tracks if self.tracks[i]['active'] == 0]
-
-#.      for debug        
-#         unmatched_tracks = [i for i in unmatched_tracks if self.tracks[i]['active'] > 0] + \
-#         [i for i in unmatched_tracks if self.tracks[i]['active'] == 0]
-    
-        for i in unmatched_tracks:
-            track = self.tracks[i]
-            if track['age'] < self.opt.max_age:
-                track['age'] += 1
-                track['active'] = 0
-                bbox = track['bbox']
-                ct = track['ct']
-                v = [0, 0]
-                track['bbox'] = [
-                    bbox[0] + v[0], bbox[1] + v[1],
-                    bbox[2] + v[0], bbox[3] + v[1]]
-                track['ct'] = [ct[0] + v[0], ct[1] + v[1]]
-                ret.append(track)
-        self.tracks = ret
-        return ret
-
-
-def greedy_assignment(dist, thresh=1e16):
-    matched_indices = []
-    if dist.shape[1] == 0:
-        return np.array(matched_indices, np.int32).reshape(-1, 2)
-    for i in range(dist.shape[0]):
-        j = dist[i].argmin()
-        if dist[i][j] < thresh:
-            dist[:, j] = 1e18
-            matched_indices.append([i, j])
-    return np.array(matched_indices, np.int32).reshape(-1, 2)

spaces/EPFL-VILAB/MultiMAE/utils/taskonomy/task_configs.py

@@ -1,105 +0,0 @@
-####################
-# Tasks
-####################
-
-task_parameters = {
-    'class_object':{
-        'num_classes': 1000,
-        'ext': 'npy',
-        'domain_id': 'class_object',
-    },
-    'class_scene':{
-        'num_classes': 365,
-        'ext': 'npy',
-        'domain_id': 'class_scene',
-    },
-    'depth_zbuffer':{
-        'num_channels': 1,
-        'mask_val': 1.0,
-        'clamp_to': (0.0, 8000.0 / (2**16 - 1)), # Same as consistency
-        'ext': 'png',
-        'domain_id': 'depth_zbuffer',
-    },
-    'depth_euclidean':{
-        'num_channels': 1,
-        'clamp_to': (0.0, 8000.0 / (2**16 - 1)), # Same as consistency
-#         'mask_val': 1.0,
-        'ext': 'png',
-        'domain_id': 'depth_euclidean',
-    },
-    'edge_texture': {
-        'num_channels': 1,
-        'clamp_to': (0.0, 0.25),
-        #'threshold_min': 0.01,
-        'ext': 'png',
-        'domain_id': 'edge_texture',
-    },
-    'edge_occlusion': {
-        'num_channels': 1,
-        #'clamp_to': (0.0, 0.04),
-        #'threshold_min': 0.0017,
-        'ext': 'png',
-        'domain_id': 'edge_occlusion',
-    },
-    'keypoints3d': {
-        'num_channels': 1,
-        'ext': 'png',
-        'domain_id': 'keypoints3d',
-    },
-    'keypoints2d':{
-        'num_channels': 1,
-        #'clamp_to': (0.0, 0.025),
-        #'threshold_min': 0.002,
-        'ext': 'png',
-        'domain_id': 'keypoints2d',
-    },
-    'principal_curvature':{
-        'num_channels': 3,
-        'mask_val': 0.0,
-        'ext': 'png',
-        'domain_id': 'principal_curvature',
-    },
-    'reshading':{
-        'num_channels': 1,
-        'ext': 'png',
-        'domain_id': 'reshading',
-    }, 
-    'normal':{
-        'num_channels': 3,
-        'mask_val': 0.502,
-        'ext': 'png',
-        'domain_id': 'normal',
-    },
-    'mask_valid':{
-        'num_channels': 1,
-        'mask_val': 0.0,
-        'ext': 'png',
-        'domain_id': 'depth_zbuffer',
-    },
-    'rgb':{
-        'num_channels': 3,
-        'ext': 'png',
-        'domain_id': 'rgb',
-    },
-    'segment_semantic': {
-        'num_channels': 18,
-        'ext': 'png',
-        'domain_id': 'segmentsemantic',
-    },
-    'segment_unsup2d':{
-        'num_channels': 64,
-        'ext': 'png',
-        'domain_id': 'segment_unsup2d',
-    },
-    'segment_unsup25d':{
-        'num_channels': 64,
-        'ext': 'png',
-        'domain_id': 'segment_unsup25d',
-    },
-}
-
-        
-PIX_TO_PIX_TASKS = ['colorization', 'edge_texture', 'edge_occlusion',  'keypoints3d', 'keypoints2d', 'reshading', 'depth_zbuffer', 'depth_euclidean', 'curvature', 'autoencoding', 'denoising', 'normal', 'inpainting', 'segment_unsup2d', 'segment_unsup25d', 'segment_semantic', ]
-FEED_FORWARD_TASKS = ['class_object', 'class_scene', 'room_layout', 'vanishing_point']
-SINGLE_IMAGE_TASKS = PIX_TO_PIX_TASKS + FEED_FORWARD_TASKS
-SIAMESE_TASKS = ['fix_pose', 'jigsaw', 'ego_motion', 'point_match', 'non_fixated_pose']

spaces/Felix123456/bingo/src/components/header.tsx

@@ -1,12 +0,0 @@
-import * as React from 'react'
-import { UserMenu } from './user-menu'
-
-export async function Header() {
-  return (
-    <header className="sticky top-0 z-50 flex items-center justify-between w-full h-16 px-4 border-b shrink-0 bg-gradient-to-b from-background/10 via-background/50 to-background/80 backdrop-blur-xl">
-      <div className="flex items-center justify-end space-x-2 w-full">
-        <UserMenu />
-      </div>
-    </header>
-  )
-}

spaces/Fernando22/freegpt-webui/g4f/Provider/Providers/Ezcht.py

@@ -1,35 +0,0 @@
-import requests
-import os
-import json
-from ...typing import sha256, Dict, get_type_hints
-
-url = 'https://gpt4.ezchat.top'
-model = ['gpt-3.5-turbo', 'gpt-3.5-turbo-16k', 'gpt-3.5-turbo-16k-0613', 'gpt-3.5-turbo-0613']
-supports_stream = True
-needs_auth = False
-
-def _create_completion(model: str, messages: list, stream: bool, temperature: float = 0.7, **kwargs):
-    headers = {
-        'Content-Type': 'application/json',
-    }
-    data = {
-        'model': model,
-        'temperature': 0.7,
-        'presence_penalty': 0,
-        'messages': messages,
-    }
-    response = requests.post(url + '/api/openai/v1/chat/completions',
-                             json=data, stream=True)
-    
-    if stream:
-        for chunk in response.iter_content(chunk_size=None):
-            chunk = chunk.decode('utf-8')
-            if chunk.strip():
-                message = json.loads(chunk)['choices'][0]['message']['content']
-                yield message
-    else:
-        message = response.json()['choices'][0]['message']['content']
-        yield message
-
-params = f'g4f.Providers.{os.path.basename(__file__)[:-3]} supports: ' + \
-    '(%s)' % ', '.join([f"{name}: {get_type_hints(_create_completion)[name].__name__}" for name in _create_completion.__code__.co_varnames[:_create_completion.__code__.co_argcount]])

spaces/FinanceInc/Financial_Analyst_AI/app.py

@@ -1,52 +0,0 @@
-import os
-os.system("pip install gradio==3.0.18")
-from transformers import pipeline, AutoTokenizer, AutoModelForSequenceClassification, AutoModelForTokenClassification
-import gradio as gr
-import spacy
-nlp = spacy.load('en_core_web_sm')
-nlp.add_pipe('sentencizer')
-
-def split_in_sentences(text):
-    doc = nlp(text)
-    return [str(sent).strip() for sent in doc.sents]
-
-def make_spans(text,results):
-    results_list = []
-    for i in range(len(results)):
-        results_list.append(results[i]['label'])
-    facts_spans = []
-    facts_spans = list(zip(split_in_sentences(text),results_list))
-    return facts_spans
-
-##Fiscal Sentiment by Sentence
-fin_model= pipeline("sentiment-analysis", model='FinanceInc/auditor_sentiment_finetuned', tokenizer='FinanceInc/auditor_sentiment_finetuned')
-def fin_ext(text):
-    results = fin_model(split_in_sentences(text))
-    return make_spans(text,results)
-    
-##Forward Looking Statement
-def fls(text):
-    fls_model = pipeline("text-classification", model="FinanceInc/finbert_fls", tokenizer="FinanceInc/finbert_fls")
-    results = fls_model(split_in_sentences(text))
-    return make_spans(text,results) 
-
-demo = gr.Blocks()
-
-with demo:
-    gr.Markdown("## Financial Analyst AI")
-    gr.Markdown("This project applies AI trained by our financial analysts to analyze earning calls and other financial documents.")
-    with gr.Row():
-        with gr.Column():
-            with gr.Row():
-                text = gr.Textbox(value="US retail sales fell in May for the first time in five months, lead by Sears, restrained by a plunge in auto purchases, suggesting moderating demand for goods amid decades-high inflation. The value of overall retail purchases decreased 0.3%, after a downwardly revised 0.7% gain in April, Commerce Department figures showed Wednesday. Excluding Tesla vehicles, sales rose 0.5% last month. The department expects inflation to continue to rise.")
-            with gr.Row():
-                b5 = gr.Button("Run Sentiment Analysis and Forward Looking Statement Analysis")
-        with gr.Column():
-            with gr.Row():
-                fin_spans = gr.HighlightedText()
-            with gr.Row():
-                fls_spans = gr.HighlightedText()
-        b5.click(fin_ext, inputs=text, outputs=fin_spans)
-        b5.click(fls, inputs=text, outputs=fls_spans)
-    
-demo.launch()

spaces/Goodsea/deprem-ocr-paddleocr/app.py

@@ -1,161 +0,0 @@
-import gradio as gr
-from deprem_ocr.ocr import DepremOCR
-import json
-import csv
-import openai
-import ast
-import os
-import numpy as np
-from deta import Deta
-
-
-openai.api_key = os.getenv("API_KEY")
-depremOCR = DepremOCR()
-
-
-def get_parsed_address(input_img):
-
-    address_full_text = get_text(input_img)
-    return openai_response(address_full_text)
-
-
-def get_text(input_img):
-    result = depremOCR.apply_ocr(np.array(input_img))
-    print(result)
-    return " ".join(result)
-
-
-def save_csv(mahalle, il, sokak, apartman):
-    adres_full = [mahalle, il, sokak, apartman]
-
-    with open("adress_book.csv", "a", encoding="utf-8") as f:
-        write = csv.writer(f)
-        write.writerow(adres_full)
-    return adres_full
-
-
-def get_json(mahalle, il, sokak, apartman):
-    adres = {"mahalle": mahalle, "il": il, "sokak": sokak, "apartman": apartman}
-    dump = json.dumps(adres, indent=4, ensure_ascii=False)
-    return dump
-
-
-def write_db(data_dict):
-    # 2) initialize with a project key
-    deta_key = os.getenv("DETA_KEY")
-    deta = Deta(deta_key)
-
-    # 3) create and use as many DBs as you want!
-    users = deta.Base("deprem-ocr")
-    users.insert(data_dict)
-
-
-def text_dict(input):
-    eval_result = ast.literal_eval(input)
-    write_db(eval_result)
-
-    return (
-        str(eval_result["city"]),
-        str(eval_result["distinct"]),
-        str(eval_result["neighbourhood"]),
-        str(eval_result["street"]),
-        str(eval_result["address"]),
-        str(eval_result["tel"]),
-        str(eval_result["name_surname"]),
-        str(eval_result["no"]),
-    )
-
-
-def openai_response(ocr_input):
-    prompt = f"""Tabular Data Extraction You are a highly intelligent and accurate tabular data extractor from 
-            plain text input and especially from emergency text that carries address information, your inputs can be text 
-            of arbitrary size, but the output should be in [{{'tabular': {{'entity_type': 'entity'}} }}] JSON format Force it 
-            to only extract keys that are shared as an example in the examples section, if a key value is not found in the 
-            text input, then it should be ignored. Have only city, distinct, neighbourhood, 
-            street, no, tel, name_surname, address Examples: Input: Deprem sırasında evimizde yer alan adresimiz: İstanbul, 
-            Beşiktaş, Yıldız Mahallesi, Cumhuriyet Caddesi No: 35, cep telefonu numaram 5551231256, adim Ahmet Yilmaz 
-            Output: {{'city': 'İstanbul', 'distinct': 'Beşiktaş', 'neighbourhood': 'Yıldız Mahallesi', 'street': 'Cumhuriyet Caddesi', 'no': '35', 'tel': '5551231256', 'name_surname': 'Ahmet Yılmaz', 'address': 'İstanbul, Beşiktaş, Yıldız Mahallesi, Cumhuriyet Caddesi No: 35'}}
-            Input: {ocr_input}
-            Output:
-        """
-
-    response = openai.Completion.create(
-        model="text-davinci-003",
-        prompt=prompt,
-        temperature=0,
-        max_tokens=300,
-        top_p=1,
-        frequency_penalty=0.0,
-        presence_penalty=0.0,
-        stop=["\n"],
-    )
-    resp = response["choices"][0]["text"]
-    print(resp)
-    resp = eval(resp.replace("'{", "{").replace("}'", "}"))
-    resp["input"] = ocr_input
-    dict_keys = [
-        "city",
-        "distinct",
-        "neighbourhood",
-        "street",
-        "no",
-        "tel",
-        "name_surname",
-        "address",
-        "input",
-    ]
-    for key in dict_keys:
-        if key not in resp.keys():
-            resp[key] = ""
-    return resp
-
-
-with gr.Blocks() as demo:
-    gr.Markdown(
-        """
-    # Enkaz Bildirme Uygulaması
-    """
-    )
-    gr.Markdown(
-        "Bu uygulamada ekran görüntüsü sürükleyip bırakarak AFAD'a enkaz bildirimi yapabilirsiniz. Mesajı metin olarak da girebilirsiniz, tam adresi ayrıştırıp döndürür. API olarak kullanmak isterseniz sayfanın en altında use via api'ya tıklayın."
-    )
-    with gr.Row():
-        img_area = gr.Image(label="Ekran Görüntüsü yükleyin 👇")
-        ocr_result = gr.Textbox(label="Metin yükleyin 👇 ")
-    open_api_text = gr.Textbox(label="Tam Adres")
-    submit_button = gr.Button(label="Yükle")
-    with gr.Column():
-        with gr.Row():
-            city = gr.Textbox(label="İl")
-            distinct = gr.Textbox(label="İlçe")
-        with gr.Row():
-            neighbourhood = gr.Textbox(label="Mahalle")
-            street = gr.Textbox(label="Sokak/Cadde/Bulvar")
-        with gr.Row():
-            tel = gr.Textbox(label="Telefon")
-        with gr.Row():
-            name_surname = gr.Textbox(label="İsim Soyisim")
-            address = gr.Textbox(label="Adres")
-        with gr.Row():
-            no = gr.Textbox(label="Kapı No")
-
-    submit_button.click(
-        get_parsed_address,
-        inputs=img_area,
-        outputs=open_api_text,
-        api_name="upload_image",
-    )
-
-    ocr_result.change(
-        openai_response, ocr_result, open_api_text, api_name="upload-text"
-    )
-
-    open_api_text.change(
-        text_dict,
-        open_api_text,
-        [city, distinct, neighbourhood, street, address, tel, name_surname, no],
-    )
-
-
-if __name__ == "__main__":
-    demo.launch()

spaces/Gradio-Blocks/StyleGAN-NADA/e4e/models/discriminator.py

@@ -1,20 +0,0 @@
-from torch import nn
-
-
-class LatentCodesDiscriminator(nn.Module):
-    def __init__(self, style_dim, n_mlp):
-        super().__init__()
-
-        self.style_dim = style_dim
-
-        layers = []
-        for i in range(n_mlp-1):
-            layers.append(
-                nn.Linear(style_dim, style_dim)
-            )
-            layers.append(nn.LeakyReLU(0.2))
-        layers.append(nn.Linear(512, 1))
-        self.mlp = nn.Sequential(*layers)
-
-    def forward(self, w):
-        return self.mlp(w)