add: streamlit app

.gitignore

@@ -0,0 +1,4 @@
+venv/
+.env
+__pycache__
+prompt_log.txt

.streamlit/config.toml

@@ -0,0 +1,6 @@
+[theme]
+primaryColor="#F63366"
+backgroundColor="#FFFFFF"
+secondaryBackgroundColor="#F0F2F6"
+textColor="#262730"
+font="sans serif"

README.md

@@ -1,3 +1,13 @@
+---
+title: SELF-DISCOVER
+emoji: 🔍
+colorFrom: gray
+colorTo: pink
+sdk: streamlit
+pinned: false
+license: apache-2.0
+---
+
 ## SELF-DISCOVER FRAMEWORK
 
 ## Paper Overview [link](https://arxiv.org/pdf/2402.03620.pdf)

app.py

@@ -0,0 +1,36 @@
+import streamlit as st
+import os
+from self_discover import SelfDiscover
+
+
+st.set_page_config(
+    page_title="Reasoning Structure Generator",
+    page_icon="🔍",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+st.title("Reasoning Structure Generator")
+
+
+api_key = st.text_input("Enter OpenAI api key ")
+task = st.text_area("Enter the task example you want to generate a reasoning structure for ")
+
+if st.button("Generate Reasoning Structure"):
+    os.environ["OPENAI_API_KEY"] = api_key
+    result = SelfDiscover(task)
+    result()
+    tab1, tab2, tab3 = st.tabs(["SELECTED_MODULES", "ADAPTED_MODULES", "REASONING_STRUCTURE"])
+    with tab1:
+        st.header("SELECTED_MODULES")
+        st.write(result.selected_modules)
+
+    with tab2:
+        st.header("ADAPTED_MODULES") 
+        st.write(result.adapted_modules)
+
+    with tab3:
+        st.header("REASONING_STRUCTURE") 
+        st.write(result.reasoning_structure)
+else:
+    st.error("Please provide both your API key and a task example.")
+

llm.py

@@ -41,10 +41,10 @@ class LLM:
                 prompt)
             return response.text
         
-        elif self.model_name == 'openai':
+        elif self.model_name == 'OpenAI':
             res = self.model.chat.completions.create(
                 model="gpt-3.5-turbo-1106",
-                response_format={"type": "json_object"},
+                # response_format={"type": "json_object"},
                 messages=[
                     # {"role": "system", "content": "You are a helpful assistant."},
                     {"role": "user", "content": f"{prompt}"},

prompts.py

@@ -54,52 +54,33 @@ objectives?
 
 
 select_prompt = """
-Select several reasoning modules that are crucial to utilize in order solve the given task:
-All reasoning module description
-{resonining_modules}
+In order to solve the given task:
+<Task>
 {Task}
+</Task>
 Select several modules that are crucial for solving the tasks above
+from all the reasoning module description given below:
+{resonining_modules}
 """
 
 adapt_prompt = """
 Rephrase and specify each reasoning module so that it better helps solving the task:
+<Task>
+{Task}
+</Task>
 SELECTED module descriptions:
 {selected_modules}
-{Task}
-Adapt each reasoning module description to better solve the tasks:
+Adapt each reasoning module description to better solve the task:
 """
 
 implement_prompt = """
-Operationalize the reasoning modules into a step-by-step reasoning plan in JSON format:
-
-Paired IMPLEMENT step Demonstration
-Example:
-This SVG path element <path d="M 55.57,80.69 L 57.38,65.80 M 57.38,65.80 L 48.90,57.46 M 48.90,57.46 L
-45.58,47.78 M 45.58,47.78 L 53.25,36.07 L 66.29,48.90 L 78.69,61.09 L 55.57,80.69"/> draws a:
-(A) circle (B) heptagon (C) hexagon (D) kite (E) line (F) octagon (G) pentagon(H) rectangle (I) sector (J) triangle
-{ "Simplify SVG Path": ...
-"Breakdown of Path Commands": {
-"Move to Command (M)": "Sets the starting point for the next
-command without drawing anything.",
-"Line to Command (L) steps":
-{"Start and end coordinates of each line segment":
-"M 55.57,80.69 L 57.38,65.80: From point (55.57, 80.69) to (57.38,
-65.80)"}, … and finally closing the shape at (55.57, 80.69)"}
-"Critical Thinking Analysis": {
-"Logical Reasoning": {
-"Analysis of path continuity": "The path includes
-multiple line segments that connect distinct points. The path ends by
-connecting back to the starting point, indicating a closed shape.",
-"Identification of closed shapes": "The final line
-segment connects the last point back to the first point, which is
-characteristic of a closed shape."},
-…
-"Final Reasoning and Decision": "With 7 distinct points all
-connected in a closed path, the shape formed is a heptagon.",
-"Final Answer": "B) heptagon}
-
+Operationalize the reasoning modules into a step-by-step reasoning plan in JSON format
+Example task:
+<Task>
+{Task}
+</Task>
 ADAPTED module descriptions:
 {adapted_modules}
-{Task}
-Implement a reasoning structure for solvers to follow step-by-dtep and arrive at correct answers
+
+Implement a reasoning structure to generalise similar task to follow step-by-step and arrive at correct answers
 """

self_discover.py

@@ -4,12 +4,30 @@ from prompts import(
     adapt_prompt,
     implement_prompt
 )
+
 from llm import LLM
 from task_example import task1
 
+import logging
+
+def setup_logging():
+    logger = logging.getLogger("__name__")
+    logger.setLevel(logging.INFO)
+        
+    handler = logging.FileHandler("prompt_log.txt")
+    handler.setLevel(logging.INFO)
+
+    formatter = logging.Formatter('%(levelname)s - %(message)s')
+    handler.setFormatter(formatter)
+
+    logger.addHandler(handler)
+    return logger
+
+logger = setup_logging()
+
 class SelfDiscover:
     def __init__(self, task) -> None:
-        self.llm = LLM(model_name="gemini-pro")
+        self.llm = LLM(model_name="OpenAI")
         self.actions = ["SELECT", "ADAPT", "IMPLEMENT"]
         self.task = task
 
@@ -17,28 +35,28 @@ class SelfDiscover:
         for action in self.actions:
             print(action)
             if action == "SELECT":
-                print("yes")
                 prompt = select_prompt.replace("{Task}",self.task)
                 prompt = prompt.replace("{resonining_modules}", reasoning_modules)
-                print(prompt)
+                logger.info("SELECT PROMPT :" + prompt)
                 self.selected_modules = self.llm(prompt)
+                print(self.selected_modules)
 
             elif action == "ADAPT":
                 prompt = adapt_prompt.replace("{Task}",self.task)
                 prompt = prompt.replace("{selected_modules}",self.selected_modules)
-                print(prompt)
+                logger.info("ADAPT PROMPT :" + prompt)
                 self.adapted_modules = self.llm(prompt)
 
             elif action == "IMPLEMENT":
                 prompt = implement_prompt.replace("{Task}",self.task)
                 prompt = prompt.replace("{adapted_modules}", self.adapted_modules)
-                print(prompt)
+                logger.info("IMPLEMENT PROMPT:" + prompt)
                 self.reasoning_structure = self.llm(prompt)
 
 
 if __name__=="__main__":
     result = SelfDiscover(task=task1)
     result()
-    print(f"SELECTED_MODULES : {result.selected_modules}")
-    print(f"ADAPTED_MODULES : {result.adapted_modules}")
-    print(f"REASONING_STRUCTURE : {result.reasoning_structure}")
+    logger.info(f"SELECTED_MODULES : {result.selected_modules}")
+    logger.info(f"ADAPTED_MODULES : {result.adapted_modules}")
+    logger.info(f"REASONING_STRUCTURE : {result.reasoning_structure}")