text-generation-webui/server.py

397 lines
18 KiB
Python
Raw Normal View History

2022-12-21 17:27:31 +01:00
import re
2023-01-06 05:33:21 +01:00
import time
import glob
2023-01-06 23:56:44 +01:00
from sys import exit
2022-12-21 17:27:31 +01:00
import torch
2023-01-06 23:56:44 +01:00
import argparse
import json
from pathlib import Path
2022-12-21 17:27:31 +01:00
import gradio as gr
import transformers
2023-01-07 03:14:08 +01:00
from html_generator import *
2023-01-16 03:15:30 +01:00
from transformers import AutoTokenizer, AutoModelForCausalLM
2023-01-15 04:39:51 +01:00
import warnings
2022-12-21 17:27:31 +01:00
2023-01-07 03:14:08 +01:00
transformers.logging.set_verbosity_error()
2023-01-06 23:56:44 +01:00
parser = argparse.ArgumentParser()
2023-01-07 00:22:26 +01:00
parser.add_argument('--model', type=str, help='Name of the model to load by default.')
2023-01-16 14:10:09 +01:00
parser.add_argument('--notebook', action='store_true', help='Launch the web UI in notebook mode, where the output is written to the same text box as the input.')
parser.add_argument('--chat', action='store_true', help='Launch the web UI in chat mode.')
parser.add_argument('--cai-chat', action='store_true', help='Launch the web UI in chat mode with a style similar to Character.AI\'s. If the file profile.png or profile.jpg exists in the same folder as server.py, this image will be used as the bot\'s profile picture.')
2023-01-09 14:58:46 +01:00
parser.add_argument('--cpu', action='store_true', help='Use the CPU to generate text.')
parser.add_argument('--auto-devices', action='store_true', help='Automatically split the model across the available GPU(s) and CPU.')
parser.add_argument('--load-in-8bit', action='store_true', help='Load the model with 8-bit precision.')
2023-01-16 14:10:09 +01:00
parser.add_argument('--max-gpu-memory', type=int, help='Maximum memory in GiB to allocate to the GPU when loading the model. This is useful if you get out of memory errors while trying to generate text. Must be an integer number.')
parser.add_argument('--no-listen', action='store_true', help='Make the web UI unreachable from your local network.')
2023-01-19 14:43:05 +01:00
parser.add_argument('--no-stream', action='store_true', help='Don\'t stream the text output in real time. This slightly improves the text generation performance.')
2023-01-16 20:35:45 +01:00
parser.add_argument('--settings', type=str, help='Load the default interface settings from this json file. See settings-template.json for an example.')
2023-01-06 23:56:44 +01:00
args = parser.parse_args()
2023-01-15 04:39:51 +01:00
2023-01-06 06:06:59 +01:00
loaded_preset = None
2023-01-16 20:35:45 +01:00
available_models = sorted(set([item.replace('.pt', '') for item in map(lambda x : str(x.name), list(Path('models/').glob('*'))+list(Path('torch-dumps/').glob('*'))) if not item.endswith('.txt')]), key=str.lower)
available_presets = sorted(set(map(lambda x : str(x.name).split('.')[0], Path('presets').glob('*.txt'))), key=str.lower)
2023-01-06 05:33:21 +01:00
settings = {
'max_new_tokens': 200,
'max_new_tokens_min': 1,
'max_new_tokens_max': 2000,
'preset': 'NovelAI-Sphinx Moth',
'name1': 'Person 1',
'name2': 'Person 2',
'name1_pygmalion': 'You',
'name2_pygmalion': 'Kawaii',
'context': 'This is a conversation between two people.',
'context_pygmalion': 'This is a conversation between two people.\n<START>',
'prompt': 'Common sense questions and answers\n\nQuestion: \nFactual answer:',
'prompt_gpt4chan': '-----\n--- 865467536\nInput text\n--- 865467537\n',
'stop_at_newline': True,
}
2023-01-16 20:35:45 +01:00
if args.settings is not None and Path(args.settings).exists():
with open(Path(args.settings), 'r') as f:
new_settings = json.load(f)
2023-01-16 20:35:45 +01:00
for item in new_settings:
if item in settings:
settings[item] = new_settings[item]
2023-01-15 04:39:51 +01:00
2022-12-21 17:27:31 +01:00
def load_model(model_name):
2023-01-06 05:41:52 +01:00
print(f"Loading {model_name}...")
2022-12-21 17:27:31 +01:00
t0 = time.time()
2023-01-06 05:41:52 +01:00
# Default settings
2023-01-16 02:33:35 +01:00
if not (args.cpu or args.auto_devices or args.load_in_8bit or args.max_gpu_memory is not None):
if Path(f"torch-dumps/{model_name}.pt").exists():
print("Loading in .pt format...")
model = torch.load(Path(f"torch-dumps/{model_name}.pt"))
elif model_name.lower().startswith(('gpt-neo', 'opt-', 'galactica')) and any(size in model_name.lower() for size in ('13b', '20b', '30b')):
model = AutoModelForCausalLM.from_pretrained(Path(f"models/{model_name}"), device_map='auto', load_in_8bit=True)
else:
model = AutoModelForCausalLM.from_pretrained(Path(f"models/{model_name}"), low_cpu_mem_usage=True, torch_dtype=torch.float16).cuda()
# Custom
2023-01-06 06:54:33 +01:00
else:
settings = ["low_cpu_mem_usage=True"]
2023-01-11 03:39:50 +01:00
command = "AutoModelForCausalLM.from_pretrained"
2023-01-09 20:28:04 +01:00
if args.cpu:
settings.append("torch_dtype=torch.float32")
2023-01-09 20:28:04 +01:00
else:
2023-01-16 03:01:51 +01:00
settings.append("device_map='auto'")
2023-01-16 02:33:35 +01:00
if args.max_gpu_memory is not None:
settings.append(f"max_memory={{0: '{args.max_gpu_memory}GiB', 'cpu': '99GiB'}}")
2023-01-16 03:01:51 +01:00
if args.load_in_8bit:
settings.append("load_in_8bit=True")
else:
settings.append("torch_dtype=torch.float16")
2023-01-16 20:35:45 +01:00
settings = ', '.join(set(settings))
2023-01-16 03:01:51 +01:00
command = f"{command}(Path(f'models/{model_name}'), {settings})"
model = eval(command)
2022-12-21 17:27:31 +01:00
2023-01-06 06:54:33 +01:00
# Loading the tokenizer
2023-01-11 05:10:11 +01:00
if model_name.lower().startswith(('gpt4chan', 'gpt-4chan', '4chan')) and Path(f"models/gpt-j-6B/").exists():
tokenizer = AutoTokenizer.from_pretrained(Path("models/gpt-j-6B/"))
2022-12-21 17:27:31 +01:00
else:
tokenizer = AutoTokenizer.from_pretrained(Path(f"models/{model_name}/"))
2023-01-16 17:43:23 +01:00
tokenizer.truncation_side = 'left'
2022-12-21 17:27:31 +01:00
2023-01-06 06:06:59 +01:00
print(f"Loaded the model in {(time.time()-t0):.2f} seconds.")
2022-12-21 17:27:31 +01:00
return model, tokenizer
2023-01-06 06:26:33 +01:00
# Removes empty replies from gpt4chan outputs
2022-12-21 17:27:31 +01:00
def fix_gpt4chan(s):
for i in range(10):
s = re.sub("--- [0-9]*\n>>[0-9]*\n---", "---", s)
s = re.sub("--- [0-9]*\n *\n---", "---", s)
s = re.sub("--- [0-9]*\n\n\n---", "---", s)
return s
2023-01-16 20:35:45 +01:00
# Fix the LaTeX equations in galactica
2023-01-07 05:56:21 +01:00
def fix_galactica(s):
s = s.replace(r'\[', r'$')
s = s.replace(r'\]', r'$')
2023-01-07 16:13:09 +01:00
s = s.replace(r'\(', r'$')
s = s.replace(r'\)', r'$')
s = s.replace(r'$$', r'$')
2023-01-07 05:56:21 +01:00
return s
def encode(prompt, tokens):
if not args.cpu:
torch.cuda.empty_cache()
input_ids = tokenizer.encode(str(prompt), return_tensors='pt', truncation=True, max_length=2048-tokens).cuda()
else:
input_ids = tokenizer.encode(str(prompt), return_tensors='pt', truncation=True, max_length=2048-tokens)
return input_ids
2023-01-19 14:43:05 +01:00
def decode(output_ids):
reply = tokenizer.decode(output_ids, skip_special_tokens=True)
reply = reply.replace(r'<|endoftext|>', '')
return reply
def formatted_outputs(reply, model_name):
if model_name.lower().startswith('galactica'):
reply = fix_galactica(reply)
return reply, reply, generate_basic_html(reply)
elif model_name.lower().startswith('gpt4chan'):
reply = fix_gpt4chan(reply)
return reply, 'Only applicable for GALACTICA models.', generate_4chan_html(reply)
else:
return reply, 'Only applicable for GALACTICA models.', generate_basic_html(reply)
2023-01-13 18:28:53 +01:00
def generate_reply(question, tokens, inference_settings, selected_model, eos_token=None):
2023-01-06 06:06:59 +01:00
global model, tokenizer, model_name, loaded_preset, preset
2022-12-21 17:27:31 +01:00
if selected_model != model_name:
model_name = selected_model
model = None
2023-01-08 18:37:43 +01:00
tokenizer = None
2023-01-09 14:58:46 +01:00
if not args.cpu:
torch.cuda.empty_cache()
2022-12-21 17:27:31 +01:00
model, tokenizer = load_model(model_name)
2023-01-06 06:06:59 +01:00
if inference_settings != loaded_preset:
with open(Path(f'presets/{inference_settings}.txt'), 'r') as infile:
2023-01-06 05:33:21 +01:00
preset = infile.read()
2023-01-06 06:06:59 +01:00
loaded_preset = inference_settings
2022-12-21 17:27:31 +01:00
2023-01-19 04:41:57 +01:00
cuda = "" if args.cpu else ".cuda()"
2023-01-19 14:43:05 +01:00
n = None if eos_token is None else tokenizer.encode(eos_token, return_tensors='pt')[0][-1]
# Generate the entire reply at once
if args.no_stream:
input_ids = encode(question, tokens)
output = eval(f"model.generate(input_ids, eos_token_id={n}, {preset}){cuda}")
reply = decode(output[0])
yield formatted_outputs(reply, model_name)
# Generate the reply 1 token at a time
else:
2023-01-19 03:56:42 +01:00
input_ids = encode(question, 1)
preset = preset.replace('max_new_tokens=tokens', 'max_new_tokens=1')
for i in range(tokens):
output = eval(f"model.generate(input_ids, {preset}){cuda}")
2023-01-19 14:43:05 +01:00
reply = decode(output[0])
2023-01-19 03:56:42 +01:00
if eos_token is not None and reply[-1] == eos_token:
break
2023-01-19 14:43:05 +01:00
yield formatted_outputs(reply, model_name)
2023-01-19 03:56:42 +01:00
input_ids = output
2023-01-06 23:56:44 +01:00
# Choosing the default model
if args.model is not None:
model_name = args.model
else:
2023-01-07 02:05:37 +01:00
if len(available_models) == 0:
2023-01-06 23:56:44 +01:00
print("No models are available! Please download at least one.")
exit(0)
elif len(available_models) == 1:
i = 0
else:
print("The following models are available:\n")
for i,model in enumerate(available_models):
print(f"{i+1}. {model}")
print(f"\nWhich one do you want to load? 1-{len(available_models)}\n")
i = int(input())-1
2023-01-09 16:56:54 +01:00
print()
2023-01-06 23:56:44 +01:00
model_name = available_models[i]
2022-12-21 17:27:31 +01:00
model, tokenizer = load_model(model_name)
2023-01-06 23:56:44 +01:00
# UI settings
2023-01-07 23:11:21 +01:00
if model_name.lower().startswith('gpt4chan'):
default_text = settings['prompt_gpt4chan']
2022-12-21 17:27:31 +01:00
else:
default_text = settings['prompt']
2023-01-07 23:11:21 +01:00
description = f"\n\n# Text generation lab\nGenerate text using Large Language Models.\n"
2023-01-15 22:16:46 +01:00
css = ".my-4 {margin-top: 0} .py-6 {padding-top: 2.5rem}"
2023-01-19 02:44:47 +01:00
if args.chat or args.cai_chat:
2023-01-08 02:52:46 +01:00
history = []
2023-01-15 04:39:51 +01:00
# This gets the new line characters right.
def clean_chat_message(text):
2023-01-15 03:50:34 +01:00
text = text.replace('\n', '\n\n')
text = re.sub(r"\n{3,}", "\n\n", text)
text = text.strip()
2023-01-15 04:39:51 +01:00
return text
def generate_chat_prompt(text, tokens, name1, name2, context):
text = clean_chat_message(text)
2023-01-15 03:50:34 +01:00
rows = [f"{context}\n\n"]
i = len(history)-1
while i >= 0 and len(encode(''.join(rows), tokens)[0]) < 2048-tokens:
rows.insert(1, f"{name2}: {history[i][1].strip()}\n")
rows.insert(1, f"{name1}: {history[i][0].strip()}\n")
i -= 1
rows.append(f"{name1}: {text}\n")
rows.append(f"{name2}:")
while len(rows) > 3 and len(encode(''.join(rows), tokens)[0]) >= 2048-tokens:
rows.pop(1)
rows.pop(1)
question = ''.join(rows)
return question
2023-01-08 02:52:46 +01:00
def chatbot_wrapper(text, tokens, inference_settings, selected_model, name1, name2, context, check):
question = generate_chat_prompt(text, tokens, name1, name2, context)
2023-01-19 02:08:23 +01:00
history.append(['', ''])
eos_token = '\n' if check else None
for i in generate_reply(question, tokens, inference_settings, selected_model, eos_token=eos_token):
reply = i[0]
next_character_found = False
if check:
idx = reply.rfind(question[-1024:])
reply = reply[idx+min(1024, len(question)):].split('\n')[0].strip()
else:
idx = reply.rfind(question[-1024:])
reply = reply[idx+min(1024, len(question)):]
idx = reply.find(f"\n{name1}:")
if idx != -1:
reply = reply[:idx]
next_character_found = True
reply = clean_chat_message(reply)
history[-1] = [text, reply]
2023-01-19 14:43:05 +01:00
if next_character_found:
break
# Prevent the chat log from flashing if something like "\nYo" is generated just
# before "\nYou:" is completed
tmp = f"\n{name1}:"
next_character_substring_found = False
2023-01-19 14:43:05 +01:00
for j in range(1, len(tmp)):
if reply[-j:] == tmp[:j]:
next_character_substring_found = True
if not next_character_substring_found:
yield history
2023-01-08 02:52:46 +01:00
2023-01-19 14:43:05 +01:00
yield history
def cai_chatbot_wrapper(text, tokens, inference_settings, selected_model, name1, name2, context, check):
for history in chatbot_wrapper(text, tokens, inference_settings, selected_model, name1, name2, context, check):
yield generate_chat_html(history, name1, name2)
def remove_last_message(name1, name2):
history.pop()
if args.cai_chat:
return generate_chat_html(history, name1, name2)
else:
return history
2023-01-08 02:52:46 +01:00
def clear():
global history
history = []
def clear_html():
return generate_chat_html([], "", "")
if 'pygmalion' in model_name.lower():
context_str = settings['context_pygmalion']
name1_str = settings['name1_pygmalion']
name2_str = settings['name2_pygmalion']
else:
context_str = settings['context']
name1_str = settings['name1']
name2_str = settings['name2']
2023-01-15 22:16:46 +01:00
with gr.Blocks(css=css+".h-\[40vh\] {height: 66.67vh} .gradio-container {max-width: 800px; margin-left: auto; margin-right: auto}", analytics_enabled=False) as interface:
if args.cai_chat:
display1 = gr.HTML(value=generate_chat_html([], "", ""))
else:
display1 = gr.Chatbot()
textbox = gr.Textbox(lines=2, label='Input')
btn = gr.Button("Generate")
2023-01-09 21:23:43 +01:00
with gr.Row():
2023-01-19 02:44:47 +01:00
btn2 = gr.Button("Clear history")
stop = gr.Button("Stop")
btn3 = gr.Button("Remove last message")
2023-01-15 22:16:46 +01:00
length_slider = gr.Slider(minimum=settings['max_new_tokens_min'], maximum=settings['max_new_tokens_max'], step=1, label='max_new_tokens', value=settings['max_new_tokens'])
with gr.Row():
2023-01-08 02:52:46 +01:00
with gr.Column():
2023-01-15 22:16:46 +01:00
model_menu = gr.Dropdown(choices=available_models, value=model_name, label='Model')
with gr.Column():
preset_menu = gr.Dropdown(choices=available_presets, value=settings['preset'], label='Settings preset')
name1 = gr.Textbox(value=name1_str, lines=1, label='Your name')
name2 = gr.Textbox(value=name2_str, lines=1, label='Bot\'s name')
context = gr.Textbox(value=context_str, lines=2, label='Context')
with gr.Row():
check = gr.Checkbox(value=settings['stop_at_newline'], label='Stop generating at new line character?')
if args.cai_chat:
2023-01-19 03:56:42 +01:00
gen_event = btn.click(cai_chatbot_wrapper, [textbox, length_slider, preset_menu, model_menu, name1, name2, context, check], display1, show_progress=args.no_stream, api_name="textgen")
gen_event2 = textbox.submit(cai_chatbot_wrapper, [textbox, length_slider, preset_menu, model_menu, name1, name2, context, check], display1, show_progress=args.no_stream)
2023-01-19 02:44:47 +01:00
btn2.click(clear_html, [], display1, show_progress=False)
else:
2023-01-19 03:56:42 +01:00
gen_event = btn.click(chatbot_wrapper, [textbox, length_slider, preset_menu, model_menu, name1, name2, context, check], display1, show_progress=args.no_stream, api_name="textgen")
gen_event2 = textbox.submit(chatbot_wrapper, [textbox, length_slider, preset_menu, model_menu, name1, name2, context, check], display1, show_progress=args.no_stream)
2023-01-19 02:44:47 +01:00
btn2.click(lambda x: "", display1, display1, show_progress=False)
2023-01-08 02:52:46 +01:00
btn2.click(clear)
btn3.click(remove_last_message, [name1, name2], display1, show_progress=False)
2023-01-08 05:10:02 +01:00
btn.click(lambda x: "", textbox, textbox, show_progress=False)
2023-01-08 05:33:45 +01:00
textbox.submit(lambda x: "", textbox, textbox, show_progress=False)
2023-01-19 02:44:47 +01:00
stop.click(None, None, None, cancels=[gen_event, gen_event2])
2023-01-11 05:33:57 +01:00
2023-01-19 02:44:47 +01:00
elif args.notebook:
with gr.Blocks(css=css, analytics_enabled=False) as interface:
gr.Markdown(description)
with gr.Tab('Raw'):
textbox = gr.Textbox(value=default_text, lines=23)
with gr.Tab('Markdown'):
markdown = gr.Markdown()
with gr.Tab('HTML'):
html = gr.HTML()
btn = gr.Button("Generate")
stop = gr.Button("Stop")
2023-01-11 05:33:57 +01:00
2023-01-19 02:44:47 +01:00
length_slider = gr.Slider(minimum=settings['max_new_tokens_min'], maximum=settings['max_new_tokens_max'], step=1, label='max_new_tokens', value=settings['max_new_tokens'])
with gr.Row():
with gr.Column():
model_menu = gr.Dropdown(choices=available_models, value=model_name, label='Model')
with gr.Column():
preset_menu = gr.Dropdown(choices=available_presets, value=settings['preset'], label='Settings preset')
2023-01-19 03:56:42 +01:00
gen_event = btn.click(generate_reply, [textbox, length_slider, preset_menu, model_menu], [textbox, markdown, html], show_progress=args.no_stream, api_name="textgen")
gen_event2 = textbox.submit(generate_reply, [textbox, length_slider, preset_menu, model_menu], [textbox, markdown, html], show_progress=args.no_stream)
2023-01-19 02:44:47 +01:00
stop.click(None, None, None, cancels=[gen_event, gen_event2])
else:
with gr.Blocks(css=css, analytics_enabled=False) as interface:
gr.Markdown(description)
2023-01-07 02:05:37 +01:00
with gr.Row():
with gr.Column():
textbox = gr.Textbox(value=default_text, lines=15, label='Input')
length_slider = gr.Slider(minimum=settings['max_new_tokens_min'], maximum=settings['max_new_tokens_max'], step=1, label='max_new_tokens', value=settings['max_new_tokens'])
preset_menu = gr.Dropdown(choices=available_presets, value=settings['preset'], label='Settings preset')
2023-01-07 02:05:37 +01:00
model_menu = gr.Dropdown(choices=available_models, value=model_name, label='Model')
btn = gr.Button("Generate")
2023-01-19 02:44:47 +01:00
with gr.Row():
with gr.Column():
cont = gr.Button("Continue")
with gr.Column():
stop = gr.Button("Stop")
2023-01-07 02:05:37 +01:00
with gr.Column():
with gr.Tab('Raw'):
2023-01-11 05:36:11 +01:00
output_textbox = gr.Textbox(lines=15, label='Output')
2023-01-07 02:05:37 +01:00
with gr.Tab('Markdown'):
markdown = gr.Markdown()
2023-01-07 03:14:08 +01:00
with gr.Tab('HTML'):
html = gr.HTML()
2023-01-07 02:05:37 +01:00
2023-01-19 03:56:42 +01:00
gen_event = btn.click(generate_reply, [textbox, length_slider, preset_menu, model_menu], [output_textbox, markdown, html], show_progress=args.no_stream, api_name="textgen")
gen_event2 = textbox.submit(generate_reply, [textbox, length_slider, preset_menu, model_menu], [output_textbox, markdown, html], show_progress=args.no_stream)
cont_event = cont.click(generate_reply, [output_textbox, length_slider, preset_menu, model_menu], [output_textbox, markdown, html], show_progress=args.no_stream)
2023-01-19 02:44:47 +01:00
stop.click(None, None, None, cancels=[gen_event, gen_event2, cont_event])
2022-12-21 17:27:31 +01:00
interface.queue()
2023-01-11 05:10:11 +01:00
if args.no_listen:
2023-01-09 23:05:36 +01:00
interface.launch(share=False)
2023-01-11 05:10:11 +01:00
else:
interface.launch(share=False, server_name="0.0.0.0")