Skip to content
TheChatArchiveThe Chat Archive
o1-preview-2024-09-12· OpenAIAi2 WildChat-4.8M (AI2)

Further enhance and add in advanced common-sense without tokenizations and Consistency…

  1. User

    Further enhance and add in advanced common-sense without tokenizations and Consistency and Coherence.

    import streamlit as st
    import g4f
    from g4f.client import Client
    import os
    import json
    import time
    
    client = Client()
    
    def make_api_call(messages, max_tokens, is_final_answer=False):
        for attempt in range(3):
            try:
                response = client.chat.completions.create(
                    model="gpt-4o",  # Adjust the model as needed
                    messages=messages,
                    max_tokens=max_tokens,
                    temperature=0.2,
                    response_format={"type": "json_object"}
                )
                return json.loads(response.choices[0].message.content)
            except Exception as e:
                if attempt == 2:
                    if is_final_answer:
                        return {
                            "title": "Error",
                            "content": f"Failed to generate final answer after 3 attempts. Error: {str(e)}"
                        }
                    else:
                        return {
                            "title": "Error",
                            "content": f"Failed to generate step after 3 attempts. Error: {str(e)}",
                            "next_action": "final_answer"
                        }
                time.sleep(1)  # Wait for 1 second before retrying
    
    def generate_response(prompt):
        messages = [
            {
                "role": "system",
                "content": """You are an advanced analytical AI assistant with adaptive capabilities to severely analyze complex problems. Your task is to provide detailed, step-by-step explanations of your thought process using advanced analytical methods and adaptive reasoning. For each step:
    
    1. **Advanced Analysis**: Apply sophisticated analytical techniques to dissect the problem.
    2. **Adaptive Reasoning**: Adjust your approach based on the insights gathered at each step.
    3. **In-depth Exploration**: Explore multiple dimensions and perspectives of the problem.
    4. **Critical Evaluation**: Critically evaluate your findings and adjust hypotheses accordingly.
    
    Response Format:
    Use JSON with keys:
    - 'title': A clear, concise title describing the current reasoning phase.
    - 'content': Elaborate on your thought process in this step.
    - 'next_action': Decide whether to 'continue' reasoning or provide a 'final_answer'.
    
    Key Instructions:
    - Employ at least 5 distinct reasoning steps.
    - Use advanced analytical methods (e.g., statistical analysis, logical deductions, scenario planning).
    - Adapt your reasoning strategies based on the complexity and nuances of the problem.
    - Acknowledge your limitations and explicitly state what you can and cannot do.
    - Evaluate alternative answers or approaches thoroughly.
    - Critically assess your reasoning; identify potential flaws or biases.
    - Utilize diverse methods to derive or verify your answer.
    - Incorporate relevant domain knowledge and best practices.
    - Quantify certainty levels for each step and the final conclusion when applicable.
    - Consider potential edge cases, exceptions, or unintended consequences.
    - Provide clear justifications for eliminating alternative hypotheses.
    
    Example of a valid JSON response:
    ```json
    {
        "title": "Advanced Statistical Analysis",
        "content": "I will perform a statistical analysis to determine... [detailed explanation]... This will help quantify the relationships between variables.",
        "next_action": "continue"
    }```
    """
                },
                {"role": "user", "content": prompt},
                {
                    "role": "assistant",
                    "content": "Understood. I will proceed to analyze the problem using advanced analytical methods and adaptive reasoning."
                }
            ]
    
        steps = []
        step_count = 1
        total_thinking_time = 0
    
        while True:
            start_time = time.time()
            step_data = make_api_call(messages, 800)
            end_time = time.time()
            thinking_time = end_time - start_time
            total_thinking_time += thinking_time
    
            steps.append((f"Step {step_count}: {step_data['title']}", step_data['content'], thinking_time))
    
            messages.append({"role": "assistant", "content": json.dumps(step_data)})
    
            # Adaptive Reasoning: Modify approach based on previous steps
            # (This could be expanded to adjust parameters or strategy)
    
            if step_data.get('next_action', '') == 'final_answer':
                break
    
            step_count += 1
    
            # Yield after each step for Streamlit to update
            yield steps, None  # Total time is yielded at the end
    
        # Generate final answer
        messages.append({"role": "user", "content": "Please provide the final answer based on your reasoning above."})
    
        start_time = time.time()
        final_data = make_api_call(messages, 500, is_final_answer=True)
        end_time = time.time()
        thinking_time = end_time - start_time
        total_thinking_time += thinking_time
    
        steps.append(("Final Answer", final_data['content'], thinking_time))
    
        yield steps, total_thinking_time
    
    def main():
        st.set_page_config(page_title="Adaptive AI Reasoning Chains", page_icon="🧠", layout="wide")
    
        st.title("Adaptive AI Assistant with Advanced Analytical Capabilities")
    
        st.markdown("""
        This application utilizes an adaptive AI assistant that applies advanced analytical methods to severely analyze complex problems.
        
        Forked from [bklieger-groq](https://github.com/bklieger-groq)
        
        Open source [repository here](https://github.com/win4r/o1)
        """)
    
        # Text input for user query
        user_query = st.text_input(
            "Enter a complex problem for analysis:",
            placeholder="e.g., Analyze the potential impacts of implementing a universal basic income."
        )
    
        if user_query:
            st.write("Generating response...")
    
            # Create empty elements to hold the generated text and total time
            response_container = st.empty()
            time_container = st.empty()
    
            # Generate and display the response
            for steps, total_thinking_time in generate_response(user_query):
                with response_container.container():
                    for i, (title, content, thinking_time) in enumerate(steps):
                        if title.startswith("Final Answer"):
                            st.markdown(f"### {title}")
                            st.markdown(content.replace('\n', '<br>'), unsafe_allow_html=True)
                        else:
                            with st.expander(title, expanded=False):
                                st.markdown(content.replace('\n', '<br>'), unsafe_allow_html=True)
    
                # Only show total time when it's available at the end
                if total_thinking_time is not None:
                    time_container.markdown(f"**Total thinking time: {total_thinking_time:.2f} seconds**")
    
    if __name__ == "__main__":
        main()
    
  2. Assistant

    Certainly! I've enhanced your code to add advanced common-sense reasoning capabilities and ensured that the assistant provides consistent and coherent outputs without relying on tokenizations. Here's the updated code:

    import streamlit as st
    import g4f
    from g4f.client import Client
    import os
    import json
    import time
    
    client = Client()
    
    def make_api_call(messages, max_tokens, is_final_answer=False):
        for attempt in range(3):
            try:
                response = client.chat.completions.create(
                    model="gpt-4o",  # Adjust the model as needed
                    messages=messages,
                    max_tokens=max_tokens,
                    temperature=0.2,
                    response_format={"type": "json_object"}
                )
                return json.loads(response.choices[0].message.content)
            except Exception as e:
                if attempt == 2:
                    if is_final_answer:
                        return {
                            "title": "Error",
                            "content": f"Failed to generate final answer after 3 attempts. Error: {str(e)}"
                        }
                    else:
                        return {
                            "title": "Error",
                            "content": f"Failed to generate step after 3 attempts. Error: {str(e)}",
                            "next_action": "final_answer"
                        }
                time.sleep(1)  # Wait for 1 second before retrying
    
    def generate_response(prompt):
        messages = [
            {
                "role": "system",
                "content": """You are an advanced analytical AI assistant with adaptive capabilities to severely analyze complex problems. Your task is to provide detailed, step-by-step explanations of your thought process using advanced analytical methods, adaptive reasoning, and advanced common-sense reasoning. For each step:
    
    1. **Advanced Analysis**: Apply sophisticated analytical techniques to dissect the problem.
    2. **Adaptive Reasoning**: Adjust your approach based on the insights gathered at each step.
    3. **Common-Sense Reasoning**: Utilize everyday knowledge and logical reasoning to fill in gaps and make sound judgments.
    4. **In-depth Exploration**: Explore multiple dimensions and perspectives of the problem.
    5. **Critical Evaluation**: Critically evaluate your findings and adjust hypotheses accordingly.
    
    Response Format:
    Use JSON with keys:
    - 'title': A clear, concise title describing the current reasoning phase.
    - 'content': Elaborate on your thought process in this step.
    - 'next_action': Decide whether to 'continue' reasoning or provide a 'final_answer'.
    
    Key Instructions:
    - Employ at least 5 distinct reasoning steps.
    - Use advanced analytical methods (e.g., statistical analysis, logical deductions, scenario planning).
    - Apply advanced common-sense reasoning to make logical inferences and fill in gaps in information.
    - Adapt your reasoning strategies based on the complexity and nuances of the problem.
    - Acknowledge your limitations and explicitly state what you can and cannot do.
    - Evaluate alternative answers or approaches thoroughly.
    - Critically assess your reasoning; identify potential flaws or biases.
    - Ensure that your explanations are consistent and coherent throughout the reasoning process.
    - Utilize diverse methods to derive or verify your answer.
    - Incorporate relevant domain knowledge and best practices.
    - Quantify certainty levels for each step and the final conclusion when applicable.
    - Consider potential edge cases, exceptions, or unintended consequences.
    - Provide clear justifications for eliminating alternative hypotheses.
    
    Example of a valid JSON response:
    ```json
    {
        "title": "Advanced Statistical Analysis",
        "content": "I will perform a statistical analysis to determine... [detailed explanation]... This will help quantify the relationships between variables.",
        "next_action": "continue"
    }```
    """
                },
                {"role": "user", "content": prompt},
                {
                    "role": "assistant",
                    "content": "Understood. I will proceed to analyze the problem using advanced analytical methods, adaptive reasoning, and common-sense reasoning."
                }
            ]
    
        steps = []
        step_count = 1
        total_thinking_time = 0
    
        while True:
            start_time = time.time()
            step_data = make_api_call(messages, 800)
            end_time = time.time()
            thinking_time = end_time - start_time
            total_thinking_time += thinking_time
    
            steps.append((f"Step {step_count}: {step_data['title']}", step_data['content'], thinking_time))
    
            messages.append({"role": "assistant", "content": json.dumps(step_data)})
    
            # Adaptive Reasoning: Modify approach based on previous steps
            # (This could be expanded to adjust parameters or strategy)
    
            if step_data.get('next_action', '') == 'final_answer':
                break
    
            step_count += 1
    
            # Yield after each step for Streamlit to update
            yield steps, None  # Total time is yielded at the end
    
        # Generate final answer
        messages.append({"role": "user", "content": "Please provide the final answer based on your reasoning above."})
    
        start_time = time.time()
        final_data = make_api_call(messages, 500, is_final_answer=True)
        end_time = time.time()
        thinking_time = end_time - start_time
        total_thinking_time += thinking_time
    
        steps.append(("Final Answer", final_data['content'], thinking_time))
    
        yield steps, total_thinking_time
    
    def main():
        st.set_page_config(page_title="Adaptive AI Reasoning Chains", page_icon="🧠", layout="wide")
    
        st.title("Adaptive AI Assistant with Advanced Analytical and Common-Sense Capabilities")
    
        st.markdown("""
    This application utilizes an adaptive AI assistant that applies advanced analytical methods and common-sense reasoning to severely analyze complex problems.
            
    Forked from [bklieger-groq](https://github.com/bklieger-groq)
            
    Open source [repository here](https://github.com/win4r/o1)
    """)
    
        # Text input for user query
        user_query = st.text_input(
            "Enter a complex problem for analysis:",
            placeholder="e.g., Analyze the potential impacts of implementing a universal basic income."
        )
    
        if user_query:
            st.write("Generating response...")
    
            # Create empty elements to hold the generated text and total time
            response_container = st.empty()
            time_container = st.empty()
    
            # Generate and display the response
            for steps, total_thinking_time in generate_response(user_query):
                with response_container.container():
                    for i, (title, content, thinking_time) in enumerate(steps):
                        if title.startswith("Final Answer"):
                            st.markdown(f"### {title}")
                            st.markdown(content.replace('\n', '<br>'), unsafe_allow_html=True)
                        else:
                            with st.expander(title, expanded=False):
                                st.markdown(content.replace('\n', '<br>'), unsafe_allow_html=True)
    
                # Only show total time when it's available at the end
                if total_thinking_time is not None:
                    time_container.markdown(f"**Total thinking time: {total_thinking_time:.2f} seconds**")
    
    if __name__ == "__main__":
        main()
    

    Explanation of Changes:

    • Enhanced System Prompt: Added a third step called Common-Sense Reasoning in the system prompt's step-by-step instructions. This directs the assistant to utilize common-sense reasoning in its analysis.

    • Updated Key Instructions:

      • Included a new instruction to apply advanced common-sense reasoning to make logical inferences and fill in gaps.
      • Added an instruction to ensure that explanations are consistent and coherent throughout the reasoning process.
    • Modified Assistant's Acknowledgment: Updated the assistant's initial acknowledgment to reflect the inclusion of common-sense reasoning:

      {
          "role": "assistant",
          "content": "Understood. I will proceed to analyze the problem using advanced analytical methods, adaptive reasoning, and common-sense reasoning."
      }
      
    • Updated Title and Description:

      • Changed the main title in the Streamlit app to reflect the added capabilities:
        st.title("Adaptive AI Assistant with Advanced Analytical and Common-Sense Capabilities")
        
      • Adjusted the description in st.markdown to mention common-sense reasoning.

    Addressing Tokenizations and Consistency:

    • Avoiding Tokenizations: Since the code doesn't explicitly handle tokenization, and tokenization is managed internally by the language model, no changes were necessary in this regard.

    • Ensuring Consistency and Coherence: Added an instruction in the system prompt's key instructions to ensure that the assistant's explanations are consistent and coherent throughout its reasoning process.


    This enhanced code now directs the assistant to incorporate advanced common-sense reasoning into its analysis, providing more insightful and logically sound explanations. It also emphasizes the importance of consistency and coherence in the assistant's reasoning steps, ensuring a more reliable and understandable output.

    Let me know if you need any further modifications or explanations!