update demo

app.py

@@ -0,0 +1,115 @@
+import streamlit as st
+from hub_name import LORA_HUB_NAMES
+from random import shuffle
+import pandas as pd
+import streamlit as st
+import contextlib
+from functools import wraps
+from io import StringIO
+import contextlib
+import redirect as rd
+import torch
+import shutil
+import os
+
+
+css = """
+<style>
+.stDataFrame { width: 100% !important; }
+</style>
+"""
+st.markdown(css, unsafe_allow_html=True)
+
+
+def main():
+    st.title("LoraHub")
+    st.markdown("Low-rank adaptations (LoRA) are techniques for fine-tuning large language models on new tasks. We propose LoraHub, a framework that allows composing multiple LoRA modules trained on different tasks. The goal is to achieve good performance on unseen tasks using just a few examples, without needing extra parameters or training. And we want to build a marketplace where users can share their trained LoRA modules, thereby facilitating the application of these modules to new tasks.")
+
+    st.markdown("In this demo, you will use avaiable lora modules selected in the left sidebar to tackle your few-shot examples. When the LoraHub learning is done, you can download the final LoRA module and use it for your new task. You can check out more details in our [paper](https://huggingface.co/papers/2307.13269).")
+        
+    with st.sidebar:
+        st.title("LoRA Module Pool")
+        st.markdown(
+            "The following modules are available for you to compose for your new task. Every module name is a peft repository in Huggingface Hub, and you can find them [here](https://huggingface.co/models?search=lorahub).")
+        
+        df = pd.DataFrame({
+            "Index": list(range(len(LORA_HUB_NAMES))),
+            "Module Name": LORA_HUB_NAMES,
+        })
+        st.data_editor(df,
+                       disabled=["LoRA Module", "Index"],
+                       hide_index=True)
+
+        st.multiselect(
+            'Select your favorite modules as the candidate for LoRA composition',
+            list(range(len(LORA_HUB_NAMES))),
+            [],
+            key="select_names")
+
+        def set_lucky_modules():
+            names = list(range(len(LORA_HUB_NAMES)))
+            shuffle(names)
+            names = names[:20]
+            st.session_state["select_names"] = names
+
+        st.button(":game_die: Give 20 Lucky Modules",
+                  on_click=set_lucky_modules)
+        st.write('We will use the following modules', [
+                 LORA_HUB_NAMES[i] for i in st.session_state["select_names"]])
+
+    st.subheader("Prepare your few-shot examples")
+
+    txt_input = st.text_area('Examples Inputs (One Line One Input)',
+                             '''
+Infer the date from context.  Q: Today, 8/3/1997, is a day that we will never forget. What is the date one week ago from today in MM/DD/YYYY? Options: (A) 03/27/1998 (B) 09/02/1997 (C) 07/27/1997 (D) 06/29/1997 (E) 07/27/1973 (F) 12/27/1997 A:
+Infer the date from context.  Q: May 6, 1992 is like yesterday to Jane, but that is actually ten years ago. What is the date tomorrow in MM/DD/YYYY? Options: (A) 04/16/2002 (B) 04/07/2003 (C) 05/07/2036 (D) 05/28/2002 (E) 05/07/2002 A:
+Infer the date from context.  Q: Today is the second day of the third month of 1966. What is the date one week ago from today in MM/DD/YYYY? Options: (A) 02/26/1966 (B) 01/13/1966 (C) 02/02/1966 (D) 10/23/1966 (E) 02/23/1968 (F) 02/23/1966 A:
+'''.strip())
+
+    txt_output = st.text_area('Examples Outputs (One Line One Output)', '''
+(C)
+(E)
+(F)
+'''.strip())
+
+    max_step = st.slider('Maximum iteration step', 10, 1000, step=10)
+
+    # st.subheader("Watch the logs below")
+    buffer = st.expander("Learning Logs")
+
+    if st.button(':rocket: Start!'):
+        if len(st.session_state["select_names"]) == 0:
+            st.error("Please select at least 1 module!")
+        elif max_step < len(st.session_state["select_names"]):
+            st.error(
+                "Please specify a larger maximum iteration step than the number of selected modules!")
+        else:
+            buffer.text("* begin to perform lorahub learning *")
+            from util import lorahub_learning
+            with rd.stderr(to=buffer):
+                recommendation, final_lora = lorahub_learning([LORA_HUB_NAMES[i] for i in st.session_state["select_names"]],
+                                                  txt_input, txt_output, max_inference_step=max_step)
+                
+            st.success("Lorahub learning finished! You got the following recommendation:")
+            df = {
+                "modules": [LORA_HUB_NAMES[i] for i in st.session_state["select_names"]],
+                "weights": recommendation.value,
+            }
+            st.table(df)
+            
+            # zip the final lora module
+            torch.save(final_lora, "lora/adapter_model.bin")
+            # create a zip file
+            shutil.make_archive("lora_module", 'zip', "lora")
+            with open("lora_module.zip", "rb") as fp:
+                btn = st.download_button(
+                    label="Download ZIP",
+                    data=fp,
+                    file_name="lora_module.zip",
+                    mime="application/zip"
+                )
+
+
+
+if __name__ == "__main__":
+    main()

hub_name.py

@@ -0,0 +1,198 @@
+LORA_HUB_NAMES = [
+    "lorahub/flan_t5_large-qasc_qa_with_separated_facts_3",
+    "lorahub/flan_t5_large-ag_news_subset",
+    "lorahub/flan_t5_large-web_questions_whats_the_answer",
+    "lorahub/flan_t5_large-wiki_hop_original_choose_best_object_affirmative_1",
+    "lorahub/flan_t5_large-quoref_What_Is_The_Answer",
+    "lorahub/flan_t5_large-qasc_is_correct_1",
+    "lorahub/flan_t5_large-ropes_given_background_situation",
+    "lorahub/flan_t5_large-duorc_SelfRC_title_generation",
+    "lorahub/flan_t5_large-wiki_hop_original_choose_best_object_affirmative_3",
+    "lorahub/flan_t5_large-wiki_hop_original_generate_subject",
+    "lorahub/flan_t5_large-coqa",
+    "lorahub/flan_t5_large-adversarial_qa_droberta_question_context_answer",
+    "lorahub/flan_t5_large-amazon_polarity_flattering_or_not",
+    "lorahub/flan_t5_large-quarel_choose_between",
+    "lorahub/flan_t5_large-adversarial_qa_dbidaf_based_on",
+    "lorahub/flan_t5_large-adversarial_qa_dbert_answer_the_following_q",
+    "lorahub/flan_t5_large-dbpedia_14_given_a_list_of_category_what_does_the_title_belong_to",
+    "lorahub/flan_t5_large-wiki_hop_original_choose_best_object_interrogative_1",
+    "lorahub/flan_t5_large-trec",
+    "lorahub/flan_t5_large-race_high_Write_a_multi_choice_question_options_given_",
+    "lorahub/flan_t5_large-social_i_qa_Show_choices_and_generate_answer",
+    "lorahub/flan_t5_large-app_reviews_categorize_rating_using_review",
+    "lorahub/flan_t5_large-wiki_hop_original_generate_subject_and_object",
+    "lorahub/flan_t5_large-true_case",
+    "lorahub/flan_t5_large-wiki_qa_Topic_Prediction_Answer_Only",
+    "lorahub/flan_t5_large-quartz_given_the_fact_answer_the_q",
+    "lorahub/flan_t5_large-quail_context_question_description_answer_text",
+    "lorahub/flan_t5_large-dbpedia_14_given_a_choice_of_categories_",
+    "lorahub/flan_t5_large-dream_baseline",
+    "lorahub/flan_t5_large-wiki_qa_Is_This_True_",
+    "lorahub/flan_t5_large-glue_wnli",
+    "lorahub/flan_t5_large-adversarial_qa_dbert_based_on",
+    "lorahub/flan_t5_large-quoref_Read_And_Extract_",
+    "lorahub/flan_t5_large-amazon_polarity_User_recommend_this_product",
+    "lorahub/flan_t5_large-wiqa_what_is_the_final_step_of_the_following_process",
+    "lorahub/flan_t5_large-ropes_plain_no_background",
+    "lorahub/flan_t5_large-wiki_hop_original_choose_best_object_affirmative_2",
+    "lorahub/flan_t5_large-race_middle_Select_the_best_answer_generate_span_",
+    "lorahub/flan_t5_large-quoref_Answer_Question_Given_Context",
+    "lorahub/flan_t5_large-wmt16_translate_tr-en",
+    "lorahub/flan_t5_large-quoref_Found_Context_Online",
+    "lorahub/flan_t5_large-wiki_qa_Decide_good_answer",
+    "lorahub/flan_t5_large-para_crawl_enes",
+    "lorahub/flan_t5_large-race_middle_Taking_a_test",
+    "lorahub/flan_t5_large-ropes_background_new_situation_answer",
+    "lorahub/flan_t5_large-fix_punct",
+    "lorahub/flan_t5_large-super_glue_rte",
+    "lorahub/flan_t5_large-ropes_background_situation_middle",
+    "lorahub/flan_t5_large-race_high_Taking_a_test",
+    "lorahub/flan_t5_large-wiki_bio_who",
+    "lorahub/flan_t5_large-quartz_paragraph_question_plain_concat",
+    "lorahub/flan_t5_large-ropes_plain_background_situation",
+    "lorahub/flan_t5_large-quoref_Given_Context_Answer_Question",
+    "lorahub/flan_t5_large-adversarial_qa_dbidaf_question_context_answer",
+    "lorahub/flan_t5_large-wmt16_translate_ro-en",
+    "lorahub/flan_t5_large-adversarial_qa_dbert_question_context_answer",
+    "lorahub/flan_t5_large-duorc_ParaphraseRC_question_answering",
+    "lorahub/flan_t5_large-race_high_Is_this_the_right_answer",
+    "lorahub/flan_t5_large-sciq_Direct_Question",
+    "lorahub/flan_t5_large-super_glue_wsc.fixed",
+    "lorahub/flan_t5_large-super_glue_wic",
+    "lorahub/flan_t5_large-quoref_Answer_Friend_Question",
+    "lorahub/flan_t5_large-imdb_reviews_plain_text",
+    "lorahub/flan_t5_large-race_middle_Select_the_best_answer",
+    "lorahub/flan_t5_large-quail_context_question_answer_description_id",
+    "lorahub/flan_t5_large-wiki_qa_found_on_google",
+    "lorahub/flan_t5_large-glue_sst2",
+    "lorahub/flan_t5_large-quail_context_description_question_answer_id",
+    "lorahub/flan_t5_large-super_glue_cb",
+    "lorahub/flan_t5_large-ropes_prompt_bottom_no_hint",
+    "lorahub/flan_t5_large-anli_r1",
+    "lorahub/flan_t5_large-ropes_read_background_situation",
+    "lorahub/flan_t5_large-qasc_qa_with_separated_facts_2",
+    "lorahub/flan_t5_large-quarel_heres_a_story",
+    "lorahub/flan_t5_large-social_i_qa_Generate_the_question_from_the_answer",
+    "lorahub/flan_t5_large-sciq_Multiple_Choice_Closed_Book_",
+    "lorahub/flan_t5_large-math_dataset_algebra__linear_1d",
+    "lorahub/flan_t5_large-yelp_polarity_reviews",
+    "lorahub/flan_t5_large-adversarial_qa_droberta_tell_what_it_is",
+    "lorahub/flan_t5_large-wiqa_what_might_be_the_last_step_of_the_process",
+    "lorahub/flan_t5_large-adversarial_qa_dbidaf_answer_the_following_q",
+    "lorahub/flan_t5_large-quoref_Guess_Answer",
+    "lorahub/flan_t5_large-amazon_polarity_convey_negative_or_positive_sentiment",
+    "lorahub/flan_t5_large-wiki_qa_Topic_Prediction_Question_Only",
+    "lorahub/flan_t5_large-ropes_new_situation_background_answer",
+    "lorahub/flan_t5_large-web_questions_potential_correct_answer",
+    "lorahub/flan_t5_large-qasc_is_correct_2",
+    "lorahub/flan_t5_large-quoref_Find_Answer",
+    "lorahub/flan_t5_large-app_reviews_convert_to_rating",
+    "lorahub/flan_t5_large-quail_description_context_question_answer_text",
+    "lorahub/flan_t5_large-qasc_qa_with_separated_facts_4",
+    "lorahub/flan_t5_large-qasc_qa_with_separated_facts_5",
+    "lorahub/flan_t5_large-quoref_Guess_Title_For_Context",
+    "lorahub/flan_t5_large-wiki_hop_original_explain_relation",
+    "lorahub/flan_t5_large-ropes_prompt_beginning",
+    "lorahub/flan_t5_large-gem_e2e_nlg",
+    "lorahub/flan_t5_large-race_high_Select_the_best_answer_no_instructions_",
+    "lorahub/flan_t5_large-quail_context_question_description_answer_id",
+    "lorahub/flan_t5_large-qasc_qa_with_combined_facts_1",
+    "lorahub/flan_t5_large-glue_cola",
+    "lorahub/flan_t5_large-quail_description_context_question_answer_id",
+    "lorahub/flan_t5_large-wiqa_which_of_the_following_is_the_supposed_perturbation",
+    "lorahub/flan_t5_large-sciq_Direct_Question_Closed_Book_",
+    "lorahub/flan_t5_large-wmt14_translate_fr-en",
+    "lorahub/flan_t5_large-quoref_Context_Contains_Answer",
+    "lorahub/flan_t5_large-kilt_tasks_hotpotqa_complex_question",
+    "lorahub/flan_t5_large-amazon_polarity_negative_or_positive_tone",
+    "lorahub/flan_t5_large-amazon_polarity_would_you_buy",
+    "lorahub/flan_t5_large-wiki_qa_exercise",
+    "lorahub/flan_t5_large-adversarial_qa_dbert_tell_what_it_is",
+    "lorahub/flan_t5_large-word_segment",
+    "lorahub/flan_t5_large-gem_dart",
+    "lorahub/flan_t5_large-duorc_ParaphraseRC_extract_answer",
+    "lorahub/flan_t5_large-duorc_ParaphraseRC_title_generation",
+    "lorahub/flan_t5_large-ropes_plain_bottom_hint",
+    "lorahub/flan_t5_large-wiki_bio_comprehension",
+    "lorahub/flan_t5_large-anli_r2",
+    "lorahub/flan_t5_large-quail_context_question_answer_description_text",
+    "lorahub/flan_t5_large-wiki_hop_original_generate_object",
+    "lorahub/flan_t5_large-squad_v1.1",
+    "lorahub/flan_t5_large-wiki_qa_Jeopardy_style",
+    "lorahub/flan_t5_large-lambada",
+    "lorahub/flan_t5_large-quartz_having_read_above_passage",
+    "lorahub/flan_t5_large-quartz_use_info_from_question_paragraph",
+    "lorahub/flan_t5_large-wiki_bio_key_content",
+    "lorahub/flan_t5_large-duorc_SelfRC_answer_question",
+    "lorahub/flan_t5_large-duorc_ParaphraseRC_answer_question",
+    "lorahub/flan_t5_large-wiki_qa_Topic_Prediction_Question_and_Answer_Pair",
+    "lorahub/flan_t5_large-anli_r3",
+    "lorahub/flan_t5_large-glue_mnli",
+    "lorahub/flan_t5_large-wiki_bio_guess_person",
+    "lorahub/flan_t5_large-race_high_Select_the_best_answer_generate_span_",
+    "lorahub/flan_t5_large-glue_stsb",
+    "lorahub/flan_t5_large-gem_web_nlg_en",
+    "lorahub/flan_t5_large-adversarial_qa_droberta_based_on",
+    "lorahub/flan_t5_large-duorc_SelfRC_question_answering",
+    "lorahub/flan_t5_large-dream_read_the_following_conversation_and_answer_the_question",
+    "lorahub/flan_t5_large-duorc_SelfRC_generate_question_by_answer",
+    "lorahub/flan_t5_large-definite_pronoun_resolution",
+    "lorahub/flan_t5_large-quartz_read_passage_below_choose",
+    "lorahub/flan_t5_large-race_middle_Is_this_the_right_answer",
+    "lorahub/flan_t5_large-wiqa_effect_with_label_answer",
+    "lorahub/flan_t5_large-wiqa_what_might_be_the_first_step_of_the_process",
+    "lorahub/flan_t5_large-sciq_Multiple_Choice",
+    "lorahub/flan_t5_large-quartz_use_info_from_paragraph_question",
+    "lorahub/flan_t5_large-quarel_do_not_use",
+    "lorahub/flan_t5_large-quac",
+    "lorahub/flan_t5_large-glue_qqp",
+    "lorahub/flan_t5_large-quail_no_prompt_text",
+    "lorahub/flan_t5_large-duorc_ParaphraseRC_decide_worth_it",
+    "lorahub/flan_t5_large-wiqa_effect_with_string_answer",
+    "lorahub/flan_t5_large-wiki_hop_original_choose_best_object_interrogative_2",
+    "lorahub/flan_t5_large-bool_q",
+    "lorahub/flan_t5_large-social_i_qa_Check_if_a_random_answer_is_valid_or_not",
+    "lorahub/flan_t5_large-ropes_prompt_bottom_hint_beginning",
+    "lorahub/flan_t5_large-newsroom",
+    "lorahub/flan_t5_large-ropes_prompt_mix",
+    "lorahub/flan_t5_large-quartz_answer_question_based_on",
+    "lorahub/flan_t5_large-qasc_qa_with_separated_facts_1",
+    "lorahub/flan_t5_large-race_high_Select_the_best_answer",
+    "lorahub/flan_t5_large-duorc_ParaphraseRC_movie_director",
+    "lorahub/flan_t5_large-amazon_polarity_user_satisfied",
+    "lorahub/flan_t5_large-sentiment140",
+    "lorahub/flan_t5_large-glue_mrpc",
+    "lorahub/flan_t5_large-super_glue_multirc",
+    "lorahub/flan_t5_large-quoref_Answer_Test",
+    "lorahub/flan_t5_large-wiqa_what_is_the_missing_first_step",
+    "lorahub/flan_t5_large-race_middle_Select_the_best_answer_no_instructions_",
+    "lorahub/flan_t5_large-snli",
+    "lorahub/flan_t5_large-dbpedia_14_pick_one_category_for_the_following_text",
+    "lorahub/flan_t5_large-amazon_polarity_Is_this_review_negative",
+    "lorahub/flan_t5_large-quarel_testing_students",
+    "lorahub/flan_t5_large-glue_qnli",
+    "lorahub/flan_t5_large-kilt_tasks_hotpotqa_final_exam",
+    "lorahub/flan_t5_large-web_questions_get_the_answer",
+    "lorahub/flan_t5_large-duorc_SelfRC_decide_worth_it",
+    "lorahub/flan_t5_large-paws_wiki",
+    "lorahub/flan_t5_large-social_i_qa_Show_choices_and_generate_index",
+    "lorahub/flan_t5_large-duorc_SelfRC_extract_answer",
+    "lorahub/flan_t5_large-drop",
+    "lorahub/flan_t5_large-adversarial_qa_droberta_answer_the_following_q",
+    "lorahub/flan_t5_large-amazon_polarity_Is_this_product_review_positive",
+    "lorahub/flan_t5_large-quail_no_prompt_id",
+    "lorahub/flan_t5_large-wiki_qa_automatic_system",
+    "lorahub/flan_t5_large-sciq_Multiple_Choice_Question_First",
+    "lorahub/flan_t5_large-squad_v2.0",
+    "lorahub/flan_t5_large-wiqa_does_the_supposed_perturbation_have_an_effect",
+    "lorahub/flan_t5_large-wiki_bio_what_content",
+    "lorahub/flan_t5_large-duorc_SelfRC_movie_director",
+    "lorahub/flan_t5_large-quarel_logic_test",
+    "lorahub/flan_t5_large-quartz_answer_question_below",
+    "lorahub/flan_t5_large-dbpedia_14_given_list_what_category_does_the_paragraph_belong_to",
+    "lorahub/flan_t5_large-amazon_polarity_Is_this_review",
+    "lorahub/flan_t5_large-race_middle_Write_a_multi_choice_question_options_given_",
+    "lorahub/flan_t5_large-adversarial_qa_dbidaf_tell_what_it_is",
+    "lorahub/flan_t5_large-quail_context_description_question_answer_text"
+]

lora/adapter_config.json

@@ -0,0 +1,20 @@
+{
+    "base_model_name_or_path": "google/flan-t5-large",
+    "bias": "none",
+    "fan_in_fan_out": false,
+    "inference_mode": true,
+    "init_lora_weights": true,
+    "layers_pattern": null,
+    "layers_to_transform": null,
+    "lora_alpha": 32,
+    "lora_dropout": 0.1,
+    "modules_to_save": null,
+    "peft_type": "LORA",
+    "r": 16,
+    "revision": null,
+    "target_modules": [
+      "q",
+      "v"
+    ],
+    "task_type": "SEQ_2_SEQ_LM"
+  }

redirect.py

@@ -0,0 +1,128 @@
+import streamlit as st
+import io
+import contextlib
+import sys
+import re
+
+
+class _Redirect:
+    class IOStuff(io.StringIO):
+        def __init__(self, trigger, max_buffer, buffer_separator, regex, dup=None):
+            super().__init__()
+            self._trigger = trigger
+            self._max_buffer = max_buffer
+            self._buffer_separator = buffer_separator
+            self._regex = regex and re.compile(regex)
+            self._dup = dup
+
+        def write(self, __s: str) -> int:
+            if self._max_buffer:
+                concatenated_len = super().tell() + len(__s)
+                if concatenated_len > self._max_buffer:
+                    rest = self.get_filtered_output()[concatenated_len - self._max_buffer:]
+                    if self._buffer_separator is not None:
+                        rest = rest.split(self._buffer_separator, 1)[-1]
+                    super().seek(0)
+                    super().write(rest)
+                    super().truncate(super().tell() + len(__s))
+            res = super().write(__s)
+            if self._dup is not None:
+                self._dup.write(__s)
+            self._trigger(self.get_filtered_output())
+            return res
+
+        def get_filtered_output(self):
+            if self._regex is None or self._buffer_separator is None:
+                return self.getvalue()
+
+            return self._buffer_separator.join(filter(self._regex.search, self.getvalue().split(self._buffer_separator)))
+
+        def print_at_end(self):
+            self._trigger(self.get_filtered_output())
+
+    def __init__(self, stdout=None, stderr=False, format=None, to=None, max_buffer=None, buffer_separator='\n',
+                 regex=None, duplicate_out=False):
+        self.io_args = {'trigger': self._write, 'max_buffer': max_buffer, 'buffer_separator': buffer_separator,
+                        'regex': regex}
+        self.redirections = []
+        self.st = None
+        self.stderr = stderr is True
+        self.stdout = stdout is True or (stdout is None and not self.stderr)
+        self.format = format or 'code'
+        self.to = to
+        self.fun = None
+        self.duplicate_out = duplicate_out or None
+        self.active_nested = None
+
+        if not self.stdout and not self.stderr:
+            raise ValueError("one of stdout or stderr must be True")
+
+        if self.format not in ['text', 'markdown', 'latex', 'code', 'write']:
+            raise ValueError(
+                f"format need oneof the following: {', '.join(['text', 'markdown', 'latex', 'code', 'write'])}")
+
+        if self.to and (not hasattr(self.to, 'text') or not hasattr(self.to, 'empty')):
+            raise ValueError(f"'to' is not a streamlit container object")
+
+    def __enter__(self):
+        if self.st is not None:
+            if self.to is None:
+                if self.active_nested is None:
+                    self.active_nested = self(format=self.format, max_buffer=self.io_args['max_buffer'],
+                                              buffer_separator=self.io_args['buffer_separator'],
+                                              regex=self.io_args['regex'], duplicate_out=self.duplicate_out)
+                return self.active_nested.__enter__()
+            else:
+                raise Exception("Already entered")
+        to = self.to or st
+
+        # to.text(f"{'stdout and stderr' if self.stdout and self.stderr else 'stdout' if self.stdout else 'stderr'}"
+        #         f"{' [' + self.io_args['regex'] + ']' if self.io_args['regex'] else ''}"
+        #         f":")
+        self.st = to.empty()
+        self.fun = getattr(self.st, self.format)
+
+        io_obj = None
+
+        def redirect(to_duplicate):
+            nonlocal io_obj
+            io_obj = _Redirect.IOStuff(dup=self.duplicate_out and to_duplicate, **self.io_args)
+            redirection = contextlib.redirect_stdout(io_obj)
+            self.redirections.append((redirection, io_obj))
+            redirection.__enter__()
+
+        if self.stderr:
+            redirect(sys.stderr)
+        if self.stdout:
+            redirect(sys.stdout)
+
+        return io_obj
+
+    def __call__(self, to=None, format=None, max_buffer=None, buffer_separator='\n', regex=None, duplicate_out=False):
+        return _Redirect(self.stdout, self.stderr, format=format, to=to, max_buffer=max_buffer,
+                         buffer_separator=buffer_separator, regex=regex, duplicate_out=duplicate_out)
+
+    def __exit__(self, *exc):
+        if self.active_nested is not None:
+            nested = self.active_nested
+            if nested.active_nested is None:
+                self.active_nested = None
+            return nested.__exit__(*exc)
+
+        res = None
+        for redirection, io_obj in reversed(self.redirections):
+            res = redirection.__exit__(*exc)
+            io_obj.print_at_end()
+
+        self.redirections = []
+        self.st = None
+        self.fun = None
+        return res
+
+    def _write(self, data):
+        self.fun(data)
+
+
+stdout = _Redirect()
+stderr = _Redirect(stderr=True)
+stdouterr = _Redirect(stdout=True, stderr=True)

requirements.txt

@@ -0,0 +1,3 @@
+peft
+transformers
+pandas

util.py

@@ -0,0 +1,170 @@
+from transformers import AutoModelForSeq2SeqLM
+import torch
+from datasets import Dataset
+from torch.utils.data import DataLoader
+from transformers import default_data_collator
+from transformers import AutoTokenizer
+from tqdm import tqdm
+import pandas as pd
+import numpy
+import random
+import nevergrad as ng
+from peft.utils.save_and_load import set_peft_model_state_dict, get_peft_model_state_dict
+from peft import PeftModel, PeftConfig
+from functools import partial
+
+random.seed(42)
+numpy.random.seed(42)
+
+def load_base_model_and_lora_modules(lora_module_list):
+    # use gpu if available
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    # load basic model
+    default_peft_model_id = lora_module_list[0]
+    # find the base model
+    model_name_or_path = PeftConfig.from_pretrained(default_peft_model_id).base_model_name_or_path
+    base_model = AutoModelForSeq2SeqLM.from_pretrained(model_name_or_path)
+    # load tokenizer
+    tokenizer = AutoTokenizer.from_pretrained(model_name_or_path)
+    # 0 is the default model
+    peft_model = PeftModel.from_pretrained(base_model, default_peft_model_id)
+    peft_model = peft_model.to(device)
+    peft_model.eval()
+
+    print("> Begin to load lora modules")
+    cache = {}
+    for peft_model_id in tqdm(lora_module_list):
+        print("> Loading {} ...".format(peft_model_id))
+        cur_peft_model = PeftModel.from_pretrained(base_model, peft_model_id)
+        cache[peft_model_id] = get_peft_model_state_dict(cur_peft_model)
+
+    return peft_model, tokenizer, cache
+
+
+def preprocess_function(examples, tokenizer):
+    inputs = examples["input"]
+    targets = examples["output"]
+    model_inputs = tokenizer(
+        inputs,
+        max_length=2048,
+        padding=True,
+        truncation=True,
+        return_tensors="pt",
+    )
+    labels = tokenizer(
+        targets,
+        max_length=256,
+        padding=True,
+        truncation=True,
+        return_tensors="pt",
+    )
+    labels = labels["input_ids"]
+    labels[labels == tokenizer.pad_token_id] = -100
+    model_inputs["labels"] = labels
+    return model_inputs
+
+
+def load_dataset_and_run(example_inputs, example_outputs, tokenizer):
+    df = [
+        {"input": example_inputs[i], "output": example_outputs[i]}
+        for i in range(len(example_inputs))
+    ]
+    dataset = Dataset.from_pandas(pd.DataFrame(df))
+    preprocess_func_with_tokenizer = partial(preprocess_function, tokenizer=tokenizer)
+    processed_datasets = dataset.map(
+        preprocess_func_with_tokenizer,
+        batched=True,
+        num_proc=1,
+        desc="Running tokenizer on dataset",
+    )
+    return processed_datasets
+
+    
+def get_score(weights, model, cache, example_dataset):
+    # the composed lora state dict
+    final_state_dict = {}
+    # module list is the list
+    lora_module_list = list(cache.keys())
+    # all keys are the same
+    keys = cache[lora_module_list[0]].keys()
+    for i, peft_model_id in enumerate(lora_module_list):
+        lora_state_dict = cache[peft_model_id]
+        if i == 0:
+            for key in keys:
+                final_state_dict[key] = weights[i] * lora_state_dict[key]
+        else:
+            for key in keys:
+                final_state_dict[key] = (
+                    final_state_dict[key] + weights[i] * lora_state_dict[key]
+                )
+    # reload the model with the new adapter config
+    set_peft_model_state_dict(model, final_state_dict)
+        
+    def get_loss():
+        # use gpu if available
+        train_dataset = example_dataset
+        train_dataloader = DataLoader(
+            train_dataset,
+            collate_fn=default_data_collator,
+            batch_size=len(train_dataset),
+            pin_memory=True,
+        )
+        train_loss = 0
+        with torch.no_grad():
+            device = "cuda" if torch.cuda.is_available() else "cpu"
+            for _, batch in enumerate(train_dataloader):
+                batch = {k: v.to(device) for k, v in batch.items()}
+                with torch.no_grad():
+                    outputs = model(**batch)
+                loss = outputs.loss
+                train_loss += loss.detach().float()
+        loss = train_loss.float()
+        return float(loss) / len(train_dataset["input"])
+        
+    # minimize the metric
+    loss = get_loss()
+    # L1 regularization term
+    sum_of_squares = sum([abs(x) for x in weights]) / len(weights)
+    metric_val = loss + 0.05 * sum_of_squares
+    
+    return metric_val
+
+def get_final_weights(weights, lora_module_list, cache):
+    final_state_dict = {}
+    keys = cache[lora_module_list[0]].keys()
+    for i, peft_model_id in enumerate(lora_module_list):
+        lora_state_dict = cache[peft_model_id]
+        if i == 0:
+            for key in keys:
+                final_state_dict[key] = weights[i] * lora_state_dict[key]
+        else:
+            for key in keys:
+                final_state_dict[key] = (
+                    final_state_dict[key] + weights[i] * lora_state_dict[key]
+                )
+    return final_state_dict
+    
+
+
+def lorahub_learning(lora_module_list, text_input, text_output, max_inference_step):
+    number_of_loras = len(lora_module_list)
+    if number_of_loras == 0:
+        return None
+    # load model
+    model, tokenizer, cache = load_base_model_and_lora_modules(lora_module_list)
+    # process dataset
+    dataset = load_dataset_and_run(text_input.split("\n"), text_output.split("\n"), tokenizer)
+    
+    get_score_partial = partial(get_score, model=model, cache=cache, 
+                                example_dataset=dataset)
+    # set up the limit of the weights
+    instrum = ng.p.Array(
+        init=[0] * number_of_loras,
+        upper=[1.5] * number_of_loras,
+        lower=[-1.5] * number_of_loras,
+    )
+    optimizer = ng.optimizers.NGOpt(parametrization=instrum, budget=max_inference_step)
+    print("> Begin to perform gradient-free optimization ...")
+    recommendation = optimizer.minimize(get_score_partial, verbosity=1)
+    final_lora = get_final_weights(recommendation.value, lora_module_list, cache)
+    return recommendation, final_lora