By using h2oGPT, you accept our [Terms of Service](https://github.com/h2oai/h2ogpt/blob/main/tos.md)
""" if is_hf: description += '''Run:
python generate.py --langchain_mode=MyData
For more options see: {langchain_readme}""", visible=kwargs['langchain_mode'] == 'Disabled', interactive=False) data_row = gr.Row(visible=kwargs['langchain_mode'] != 'Disabled') with data_row: if is_hf: # don't show 'wiki' since only usually useful for internal testing at moment no_show_modes = ['Disabled', 'wiki'] else: no_show_modes = ['Disabled'] allowed_modes = visible_langchain_modes.copy() allowed_modes = [x for x in allowed_modes if x in dbs] allowed_modes += ['ChatLLM', 'LLM'] if allow_upload_to_my_data and 'MyData' not in allowed_modes: allowed_modes += ['MyData'] if allow_upload_to_user_data and 'UserData' not in allowed_modes: allowed_modes += ['UserData'] langchain_mode = gr.Radio( [x for x in langchain_modes if x in allowed_modes and x not in no_show_modes], value=kwargs['langchain_mode'], label="Data Source", visible=kwargs['langchain_mode'] != 'Disabled') def upload_file(files, x): file_paths = [file.name for file in files] return files, file_paths upload_row = gr.Row(visible=kwargs['langchain_mode'] != 'Disabled' and allow_upload).style( equal_height=False) # import control if kwargs['langchain_mode'] != 'Disabled': from gpt_langchain import file_types, have_arxiv else: have_arxiv = False file_types = [] with upload_row: file_types_str = '[' + ' '.join(file_types) + ']' fileup_output = gr.File(label=f'Upload {file_types_str}', file_types=file_types, file_count="multiple", elem_id="warning", elem_classes="feedback") with gr.Row(): upload_button = gr.UploadButton("Upload %s" % file_types_str, file_types=file_types, file_count="multiple", visible=False, ) # add not visible until upload something with gr.Column(): add_to_shared_db_btn = gr.Button("Add File(s) to Shared UserData DB", visible=allow_upload_to_user_data) # and False) add_to_my_db_btn = gr.Button("Add File(s) to Scratch MyData DB", visible=allow_upload_to_my_data) # and False) url_row = gr.Row( visible=kwargs['langchain_mode'] != 'Disabled' and allow_upload and enable_url_upload).style( equal_height=False) with url_row: url_label = 'URL (http/https) or ArXiv:' if have_arxiv else 'URL (http/https)' url_text = gr.Textbox(label=url_label, interactive=True) with gr.Column(): url_user_btn = gr.Button(value='Add URL content to Shared UserData DB', visible=allow_upload_to_user_data) url_my_btn = gr.Button(value='Add URL content to Scratch MyData DB', visible=allow_upload_to_my_data) text_row = gr.Row( visible=kwargs['langchain_mode'] != 'Disabled' and allow_upload and enable_text_upload).style( equal_height=False) with text_row: user_text_text = gr.Textbox(label='Paste Text', interactive=True) with gr.Column(): user_text_user_btn = gr.Button(value='Add Text to Shared UserData DB', visible=allow_upload_to_user_data) user_text_my_btn = gr.Button(value='Add Text to Scratch MyData DB', visible=allow_upload_to_my_data) # WIP: with gr.Row(visible=False).style(equal_height=False): github_textbox = gr.Textbox(label="Github URL") with gr.Row(visible=True): github_shared_btn = gr.Button(value="Add Github to Shared UserData DB", visible=allow_upload_to_user_data) github_my_btn = gr.Button(value="Add Github to Scratch MyData DB", visible=allow_upload_to_my_data) sources_row = gr.Row(visible=kwargs['langchain_mode'] != 'Disabled' and enable_sources_list).style( equal_height=False) with sources_row: sources_text = gr.HTML(label='Sources Added', interactive=False) sources_row2 = gr.Row(visible=kwargs['langchain_mode'] != 'Disabled' and enable_sources_list).style( equal_height=False) with sources_row2: get_sources_btn = gr.Button(value="Get Sources List for Selected DB") file_source = gr.File(interactive=False, label="Download File with list of Sources") with gr.TabItem("Expert"): with gr.Row(): with gr.Column(): stream_output = gr.components.Checkbox(label="Stream output", value=kwargs['stream_output']) prompt_type = gr.Dropdown(prompt_types_strings, value=kwargs['prompt_type'], label="Prompt Type", visible=not is_public) prompt_type2 = gr.Dropdown(prompt_types_strings, value=kwargs['prompt_type'], label="Prompt Type Model 2", visible=not is_public and False) do_sample = gr.Checkbox(label="Sample", info="Enable sampler, required for use of temperature, top_p, top_k", value=kwargs['do_sample']) temperature = gr.Slider(minimum=0.01, maximum=3, value=kwargs['temperature'], label="Temperature", info="Lower is deterministic (but may lead to repeats), Higher more creative (but may lead to hallucinations)") top_p = gr.Slider(minimum=0, maximum=1, value=kwargs['top_p'], label="Top p", info="Cumulative probability of tokens to sample from") top_k = gr.Slider( minimum=0, maximum=100, step=1, value=kwargs['top_k'], label="Top k", info='Num. tokens to sample from' ) # FIXME: https://github.com/h2oai/h2ogpt/issues/106 if os.getenv('TESTINGFAIL'): max_beams = 8 if not (is_low_mem or is_public) else 1 else: max_beams = 1 num_beams = gr.Slider(minimum=1, maximum=max_beams, step=1, value=min(max_beams, kwargs['num_beams']), label="Beams", info="Number of searches for optimal overall probability. " "Uses more GPU memory/compute") max_max_new_tokens = 2048 if not is_low_mem else kwargs['max_new_tokens'] max_new_tokens = gr.Slider( minimum=1, maximum=max_max_new_tokens, step=1, value=min(max_max_new_tokens, kwargs['max_new_tokens']), label="Max output length", ) min_new_tokens = gr.Slider( minimum=0, maximum=max_max_new_tokens, step=1, value=min(max_max_new_tokens, kwargs['min_new_tokens']), label="Min output length", ) early_stopping = gr.Checkbox(label="EarlyStopping", info="Stop early in beam search", value=kwargs['early_stopping']) max_max_time = 60 * 5 if not is_public else 60 * 2 if is_hf: max_max_time = min(max_max_time, 60 * 1) max_time = gr.Slider(minimum=0, maximum=max_max_time, step=1, value=min(max_max_time, kwargs['max_time']), label="Max. time", info="Max. time to search optimal output.") repetition_penalty = gr.Slider(minimum=0.01, maximum=3.0, value=kwargs['repetition_penalty'], label="Repetition Penalty") num_return_sequences = gr.Slider(minimum=1, maximum=10, step=1, value=kwargs['num_return_sequences'], label="Number Returns", info="Must be <= num_beams", visible=not is_public) iinput = gr.Textbox(lines=4, label="Input", placeholder=kwargs['placeholder_input'], visible=not is_public) context = gr.Textbox(lines=3, label="System Pre-Context", info="Directly pre-appended without prompt processing", visible=not is_public) chat = gr.components.Checkbox(label="Chat mode", value=kwargs['chat'], visible=not is_public) with gr.TabItem("Models"): load_msg = "Load-Unload Model/LORA" if not is_public \ else "LOAD-UNLOAD DISABLED FOR HOSTED DEMO" load_msg2 = "Load-Unload Model/LORA 2" if not is_public \ else "LOAD-UNLOAD DISABLED FOR HOSTED DEMO 2" compare_checkbox = gr.components.Checkbox(label="Compare Mode", value=False, visible=not is_public) with gr.Row(): n_gpus_list = [str(x) for x in list(range(-1, n_gpus))] with gr.Column(): with gr.Row(): with gr.Column(scale=50): model_choice = gr.Dropdown(model_options_state.value[0], label="Choose Model", value=kwargs['base_model']) lora_choice = gr.Dropdown(lora_options_state.value[0], label="Choose LORA", value=kwargs['lora_weights'], visible=kwargs['show_lora']) with gr.Column(scale=1): load_model_button = gr.Button(load_msg) model_load8bit_checkbox = gr.components.Checkbox( label="Load 8-bit [requires support]", value=kwargs['load_8bit']) model_infer_devices_checkbox = gr.components.Checkbox( label="Choose Devices [If not Checked, use all GPUs]", value=kwargs['infer_devices']) model_gpu = gr.Dropdown(n_gpus_list, label="GPU ID 2 [-1 = all GPUs, if Choose is enabled]", value=kwargs['gpu_id']) model_used = gr.Textbox(label="Current Model", value=kwargs['base_model'], interactive=False) lora_used = gr.Textbox(label="Current LORA", value=kwargs['lora_weights'], visible=kwargs['show_lora'], interactive=False) with gr.Row(): with gr.Column(scale=50): new_model = gr.Textbox(label="New Model HF name/path") new_lora = gr.Textbox(label="New LORA HF name/path", visible=kwargs['show_lora']) with gr.Column(scale=1): add_model_button = gr.Button("Add new model name") add_lora_button = gr.Button("Add new LORA name", visible=kwargs['show_lora']) col_model2 = gr.Column(visible=False) with col_model2: with gr.Row(): with gr.Column(scale=50): model_choice2 = gr.Dropdown(model_options_state.value[0], label="Choose Model 2", value=no_model_str) lora_choice2 = gr.Dropdown(lora_options_state.value[0], label="Choose LORA 2", value=no_lora_str, visible=kwargs['show_lora']) with gr.Column(scale=1): load_model_button2 = gr.Button(load_msg2) model_load8bit_checkbox2 = gr.components.Checkbox( label="Load 8-bit 2 [requires support]", value=kwargs['load_8bit']) model_infer_devices_checkbox2 = gr.components.Checkbox( label="Choose Devices 2 [If not Checked, use all GPUs]", value=kwargs[ 'infer_devices']) model_gpu2 = gr.Dropdown(n_gpus_list, label="GPU ID [-1 = all GPUs, if choose is enabled]", value=kwargs['gpu_id']) # no model/lora loaded ever in model2 by default model_used2 = gr.Textbox(label="Current Model 2", value=no_model_str) lora_used2 = gr.Textbox(label="Current LORA 2", value=no_lora_str, visible=kwargs['show_lora']) with gr.TabItem("System"): admin_row = gr.Row() with admin_row: admin_pass_textbox = gr.Textbox(label="Admin Password", type='password', visible=is_public) admin_btn = gr.Button(value="Admin Access", visible=is_public) system_row = gr.Row(visible=not is_public) with system_row: with gr.Column(): with gr.Row(): system_btn = gr.Button(value='Get System Info') system_text = gr.Textbox(label='System Info', interactive=False).style( show_copy_button=True) with gr.Row(): zip_btn = gr.Button("Zip") zip_text = gr.Textbox(label="Zip file name", interactive=False) file_output = gr.File(interactive=False) with gr.Row(): s3up_btn = gr.Button("S3UP") s3up_text = gr.Textbox(label='S3UP result', interactive=False) with gr.TabItem("Disclaimers"): description = "" description += """
DISCLAIMERS:
'):
prompt = prompt[:-4]
prompt = prompt.replace('
', chat_sep)
if not prompt.endswith(chat_sep):
prompt += chat_sep
# most recent first, add older if can
# only include desired chat history
if len(prompt + context1) > max_prompt_length:
break
context1 = prompt + context1
_, pre_response, terminate_response, chat_sep = generate_prompt({}, prompt_type1, chat1,
reduced=True)
if context1 and not context1.endswith(chat_sep):
context1 += chat_sep # ensure if terminates abruptly, then human continues on next line
args_list[0] = instruction1 # override original instruction with history from user
args_list[2] = context1
if model_state1[0] is None or model_state1[0] == no_model_str:
history = [['', None]]
yield history, ''
return
fun1 = partial(evaluate,
model_state1,
my_db_state1,
**kwargs_evaluate)
try:
for output in fun1(*tuple(args_list)):
bot_message = output
history[-1][1] = bot_message
yield history, ''
except StopIteration:
yield history, ''
except RuntimeError as e:
if "generator raised StopIteration" in str(e):
# assume last entry was bad, undo
history.pop()
yield history, ''
else:
if history and len(history) > 0 and len(history[0]) > 1 and history[-1][1] is None:
history[-1][1] = ''
yield history, str(e)
raise
except Exception as e:
# put error into user input
ex = "Exception: %s" % str(e)
if history and len(history) > 0 and len(history[0]) > 1 and history[-1][1] is None:
history[-1][1] = ''
yield history, ex
raise
return
# NORMAL MODEL
user_args = dict(fn=functools.partial(user, sanitize_user_prompt=kwargs['sanitize_user_prompt']),
inputs=inputs_list + [text_output],
outputs=text_output,
)
bot_args = dict(fn=bot,
inputs=inputs_list + [model_state, my_db_state] + [text_output],
outputs=[text_output, exception_text],
)
retry_bot_args = dict(fn=functools.partial(bot, retry=True),
inputs=inputs_list + [model_state, my_db_state] + [text_output],
outputs=[text_output, exception_text],
)
undo_user_args = dict(fn=functools.partial(user, undo=True),
inputs=inputs_list + [text_output],
outputs=text_output,
)
# MODEL2
user_args2 = dict(fn=functools.partial(user, sanitize_user_prompt=kwargs['sanitize_user_prompt'], model2=True),
inputs=inputs_list + [text_output2],
outputs=text_output2,
)
bot_args2 = dict(fn=bot,
inputs=inputs_list + [model_state2, my_db_state] + [text_output2],
outputs=[text_output2, exception_text],
)
retry_bot_args2 = dict(fn=functools.partial(bot, retry=True),
inputs=inputs_list + [model_state2, my_db_state] + [text_output2],
outputs=[text_output2, exception_text],
)
undo_user_args2 = dict(fn=functools.partial(user, undo=True),
inputs=inputs_list + [text_output2],
outputs=text_output2,
)
def clear_instruct():
return gr.Textbox.update(value='')
if kwargs['auto_score']:
score_args_submit = score_args
score_args2_submit = score_args2
else:
score_args_submit = dict(fn=lambda: None, inputs=None, outputs=None)
score_args2_submit = dict(fn=lambda: None, inputs=None, outputs=None)
# in case 2nd model, consume instruction first, so can clear quickly
# bot doesn't consume instruction itself, just history from user, so why works
submit_event1a = instruction.submit(**user_args, queue=queue,
api_name='instruction' if allow_api else None)
submit_event1b = submit_event1a.then(**user_args2, api_name='instruction2' if allow_api else None)
submit_event1c = submit_event1b.then(clear_instruct, None, instruction) \
.then(clear_instruct, None, iinput)
submit_event1d = submit_event1c.then(**bot_args, api_name='instruction_bot' if allow_api else None,
queue=queue)
submit_event1e = submit_event1d.then(**score_args_submit,
api_name='instruction_bot_score' if allow_api else None,
queue=queue)
submit_event1f = submit_event1e.then(**bot_args2, api_name='instruction_bot2' if allow_api else None,
queue=queue)
submit_event1g = submit_event1f.then(**score_args2_submit,
api_name='instruction_bot_score2' if allow_api else None, queue=queue)
submit_event1h = submit_event1g.then(clear_torch_cache)
submit_event2a = submit.click(**user_args, api_name='submit' if allow_api else None)
submit_event2b = submit_event2a.then(**user_args2, api_name='submit2' if allow_api else None)
submit_event2c = submit_event2b.then(clear_instruct, None, instruction) \
.then(clear_instruct, None, iinput)
submit_event2d = submit_event2c.then(**bot_args, api_name='submit_bot' if allow_api else None, queue=queue)
submit_event2e = submit_event2d.then(**score_args_submit, api_name='submit_bot_score' if allow_api else None,
queue=queue)
submit_event2f = submit_event2e.then(**bot_args2, api_name='submit_bot2' if allow_api else None, queue=queue)
submit_event2g = submit_event2f.then(**score_args2_submit, api_name='submit_bot_score2' if allow_api else None,
queue=queue)
submit_event2h = submit_event2g.then(clear_torch_cache)
submit_event3a = retry.click(**user_args, api_name='retry' if allow_api else None)
submit_event3b = submit_event3a.then(**user_args2, api_name='retry2' if allow_api else None)
submit_event3c = submit_event3b.then(clear_instruct, None, instruction) \
.then(clear_instruct, None, iinput)
submit_event3d = submit_event3c.then(**retry_bot_args, api_name='retry_bot' if allow_api else None,
queue=queue)
submit_event3e = submit_event3d.then(**score_args_submit, api_name='retry_bot_score' if allow_api else None,
queue=queue)
submit_event3f = submit_event3e.then(**retry_bot_args2, api_name='retry_bot2' if allow_api else None,
queue=queue)
submit_event3g = submit_event3f.then(**score_args2_submit, api_name='retry_bot_score2' if allow_api else None,
queue=queue)
submit_event3h = submit_event3g.then(clear_torch_cache)
submit_event4 = undo.click(**undo_user_args, api_name='undo' if allow_api else None) \
.then(**undo_user_args2, api_name='undo2' if allow_api else None) \
.then(clear_instruct, None, instruction) \
.then(clear_instruct, None, iinput) \
.then(**score_args_submit, api_name='undo_score' if allow_api else None) \
.then(**score_args2_submit, api_name='undo_score2' if allow_api else None)
# MANAGE CHATS
def dedup(short_chat, short_chats):
if short_chat not in short_chats:
return short_chat
for i in range(1, 1000):
short_chat_try = short_chat + "_" + str(i)
if short_chat_try not in short_chats:
return short_chat_try
# fallback and hope for best
short_chat = short_chat + "_" + str(random.random())
return short_chat
def get_short_chat(x, short_chats, short_len=20, words=4):
if x and len(x[0]) == 2 and x[0][0] is not None:
short_chat = ' '.join(x[0][0][:short_len].split(' ')[:words]).strip()
short_chat = dedup(short_chat, short_chats)
else:
short_chat = None
return short_chat
def is_chat_same(x, y):
#
etc. added in chat, try to remove some of that to help avoid dup entries when hit new conversation is_same = True # length of conversation has to be same if len(x) != len(y): return False for stepx, stepy in zip(x, y): if len(stepx) != len(stepy): # something off with a conversation return False if len(stepx) != 2: # something off return False if len(stepy) != 2: # something off return False questionx = stepx[0].replace('
', '').replace('
', '') answerx = stepx[1].replace('', '').replace('
', '') questiony = stepy[0].replace('', '').replace('
', '') answery = stepy[1].replace('', '').replace('
', '') if questionx != questiony or answerx != answery: return False return is_same def save_chat(chat1, chat2, chat_state1): short_chats = list(chat_state1.keys()) for chati in [chat1, chat2]: if chati and len(chati) > 0 and len(chati[0]) == 2 and chati[0][1] is not None: short_chat = get_short_chat(chati, short_chats) if short_chat: already_exists = any([is_chat_same(chati, x) for x in chat_state1.values()]) if not already_exists: chat_state1[short_chat] = chati return chat_state1 def update_radio_chats(chat_state1): return gr.update(choices=list(chat_state1.keys()), value=None) def deselect_radio_chats(): return gr.update(value=None) def switch_chat(chat_key, chat_state1): chosen_chat = chat_state1[chat_key] return chosen_chat, chosen_chat radio_chats.input(switch_chat, inputs=[radio_chats, chat_state], outputs=[text_output, text_output2]) def remove_chat(chat_key, chat_state1): chat_state1.pop(chat_key, None) return chat_state1 remove_chat_btn.click(remove_chat, inputs=[radio_chats, chat_state], outputs=chat_state) \ .then(update_radio_chats, inputs=chat_state, outputs=radio_chats) def get_chats1(chat_state1): base = 'chats' makedirs(base, exist_ok=True) filename = os.path.join(base, 'chats_%s.json' % str(uuid.uuid4())) with open(filename, "wt") as f: f.write(json.dumps(chat_state1, indent=2)) return filename export_chats_btn.click(get_chats1, inputs=chat_state, outputs=chats_file, queue=False, api_name='export_chats' if allow_api else None) def add_chats_from_file(file, chat_state1, add_btn): if isinstance(file, str): files = [file] else: files = file for file1 in files: try: if hasattr(file1, 'name'): file1 = file1.name with open(file1, "rt") as f: new_chats = json.loads(f.read()) for chat1_k, chat1_v in new_chats.items(): # ignore chat1_k, regenerate and de-dup to avoid loss chat_state1 = save_chat(chat1_v, None, chat_state1) except BaseException as e: print("Add chats exception: %s" % str(e), flush=True) return chat_state1, add_btn # note for update_user_db_func output is ignored for db add_to_chats_btn.click(add_chats_from_file, inputs=[chatsup_output, chat_state, add_to_chats_btn], outputs=[chat_state, add_to_my_db_btn], queue=False, api_name='add_to_chats' if allow_api else None) \ .then(clear_file_list, outputs=chatsup_output, queue=False) \ .then(update_radio_chats, inputs=chat_state, outputs=radio_chats, queue=False) clear_chat_btn.click(lambda: None, None, text_output, queue=False, api_name='clear' if allow_api else None) \ .then(lambda: None, None, text_output2, queue=False, api_name='clear2' if allow_api else None) \ .then(deselect_radio_chats, inputs=None, outputs=radio_chats, queue=False) # does both models clear.click(save_chat, inputs=[text_output, text_output2, chat_state], outputs=chat_state, api_name='save_chat' if allow_api else None) \ .then(update_radio_chats, inputs=chat_state, outputs=radio_chats, api_name='update_chats' if allow_api else None) \ .then(lambda: None, None, text_output, queue=False, api_name='clearB' if allow_api else None) \ .then(lambda: None, None, text_output2, queue=False, api_name='clearB2' if allow_api else None) # NOTE: clear of instruction/iinput for nochat has to come after score, # because score for nochat consumes actual textbox, while chat consumes chat history filled by user() submit_event_nochat = submit_nochat.click(fun, inputs=[model_state, my_db_state] + inputs_list, outputs=text_output_nochat, queue=queue, api_name='submit_nochat' if allow_api else None) \ .then(**score_args_nochat, api_name='instruction_bot_score_nochat' if allow_api else None, queue=queue) \ .then(clear_instruct, None, instruction_nochat) \ .then(clear_instruct, None, iinput_nochat) \ .then(clear_torch_cache) def load_model(model_name, lora_weights, model_state_old, prompt_type_old, load_8bit, infer_devices, gpu_id): # ensure old model removed from GPU memory if kwargs['debug']: print("Pre-switch pre-del GPU memory: %s" % get_torch_allocated(), flush=True) model0 = model_state0[0] if isinstance(model_state_old[0], str) and model0 is not None: # best can do, move model loaded at first to CPU model0.cpu() if model_state_old[0] is not None and not isinstance(model_state_old[0], str): try: model_state_old[0].cpu() except Exception as e: # sometimes hit NotImplementedError: Cannot copy out of meta tensor; no data! print("Unable to put model on CPU: %s" % str(e), flush=True) del model_state_old[0] model_state_old[0] = None if model_state_old[1] is not None and not isinstance(model_state_old[1], str): del model_state_old[1] model_state_old[1] = None clear_torch_cache() if kwargs['debug']: print("Pre-switch post-del GPU memory: %s" % get_torch_allocated(), flush=True) if model_name is None or model_name == no_model_str: # no-op if no model, just free memory # no detranscribe needed for model, never go into evaluate lora_weights = no_lora_str return [None, None, None, model_name], model_name, lora_weights, prompt_type_old # don't deepcopy, can contain model itself all_kwargs1 = all_kwargs.copy() all_kwargs1['base_model'] = model_name.strip() all_kwargs1['load_8bit'] = load_8bit all_kwargs1['infer_devices'] = infer_devices all_kwargs1['gpu_id'] = int(gpu_id) # detranscribe model_lower = model_name.strip().lower() if model_lower in inv_prompt_type_to_model_lower: prompt_type1 = inv_prompt_type_to_model_lower[model_lower] else: prompt_type1 = prompt_type_old # detranscribe if lora_weights == no_lora_str: lora_weights = '' all_kwargs1['lora_weights'] = lora_weights.strip() model1, tokenizer1, device1 = get_model(**all_kwargs1) clear_torch_cache() if kwargs['debug']: print("Post-switch GPU memory: %s" % get_torch_allocated(), flush=True) return [model1, tokenizer1, device1, model_name], model_name, lora_weights, prompt_type1 def dropdown_prompt_type_list(x): return gr.Dropdown.update(value=x) def chatbot_list(x, model_used_in): return gr.Textbox.update(label=f'h2oGPT [Model: {model_used_in}]') load_model_args = dict(fn=load_model, inputs=[model_choice, lora_choice, model_state, prompt_type, model_load8bit_checkbox, model_infer_devices_checkbox, model_gpu], outputs=[model_state, model_used, lora_used, prompt_type]) prompt_update_args = dict(fn=dropdown_prompt_type_list, inputs=prompt_type, outputs=prompt_type) chatbot_update_args = dict(fn=chatbot_list, inputs=[text_output, model_used], outputs=text_output) nochat_update_args = dict(fn=chatbot_list, inputs=[text_output_nochat, model_used], outputs=text_output_nochat) if not is_public: load_model_event = load_model_button.click(**load_model_args) \ .then(**prompt_update_args) \ .then(**chatbot_update_args) \ .then(**nochat_update_args) \ .then(clear_torch_cache) load_model_args2 = dict(fn=load_model, inputs=[model_choice2, lora_choice2, model_state2, prompt_type2, model_load8bit_checkbox2, model_infer_devices_checkbox2, model_gpu2], outputs=[model_state2, model_used2, lora_used2, prompt_type2]) prompt_update_args2 = dict(fn=dropdown_prompt_type_list, inputs=prompt_type2, outputs=prompt_type2) chatbot_update_args2 = dict(fn=chatbot_list, inputs=[text_output2, model_used2], outputs=text_output2) if not is_public: load_model_event2 = load_model_button2.click(**load_model_args2) \ .then(**prompt_update_args2) \ .then(**chatbot_update_args2) \ .then(clear_torch_cache) def dropdown_model_list(list0, x): new_state = [list0[0] + [x]] new_options = [*new_state[0]] return gr.Dropdown.update(value=x, choices=new_options), \ gr.Dropdown.update(value=x, choices=new_options), \ '', new_state add_model_event = add_model_button.click(fn=dropdown_model_list, inputs=[model_options_state, new_model], outputs=[model_choice, model_choice2, new_model, model_options_state], queue=False) def dropdown_lora_list(list0, x, model_used1, lora_used1, model_used2, lora_used2): new_state = [list0[0] + [x]] new_options = [*new_state[0]] # don't switch drop-down to added lora if already have model loaded x1 = x if model_used1 == no_model_str else lora_used1 x2 = x if model_used2 == no_model_str else lora_used2 return gr.Dropdown.update(value=x1, choices=new_options), \ gr.Dropdown.update(value=x2, choices=new_options), \ '', new_state add_lora_event = add_lora_button.click(fn=dropdown_lora_list, inputs=[lora_options_state, new_lora, model_used, lora_used, model_used2, lora_used2], outputs=[lora_choice, lora_choice2, new_lora, lora_options_state], queue=False) go_btn.click(lambda: gr.update(visible=False), None, go_btn, api_name="go" if allow_api else None, queue=False) \ .then(lambda: gr.update(visible=True), None, normal_block, queue=False) \ .then(**load_model_args, queue=False).then(**prompt_update_args, queue=False) def compare_textbox_fun(x): return gr.Textbox.update(visible=x) def compare_column_fun(x): return gr.Column.update(visible=x) def compare_prompt_fun(x): return gr.Dropdown.update(visible=x) compare_checkbox.select(compare_textbox_fun, compare_checkbox, text_output2, api_name="compare_checkbox" if allow_api else None) \ .then(compare_column_fun, compare_checkbox, col_model2) \ .then(compare_prompt_fun, compare_checkbox, prompt_type2) \ .then(compare_textbox_fun, compare_checkbox, score_text2) # FIXME: add score_res2 in condition, but do better # callback for logging flagged input/output callback.setup(inputs_list + [text_output, text_output2], "flagged_data_points") flag_btn.click(lambda *args: callback.flag(args), inputs_list + [text_output, text_output2], None, preprocess=False, api_name='flag' if allow_api else None, queue=False) flag_btn_nochat.click(lambda *args: callback.flag(args), inputs_list + [text_output_nochat], None, preprocess=False, api_name='flag_nochat' if allow_api else None, queue=False) def get_system_info(): return gr.Textbox.update(value=system_info_print()) system_event = system_btn.click(get_system_info, outputs=system_text, api_name='system_info' if allow_api else None, queue=False) # don't pass text_output, don't want to clear output, just stop it # cancel only stops outer generation, not inner generation or non-generation stop_btn.click(lambda: None, None, None, cancels=[submit_event1d, submit_event1f, submit_event2d, submit_event2f, submit_event3d, submit_event3f, submit_event_nochat], queue=False, api_name='stop' if allow_api else None).then(clear_torch_cache, queue=False) demo.load(None, None, None, _js=get_dark_js() if kwargs['h2ocolors'] else None) demo.queue(concurrency_count=kwargs['concurrency_count'], api_open=kwargs['api_open']) favicon_path = "h2o-logo.svg" scheduler = BackgroundScheduler() scheduler.add_job(func=clear_torch_cache, trigger="interval", seconds=20) if is_public and \ kwargs['base_model'] not in ['gptj', 'llama']: # FIXME: disable for gptj, langchain or gpt4all modify print itself # FIXME: and any multi-threaded/async print will enter model output! scheduler.add_job(func=ping, trigger="interval", seconds=60) scheduler.start() # import control if kwargs['langchain_mode'] == 'Disabled' and \ os.environ.get("TEST_LANGCHAIN_IMPORT") and \ kwargs['base_model'] not in ['gptj', 'llama']: assert 'gpt_langchain' not in sys.modules, "Dev bug, import of langchain when should not have" assert 'langchain' not in sys.modules, "Dev bug, import of langchain when should not have" demo.launch(share=kwargs['share'], server_name="0.0.0.0", show_error=True, favicon_path=favicon_path, prevent_thread_lock=True, auth=kwargs['auth']) print("Started GUI", flush=True) if kwargs['block_gradio_exit']: demo.block_thread() input_args_list = ['model_state', 'my_db_state'] def get_inputs_list(inputs_dict, model_lower): """ map gradio objects in locals() to inputs for evaluate(). :param inputs_dict: :param model_lower: :return: """ inputs_list_names = list(inspect.signature(evaluate).parameters) inputs_list = [] for k in inputs_list_names: if k == 'kwargs': continue if k in input_args_list + inputs_kwargs_list: # these are added at use time for args or partial for kwargs, not taken as input continue if 'mbart-' not in model_lower and k in ['src_lang', 'tgt_lang']: continue inputs_list.append(inputs_dict[k]) return inputs_list def get_sources(db1, langchain_mode, dbs=None): if langchain_mode in ['ChatLLM', 'LLM']: source_files_added = "NA" elif langchain_mode in ['wiki_full']: source_files_added = "Not showing wiki_full, takes about 20 seconds and makes 4MB file." \ " Ask jon.mckinney@h2o.ai for file if required." elif langchain_mode == 'MyData' and len(db1) > 0 and db1[0] is not None: db_get = db1[0].get() source_files_added = '\n'.join(sorted(set([x['source'] for x in db_get['metadatas']]))) elif langchain_mode in dbs and dbs[langchain_mode] is not None: db1 = dbs[langchain_mode] db_get = db1.get() source_files_added = '\n'.join(sorted(set([x['source'] for x in db_get['metadatas']]))) else: source_files_added = "None" sources_file = 'sources_%s_%s' % (langchain_mode, str(uuid.uuid4())) with open(sources_file, "wt") as f: f.write(source_files_added) return sources_file def update_user_db(file, db1, x, y, *args, dbs=None, langchain_mode='UserData', **kwargs): try: return _update_user_db(file, db1, x, y, *args, dbs=dbs, langchain_mode=langchain_mode, **kwargs) except BaseException as e: print(traceback.format_exc(), flush=True) # gradio has issues if except, so fail semi-gracefully, else would hang forever in processing textbox ex_str = "Exception: %s" % str(e) source_files_added = """\
Sources:
Sources:
Sources:
Exceptions: