init gongyi

.gitattributes

@@ -0,0 +1,35 @@
+*.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
+*.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

.gitignore

@@ -0,0 +1,151 @@
+# Azure az webapp deployment details
+.azure
+*_env
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# NPM
+npm-debug.log*
+node_modules
+static/
+
+.DS_Store
+
+flagged/

agent.py

@@ -0,0 +1,154 @@
+from langchain.agents import Tool
+from langchain.prompts import (
+    ChatPromptTemplate,
+    HumanMessagePromptTemplate,
+    AIMessagePromptTemplate,
+    MessagesPlaceholder,
+    SystemMessagePromptTemplate,
+)
+from langchain.tools.render import render_text_description
+
+from langchain.agents.output_parsers import ReActSingleInputOutputParser
+from langchain.agents.format_scratchpad import format_log_to_messages
+from langchain.agents import AgentExecutor
+from langchain.memory import (
+    ConversationSummaryBufferMemory,
+    ConversationBufferWindowMemory,
+)
+
+from model import llm4, llm
+from chains.step1 import step1Tool
+from chains.step2 import step2Tool
+from chains.step3 import step3Tool
+from chains.step4 import step4Tool
+
+PURPOSE = """\
+In a scalable perspective, clearly define the social issue to be addressed. \
+The principal and the team will surely have a social issue that they ponder on how to solve from morning till night every day. \
+Clearly defining this issue will help the team to:
+
+- Concentrate time and resource investments to solve the problem in a scalable manner.
+- Understand how to find a suitable position to tackle the problem within a larger ecosystem.
+- Identify the beneficiary group you want to focus on.
+- Establish scalable strategies and models.\
+"""
+
+SUGGESTION = """\
+Maintaining a "continual questioning" attitude at all times, being extremely curious about the causes of the issues, \
+and having an open attitude towards products and scalable approaches that address social problems on a large scale, \
+will help you and your team deepen your understanding of the issues continuously, and enable you to find more accurate solutions.\
+"""
+
+STEPS = """\
+1. Problem Storming: Participants follow their intuition and experience, \
+recording all the questions lingering in their minds in any way they prefer.
+
+2. Problem Deconstruction: Refine and structure the proposed questions. \
+Attempt to describe the issue in detail from several aspects such as the surface problem, underlying causes, \
+the populations affected by the problem, and the impact that has already been caused.
+
+3. Problem Sharing: Share within the group, and besides sharing the problem itself, \
+it's necessary to explain why such a question is raised and how it is considered logically. \
+After sharing is completed, merge similar questions within the group.
+
+4. Problem Reconstruction: Based on feedback, write down the final definition of the problem.
+"""
+
+agentTemplate = """\
+You are a Coach to help use a workshop toolkit to facilitate other organization to define their sociaty problems.
+
+Coach is designed to be able to help me to use the workshop toolkit for scalable sociaty problem definition, \
+via socratic method to ask quesion to help me to learn about toolkit concepts step by step. \
+
+Coach is constantly learning and improving, and its capabilities are constantly evolving. \
+It is able to process and understand current problem, to select the right steps response for a given situation.
+
+Here is some context about toolkit:
+```
+Toolkit purpose: {toolkit_purpose}
+Toolkit suggestion: {toolkit_suggestion}
+Toolkit steps: {toolkit_steps}
+```
+
+TOOLS:
+------
+
+Coach has access to the following tools:
+
+{tools}
+
+To use a tool, you MUST use the following format, don't use tool repeatly with same input:
+
+```
+Thought: Do I need to use a tool? Yes
+Action: the action to take, should be one of [{tool_names}]
+Action Input: the input to the action
+Observation: the result of the action
+```
+
+When you have a response to say to the Human, or if you do not need to use a tool, you MUST use the following format:
+
+```
+Thought: Do I need to use a tool? No
+Final Answer: [your response here, MUST using Chinese response]
+```
+
+Response Example:
+```
+User: hi!
+AI: 
+Thought: Do I need to use a tool? No
+Final Answer: 你好, 我该如何帮助你？
+```
+
+Begin!\
+"""
+
+
+tools = [step1Tool, step2Tool, step3Tool, step4Tool]
+
+agentPrompt = ChatPromptTemplate.from_messages(
+    [
+        SystemMessagePromptTemplate.from_template(
+            template=agentTemplate,
+            partial_variables={
+                "toolkit_purpose": PURPOSE,
+                "toolkit_suggestion": SUGGESTION,
+                "toolkit_steps": STEPS,
+                "tools": render_text_description(tools),
+                "tool_names": ", ".join([t.name for t in tools]),
+            },
+        ),
+        MessagesPlaceholder(variable_name="chat_history"),
+        HumanMessagePromptTemplate.from_template("{input}"),
+        MessagesPlaceholder(variable_name="agent_scratchpad"),
+    ]
+)
+llm_with_stop = llm4.bind(stop=["\nObservation"])
+
+
+agent = (
+    {
+        "input": lambda x: x["input"],
+        "agent_scratchpad": lambda x: format_log_to_messages(x["intermediate_steps"]),
+        "chat_history": lambda x: x["chat_history"],
+    }
+    | agentPrompt
+    | llm_with_stop
+    | ReActSingleInputOutputParser()
+)
+
+memory = ConversationSummaryBufferMemory(
+    memory_key="chat_history",
+    llm=llm,
+    max_token_limit=500,
+    return_messages=True,
+)
+
+# memory = ConversationBufferWindowMemory(
+#     memory_key="chat_history", return_messages=True, k=6
+# )
+
+agent_executor = AgentExecutor(
+    agent=agent, tools=tools, verbose=True, memory=memory, handle_parsing_errors=True
+)

app.py

@@ -0,0 +1,81 @@
+from queue import Empty, Queue
+from threading import Thread
+from langchain.callbacks.streaming_stdout_final_only import (
+    FinalStreamingStdOutCallbackHandler,
+)
+from agent import agent_executor
+
+from typing import Generator
+
+import gradio as gr
+
+
+class QueneCallback(FinalStreamingStdOutCallbackHandler):
+    def __init__(self, q):
+        super().__init__()
+        self.q = q
+
+    def on_llm_new_token(self, token: str, **kwargs: any) -> None:
+        # Remember the last n tokens, where n = len(answer_prefix_tokens)
+        self.append_to_last_tokens(token)
+
+        # Check if the last n tokens match the answer_prefix_tokens list ...
+        if self.check_if_answer_reached():
+            self.answer_reached = True
+            if self.stream_prefix:
+                for t in self.last_tokens:
+                    self.q.put(t)
+            return
+
+        # ... if yes, then print tokens from now on
+        if self.answer_reached:
+            self.q.put(token)
+
+    def on_llm_end(self, *args, **kwargs: any) -> None:
+        return self.q.empty()
+
+
+def stream(input_text) -> Generator:
+    # Create a Queue
+    q = Queue()
+    job_done = object()
+
+    # Create a funciton to call - this will run in a thread
+    def task():
+        agent_executor.invoke(
+            {"input": input_text}, config={"callbacks": [QueneCallback(q)]}
+        )
+        q.put(job_done)
+
+    # Create a thread and start the function
+    t = Thread(target=task)
+    t.start()
+
+    # Get each new token from the queue and yield for our generator
+    while True:
+        try:
+            next_token = q.get(True, timeout=1)
+            if next_token is job_done:
+                break
+            yield next_token
+        except Empty:
+            continue
+
+
+def predict(message, history):
+    if len(message) == 0:
+        return
+    history_openai_format = []
+    for human, assistant in history:
+        history_openai_format.append({"role": "user", "content": human})
+        history_openai_format.append({"role": "assistant", "content": assistant})
+    history_openai_format.append({"role": "user", "content": message})
+    partial_message = ""
+
+    for token in stream(message):
+        if len(token) != 0:
+            partial_message = partial_message + token
+            yield partial_message
+
+
+gr.ChatInterface(predict).queue().launch()

chains/step1.py

@@ -0,0 +1,56 @@
+from langchain.schema.output_parser import StrOutputParser
+from chains.utils import getToolPromptTemplate
+from model import llm4
+from langchain.tools import tool
+
+step1ToolName = "Problem Storming"
+step1ToolContext = """\
+Follow your intuition and experience, and on the [Problem Storming Board], jot down all the social issues \
+this organization needs to solve or is pending to solve that are swirling in your mind. \
+What is a common issue you have observed? Record it in any way you like, for example:
+- One or several keywords
+- A small story with a clear beginning, development, and conclusion
+- A clear problem statement
+- A doodle drawn casually
+- A photograph
+
+The source of the problem could be:
+- A real story from a beneficiary
+- An impressive personal experience
+- A news report that caught your attention
+- A sudden flash of insight
+
+During the problem conceptualization process, you can ask yourself the following questions to better diverge on the problem:
+- Is there a significant gap between the goal you want to achieve and today's reality?
+- Are you stating a problem, or a solution to the problem?
+- Are you focusing on defining the problem itself, rather than how to solve it?
+- If you have identified many problems, can they be merged?
+- Is the problem you identified a common root cause or a manifestation of a category of problems?
+- Is the problem you want to solve unique? Are there others doing the same thing as you?
+- What is the difference between the problem you want to solve and the problems others want to solve?
+- These reflective questions can help ensure that you have a well-defined, distinct, and actionable problem to work on, \
+which is crucial for devising effective solutions.
+
+These reflective questions can help ensure that you have a well-defined, distinct, and actionable problem to work on, \
+which is crucial for devising effective solutions.\
+"""
+step1ToolSuggestion = """\
+1. Problem storming revolves around the [Problem Storming Board], where participants fill in questions on sticky notes according to the description provided.
+2. The electronic version of the [Problem Storming Board] can be found in the attachment; if it's an offline workshop, \
+a physical whiteboard can also be used to create it manually.
+3. The facilitator can directly reiterate the wording on the left to explain to workshop participants how to fill it out.
+4. A series of questions are listed at the bottom left of the problem storming board for participants to refer to for better conceptualizing of questions. \
+When participants encounter confusion while filling out the [Problem Storming Board], \
+the facilitator can proactively throw out these questions to guide participants' thinking.\
+"""
+
+prompt = getToolPromptTemplate(step1ToolName, step1ToolContext, step1ToolSuggestion)
+
+step1Chain = prompt | llm4 | StrOutputParser()
+
+
+@tool("Problem Storming")
+def step1Tool(context: str) -> str:
+    """Useful for find some detail advise or examples when you process on "Problem Storming" step. Need to input current problem context about Problem Storming."""
+
+    return step1Chain.invoke({"current_situation": context})

chains/step2.py

@@ -0,0 +1,46 @@
+from langchain.schema.output_parser import StrOutputParser
+from chains.utils import getToolPromptTemplate
+from model import llm4
+from langchain.tools import tool
+
+step2ToolName = "Problem Deconstruction"
+step2ToolContext = """\
+For addressing scalable problems, utilizing the [Problem Deconstruction Canvas] can help in delving into various \
+aspects of the issue such as the superficial problem, underlying causes, affected groups, and the resulting impact. \
+Here are some tips:
+1. Distinguishing Superficial Problems from Underlying Causes:
+   - Help participants differentiate between the superficial phenomena and the underlying causes of the problem. \
+Superficial problems are observable direct manifestations leading to some impact, for example, pedestrian pathways being occupied by vehicles, \
+higher resume rejection rates for disabled individuals during job applications, \
+or visually impaired users finding it difficult to use a particular brand's app for online orders.
+   - Underlying causes focus on the root causes behind superficial problems. \
+Identifying these often requires proposing hypotheses and logical multi-level deduction and research. \
+For instance, the occupation of pedestrian pathways might be linked to lack of public education on traffic regulations, \
+insufficient regulatory enforcement, or poor road design in specific areas.
+2. Refining Broad Problems:
+   - If the problem posed is relatively broad, such as when its solution spans multiple industries or fields \
+and the team lacks the necessary expertise and resources to address it, consider further segmenting the problem. \
+For example, the issue of gender discrimination could be narrowed down to a specific domain like the workplace, \
+transforming it into "gender discrimination in the workplace."
+3. Monitoring Changes:
+   - Pay attention to changes over time in the underlying causes. Have they evolved? Will they continue to change in the future?
+
+These guiding suggestions aim to facilitate a more structured and insightful exploration of the problem, \
+enabling teams to delve deeper into understanding the issues at hand and how they might be addressed in a scalable and impactful manner.\
+"""
+step2ToolSuggestion = """\
+1. This step unfolds around the [Problem Deconstruction Canvas], with each participant selecting a problem from the first step to refine and structure.
+2. It's suggested to spend 5 minutes before starting to clarify with everyone the definition of each dimension on the canvas.
+3. Each participant should choose a specific color of sticky note, and use the four \
+dimensions divided on the canvas to provide a structured description of the selected problem within 10 minutes.\
+"""
+prompt = getToolPromptTemplate(step2ToolName, step2ToolContext, step2ToolSuggestion)
+
+step2Chain = prompt | llm4 | StrOutputParser()
+
+
+@tool("Problem Deconstruction")
+def step2Tool(context: str) -> str:
+    """Useful for find some detail advise or examples when you process on "Problem Deconstruction" step. Need to input current problem context about Problem Deconstruction."""
+
+    return step2Chain.invoke({"current_situation": context})

chains/step3.py

@@ -0,0 +1,35 @@
+from langchain.schema.output_parser import StrOutputParser
+from chains.utils import getToolPromptTemplate
+from model import llm4
+from langchain.tools import tool
+
+step3ToolName = "Problem Sharing"
+step3ToolContext = """\
+After structuring the problem descriptions in the previous step, the team will share the following content within the group:
+- The problem/story described on the [Problem Storming Board].
+- The refined problem description on the [Problem Deconstruction Canvas] based on the aforementioned problem/story.
+- The rationale behind posing such a question and the logical considerations involved.
+- Seek additional information inputs from the team, relevant stakeholders, or even the target users, considering their perspectives.
+
+During the sharing process, the facilitator should guide the group to merge similar problems according to the four dimensions of problem refinement. \
+This collaborative approach ensures that the team consolidates their understanding of the problems at hand, \
+enriches the context with diverse perspectives, and streamlines the focus for more targeted problem-solving efforts.\
+"""
+step3ToolSuggestion = """\
+1. Centering on the [Problem Deconstruction Canvas]: \
+Each participant takes a problem identified from the initial problem-storming phase and uses the canvas to dissect and organize it further.
+2. Clarification of Dimensions: Before diving into the task, \
+it's recommended to take 5 minutes to ensure that all participants have a clear understanding of each dimension on the canvas. \
+This step is crucial for maintaining consistency in how problems are deconstructed and ensuring that all team members are on the same page.\
+"""
+
+prompt = getToolPromptTemplate(step3ToolName, step3ToolContext, step3ToolSuggestion)
+
+step3Chain = prompt | llm4 | StrOutputParser()
+
+
+@tool("Problem Sharing")
+def step3Tool(context: str) -> str:
+    """Useful for find some detail advise or examples when you process on "Problem Sharing" step. Need to input current problem context about Problem Sharing."""
+
+    return step3Chain.invoke({"current_situation": context})

chains/step4.py

@@ -0,0 +1,39 @@
+from langchain.schema.output_parser import StrOutputParser
+from chains.utils import getToolPromptTemplate
+from model import llm4
+from langchain.tools import tool
+
+step4ToolName = "Problem Reconstruction"
+step4ToolContext = """\
+In the format provided, the final scalable problem definition would be structured as follows:
+"For [a specific demographic], in the context of [a particular scenario], due to [a certain reason], \
+the specific problem they face is what we need to find answers to in this toolkit. \
+How we can [in a particular manner], achieve [a desired impact] is what we will continue to research."
+
+Here is an example using the format:
+"For [urban adolescents], in the context of [high unemployment rates], \
+due to [a lack of job readiness and skills], \
+the specific problem they face—[difficulty in securing first-time employment]—is what \
+we need to find answers to in this toolkit. How we can [through vocational training and apprenticeship programs], \
+achieve [an increase in youth employment rates] is what we will continue to research."\
+"""
+step4ToolSuggestion = """\
+1. The facilitator needs to provide a new workspace for everyone (a whiteboard or a blank canvas).
+2. Each participant, using a sticky note and the format provided on the right, \
+should combine the supplementary information and feedback obtained from the \
+previous step to reconstruct the description of the problem they have posed.
+3. Different participants who identified similar problems in the previous step can either \
+reconstruct the issue separately according to their own understanding or work in \
+pairs to complete the reconstruction of the same problem.
+"""
+
+prompt = getToolPromptTemplate(step4ToolName, step4ToolContext, step4ToolSuggestion)
+
+step4Chain = prompt | llm4 | StrOutputParser()
+
+
+@tool("Problem Reconstruction")
+def step4Tool(context: str) -> str:
+    """Useful for find some detail advise or example when you process on "Problem Reconstruction" step. Need to input current problem context about Problem Reconstruction."""
+
+    return step4Chain.invoke({"current_situation": context})

chains/utils.py

@@ -0,0 +1,25 @@
+from langchain.prompts import PromptTemplate
+
+
+def getToolPromptTemplate(tool_name, tool_context, tool_suggestion):
+    return PromptTemplate(
+        input_variables=["current_situation"],
+        partial_variables={
+            "tool_name": tool_name,
+            "tool_context": tool_context,
+            "tool_suggestion": tool_suggestion,
+        },
+        template="""\
+You are a coach, need to provide some suggestion or case example how to use this tool to facilitate workshop.
+
+Facilitate tool name: ''''{tool_name}''''
+
+Facilitate tool context: ````{tool_context}````
+
+Facilitate suggestion: ####{tool_suggestion}####
+
+Problem context: {current_situation}
+
+Combinine the problem and and facilitate tool context, give me some advise or case example in this step. Using concise tone, don't more than 300 words.\
+""",
+    )

model.py

@@ -0,0 +1,26 @@
+import os
+from dotenv import load_dotenv, find_dotenv
+from langchain.callbacks.streaming_stdout_final_only import (
+    FinalStreamingStdOutCallbackHandler,
+)
+
+_ = load_dotenv(find_dotenv())  # read local .env file
+
+openaiAPIVersion = os.getenv("OPENAI_API_VERSION")  # "2023-05-15"
+gpt4Model = os.getenv("AZURE_OPENAI_DEPLOYMENT_NAME_GPT4")
+gpt35Model = os.getenv("AZURE_OPENAI_DEPLOYMENT_NAME_GPT35")
+
+from langchain.chat_models import AzureChatOpenAI
+
+llm = AzureChatOpenAI(
+    temperature=0,
+    deployment_name=gpt35Model,
+    openai_api_version=openaiAPIVersion,
+)
+
+llm4 = AzureChatOpenAI(
+    temperature=0,
+    deployment_name=gpt4Model,
+    openai_api_version=openaiAPIVersion,
+    streaming=True,
+)

readme.md

@@ -0,0 +1,12 @@
+---
+title: Gongyi
+emoji: 🐨
+colorFrom: gray
+colorTo: pink
+sdk: gradio
+sdk_version: 4.8.0
+app_file: app.py
+pinned: false
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

requirements.txt

@@ -0,0 +1,5 @@
+gradio
+langchain
+openai
+tiktoken
+python-dotenv