Duplicate from Weyaxi/commit-trash-huggingface-spaces-codes

.gitattributes

@@ -0,0 +1,63 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.lz4 filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+# Audio files - uncompressed
+*.pcm filter=lfs diff=lfs merge=lfs -text
+*.sam filter=lfs diff=lfs merge=lfs -text
+*.raw filter=lfs diff=lfs merge=lfs -text
+# Audio files - compressed
+*.aac filter=lfs diff=lfs merge=lfs -text
+*.flac filter=lfs diff=lfs merge=lfs -text
+*.mp3 filter=lfs diff=lfs merge=lfs -text
+*.ogg filter=lfs diff=lfs merge=lfs -text
+*.wav filter=lfs diff=lfs merge=lfs -text
+# Image files - uncompressed
+*.bmp filter=lfs diff=lfs merge=lfs -text
+*.gif filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.tiff filter=lfs diff=lfs merge=lfs -text
+# Image files - compressed
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text
+*.webp filter=lfs diff=lfs merge=lfs -text
+spaces/Pattr/DrumClassification/lilypond-2.24.2/lib/guile/2.2/ccache/system/vm/assembler.go filter=lfs diff=lfs merge=lfs -text
+spaces/Pattr/DrumClassification/lilypond-2.24.2/lib/guile/2.2/ccache/system/vm/dwarf.go filter=lfs diff=lfs merge=lfs -text
+spaces/bigscience-data/bloom-tokenizer-multilinguality/index.html filter=lfs diff=lfs merge=lfs -text
+spaces/bigscience-data/bloom-tokens/index.html filter=lfs diff=lfs merge=lfs -text
+spaces/ghuron/artist/dataset/astro.sql filter=lfs diff=lfs merge=lfs -text
+spaces/pdjewell/sommeli_ai/images/px.html filter=lfs diff=lfs merge=lfs -text
+spaces/pdjewell/sommeli_ai/images/px_2d.html filter=lfs diff=lfs merge=lfs -text
+spaces/pdjewell/sommeli_ai/images/px_3d.html filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,202 @@
+---
+configs:
+- config_name: default
+  data_files:
+    spaces.csv
+
+license: other
+language:
+- code
+size_categories:
+- 100K<n<1M
+---
+![image/png](https://cdn-uploads.huggingface.co/production/uploads/6468ce47e134d050a58aa89c/lzGCX2qjX_nPeRBZoa2v0.png)
+
+# 📊 Dataset Description
+
+This dataset comprises code files of Huggingface Spaces that have more than 0 likes as of November 10, 2023. This dataset contains various programming languages totaling in 672 MB of compressed and 2.05 GB of uncompressed data.
+
+# 📝 Data Fields
+
+| Field      | Type   | Description                              |
+|------------|--------|------------------------------------------|
+| repository | string | Huggingface Spaces repository names.     |
+| sdk        | string | Software Development Kit of the space.   |
+| license    | string | License type of the space.               |
+
+## 🧩 Data Structure
+
+Data structure of the data.
+
+```
+spaces/
+├─ author1/
+│  ├─ space1
+│  ├─ space2
+├─ author2/
+│  ├─ space1
+│  ├─ space2
+│  ├─ space3
+```
+
+# 🏛️ Licenses
+
+Huggingface Spaces contains a variety of licenses. Here is the list of the licenses that this dataset contains:
+
+```python
+[
+   'None',
+   'mit',
+   'apache-2.0',
+   'openrail',
+   'gpl-3.0',
+   'other',
+   'afl-3.0',
+   'unknown',
+   'creativeml-openrail-m',
+   'cc-by-nc-4.0',
+   'cc-by-4.0',
+   'cc',
+   'cc-by-nc-sa-4.0',
+   'bigscience-openrail-m',
+   'bsd-3-clause',
+   'agpl-3.0',
+   'wtfpl',
+   'gpl',
+   'artistic-2.0',
+   'lgpl-3.0',
+   'cc-by-sa-4.0',
+   'Configuration error',
+   'bsd',
+   'cc-by-nc-nd-4.0',
+   'cc0-1.0',
+   'unlicense',
+   'llama2',
+   'bigscience-bloom-rail-1.0',
+   'gpl-2.0',
+   'bsd-2-clause',
+   'osl-3.0',
+   'cc-by-2.0',
+   'cc-by-3.0',
+   'cc-by-nc-3.0',
+   'cc-by-nc-2.0',
+   'cc-by-nd-4.0',
+   'openrail++',
+   'bigcode-openrail-m',
+   'bsd-3-clause-clear',
+   'eupl-1.1',
+   'cc-by-sa-3.0',
+   'mpl-2.0',
+   'c-uda',
+   'gfdl',
+   'cc-by-nc-sa-2.0',
+   'cc-by-2.5',
+   'bsl-1.0',
+   'odc-by',
+   'deepfloyd-if-license',
+   'ms-pl',
+   'ecl-2.0',
+   'pddl',
+   'ofl-1.1',
+   'lgpl-2.1',
+   'postgresql',
+   'lppl-1.3c',
+   'ncsa',
+   'cc-by-nc-sa-3.0'
+]
+```
+
+# 📊 Dataset Statistics
+
+| Language   | File Extension | File Counts | File Size (MB) | Line Counts |
+|------------|-----------------|-------------|----------------|-------------|
+| Python     | .py             | 141,560     | 1079.0         | 28,653,744  |
+| SQL        | .sql            | 21          | 523.6          | 645         |
+| JavaScript | .js             | 6,790       | 369.8          | 2,137,054   |
+| Markdown   | .md             | 63,237      | 273.4          | 3,110,443   |
+| HTML       | .html           | 1,953       | 265.8          | 516,020     |
+| C          | .c              | 1,320       | 132.2          | 3,558,826   |
+| Go         | .go             | 429         | 46.3           | 6,331       |
+| CSS        | .css            | 3,097       | 25.6           | 386,334     |
+| C Header   | .h              | 2,824       | 20.4           | 570,948     |
+| C++        | .cpp            | 1,117       | 15.3           | 494,939     |
+| TypeScript | .ts             | 4,158       | 14.8           | 439,551     |
+| TSX        | .tsx            | 4,273       | 9.4            | 306,416     |
+| Shell      | .sh             | 3,294       | 5.5            | 171,943     |
+| Perl       | .pm             | 92          | 4.2            | 128,594     |
+| C#         | .cs             | 22          | 3.9            | 41,265      |
+
+
+## 🖥️ Language
+
+![image/png](https://cdn-uploads.huggingface.co/production/uploads/6468ce47e134d050a58aa89c/Dn8oaZh2BXtOHgQ8DaX09.png)
+
+## 📁 Size
+
+![image/png](https://cdn-uploads.huggingface.co/production/uploads/6468ce47e134d050a58aa89c/vRLCfs-QrEnDwhBnBu3rc.png)
+
+## 📝 Line Count
+
+![image/png](https://cdn-uploads.huggingface.co/production/uploads/6468ce47e134d050a58aa89c/8F_qgL1o7xZxR1zZ8bP76.png)
+
+# 🤗 Huggingface Spaces Statistics
+
+## 🛠️ Software Development Kit (SDK)
+
+Software Development Kit pie chart.
+
+![image/png](https://cdn-uploads.huggingface.co/production/uploads/6468ce47e134d050a58aa89c/BmW_BdYtH3XpYNH23NLVZ.png)
+
+## 🏛️ License
+
+License chart.
+
+![image/png](https://cdn-uploads.huggingface.co/production/uploads/6468ce47e134d050a58aa89c/dnxm5dJA_QzekwULwPS33.png)
+
+# 📅 Dataset Creation
+
+This dataset was created in these steps:
+
+1. Scraped all spaces using the Huggingface Hub API.
+
+```python
+from huggingface_hub import HfApi
+api = HfApi()
+
+spaces = api.list_spaces(sort="likes", full=1, direction=-1)
+```
+
+2. Filtered spaces with more than 0 likes.
+
+```python
+a = {}
+
+for i in tqdm(spaces):
+  i = i.__dict__
+  if i['likes'] > 0:
+    try:
+      try:
+          a[i['id']] = {'sdk': i['sdk'], 'license': i['cardData']['license'], 'likes': i['likes']}
+      except KeyError:
+        a[i['id']] = {'sdk': i['sdk'], 'license': None, 'likes': i['likes']}
+    except:
+      a[i['id']] = {'sdk': "Configuration error", 'license': "Configuration error", 'likes': i['likes']}
+
+data_list = [{'repository': key, 'sdk': value['sdk'], 'license': value['license'], 'likes': value['likes']} for key, value in a.items()]
+
+df = pd.DataFrame(data_list)
+```
+
+3. Cloned spaces locally.
+
+```python
+from huggingface_hub import snapshot_download
+
+programming = ['.asm', '.bat', '.cmd', '.c', '.h', '.cs', '.cpp', '.hpp', '.c++', '.h++', '.cc', '.hh', '.C', '.H', '.cmake', '.css', '.dockerfile', 'Dockerfile', '.f90', '.f', '.f03', '.f08', '.f77', '.f95', '.for', '.fpp', '.go', '.hs', '.html', '.java', '.js', '.jl', '.lua', 'Makefile', '.md', '.markdown', '.php', '.php3', '.php4', '.php5', '.phps', '.phpt', '.pl', '.pm', '.pod', '.perl', '.ps1', '.psd1', '.psm1', '.py', '.rb', '.rs', '.sql', '.scala', '.sh', '.bash', '.command', '.zsh', '.ts', '.tsx', '.tex', '.vb']
+pattern = [f"*{i}" for i in programming]
+
+for i in repos:
+  snapshot_download(i, repo_type="space", local_dir=f"spaces/{i}", allow_patterns=pattern)
+````
+
+4. Processed the data to derive statistics.

errors.txt

@@ -0,0 +1,24 @@
+ky2k/Toxicity_Classifier_POC
+tialenAdioni/chat-gpt-api
+Narsil/myspace
+arxify/RVC-beta-v2-0618
+WitchHuntTV/WinnieThePoohSVC_sovits4
+yizhangliu/Grounded-Segment-Anything
+Robert001/UniControl-Demo
+internetsignal/audioLDM
+inamXcontru/PoeticTTS
+dcarpintero/nlp-summarizer-pegasus
+SungBeom/chatwine-korean
+x6/BingAi
+1gistliPinn/ChatGPT4
+colakin/video-generater
+stomexserde/gpt4-ui
+quidiaMuxgu/Expedit-SAM
+NasirKhalid24/Dalle2-Diffusion-Prior
+joaopereirajp/livvieChatBot
+diacanFperku/AutoGPT
+tioseFevbu/cartoon-converter
+chuan-hd/law-assistant-chatbot
+mshukor/UnIVAL
+xuyingliKepler/openai_play_tts
+TNR-5/lib111

spaces.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fbb4b253de8e51bfa330e5c7cf31f7841e64ef30c1718d4a05c75e21c8ccf729
+size 671941275

spaces/0019c/NewBing/Dockerfile

@@ -0,0 +1,34 @@
+# Build Stage
+# 使用 golang:alpine 作为构建阶段的基础镜像
+FROM golang:alpine AS builder
+
+# 添加 git，以便之后能从GitHub克隆项目
+RUN apk --no-cache add git
+
+# 从 GitHub 克隆 go-proxy-bingai 项目到 /workspace/app 目录下
+RUN git clone https://github.com/Harry-zklcdc/go-proxy-bingai.git /workspace/app
+
+# 设置工作目录为之前克隆的项目目录
+WORKDIR /workspace/app
+
+# 编译 go 项目。-ldflags="-s -w" 是为了减少编译后的二进制大小
+RUN go build -ldflags="-s -w" -tags netgo -trimpath -o go-proxy-bingai main.go
+
+# Runtime Stage
+# 使用轻量级的 alpine 镜像作为运行时的基础镜像
+FROM alpine
+
+# 设置工作目录
+WORKDIR /workspace/app
+
+# 从构建阶段复制编译后的二进制文件到运行时镜像中
+COPY --from=builder /workspace/app/go-proxy-bingai .
+
+# 设置环境变量，此处为随机字符
+ENV Go_Proxy_BingAI_USER_TOKEN_1="1h_21qf8tNmRtDy5a4fZ05RFgkZeZ9akmnW9NtSo5s6aJilplld4X4Lj7BkJ3EQSNbu7tu-z_-OAHqeELJqlpF-bvOCMo5lWGjyCTcJcqIHnYiu_vlgrdDyo99wQHgsvNR5pKASGikeDgAVSN7CN6YM74n7glWgJ7hGpd33s9zcgdCea94XcsO5AmoPIoxA02O6zGkpTnIdc61W7D1WQUflqxgaSHCGWlrhw7aoPs-io"
+
+# 暴露8080端口
+EXPOSE 8080
+
+# 容器启动时运行的命令
+CMD ["/workspace/app/go-proxy-bingai"]

spaces/0019c/NewBing/README.md

@@ -0,0 +1,12 @@
+---
+title: NewBing
+emoji: 🏢
+colorFrom: green
+colorTo: red
+sdk: docker
+pinned: false
+license: mit
+app_port: 8080
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/01zhangclare/bingai/Dockerfile

@@ -0,0 +1,34 @@
+# Build Stage
+# 使用 golang:alpine 作为构建阶段的基础镜像
+FROM golang:alpine AS builder
+
+# 添加 git，以便之后能从GitHub克隆项目
+RUN apk --no-cache add git
+
+# 从 GitHub 克隆 go-proxy-bingai 项目到 /workspace/app 目录下
+RUN git clone https://github.com/Harry-zklcdc/go-proxy-bingai.git /workspace/app
+
+# 设置工作目录为之前克隆的项目目录
+WORKDIR /workspace/app
+
+# 编译 go 项目。-ldflags="-s -w" 是为了减少编译后的二进制大小
+RUN go build -ldflags="-s -w" -tags netgo -trimpath -o go-proxy-bingai main.go
+
+# Runtime Stage
+# 使用轻量级的 alpine 镜像作为运行时的基础镜像
+FROM alpine
+
+# 设置工作目录
+WORKDIR /workspace/app
+
+# 从构建阶段复制编译后的二进制文件到运行时镜像中
+COPY --from=builder /workspace/app/go-proxy-bingai .
+
+# 设置环境变量，此处为随机字符
+ENV Go_Proxy_BingAI_USER_TOKEN_1="kJs8hD92ncMzLaoQWYtX5rG6bE3fZ4iO"
+
+# 暴露8080端口
+EXPOSE 8080
+
+# 容器启动时运行的命令
+CMD ["/workspace/app/go-proxy-bingai"]

spaces/01zhangclare/bingai/README.md

@@ -0,0 +1,12 @@
+---
+title: Bingai
+emoji: 🏃
+colorFrom: indigo
+colorTo: purple
+sdk: docker
+pinned: false
+license: mit
+app_port: 8080
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/07jeancms/minima/README.md

@@ -0,0 +1,13 @@
+---
+title: Minima
+emoji: 🔥
+colorFrom: yellow
+colorTo: gray
+sdk: gradio
+sdk_version: 3.35.2
+app_file: app.py
+pinned: false
+license: apache-2.0
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/07jeancms/minima/app.py

@@ -0,0 +1,7 @@
+import gradio as gr
+
+def greet(name):
+    return "Hello " + name + "!!"
+
+iface = gr.Interface(fn=greet, inputs="text", outputs="text")
+iface.launch()

spaces/0x1337/vector-inference/README.md

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

spaces/0x1337/vector-inference/app.py

@@ -0,0 +1,5 @@
+import gradio as gr
+
+gr.Interface.load("models/coder119/Vectorartz_Diffusion").launch()\
+
+iface.launch()

spaces/0x7194633/mbrat-ru-sum/README.md

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

spaces/0x7194633/mbrat-ru-sum/app.py

@@ -0,0 +1,13 @@
+import gradio as gr
+from transformers import MBartTokenizer, MBartForConditionalGeneration
+
+model_name = "IlyaGusev/mbart_ru_sum_gazeta"
+tokenizer = MBartTokenizer.from_pretrained(model_name)
+model = MBartForConditionalGeneration.from_pretrained(model_name)
+
+def summarize(text):
+  input_ids = tokenizer.batch_encode_plus([text], return_tensors="pt", max_length=1024)["input_ids"].to(model.device)
+  summary_ids = model.generate(input_ids=input_ids, no_repeat_ngram_size=4)
+  return tokenizer.decode(summary_ids[0], skip_special_tokens=True)
+
+gr.Interface(fn=summarize, inputs="text", outputs="text", description="Russian Summarizer").launch()

spaces/0x7194633/nllb-1.3B-demo/README.md

@@ -0,0 +1,12 @@
+---
+title: Nllb Translation Demo
+emoji: 👀
+colorFrom: indigo
+colorTo: green
+sdk: gradio
+sdk_version: 3.0.26
+app_file: app.py
+pinned: false
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/0x7194633/nllb-1.3B-demo/app.py

@@ -0,0 +1,83 @@
+import os
+import torch
+import gradio as gr
+import time
+from transformers import AutoTokenizer, AutoModelForSeq2SeqLM, pipeline
+from flores200_codes import flores_codes
+
+
+def load_models():
+    # build model and tokenizer
+    model_name_dict = {'nllb-distilled-1.3B': 'facebook/nllb-200-distilled-1.3B'}
+
+    model_dict = {}
+
+    for call_name, real_name in model_name_dict.items():
+        print('\tLoading model: %s' % call_name)
+        model = AutoModelForSeq2SeqLM.from_pretrained(real_name)
+        tokenizer = AutoTokenizer.from_pretrained(real_name)
+        model_dict[call_name+'_model'] = model
+        model_dict[call_name+'_tokenizer'] = tokenizer
+
+    return model_dict
+
+
+def translation(source, target, text):
+    if len(model_dict) == 2:
+        model_name = 'nllb-distilled-1.3B'
+
+    start_time = time.time()
+    source = flores_codes[source]
+    target = flores_codes[target]
+
+    model = model_dict[model_name + '_model']
+    tokenizer = model_dict[model_name + '_tokenizer']
+
+    translator = pipeline('translation', model=model, tokenizer=tokenizer, src_lang=source, tgt_lang=target)
+    output = translator(text, max_length=400)
+
+    end_time = time.time()
+
+    output = output[0]['translation_text']
+    result = {'inference_time': end_time - start_time,
+              'source': source,
+              'target': target,
+              'result': output}
+    return result
+
+
+if __name__ == '__main__':
+    print('\tinit models')
+
+    global model_dict
+
+    model_dict = load_models()
+    
+    # define gradio demo
+    lang_codes = list(flores_codes.keys())
+    #inputs = [gr.inputs.Radio(['nllb-distilled-600M', 'nllb-1.3B', 'nllb-distilled-1.3B'], label='NLLB Model'),
+    inputs = [gr.inputs.Dropdown(lang_codes, default='English', label='Source'),
+              gr.inputs.Dropdown(lang_codes, default='Korean', label='Target'),
+              gr.inputs.Textbox(lines=5, label="Input text"),
+              ]
+
+    outputs = gr.outputs.JSON()
+
+    title = "NLLB distilled 1.3B demo"
+
+    demo_status = "Demo is running on CPU"
+    description = f"Details: https://github.com/facebookresearch/fairseq/tree/nllb. {demo_status}"
+    examples = [
+    ['English', 'Korean', 'Hi. nice to meet you']
+    ]
+
+    gr.Interface(translation,
+                 inputs,
+                 outputs,
+                 title=title,
+                 description=description,
+                 examples=examples,
+                 examples_per_page=50,
+                 ).launch()
+
+

spaces/0x7194633/nllb-1.3B-demo/flores200_codes.py

@@ -0,0 +1,211 @@
+codes_as_string = '''Acehnese (Arabic script)	ace_Arab
+Acehnese (Latin script)	ace_Latn
+Mesopotamian Arabic	acm_Arab
+Ta’izzi-Adeni Arabic	acq_Arab
+Tunisian Arabic	aeb_Arab
+Afrikaans	afr_Latn
+South Levantine Arabic	ajp_Arab
+Akan	aka_Latn
+Amharic	amh_Ethi
+North Levantine Arabic	apc_Arab
+Modern Standard Arabic	arb_Arab
+Modern Standard Arabic (Romanized)	arb_Latn
+Najdi Arabic	ars_Arab
+Moroccan Arabic	ary_Arab
+Egyptian Arabic	arz_Arab
+Assamese	asm_Beng
+Asturian	ast_Latn
+Awadhi	awa_Deva
+Central Aymara	ayr_Latn
+South Azerbaijani	azb_Arab
+North Azerbaijani	azj_Latn
+Bashkir	bak_Cyrl
+Bambara	bam_Latn
+Balinese	ban_Latn
+Belarusian	bel_Cyrl
+Bemba	bem_Latn
+Bengali	ben_Beng
+Bhojpuri	bho_Deva
+Banjar (Arabic script)	bjn_Arab
+Banjar (Latin script)	bjn_Latn
+Standard Tibetan	bod_Tibt
+Bosnian	bos_Latn
+Buginese	bug_Latn
+Bulgarian	bul_Cyrl
+Catalan	cat_Latn
+Cebuano	ceb_Latn
+Czech	ces_Latn
+Chokwe	cjk_Latn
+Central Kurdish	ckb_Arab
+Crimean Tatar	crh_Latn
+Welsh	cym_Latn
+Danish	dan_Latn
+German	deu_Latn
+Southwestern Dinka	dik_Latn
+Dyula	dyu_Latn
+Dzongkha	dzo_Tibt
+Greek	ell_Grek
+English	eng_Latn
+Esperanto	epo_Latn
+Estonian	est_Latn
+Basque	eus_Latn
+Ewe	ewe_Latn
+Faroese	fao_Latn
+Fijian	fij_Latn
+Finnish	fin_Latn
+Fon	fon_Latn
+French	fra_Latn
+Friulian	fur_Latn
+Nigerian Fulfulde	fuv_Latn
+Scottish Gaelic	gla_Latn
+Irish	gle_Latn
+Galician	glg_Latn
+Guarani	grn_Latn
+Gujarati	guj_Gujr
+Haitian Creole	hat_Latn
+Hausa	hau_Latn
+Hebrew	heb_Hebr
+Hindi	hin_Deva
+Chhattisgarhi	hne_Deva
+Croatian	hrv_Latn
+Hungarian	hun_Latn
+Armenian	hye_Armn
+Igbo	ibo_Latn
+Ilocano	ilo_Latn
+Indonesian	ind_Latn
+Icelandic	isl_Latn
+Italian	ita_Latn
+Javanese	jav_Latn
+Japanese	jpn_Jpan
+Kabyle	kab_Latn
+Jingpho	kac_Latn
+Kamba	kam_Latn
+Kannada	kan_Knda
+Kashmiri (Arabic script)	kas_Arab
+Kashmiri (Devanagari script)	kas_Deva
+Georgian	kat_Geor
+Central Kanuri (Arabic script)	knc_Arab
+Central Kanuri (Latin script)	knc_Latn
+Kazakh	kaz_Cyrl
+Kabiyè	kbp_Latn
+Kabuverdianu	kea_Latn
+Khmer	khm_Khmr
+Kikuyu	kik_Latn
+Kinyarwanda	kin_Latn
+Kyrgyz	kir_Cyrl
+Kimbundu	kmb_Latn
+Northern Kurdish	kmr_Latn
+Kikongo	kon_Latn
+Korean	kor_Hang
+Lao	lao_Laoo
+Ligurian	lij_Latn
+Limburgish	lim_Latn
+Lingala	lin_Latn
+Lithuanian	lit_Latn
+Lombard	lmo_Latn
+Latgalian	ltg_Latn
+Luxembourgish	ltz_Latn
+Luba-Kasai	lua_Latn
+Ganda	lug_Latn
+Luo	luo_Latn
+Mizo	lus_Latn
+Standard Latvian	lvs_Latn
+Magahi	mag_Deva
+Maithili	mai_Deva
+Malayalam	mal_Mlym
+Marathi	mar_Deva
+Minangkabau (Arabic script)	min_Arab
+Minangkabau (Latin script)	min_Latn
+Macedonian	mkd_Cyrl
+Plateau Malagasy	plt_Latn
+Maltese	mlt_Latn
+Meitei (Bengali script)	mni_Beng
+Halh Mongolian	khk_Cyrl
+Mossi	mos_Latn
+Maori	mri_Latn
+Burmese	mya_Mymr
+Dutch	nld_Latn
+Norwegian Nynorsk	nno_Latn
+Norwegian Bokmål	nob_Latn
+Nepali	npi_Deva
+Northern Sotho	nso_Latn
+Nuer	nus_Latn
+Nyanja	nya_Latn
+Occitan	oci_Latn
+West Central Oromo	gaz_Latn
+Odia	ory_Orya
+Pangasinan	pag_Latn
+Eastern Panjabi	pan_Guru
+Papiamento	pap_Latn
+Western Persian	pes_Arab
+Polish	pol_Latn
+Portuguese	por_Latn
+Dari	prs_Arab
+Southern Pashto	pbt_Arab
+Ayacucho Quechua	quy_Latn
+Romanian	ron_Latn
+Rundi	run_Latn
+Russian	rus_Cyrl
+Sango	sag_Latn
+Sanskrit	san_Deva
+Santali	sat_Olck
+Sicilian	scn_Latn
+Shan	shn_Mymr
+Sinhala	sin_Sinh
+Slovak	slk_Latn
+Slovenian	slv_Latn
+Samoan	smo_Latn
+Shona	sna_Latn
+Sindhi	snd_Arab
+Somali	som_Latn
+Southern Sotho	sot_Latn
+Spanish	spa_Latn
+Tosk Albanian	als_Latn
+Sardinian	srd_Latn
+Serbian	srp_Cyrl
+Swati	ssw_Latn
+Sundanese	sun_Latn
+Swedish	swe_Latn
+Swahili	swh_Latn
+Silesian	szl_Latn
+Tamil	tam_Taml
+Tatar	tat_Cyrl
+Telugu	tel_Telu
+Tajik	tgk_Cyrl
+Tagalog	tgl_Latn
+Thai	tha_Thai
+Tigrinya	tir_Ethi
+Tamasheq (Latin script)	taq_Latn
+Tamasheq (Tifinagh script)	taq_Tfng
+Tok Pisin	tpi_Latn
+Tswana	tsn_Latn
+Tsonga	tso_Latn
+Turkmen	tuk_Latn
+Tumbuka	tum_Latn
+Turkish	tur_Latn
+Twi	twi_Latn
+Central Atlas Tamazight	tzm_Tfng
+Uyghur	uig_Arab
+Ukrainian	ukr_Cyrl
+Umbundu	umb_Latn
+Urdu	urd_Arab
+Northern Uzbek	uzn_Latn
+Venetian	vec_Latn
+Vietnamese	vie_Latn
+Waray	war_Latn
+Wolof	wol_Latn
+Xhosa	xho_Latn
+Eastern Yiddish	ydd_Hebr
+Yoruba	yor_Latn
+Yue Chinese	yue_Hant
+Chinese (Simplified)	zho_Hans
+Chinese (Traditional)	zho_Hant
+Standard Malay	zsm_Latn
+Zulu	zul_Latn'''
+
+codes_as_string = codes_as_string.split('\n')
+
+flores_codes = {}
+for code in codes_as_string:
+    lang, lang_code = code.split('\t')
+    flores_codes[lang] = lang_code

spaces/0x876/Yotta_Mix/README.md

@@ -0,0 +1,12 @@
+---
+title: CompVis Stable Diffusion V1 4
+emoji: 📉
+colorFrom: pink
+colorTo: red
+sdk: gradio
+sdk_version: 3.39.0
+app_file: app.py
+pinned: false
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/0x876/Yotta_Mix/app.py

@@ -0,0 +1,3 @@
+import gradio as gr
+
+gr.Interface.load("models/CompVis/stable-diffusion-v1-4").launch()

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

@@ -0,0 +1,37 @@
+import math
+import torch
+import torch.nn as nn
+import ESRGAN.block as B
+
+class RRDB_Net(nn.Module):
+    def __init__(self, in_nc, out_nc, nf, nb, gc=32, upscale=4, norm_type=None, act_type='leakyrelu', \
+            mode='CNA', res_scale=1, upsample_mode='upconv'):
+        super(RRDB_Net, self).__init__()
+        n_upscale = int(math.log(upscale, 2))
+        if upscale == 3:
+            n_upscale = 1
+
+        fea_conv = B.conv_block(in_nc, nf, kernel_size=3, norm_type=None, act_type=None)
+        rb_blocks = [B.RRDB(nf, kernel_size=3, gc=32, stride=1, bias=True, pad_type='zero', \
+            norm_type=norm_type, act_type=act_type, mode='CNA') for _ in range(nb)]
+        LR_conv = B.conv_block(nf, nf, kernel_size=3, norm_type=norm_type, act_type=None, mode=mode)
+
+        if upsample_mode == 'upconv':
+            upsample_block = B.upconv_blcok
+        elif upsample_mode == 'pixelshuffle':
+            upsample_block = B.pixelshuffle_block
+        else:
+            raise NotImplementedError('upsample mode [%s] is not found' % upsample_mode)
+        if upscale == 3:
+            upsampler = upsample_block(nf, nf, 3, act_type=act_type)
+        else:
+            upsampler = [upsample_block(nf, nf, act_type=act_type) for _ in range(n_upscale)]
+        HR_conv0 = B.conv_block(nf, nf, kernel_size=3, norm_type=None, act_type=act_type)
+        HR_conv1 = B.conv_block(nf, out_nc, kernel_size=3, norm_type=None, act_type=None)
+
+        self.model = B.sequential(fea_conv, B.ShortcutBlock(B.sequential(*rb_blocks, LR_conv)),\
+            *upsampler, HR_conv0, HR_conv1)
+
+    def forward(self, x):
+        x = self.model(x)
+        return x

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

@@ -0,0 +1,261 @@
+from collections import OrderedDict
+import torch
+import torch.nn as nn
+
+####################
+# Basic blocks
+####################
+
+
+def act(act_type, inplace=True, neg_slope=0.2, n_prelu=1):
+    # helper selecting activation
+    # neg_slope: for leakyrelu and init of prelu
+    # n_prelu: for p_relu num_parameters
+    act_type = act_type.lower()
+    if act_type == 'relu':
+        layer = nn.ReLU(inplace)
+    elif act_type == 'leakyrelu':
+        layer = nn.LeakyReLU(neg_slope, inplace)
+    elif act_type == 'prelu':
+        layer = nn.PReLU(num_parameters=n_prelu, init=neg_slope)
+    else:
+        raise NotImplementedError('activation layer [%s] is not found' % act_type)
+    return layer
+
+
+def norm(norm_type, nc):
+    # helper selecting normalization layer
+    norm_type = norm_type.lower()
+    if norm_type == 'batch':
+        layer = nn.BatchNorm2d(nc, affine=True)
+    elif norm_type == 'instance':
+        layer = nn.InstanceNorm2d(nc, affine=False)
+    else:
+        raise NotImplementedError('normalization layer [%s] is not found' % norm_type)
+    return layer
+
+
+def pad(pad_type, padding):
+    # helper selecting padding layer
+    # if padding is 'zero', do by conv layers
+    pad_type = pad_type.lower()
+    if padding == 0:
+        return None
+    if pad_type == 'reflect':
+        layer = nn.ReflectionPad2d(padding)
+    elif pad_type == 'replicate':
+        layer = nn.ReplicationPad2d(padding)
+    else:
+        raise NotImplementedError('padding layer [%s] is not implemented' % pad_type)
+    return layer
+
+
+def get_valid_padding(kernel_size, dilation):
+    kernel_size = kernel_size + (kernel_size - 1) * (dilation - 1)
+    padding = (kernel_size - 1) // 2
+    return padding
+
+
+class ConcatBlock(nn.Module):
+    # Concat the output of a submodule to its input
+    def __init__(self, submodule):
+        super(ConcatBlock, self).__init__()
+        self.sub = submodule
+
+    def forward(self, x):
+        output = torch.cat((x, self.sub(x)), dim=1)
+        return output
+
+    def __repr__(self):
+        tmpstr = 'Identity .. \n|'
+        modstr = self.sub.__repr__().replace('\n', '\n|')
+        tmpstr = tmpstr + modstr
+        return tmpstr
+
+
+class ShortcutBlock(nn.Module):
+    #Elementwise sum the output of a submodule to its input
+    def __init__(self, submodule):
+        super(ShortcutBlock, self).__init__()
+        self.sub = submodule
+
+    def forward(self, x):
+        output = x + self.sub(x)
+        return output
+
+    def __repr__(self):
+        tmpstr = 'Identity + \n|'
+        modstr = self.sub.__repr__().replace('\n', '\n|')
+        tmpstr = tmpstr + modstr
+        return tmpstr
+
+
+def sequential(*args):
+    # Flatten Sequential. It unwraps nn.Sequential.
+    if len(args) == 1:
+        if isinstance(args[0], OrderedDict):
+            raise NotImplementedError('sequential does not support OrderedDict input.')
+        return args[0]  # No sequential is needed.
+    modules = []
+    for module in args:
+        if isinstance(module, nn.Sequential):
+            for submodule in module.children():
+                modules.append(submodule)
+        elif isinstance(module, nn.Module):
+            modules.append(module)
+    return nn.Sequential(*modules)
+
+
+def conv_block(in_nc, out_nc, kernel_size, stride=1, dilation=1, groups=1, bias=True,
+               pad_type='zero', norm_type=None, act_type='relu', mode='CNA'):
+    """
+    Conv layer with padding, normalization, activation
+    mode: CNA --> Conv -> Norm -> Act
+        NAC --> Norm -> Act --> Conv (Identity Mappings in Deep Residual Networks, ECCV16)
+    """
+    assert mode in ['CNA', 'NAC', 'CNAC'], 'Wong conv mode [%s]' % mode
+    padding = get_valid_padding(kernel_size, dilation)
+    p = pad(pad_type, padding) if pad_type and pad_type != 'zero' else None
+    padding = padding if pad_type == 'zero' else 0
+
+    c = nn.Conv2d(in_nc, out_nc, kernel_size=kernel_size, stride=stride, padding=padding, \
+            dilation=dilation, bias=bias, groups=groups)
+    a = act(act_type) if act_type else None
+    if 'CNA' in mode:
+        n = norm(norm_type, out_nc) if norm_type else None
+        return sequential(p, c, n, a)
+    elif mode == 'NAC':
+        if norm_type is None and act_type is not None:
+            a = act(act_type, inplace=False)
+            # Important!
+            # input----ReLU(inplace)----Conv--+----output
+            #        |________________________|
+            # inplace ReLU will modify the input, therefore wrong output
+        n = norm(norm_type, in_nc) if norm_type else None
+        return sequential(n, a, p, c)
+
+
+####################
+# Useful blocks
+####################
+
+
+class ResNetBlock(nn.Module):
+    """
+    ResNet Block, 3-3 style
+    with extra residual scaling used in EDSR
+    (Enhanced Deep Residual Networks for Single Image Super-Resolution, CVPRW 17)
+    """
+
+    def __init__(self, in_nc, mid_nc, out_nc, kernel_size=3, stride=1, dilation=1, groups=1, \
+            bias=True, pad_type='zero', norm_type=None, act_type='relu', mode='CNA', res_scale=1):
+        super(ResNetBlock, self).__init__()
+        conv0 = conv_block(in_nc, mid_nc, kernel_size, stride, dilation, groups, bias, pad_type, \
+            norm_type, act_type, mode)
+        if mode == 'CNA':
+            act_type = None
+        if mode == 'CNAC':  # Residual path: |-CNAC-|
+            act_type = None
+            norm_type = None
+        conv1 = conv_block(mid_nc, out_nc, kernel_size, stride, dilation, groups, bias, pad_type, \
+            norm_type, act_type, mode)
+        # if in_nc != out_nc:
+        #     self.project = conv_block(in_nc, out_nc, 1, stride, dilation, 1, bias, pad_type, \
+        #         None, None)
+        #     print('Need a projecter in ResNetBlock.')
+        # else:
+        #     self.project = lambda x:x
+        self.res = sequential(conv0, conv1)
+        self.res_scale = res_scale
+
+    def forward(self, x):
+        res = self.res(x).mul(self.res_scale)
+        return x + res
+
+
+class ResidualDenseBlock_5C(nn.Module):
+    """
+    Residual Dense Block
+    style: 5 convs
+    The core module of paper: (Residual Dense Network for Image Super-Resolution, CVPR 18)
+    """
+
+    def __init__(self, nc, kernel_size=3, gc=32, stride=1, bias=True, pad_type='zero', \
+            norm_type=None, act_type='leakyrelu', mode='CNA'):
+        super(ResidualDenseBlock_5C, self).__init__()
+        # gc: growth channel, i.e. intermediate channels
+        self.conv1 = conv_block(nc, gc, kernel_size, stride, bias=bias, pad_type=pad_type, \
+            norm_type=norm_type, act_type=act_type, mode=mode)
+        self.conv2 = conv_block(nc+gc, gc, kernel_size, stride, bias=bias, pad_type=pad_type, \
+            norm_type=norm_type, act_type=act_type, mode=mode)
+        self.conv3 = conv_block(nc+2*gc, gc, kernel_size, stride, bias=bias, pad_type=pad_type, \
+            norm_type=norm_type, act_type=act_type, mode=mode)
+        self.conv4 = conv_block(nc+3*gc, gc, kernel_size, stride, bias=bias, pad_type=pad_type, \
+            norm_type=norm_type, act_type=act_type, mode=mode)
+        if mode == 'CNA':
+            last_act = None
+        else:
+            last_act = act_type
+        self.conv5 = conv_block(nc+4*gc, nc, 3, stride, bias=bias, pad_type=pad_type, \
+            norm_type=norm_type, act_type=last_act, mode=mode)
+
+    def forward(self, x):
+        x1 = self.conv1(x)
+        x2 = self.conv2(torch.cat((x, x1), 1))
+        x3 = self.conv3(torch.cat((x, x1, x2), 1))
+        x4 = self.conv4(torch.cat((x, x1, x2, x3), 1))
+        x5 = self.conv5(torch.cat((x, x1, x2, x3, x4), 1))
+        return x5.mul(0.2) + x
+
+
+class RRDB(nn.Module):
+    """
+    Residual in Residual Dense Block
+    """
+
+    def __init__(self, nc, kernel_size=3, gc=32, stride=1, bias=True, pad_type='zero', \
+            norm_type=None, act_type='leakyrelu', mode='CNA'):
+        super(RRDB, self).__init__()
+        self.RDB1 = ResidualDenseBlock_5C(nc, kernel_size, gc, stride, bias, pad_type, \
+            norm_type, act_type, mode)
+        self.RDB2 = ResidualDenseBlock_5C(nc, kernel_size, gc, stride, bias, pad_type, \
+            norm_type, act_type, mode)
+        self.RDB3 = ResidualDenseBlock_5C(nc, kernel_size, gc, stride, bias, pad_type, \
+            norm_type, act_type, mode)
+
+    def forward(self, x):
+        out = self.RDB1(x)
+        out = self.RDB2(out)
+        out = self.RDB3(out)
+        return out.mul(0.2) + x
+
+
+####################
+# Upsampler
+####################
+
+
+def pixelshuffle_block(in_nc, out_nc, upscale_factor=2, kernel_size=3, stride=1, bias=True,
+                        pad_type='zero', norm_type=None, act_type='relu'):
+    """
+    Pixel shuffle layer
+    (Real-Time Single Image and Video Super-Resolution Using an Efficient Sub-Pixel Convolutional
+    Neural Network, CVPR17)
+    """
+    conv = conv_block(in_nc, out_nc * (upscale_factor ** 2), kernel_size, stride, bias=bias,
+                        pad_type=pad_type, norm_type=None, act_type=None)
+    pixel_shuffle = nn.PixelShuffle(upscale_factor)
+
+    n = norm(norm_type, out_nc) if norm_type else None
+    a = act(act_type) if act_type else None
+    return sequential(conv, pixel_shuffle, n, a)
+
+
+def upconv_blcok(in_nc, out_nc, upscale_factor=2, kernel_size=3, stride=1, bias=True,
+                pad_type='zero', norm_type=None, act_type='relu', mode='nearest'):
+    # Up conv
+    # described in https://distill.pub/2016/deconv-checkerboard/
+    upsample = nn.Upsample(scale_factor=upscale_factor, mode=mode)
+    conv = conv_block(in_nc, out_nc, kernel_size, stride, bias=bias,
+                        pad_type=pad_type, norm_type=norm_type, act_type=act_type)
+    return sequential(upsample, conv)

spaces/0x90e/ESRGAN-MANGA/ESRGAN_plus/architecture.py

@@ -0,0 +1,38 @@
+import math
+import torch
+import torch.nn as nn
+import ESRGAN_plus.block as B
+
+
+class RRDB_Net(nn.Module):
+    def __init__(self, in_nc, out_nc, nf, nb, gc=32, upscale=4, norm_type=None, act_type='leakyrelu', \
+            mode='CNA', res_scale=1, upsample_mode='upconv'):
+        super(RRDB_Net, self).__init__()
+        n_upscale = int(math.log(upscale, 2))
+        if upscale == 3:
+            n_upscale = 1
+
+        fea_conv = B.conv_block(in_nc, nf, kernel_size=3, norm_type=None, act_type=None)
+        rb_blocks = [B.RRDB(nf, kernel_size=3, gc=32, stride=1, bias=True, pad_type='zero', \
+            norm_type=norm_type, act_type=act_type, mode='CNA') for _ in range(nb)]
+        LR_conv = B.conv_block(nf, nf, kernel_size=3, norm_type=norm_type, act_type=None, mode=mode)
+
+        if upsample_mode == 'upconv':
+            upsample_block = B.upconv_blcok
+        elif upsample_mode == 'pixelshuffle':
+            upsample_block = B.pixelshuffle_block
+        else:
+            raise NotImplementedError('upsample mode [%s] is not found' % upsample_mode)
+        if upscale == 3:
+            upsampler = upsample_block(nf, nf, 3, act_type=act_type)
+        else:
+            upsampler = [upsample_block(nf, nf, act_type=act_type) for _ in range(n_upscale)]
+        HR_conv0 = B.conv_block(nf, nf, kernel_size=3, norm_type=None, act_type=act_type)
+        HR_conv1 = B.conv_block(nf, out_nc, kernel_size=3, norm_type=None, act_type=None)
+
+        self.model = B.sequential(fea_conv, B.ShortcutBlock(B.sequential(*rb_blocks, LR_conv)),\
+            *upsampler, HR_conv0, HR_conv1)
+
+    def forward(self, x):
+        x = self.model(x)
+        return x

spaces/0x90e/ESRGAN-MANGA/ESRGAN_plus/block.py

@@ -0,0 +1,287 @@
+from collections import OrderedDict
+import torch
+import torch.nn as nn
+
+####################
+# Basic blocks
+####################
+
+
+def act(act_type, inplace=True, neg_slope=0.2, n_prelu=1):
+    # helper selecting activation
+    # neg_slope: for leakyrelu and init of prelu
+    # n_prelu: for p_relu num_parameters
+    act_type = act_type.lower()
+    if act_type == 'relu':
+        layer = nn.ReLU(inplace)
+    elif act_type == 'leakyrelu':
+        layer = nn.LeakyReLU(neg_slope, inplace)
+    elif act_type == 'prelu':
+        layer = nn.PReLU(num_parameters=n_prelu, init=neg_slope)
+    else:
+        raise NotImplementedError('activation layer [{:s}] is not found'.format(act_type))
+    return layer
+
+
+def norm(norm_type, nc):
+    # helper selecting normalization layer
+    norm_type = norm_type.lower()
+    if norm_type == 'batch':
+        layer = nn.BatchNorm2d(nc, affine=True)
+    elif norm_type == 'instance':
+        layer = nn.InstanceNorm2d(nc, affine=False)
+    else:
+        raise NotImplementedError('normalization layer [{:s}] is not found'.format(norm_type))
+    return layer
+
+
+def pad(pad_type, padding):
+    # helper selecting padding layer
+    # if padding is 'zero', do by conv layers
+    pad_type = pad_type.lower()
+    if padding == 0:
+        return None
+    if pad_type == 'reflect':
+        layer = nn.ReflectionPad2d(padding)
+    elif pad_type == 'replicate':
+        layer = nn.ReplicationPad2d(padding)
+    else:
+        raise NotImplementedError('padding layer [{:s}] is not implemented'.format(pad_type))
+    return layer
+
+
+def get_valid_padding(kernel_size, dilation):
+    kernel_size = kernel_size + (kernel_size - 1) * (dilation - 1)
+    padding = (kernel_size - 1) // 2
+    return padding
+
+
+class ConcatBlock(nn.Module):
+    # Concat the output of a submodule to its input
+    def __init__(self, submodule):
+        super(ConcatBlock, self).__init__()
+        self.sub = submodule
+
+    def forward(self, x):
+        output = torch.cat((x, self.sub(x)), dim=1)
+        return output
+
+    def __repr__(self):
+        tmpstr = 'Identity .. \n|'
+        modstr = self.sub.__repr__().replace('\n', '\n|')
+        tmpstr = tmpstr + modstr
+        return tmpstr
+
+
+class ShortcutBlock(nn.Module):
+    #Elementwise sum the output of a submodule to its input
+    def __init__(self, submodule):
+        super(ShortcutBlock, self).__init__()
+        self.sub = submodule
+
+    def forward(self, x):
+        output = x + self.sub(x)
+        return output
+
+    def __repr__(self):
+        tmpstr = 'Identity + \n|'
+        modstr = self.sub.__repr__().replace('\n', '\n|')
+        tmpstr = tmpstr + modstr
+        return tmpstr
+
+
+def sequential(*args):
+    # Flatten Sequential. It unwraps nn.Sequential.
+    if len(args) == 1:
+        if isinstance(args[0], OrderedDict):
+            raise NotImplementedError('sequential does not support OrderedDict input.')
+        return args[0]  # No sequential is needed.
+    modules = []
+    for module in args:
+        if isinstance(module, nn.Sequential):
+            for submodule in module.children():
+                modules.append(submodule)
+        elif isinstance(module, nn.Module):
+            modules.append(module)
+    return nn.Sequential(*modules)
+
+
+def conv_block(in_nc, out_nc, kernel_size, stride=1, dilation=1, groups=1, bias=True, \
+               pad_type='zero', norm_type=None, act_type='relu', mode='CNA'):
+    '''
+    Conv layer with padding, normalization, activation
+    mode: CNA --> Conv -> Norm -> Act
+        NAC --> Norm -> Act --> Conv (Identity Mappings in Deep Residual Networks, ECCV16)
+    '''
+    assert mode in ['CNA', 'NAC', 'CNAC'], 'Wong conv mode [{:s}]'.format(mode)
+    padding = get_valid_padding(kernel_size, dilation)
+    p = pad(pad_type, padding) if pad_type and pad_type != 'zero' else None
+    padding = padding if pad_type == 'zero' else 0
+
+    c = nn.Conv2d(in_nc, out_nc, kernel_size=kernel_size, stride=stride, padding=padding, \
+            dilation=dilation, bias=bias, groups=groups)
+    a = act(act_type) if act_type else None
+    if 'CNA' in mode:
+        n = norm(norm_type, out_nc) if norm_type else None
+        return sequential(p, c, n, a)
+    elif mode == 'NAC':
+        if norm_type is None and act_type is not None:
+            a = act(act_type, inplace=False)
+            # Important!
+            # input----ReLU(inplace)----Conv--+----output
+            #        |________________________|
+            # inplace ReLU will modify the input, therefore wrong output
+        n = norm(norm_type, in_nc) if norm_type else None
+        return sequential(n, a, p, c)
+    
+    
+def conv1x1(in_planes, out_planes, stride=1):
+    """1x1 convolution"""
+    return nn.Conv2d(in_planes, out_planes, kernel_size=1, stride=stride, bias=False)
+
+
+class GaussianNoise(nn.Module):
+    def __init__(self, sigma=0.1, is_relative_detach=False):
+        super().__init__()
+        self.sigma = sigma
+        self.is_relative_detach = is_relative_detach
+        self.noise = torch.tensor(0, dtype=torch.float).to(torch.device('cuda'))
+
+    def forward(self, x):
+        if self.training and self.sigma != 0:
+            scale = self.sigma * x.detach() if self.is_relative_detach else self.sigma * x
+            sampled_noise = self.noise.repeat(*x.size()).normal_() * scale
+            x = x + sampled_noise
+        return x 
+
+
+####################
+# Useful blocks
+####################
+
+
+class ResNetBlock(nn.Module):
+    '''
+    ResNet Block, 3-3 style
+    with extra residual scaling used in EDSR
+    (Enhanced Deep Residual Networks for Single Image Super-Resolution, CVPRW 17)
+    '''
+
+    def __init__(self, in_nc, mid_nc, out_nc, kernel_size=3, stride=1, dilation=1, groups=1, \
+            bias=True, pad_type='zero', norm_type=None, act_type='relu', mode='CNA', res_scale=1):
+        super(ResNetBlock, self).__init__()
+        conv0 = conv_block(in_nc, mid_nc, kernel_size, stride, dilation, groups, bias, pad_type, \
+            norm_type, act_type, mode)
+        if mode == 'CNA':
+            act_type = None
+        if mode == 'CNAC':  # Residual path: |-CNAC-|
+            act_type = None
+            norm_type = None
+        conv1 = conv_block(mid_nc, out_nc, kernel_size, stride, dilation, groups, bias, pad_type, \
+            norm_type, act_type, mode)
+        # if in_nc != out_nc:
+        #     self.project = conv_block(in_nc, out_nc, 1, stride, dilation, 1, bias, pad_type, \
+        #         None, None)
+        #     print('Need a projecter in ResNetBlock.')
+        # else:
+        #     self.project = lambda x:x
+        self.res = sequential(conv0, conv1)
+        self.res_scale = res_scale
+
+    def forward(self, x):
+        res = self.res(x).mul(self.res_scale)
+        return x + res
+
+
+class ResidualDenseBlock_5C(nn.Module):
+    '''
+    Residual Dense Block
+    style: 5 convs
+    The core module of paper: (Residual Dense Network for Image Super-Resolution, CVPR 18)
+    '''
+
+    def __init__(self, nc, kernel_size=3, gc=32, stride=1, bias=True, pad_type='zero', \
+            norm_type=None, act_type='leakyrelu', mode='CNA', noise_input=True):
+        super(ResidualDenseBlock_5C, self).__init__()
+        # gc: growth channel, i.e. intermediate channels
+        self.noise = GaussianNoise() if noise_input else None
+        self.conv1x1 = conv1x1(nc, gc)
+        self.conv1 = conv_block(nc, gc, kernel_size, stride, bias=bias, pad_type=pad_type, \
+            norm_type=norm_type, act_type=act_type, mode=mode)
+        self.conv2 = conv_block(nc+gc, gc, kernel_size, stride, bias=bias, pad_type=pad_type, \
+            norm_type=norm_type, act_type=act_type, mode=mode)
+        self.conv3 = conv_block(nc+2*gc, gc, kernel_size, stride, bias=bias, pad_type=pad_type, \
+            norm_type=norm_type, act_type=act_type, mode=mode)
+        self.conv4 = conv_block(nc+3*gc, gc, kernel_size, stride, bias=bias, pad_type=pad_type, \
+            norm_type=norm_type, act_type=act_type, mode=mode)
+        if mode == 'CNA':
+            last_act = None
+        else:
+            last_act = act_type
+        self.conv5 = conv_block(nc+4*gc, nc, 3, stride, bias=bias, pad_type=pad_type, \
+            norm_type=norm_type, act_type=last_act, mode=mode)
+
+    def forward(self, x):
+        x1 = self.conv1(x)
+        x2 = self.conv2(torch.cat((x, x1), 1))
+        x2 = x2 + self.conv1x1(x)
+        x3 = self.conv3(torch.cat((x, x1, x2), 1))
+        x4 = self.conv4(torch.cat((x, x1, x2, x3), 1))
+        x4 = x4 + x2
+        x5 = self.conv5(torch.cat((x, x1, x2, x3, x4), 1))
+        return self.noise(x5.mul(0.2) + x)
+
+
+class RRDB(nn.Module):
+    '''
+    Residual in Residual Dense Block
+    (ESRGAN: Enhanced Super-Resolution Generative Adversarial Networks)
+    '''
+
+    def __init__(self, nc, kernel_size=3, gc=32, stride=1, bias=True, pad_type='zero', \
+            norm_type=None, act_type='leakyrelu', mode='CNA'):
+        super(RRDB, self).__init__()
+        self.RDB1 = ResidualDenseBlock_5C(nc, kernel_size, gc, stride, bias, pad_type, \
+            norm_type, act_type, mode)
+        self.RDB2 = ResidualDenseBlock_5C(nc, kernel_size, gc, stride, bias, pad_type, \
+            norm_type, act_type, mode)
+        self.RDB3 = ResidualDenseBlock_5C(nc, kernel_size, gc, stride, bias, pad_type, \
+            norm_type, act_type, mode)
+        self.noise = GaussianNoise()
+
+    def forward(self, x):
+        out = self.RDB1(x)
+        out = self.RDB2(out)
+        out = self.RDB3(out)
+        return self.noise(out.mul(0.2) + x)
+
+
+####################
+# Upsampler
+####################
+
+
+def pixelshuffle_block(in_nc, out_nc, upscale_factor=2, kernel_size=3, stride=1, bias=True, \
+                        pad_type='zero', norm_type=None, act_type='relu'):
+    '''
+    Pixel shuffle layer
+    (Real-Time Single Image and Video Super-Resolution Using an Efficient Sub-Pixel Convolutional
+    Neural Network, CVPR17)
+    '''
+    conv = conv_block(in_nc, out_nc * (upscale_factor ** 2), kernel_size, stride, bias=bias, \
+                        pad_type=pad_type, norm_type=None, act_type=None)
+    pixel_shuffle = nn.PixelShuffle(upscale_factor)
+
+    n = norm(norm_type, out_nc) if norm_type else None
+    a = act(act_type) if act_type else None
+    return sequential(conv, pixel_shuffle, n, a)
+
+
+def upconv_blcok(in_nc, out_nc, upscale_factor=2, kernel_size=3, stride=1, bias=True, \
+                pad_type='zero', norm_type=None, act_type='relu', mode='nearest'):
+    # Up conv
+    # described in https://distill.pub/2016/deconv-checkerboard/
+    upsample = nn.Upsample(scale_factor=upscale_factor, mode=mode)
+    conv = conv_block(in_nc, out_nc, kernel_size, stride, bias=bias, \
+                        pad_type=pad_type, norm_type=norm_type, act_type=act_type)
+    return sequential(upsample, conv)

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

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

spaces/0x90e/ESRGAN-MANGA/README.md

@@ -0,0 +1,10 @@
+---
+title: ESRGAN MANGA
+emoji: 🏃
+colorFrom: red
+colorTo: indigo
+sdk: gradio
+sdk_version: 3.12.0
+app_file: app.py
+pinned: false
+---

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

@@ -0,0 +1,86 @@
+import gradio as gr
+import util
+import process_image
+from run_cmd import run_cmd
+
+is_colab = util.is_google_colab()
+
+css = '''
+    .file-preview {
+        overflow: hidden !important;
+        margin: 5px 0 !important;
+        padding: 0 10px !important;
+    }
+
+    .file-preview div div:nth-child(2) {
+        flex-grow: 1 !important;
+    }
+
+    .file-preview div div:nth-child(3) {
+        text-align: right !important;
+        padding: 0.5rem 0;
+        width: auto;
+    }
+
+    #preview_file .h-full.min-h-\[15rem\].flex.justify-center.items-center {
+        min-height: initial !important;
+        padding: 10px 0;
+    }
+
+    #preview_file a {
+        border-radius: 0.5rem;
+        padding-top: 0.5rem;
+        padding-bottom: 0.5rem;
+        padding-left: 1rem;
+        padding-right: 1rem;
+        font-size: 1rem;
+        line-height: 1.5rem;
+        font-weight: 600;
+        color: white;
+        background-color: gray;
+    }
+
+    .colab_img {
+        margin: 10px 0;
+        display: inline-block;
+        margin: 0 10px;
+    }
+'''
+
+title = "ESRGAN Upscaling With Custom Models"
+
+with gr.Blocks(title=title, css=css) as demo:
+    gr.Markdown(
+    f"""
+    # {title}
+    This space uses old ESRGAN architecture to upscale images, using models made by the community.
+
+    Once the photo upscaled (*it can take a long time, this space only uses CPU*).
+    """)
+
+    gr.HTML(value="For faster upscaling using GPU: <a href='https://colab.research.google.com/drive/1QfOA6BBdL4NrUmx-9d-pjacxNfu81HQo#scrollTo=H7qo-6AWFbLH' target='_blank'><img class='colab_img' src='https://colab.research.google.com/assets/colab-badge.svg' alt='Open In Colab'></a> buy me a coffee (beer) if this helped 🍺😁")
+
+    gr.HTML(value="<a href='https://ko-fi.com/Y8Y7GVAAF' target='_blank' style='display:block;margin-bottom:5px'><img height='36' style='border:0px;height:36px;' src='https://storage.ko-fi.com/cdn/kofi1.png?v=3' border='0' alt='Buy Me a Coffee at ko-fi.com' /></a>")
+
+    with gr.Box():
+        with gr.Row():
+            with gr.Column():
+                input_image = gr.Image(type="pil", label="Input")
+                upscale_size = gr.Radio(["x4", "x2"], label="Upscale by:", value="x4")
+                upscale_type = gr.Radio(["Manga", "Anime", "Photo", "General"], label="Select the type of picture you want to upscale:", value="Manga")
+
+                with gr.Row():
+                    upscale_btn = gr.Button(value="Upscale", variant="primary")
+
+            with gr.Column():
+                output_image = gr.Image(type="filepath", interactive=False, label="Upscaled image", elem_id="preview_img")
+                
+                with gr.Row():
+                    out_file = gr.File(interactive=False, show_label=False, elem_id="preview_file")
+
+    gr.HTML(value="<p><a href='https://upscale.wiki/wiki/Model_Database'>Model Database</a></p>")
+        
+    upscale_btn.click(process_image.inference, inputs=[input_image, upscale_size, upscale_type], outputs=[output_image, out_file])
+
+demo.queue()
+demo.launch(debug=is_colab, share=is_colab, inline=is_colab)

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

@@ -0,0 +1,59 @@
+import sys
+import cv2
+import numpy as np
+import torch
+import ESRGAN.architecture as esrgan
+import ESRGAN_plus.architecture as esrgan_plus
+from run_cmd import run_cmd
+from ESRGANer import ESRGANer
+
+def is_cuda():
+    if torch.cuda.is_available():
+        return True
+    else:
+        return False
+
+model_type = sys.argv[2]
+
+if model_type == "Anime":
+    model_path = "models/4x-AnimeSharp.pth"
+if model_type == "Photo":
+    model_path = "models/4x_Valar_v1.pth"
+else:
+    model_path = "models/4x_NMKD-Siax_200k.pth"
+
+OUTPUT_PATH = sys.argv[1]
+device = torch.device('cuda' if is_cuda() else 'cpu')
+
+if model_type != "Photo":
+    model = esrgan.RRDB_Net(3, 3, 64, 23, gc=32, upscale=4, norm_type=None, act_type='leakyrelu', mode='CNA', res_scale=1, upsample_mode='upconv')
+else:
+    model = esrgan_plus.RRDB_Net(3, 3, 64, 23, gc=32, upscale=4, norm_type=None, act_type='leakyrelu', mode='CNA', res_scale=1, upsample_mode='upconv')
+
+if is_cuda():
+    print("Using GPU 🥶")
+    model.load_state_dict(torch.load(model_path), strict=True)
+else:
+    print("Using CPU 😒")
+    model.load_state_dict(torch.load(model_path, map_location=torch.device('cpu')), strict=True)
+
+model.eval()
+
+for k, v in model.named_parameters():
+    v.requires_grad = False
+model = model.to(device)
+
+# Read image
+img = cv2.imread(OUTPUT_PATH, cv2.IMREAD_COLOR)
+img = img * 1.0 / 255
+img = torch.from_numpy(np.transpose(img[:, :, [2, 1, 0]], (2, 0, 1))).float()
+img_LR = img.unsqueeze(0)
+img_LR = img_LR.to(device)
+
+upsampler = ESRGANer(model=model)
+output = upsampler.enhance(img_LR)
+
+output = output.squeeze().float().cpu().clamp_(0, 1).numpy()
+output = np.transpose(output[[2, 1, 0], :, :], (1, 2, 0))
+output = (output * 255.0).round()
+cv2.imwrite(OUTPUT_PATH, output, [int(cv2.IMWRITE_PNG_COMPRESSION), 5])

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

@@ -0,0 +1,46 @@
+import sys
+import cv2
+import numpy as np
+import torch
+import ESRGAN.architecture as arch
+from ESRGANer import ESRGANer
+
+def is_cuda():
+    if torch.cuda.is_available():
+        return True
+    else:
+        return False
+
+model_path = 'models/4x_eula_digimanga_bw_v2_nc1_307k.pth'
+OUTPUT_PATH = sys.argv[1]
+device = torch.device('cuda' if is_cuda() else 'cpu')
+
+model = arch.RRDB_Net(1, 1, 64, 23, gc=32, upscale=4, norm_type=None, act_type='leakyrelu', mode='CNA', res_scale=1, upsample_mode='upconv')
+
+if is_cuda():
+    print("Using GPU 🥶")
+    model.load_state_dict(torch.load(model_path), strict=True)
+else:
+    print("Using CPU 😒")
+    model.load_state_dict(torch.load(model_path, map_location=torch.device('cpu')), strict=True)
+
+model.eval()
+
+for k, v in model.named_parameters():
+    v.requires_grad = False
+model = model.to(device)
+
+# Read image
+img = cv2.imread(OUTPUT_PATH, cv2.IMREAD_GRAYSCALE)
+img = img * 1.0 / 255
+img = torch.from_numpy(img[np.newaxis, :, :]).float()
+img_LR = img.unsqueeze(0)
+img_LR = img_LR.to(device)
+
+upsampler = ESRGANer(model=model)
+output = upsampler.enhance(img_LR)
+
+output = output.squeeze(dim=0).float().cpu().clamp_(0, 1).numpy()
+output = np.transpose(output, (1, 2, 0))
+output = (output * 255.0).round()
+cv2.imwrite(OUTPUT_PATH, output, [int(cv2.IMWRITE_PNG_COMPRESSION), 5])

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

@@ -0,0 +1,31 @@
+import os
+import gradio as gr
+from run_cmd import run_cmd
+from PIL import Image
+import tempfile
+import uuid
+import numpy as np
+
+temp_path = tempfile.gettempdir()
+
+def inference(img, size, type):
+    if not img:
+        raise Exception("No image!")
+
+    OUTPUT_PATH = os.path.join(temp_path, f"{str(uuid.uuid4())[0:12]}_{size}.png")
+    
+    img.save(OUTPUT_PATH)
+
+    if type == "Manga":
+        run_cmd(f"python inference_manga_v2.py {OUTPUT_PATH}")
+    else:
+        run_cmd(f"python inference.py {OUTPUT_PATH} {type}")
+
+    img_out = Image.open(OUTPUT_PATH)
+
+    if size == "x2":
+        img_out = img_out.resize((img_out.width // 2, img_out.height // 2), resample=Image.BICUBIC)
+
+    img_out = np.array(img_out)
+
+    return img_out, gr.File.update(value=OUTPUT_PATH)

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

@@ -0,0 +1,9 @@
+from subprocess import call
+import sys
+
+def run_cmd(command):
+    try:
+        call(command, shell=True)
+    except KeyboardInterrupt:
+        print("Process interrupted")
+        sys.exit(1)

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

@@ -0,0 +1,6 @@
+import os
+
+def is_google_colab():
+    if os.getenv("COLAB_RELEASE_TAG"):
+        return True
+    return False

spaces/0xAnders/ama-bot/README.md

@@ -0,0 +1,13 @@
+---
+title: Ama Bot
+emoji: 🌍
+colorFrom: gray
+colorTo: yellow
+sdk: gradio
+sdk_version: 3.32.0
+app_file: app.py
+pinned: false
+license: apache-2.0
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/0xAnders/ama-bot/app.py

@@ -0,0 +1,70 @@
+import gradio as gr
+
+import git
+
+git.Git().clone("https://github.com/Jesse-zj/bobo-test.git")
+
+from llama_index import SimpleDirectoryReader, GPTListIndex, readers, GPTVectorStoreIndex, LLMPredictor, PromptHelper,ServiceContext
+from llama_index import StorageContext, load_index_from_storage
+from langchain import OpenAI
+import sys
+import os
+from IPython.display import Markdown, display
+
+openai_api_key = os.environ['OPENAI_API_KEY']
+
+def construct_index(directory_path):
+    # set maximum input size
+    max_input_size = 4096
+    # set number of output tokens
+    num_outputs = 1000
+    # set maximum chunk overlap
+    max_chunk_overlap = 30
+    # set chunk size limit
+    chunk_size_limit = 600 
+
+    # define LLM
+    llm_predictor = LLMPredictor(llm=OpenAI(temperature=0.5, model_name="text-davinci-003", max_tokens=num_outputs))
+    prompt_helper = PromptHelper(max_input_size, num_outputs, max_chunk_overlap, chunk_size_limit=chunk_size_limit)
+ 
+    documents = SimpleDirectoryReader(directory_path).load_data()
+
+    service_context = ServiceContext.from_defaults(llm_predictor=llm_predictor, prompt_helper=prompt_helper)
+    
+    index = GPTVectorStoreIndex.from_documents(
+        documents, service_context=service_context
+    )
+
+    index.storage_context.persist('index.json')
+
+    return index
+
+def ask_ai(query):
+    # set maximum input size
+    max_input_size = 4096
+    # set number of output tokens
+    num_outputs = 1000
+    # set maximum chunk overlap
+    max_chunk_overlap = 30
+    # set chunk size limit
+    chunk_size_limit = 600 
+
+    # define LLM
+    llm_predictor = LLMPredictor(llm=OpenAI(temperature=0.5, model_name="text-davinci-003", max_tokens=num_outputs))
+    prompt_helper = PromptHelper(max_input_size, num_outputs, max_chunk_overlap, chunk_size_limit=chunk_size_limit)
+    
+    service_context = ServiceContext.from_defaults(llm_predictor=llm_predictor, prompt_helper=prompt_helper)
+    # rebuild storage context
+    storage_context = StorageContext.from_defaults(persist_dir="index.json")
+    # load index
+    index = load_index_from_storage(storage_context, service_context=service_context)
+    
+    query_engine = index.as_query_engine()
+    response = query_engine.query(query)
+    return str(response)
+    
+
+construct_index('bobo-test')
+
+iface = gr.Interface(fn=ask_ai, inputs="textbox", outputs="text")
+iface.launch()

spaces/0xHacked/zkProver/Dockerfile

@@ -0,0 +1,21 @@
+FROM nvidia/cuda:12.1.1-devel-ubuntu20.04
+ARG DEBIAN_FRONTEND=noninteractive
+ENV TZ=Asia/Hong_Kong
+RUN apt-get update && apt-get install --no-install-recommends -y tzdata python3.9 python3.9-dev python3.9-venv build-essential && \
+   apt-get clean && rm -rf /var/lib/apt/lists/*
+
+RUN useradd -m -u 1000 user
+USER user
+
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH
+
+WORKDIR $HOME/app
+COPY --chown=user . $HOME/app
+
+RUN python3.9 -m venv $HOME/app/venv && $HOME/app/venv/bin/pip install --no-cache-dir --upgrade pip
+RUN $HOME/app/venv/bin/pip install --no-cache-dir --upgrade -r requirements.txt
+
+RUN cd $HOME/app && chmod +x $HOME/app/bin/*
+
+CMD ["/home/user/app/venv/bin/python", "app.py"]

spaces/0xHacked/zkProver/README.md

@@ -0,0 +1,11 @@
+---
+title: ZkProver
+emoji: ⚡
+colorFrom: red
+colorTo: yellow
+sdk: docker
+pinned: false
+license: bsd
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/0xHacked/zkProver/app.py

@@ -0,0 +1,77 @@
+import os
+import tempfile
+import uuid
+import subprocess
+import gradio as gr
+
+
+BIN = os.path.join(os.path.dirname(__file__), "bin", "zkProver_linux_gpu")
+
+
+def run_zk_prover(network, block_number, contract, file):
+    if not contract:
+        raise gr.Error("contract is required")
+    if not file:
+        raise gr.Error('file is required')
+    args = [
+        BIN,
+        "evm", "-r", "https://rpc.flashbots.net/"
+    ]
+    if block_number:
+        args.extend(["-b", str(block_number)])
+    proof_path = "/tmp/" + str(uuid.uuid4()) + ".bin"
+    args.extend(["-o", proof_path])
+
+    args.append(file.name + ":" + contract)
+
+    proc = subprocess.Popen(args,)
+    proc.wait()
+
+    if proc.returncode != 0:
+        raise gr.Error("generate proof failed")
+    return proof_path
+
+
+with gr.Blocks() as demo:
+    gr.Markdown(
+    """
+        # 0xHacked
+        This is the demo for [0xHacked](https://0xHacked.com), a trustless bug bounty platform. You can generate the proof of exploit here. However, due to the constraints of ZKP, the generation might be low on Huggingface.
+        <br/>
+        We recommend [compiling it from the source](https://github.com/0xHackedLabs/zkProver). The generation can be very quick on GPU. For more details, please refer to [0xHacked Documentation](https://docs.0xHacked.com).
+        <br/>
+        The sample PoC provided below takes ~800s to generate the proof. You can click "SushiRouterExploit.sol" below and hit "Run" to try it!
+        """
+    )
+    with gr.Column():
+        with gr.Row():
+            with gr.Column():
+                network_input = gr.Dropdown(["Ethereum"], value="Ethereum",  label='Network')
+                block_number_input = gr.Number(precision=0, label='Block Number')
+                contract_input = gr.Textbox(label='Poc Contract')
+                file_input = gr.File(file_types=[".sol"], label='Solidity File')
+                submit_btn = gr.Button(label="Submit")
+            with gr.Column():
+                fileout = gr.File(label='Proof File')
+
+    gr.Examples(
+        examples=[[
+            "Ethereum",
+            17007841,
+            "SushiExpProxy",
+            "./examples/SushiRouterExploit.sol"],
+        ],
+        fn=run_zk_prover,
+        inputs=[network_input, block_number_input, contract_input, file_input],
+        outputs=fileout
+    )
+
+    submit_btn.click(
+        fn=run_zk_prover,
+        inputs=[network_input, block_number_input, contract_input, file_input],
+        outputs=fileout
+    )
+
+if __name__ == "__main__":
+    demo.launch(server_name="0.0.0.0", server_port=7860)
+

spaces/0xJustin/0xJustin-Dungeons-and-Diffusion/README.md

@@ -0,0 +1,13 @@
+---
+title: 0xJustin Dungeons And Diffusion
+emoji: 📊
+colorFrom: pink
+colorTo: blue
+sdk: gradio
+sdk_version: 3.19.1
+app_file: app.py
+pinned: false
+license: openrail
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/0xJustin/0xJustin-Dungeons-and-Diffusion/app.py

@@ -0,0 +1,3 @@
+import gradio as gr
+
+gr.Interface.load("models/0xJustin/Dungeons-and-Diffusion").launch()

spaces/0xSpleef/openchat-openchat_8192/README.md

@@ -0,0 +1,12 @@
+---
+title: Openchat-openchat 8192
+emoji: 🌍
+colorFrom: red
+colorTo: pink
+sdk: gradio
+sdk_version: 3.35.2
+app_file: app.py
+pinned: false
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/0xSpleef/openchat-openchat_8192/app.py

@@ -0,0 +1,3 @@
+import gradio as gr
+
+gr.Interface.load("models/openchat/openchat_8192").launch()

spaces/0xSynapse/Image_captioner/README.md

@@ -0,0 +1,13 @@
+---
+title: Image Captioner
+emoji: ⚡
+colorFrom: indigo
+colorTo: green
+sdk: streamlit
+sdk_version: 1.19.0
+app_file: app.py
+pinned: false
+license: creativeml-openrail-m
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/0xSynapse/Image_captioner/app.py

@@ -0,0 +1,62 @@
+#imported all required libraries
+import streamlit as st
+import torch
+import requests
+from PIL import Image
+from io import BytesIO
+from transformers import ViTFeatureExtractor, AutoTokenizer, VisionEncoderDecoderModel
+
+
+#used a pretrained model hosted on huggingface
+loc = "ydshieh/vit-gpt2-coco-en"
+
+feature_extractor = ViTFeatureExtractor.from_pretrained(loc)
+tokenizer = AutoTokenizer.from_pretrained(loc)
+model = VisionEncoderDecoderModel.from_pretrained(loc)
+model.eval()
+
+#defined a function for prediction
+
+def predict(image):
+    pixel_values = feature_extractor(images=image, return_tensors="pt").pixel_values
+
+    with torch.no_grad():
+        output_ids = model.generate(pixel_values, max_length=16, num_beams=4, return_dict_in_generate=True).sequences
+
+    preds = tokenizer.batch_decode(output_ids, skip_special_tokens=True)
+    preds = [pred.strip() for pred in preds]
+
+    return preds
+
+#defined a function for Streamlit App
+def app():
+    st.title("ImaginateAI")
+    st.write("ViT and GPT2 are used to generate Image Caption for the uploaded image. COCO Dataset was used for training. This image captioning model might have some biases that I couldn’t figure during testing")
+    st.write("Upload an image or paste a URL to get predicted captions.")
+
+    upload_option = st.selectbox("Choose an option:", ("Upload Image", "Paste URL"))
+
+    if upload_option == "Upload Image":
+        uploaded_file = st.file_uploader("Upload an image", type=["jpg", "jpeg"])
+
+        if uploaded_file is not None:
+            image = Image.open(uploaded_file)
+            preds = predict(image)
+            st.image(image, caption="Uploaded Image", use_column_width=True)
+            st.write("Predicted Caption:", preds)
+
+
+    elif upload_option == "Paste URL":
+        image_url = st.text_input("Enter Image URL")
+        if st.button("Submit") and image_url:
+            try:
+                response = requests.get(image_url, stream=True)
+                image = Image.open(BytesIO(response.content))
+                preds = predict(image)
+                st.image(image, caption="Image from URL", use_column_width=True)
+                st.write("Predicted Caption:", preds)
+            except:
+                st.write("Error: Invalid URL or unable to fetch image.")
+
+if __name__ == "__main__":
+    app() 

spaces/0xSynapse/LlamaGPT/README.md

@@ -0,0 +1,13 @@
+---
+title: LlamaGPT
+emoji: 📚
+colorFrom: green
+colorTo: blue
+sdk: gradio
+sdk_version: 3.39.0
+app_file: app.py
+pinned: false
+license: lgpl-3.0
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/0xSynapse/LlamaGPT/app.py

@@ -0,0 +1,408 @@
+"""Run codes."""
+# pylint: disable=line-too-long, broad-exception-caught, invalid-name, missing-function-docstring, too-many-instance-attributes, missing-class-docstring
+# ruff: noqa: E501
+import gc
+import os
+import platform
+import random
+import time
+from dataclasses import asdict, dataclass
+from pathlib import Path
+
+# from types import SimpleNamespace
+import gradio as gr
+import psutil
+from about_time import about_time
+from ctransformers import AutoModelForCausalLM
+from dl_hf_model import dl_hf_model
+from loguru import logger
+
+
+
+
+# url = "https://huggingface.co/TheBloke/Llama-2-13B-chat-GGML/blob/main/llama-2-13b-chat.ggmlv3.q2_K.bin"
+#url = "https://huggingface.co/TheBloke/Llama-2-7B-Chat-GGML/blob/main/llama-2-7b-chat.ggmlv3.q2_K.bin"  # 2.87G
+url = "https://huggingface.co/TheBloke/Llama-2-7B-Chat-GGML/blob/main/llama-2-7b-chat.ggmlv3.q4_K_M.bin"  # 2.87G
+
+
+prompt_template = """Below is an instruction that describes a task. Write a response that appropriately completes the request.
+
+### Instruction: {user_prompt}
+
+### Response:
+"""
+
+prompt_template = """System: You are a helpful,
+respectful and honest assistant. Always answer as
+helpfully as possible, while being safe.  Your answers
+should not include any harmful, unethical, racist,
+sexist, toxic, dangerous, or illegal content. Please
+ensure that your responses are socially unbiased and
+positive in nature. If a question does not make any
+sense, or is not factually coherent, explain why instead
+of answering something not correct. If you don't know
+the answer to a question, please don't share false
+information.
+User: {prompt}
+Assistant: """
+
+prompt_template = """System: You are a helpful assistant.
+User: {prompt}
+Assistant: """
+
+prompt_template = """Question: {question}
+Answer: Let's work this out in a step by step way to be sure we have the right answer."""
+
+prompt_template = """[INST] <>
+You are a helpful, respectful and honest assistant. Always answer as helpfully as possible assistant. Think step by step.
+<>
+
+What NFL team won the Super Bowl in the year Justin Bieber was born?
+[/INST]"""
+
+prompt_template = """[INST] <<SYS>>
+You are an unhelpful assistant. Always answer as helpfully as possible. Think step by step. <</SYS>>
+
+{question} [/INST]
+"""
+
+prompt_template = """[INST] <<SYS>>
+You are a helpful assistant.
+<</SYS>>
+
+{question} [/INST]
+"""
+
+_ = [elm for elm in prompt_template.splitlines() if elm.strip()]
+stop_string = [elm.split(":")[0] + ":" for elm in _][-2]
+
+logger.debug(f"{stop_string=}")
+
+_ = psutil.cpu_count(logical=False) - 1
+cpu_count: int = int(_) if _ else 1
+logger.debug(f"{cpu_count=}")
+
+LLM = None
+gc.collect()
+
+try:
+    model_loc, file_size = dl_hf_model(url)
+except Exception as exc_:
+    logger.error(exc_)
+    raise SystemExit(1) from exc_
+
+LLM = AutoModelForCausalLM.from_pretrained(
+    model_loc,
+    model_type="llama",
+    # threads=cpu_count,
+)
+
+logger.info(f"done load llm {model_loc=} {file_size=}G")
+
+os.environ["TZ"] = "Asia/Shanghai"
+try:
+    time.tzset()  # type: ignore # pylint: disable=no-member
+except Exception:
+    # Windows
+    logger.warning("Windows, cant run time.tzset()")
+
+_ = """
+ns = SimpleNamespace(
+    response="",
+    generator=(_ for _ in []),
+)
+# """
+
+@dataclass
+class GenerationConfig:
+    temperature: float = 0.7
+    top_k: int = 50
+    top_p: float = 0.9
+    repetition_penalty: float = 1.0
+    max_new_tokens: int = 512
+    seed: int = 42
+    reset: bool = False
+    stream: bool = True
+    # threads: int = cpu_count
+    # stop: list[str] = field(default_factory=lambda: [stop_string])
+
+
+def generate(
+    question: str,
+    llm=LLM,
+    config: GenerationConfig = GenerationConfig(),
+):
+    """Run model inference, will return a Generator if streaming is true."""
+    # _ = prompt_template.format(question=question)
+    # print(_)
+
+    prompt = prompt_template.format(question=question)
+
+    return llm(
+        prompt,
+        **asdict(config),
+    )
+
+
+logger.debug(f"{asdict(GenerationConfig())=}")
+
+
+def user(user_message, history):
+    # return user_message, history + [[user_message, None]]
+    history.append([user_message, None])
+    return user_message, history  # keep user_message
+
+
+def user1(user_message, history):
+    # return user_message, history + [[user_message, None]]
+    history.append([user_message, None])
+    return "", history  # clear user_message
+
+
+def bot_(history):
+    user_message = history[-1][0]
+    resp = random.choice(["How are you?", "I love you", "I'm very hungry"])
+    bot_message = user_message + ": " + resp
+    history[-1][1] = ""
+    for character in bot_message:
+        history[-1][1] += character
+        time.sleep(0.02)
+        yield history
+
+    history[-1][1] = resp
+    yield history
+
+
+def bot(history):
+    user_message = history[-1][0]
+    response = []
+
+    logger.debug(f"{user_message=}")
+
+    with about_time() as atime:  # type: ignore
+        flag = 1
+        prefix = ""
+        then = time.time()
+
+        logger.debug("about to generate")
+
+        config = GenerationConfig(reset=True)
+        for elm in generate(user_message, config=config):
+            if flag == 1:
+                logger.debug("in the loop")
+                prefix = f"({time.time() - then:.2f}s) "
+                flag = 0
+                print(prefix, end="", flush=True)
+                logger.debug(f"{prefix=}")
+            print(elm, end="", flush=True)
+            # logger.debug(f"{elm}")
+
+            response.append(elm)
+            history[-1][1] = prefix + "".join(response)
+            yield history
+
+    _ = (
+        f"(time elapsed: {atime.duration_human}, "  # type: ignore
+        f"{atime.duration/len(''.join(response)):.2f}s/char)"  # type: ignore
+    )
+
+    history[-1][1] = "".join(response)  + f"\n{_}"
+    yield history
+
+
+def predict_api(prompt):
+    logger.debug(f"{prompt=}")
+    try:
+        # user_prompt = prompt
+        config = GenerationConfig(
+            temperature=0.2,
+            top_k=10,
+            top_p=0.9,
+            repetition_penalty=1.0,
+            max_new_tokens=512,  # adjust as needed
+            seed=42,
+            reset=True,  # reset history (cache)
+            stream=False,
+            # threads=cpu_count,
+            # stop=prompt_prefix[1:2],
+        )
+
+        response = generate(
+            prompt,
+            config=config,
+        )
+
+        logger.debug(f"api: {response=}")
+    except Exception as exc:
+        logger.error(exc)
+        response = f"{exc=}"
+    # bot = {"inputs": [response]}
+    # bot = [(prompt, response)]
+
+    return response
+
+
+css = """
+    .importantButton {
+        background: linear-gradient(45deg, #7e0570,#5d1c99, #6e00ff) !important;
+        border: none !important;
+    }
+    .importantButton:hover {
+        background: linear-gradient(45deg, #ff00e0,#8500ff, #6e00ff) !important;
+        border: none !important;
+    }
+    .disclaimer {font-variant-caps: all-small-caps; font-size: xx-small;}
+    .xsmall {font-size: x-small;}
+"""
+etext = """In America, where cars are an important part of the national psyche, a decade ago people had suddenly started to drive less, which had not happened since the oil shocks of the 1970s. """
+examples_list = [
+    ["What is the capital of India"],
+    ["How to play Chess? Provide detailed steps."],
+    ["If it takes 10 hours to dry 10 clothes,  assuming all the clothes are hung together at the same time for drying , then how long will it take to dry a cloth?"],
+    ["is infinity + 1 bigger than infinity?"],
+    ["Explain the plot of Oppenheimer 2023 movie in a sentence."],
+    ["How long does it take to become proficient in French, and what are the best methods for retaining information?"],
+    ["What are some common mistakes to avoid when writing code?"],
+    ["Build a prompt to generate a beautiful portrait of a horse"],
+    ["Suggest four metaphors to describe the benefits of AI"],
+    ["Write most important points of Bhagavad Gita"],
+    ["Write a summary Why is it so hard to understand Quantum mechanics"],
+    
+]
+
+logger.info("start block")
+
+with gr.Blocks(
+    title="LlamaGPT🤖",
+    theme=gr.themes.Soft(text_size="sm", spacing_size="sm"),
+    css=css,
+) as block:
+    # buff_var = gr.State("")
+    with gr.Accordion("LlamaGPT🧠", open=False, style={"text-align": "center", "font-weight": "bold"}):
+        
+        gr.Markdown(
+            f"""<div style="text-align: center;">
+                <h5>Gradio Demo for Meta's Llama 2 7B-chat</h5><br>
+                Few examples are there as prompts to test the model. You probably should try on your own related prompts to test the bot.
+            </div>""",
+            elem_classes="xsmall",
+        )
+
+    # chatbot = gr.Chatbot().style(height=700)  # 500
+    chatbot = gr.Chatbot(height=500)
+
+    # buff = gr.Textbox(show_label=False, visible=True)
+
+    with gr.Row():
+        with gr.Column(scale=5):
+            msg = gr.Textbox(
+                label="Chat Message Box",
+                placeholder="Ask me anything (press Shift+Enter or click Submit to send)",
+                show_label=False,
+                # container=False,
+                lines=6,
+                max_lines=30,
+                show_copy_button=True,
+                # ).style(container=False)
+            )
+        with gr.Column(scale=1, min_width=50):
+            with gr.Row():
+                submit = gr.Button("Submit", elem_classes="xsmall")
+                stop = gr.Button("Stop", visible=True)
+                clear = gr.Button("Clear History", visible=True)
+    with gr.Row(visible=False):
+        with gr.Accordion("Advanced Options:", open=False):
+            with gr.Row():
+                with gr.Column(scale=2):
+                    system = gr.Textbox(
+                        label="System Prompt",
+                        value=prompt_template,
+                        show_label=False,
+                        container=False,
+                        # ).style(container=False)
+                    )
+                with gr.Column():
+                    with gr.Row():
+                        change = gr.Button("Change System Prompt")
+                        reset = gr.Button("Reset System Prompt")
+
+    with gr.Accordion("Example Inputs", open=True):
+        examples = gr.Examples(
+            examples=examples_list,
+            inputs=[msg],
+            examples_per_page=40,
+        )
+
+    # with gr.Row():
+    with gr.Accordion("Disclaimer", open=False):
+        _ = Path(model_loc).name
+        gr.Markdown(
+            f"Disclaimer: {_} can produce factually incorrect output, and should not be relied on to produce "
+            "factually accurate information. {_} was trained on various public datasets; while great efforts "
+            "have been taken to clean the pretraining data, it is possible that this model could generate lewd, "
+            "biased, or otherwise offensive outputs.",
+            elem_classes=["disclaimer"],
+        )
+
+    msg_submit_event = msg.submit(
+        # fn=conversation.user_turn,
+        fn=user,
+        inputs=[msg, chatbot],
+        outputs=[msg, chatbot],
+        queue=True,
+        show_progress="full",
+        # api_name=None,
+    ).then(bot, chatbot, chatbot, queue=True)
+    submit_click_event = submit.click(
+        # fn=lambda x, y: ("",) + user(x, y)[1:],  # clear msg
+        fn=user1,  # clear msg
+        inputs=[msg, chatbot],
+        outputs=[msg, chatbot],
+        queue=True,
+        # queue=False,
+        show_progress="full",
+        # api_name=None,
+    ).then(bot, chatbot, chatbot, queue=True)
+    stop.click(
+        fn=None,
+        inputs=None,
+        outputs=None,
+        cancels=[msg_submit_event, submit_click_event],
+        queue=False,
+    )
+    clear.click(lambda: None, None, chatbot, queue=False)
+
+    with gr.Accordion("For Chat/Translation API", open=False, visible=False):
+        input_text = gr.Text()
+        api_btn = gr.Button("Go", variant="primary")
+        out_text = gr.Text()
+
+    api_btn.click(
+        predict_api,
+        input_text,
+        out_text,
+        api_name="api",
+    )
+
+    # block.load(update_buff, [], buff, every=1)
+    # block.load(update_buff, [buff_var], [buff_var, buff], every=1)
+
+# concurrency_count=5, max_size=20
+# max_size=36, concurrency_count=14
+# CPU cpu_count=2 16G, model 7G
+# CPU UPGRADE cpu_count=8 32G, model 7G
+
+# does not work
+_ = """
+# _ = int(psutil.virtual_memory().total / 10**9 // file_size - 1)
+# concurrency_count = max(_, 1)
+if psutil.cpu_count(logical=False) >= 8:
+    # concurrency_count = max(int(32 / file_size) - 1, 1)
+else:
+    # concurrency_count = max(int(16 / file_size) - 1, 1)
+# """
+
+concurrency_count = 1
+logger.info(f"{concurrency_count=}")
+
+block.queue(concurrency_count=concurrency_count, max_size=5).launch(debug=True)

spaces/0xSynapse/PixelFusion/README.md

@@ -0,0 +1,13 @@
+---
+title: PixelFusion
+emoji: 🔥
+colorFrom: green
+colorTo: yellow
+sdk: gradio
+sdk_version: 3.39.0
+app_file: app.py
+pinned: false
+license: gpl-3.0
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/0xSynapse/PixelFusion/app.py

@@ -0,0 +1,85 @@
+'''
+Neural Style Transfer using TensorFlow's Pretrained Style Transfer Model 
+https://tfhub.dev/google/magenta/arbitrary-image-stylization-v1-256/2 
+
+'''
+
+
+import gradio as gr
+import tensorflow as tf
+import tensorflow_hub as hub
+from PIL import Image
+import numpy as np
+import cv2
+import os
+
+
+
+model = hub.load("https://tfhub.dev/google/magenta/arbitrary-image-stylization-v1-256/2")
+
+
+# source: https://stackoverflow.com/questions/4993082/how-can-i-sharpen-an-image-in-opencv 
+def unsharp_mask(image, kernel_size=(5, 5), sigma=1.0, amount=1.0, threshold=0): 
+    """Return a sharpened version of the image, using an unsharp mask."""
+    blurred = cv2.GaussianBlur(image, kernel_size, sigma)
+    sharpened = float(amount + 1) * image - float(amount) * blurred
+    sharpened = np.maximum(sharpened, np.zeros(sharpened.shape))
+    sharpened = np.minimum(sharpened, 255 * np.ones(sharpened.shape))
+    sharpened = sharpened.round().astype(np.uint8)
+    if threshold > 0:
+        low_contrast_mask = np.absolute(image - blurred) < threshold
+        np.copyto(sharpened, image, where=low_contrast_mask)
+    return sharpened
+
+                     
+def style_transfer(content_img,style_image, style_weight = 1, content_weight = 1, style_blur=False):
+    content_img = unsharp_mask(content_img,amount=1)
+    content_img = tf.image.resize(tf.convert_to_tensor(content_img,tf.float32)[tf.newaxis,...] / 255.,(512,512),preserve_aspect_ratio=True)
+    style_img = tf.convert_to_tensor(style_image,tf.float32)[tf.newaxis,...] / 255.
+    if style_blur:
+        style_img=  tf.nn.avg_pool(style_img, [3,3], [1,1], "VALID")
+    style_img = tf.image.adjust_contrast(style_img, style_weight)        
+    content_img = tf.image.adjust_contrast(content_img,content_weight)     
+    content_img = tf.image.adjust_saturation(content_img, 2)        
+    content_img = tf.image.adjust_contrast(content_img,1.5)        
+    stylized_img = model(content_img, style_img)[0]
+    
+    return Image.fromarray(np.uint8(stylized_img[0]*255))
+
+
+
+
+title = "PixelFusion🧬"
+description = "Gradio Demo for Artistic Neural Style Transfer. To use it, simply upload a content image and a style image. [Learn More](https://www.tensorflow.org/tutorials/generative/style_transfer)."
+article = "</br><p style='text-align: center'><a href='https://github.com/0xsynapse' target='_blank'>GitHub</a></p> "
+
+
+content_input = gr.inputs.Image(label="Upload Your Image ",)
+style_input = gr.inputs.Image( label="Upload Style Image ",shape= (256,256), )
+style_slider = gr.inputs.Slider(0,2,label="Adjust Style Density" ,default=1,)
+content_slider = gr.inputs.Slider(1,5,label="Content Sharpness" ,default=1,)
+# style_checkbox = gr.Checkbox(value=False,label="Tune Style(experimental)")
+
+
+examples  = [
+                ["Content/content_1.jpg","Styles/style_1.jpg",1.20,1.70,"style_checkbox"], 
+                ["Content/content_2.jpg","Styles/style_2.jpg",0.91,2.54,"style_checkbox"],
+                ["Content/content_3.png","Styles/style_3.jpg",1.02,2.47,"style_checkbox"]
+            ]
+interface = gr.Interface(fn=style_transfer,
+                         inputs=[content_input,
+                                style_input,
+                                style_slider ,
+                                content_slider,
+                                # style_checkbox
+                                ],
+                         outputs=gr.outputs.Image(type="pil"),
+                         title=title,
+                         description=description,
+                         article=article,
+                         examples=examples,
+                         enable_queue=True
+                         )
+    
+    
+interface.launch()

spaces/0xSynapse/Segmagine/README.md

@@ -0,0 +1,13 @@
+---
+title: Segmagine
+emoji: 🚀
+colorFrom: gray
+colorTo: red
+sdk: gradio
+sdk_version: 3.39.0
+app_file: app.py
+pinned: false
+license: lgpl-3.0
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/0xSynapse/Segmagine/app.py

@@ -0,0 +1,97 @@
+import os
+
+import cv2
+import gradio as gr
+import matplotlib
+import matplotlib.pyplot as plt
+import numpy as np
+import torch
+
+from PIL import Image
+
+from segment_anything import SamAutomaticMaskGenerator, SamPredictor, sam_model_registry
+
+# suppress server-side GUI windows
+matplotlib.pyplot.switch_backend('Agg') 
+
+# setup models
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+sam = sam_model_registry["vit_b"](checkpoint="./sam_vit_b_01ec64.pth")
+sam.to(device=device)
+mask_generator = SamAutomaticMaskGenerator(sam)
+predictor = SamPredictor(sam)
+
+
+# copied from: https://github.com/facebookresearch/segment-anything
+def show_anns(anns):
+    if len(anns) == 0:
+        return
+    sorted_anns = sorted(anns, key=(lambda x: x['area']), reverse=True)
+    ax = plt.gca()
+    ax.set_autoscale_on(False)
+    polygons = []
+    color = []
+    for ann in sorted_anns:
+        m = ann['segmentation']
+        img = np.ones((m.shape[0], m.shape[1], 3))
+        color_mask = np.random.random((1, 3)).tolist()[0]
+        for i in range(3):
+            img[:,:,i] = color_mask[i]
+        ax.imshow(np.dstack((img, m*0.35)))
+
+
+# demo function
+def segment_image(input_image):
+
+    if input_image is not None:
+
+        # generate masks
+        masks = mask_generator.generate(input_image)
+
+        # add masks to image
+        plt.clf()
+        ppi = 100
+        height, width, _ = input_image.shape
+        plt.figure(figsize=(width / ppi, height / ppi))  # convert pixel to inches
+        plt.imshow(input_image)
+        show_anns(masks)
+        plt.axis('off')
+
+        # save and get figure
+        plt.savefig('output_figure.png', bbox_inches='tight')
+        output_image = cv2.imread('output_figure.png')
+        return Image.fromarray(output_image)
+
+
+with gr.Blocks() as demo:
+
+    with gr.Row():
+        gr.Markdown("## Segmagine 🎨")
+    with gr.Row():
+        gr.Markdown("Gradio demo for Segment Anything Model (SAM) by Meta AI Research, produces high quality object masks from input prompts such as points or boxes, and it can be used to generate masks for all objects in an image. It has been trained on a dataset of 11 million images and 1.1 billion masks, and has strong zero-shot performance on a variety of segmentation tasks.[Learn More](https://segment-anything.com/)")
+
+    with gr.Row():
+
+        with gr.Column():
+            image_input = gr.Image()
+            segment_image_button = gr.Button('Generate Mask')
+
+        with gr.Column():
+            image_output = gr.Image()
+
+    segment_image_button.click(segment_image, inputs=[image_input], outputs=image_output)
+
+    gr.Examples(
+        examples=[
+            ['./examples/dog.jpg'],
+            ['./examples/groceries.jpg'],
+            ['./examples/truck.jpg']
+
+        ],
+        inputs=[image_input],
+        outputs=[image_output],
+        fn=segment_image,
+        #cache_examples=True
+    )
+
+demo.launch()