Page Comparison

from langchain.chains import LLMChain
from langchain.prompts import PromptTemplate
from langchain_openai import OpenAI

template = """Question: {question}

Answer: Let's keep the answer very short and so simple so that
 a child can understand it."""

prompt = PromptTemplate.from_template(template)

llm = OpenAI()

llm_chain = LLMChain(prompt=prompt, llm=llm)

# Define the question as a dictionary to match the expected input format
question_dict = {"question": "explain quantum mechanics in one sentence"}

# Invoke the chain with the question dictionary
output = llm_chain.invoke(question_dict)

print(output)

> Entering new SimpleSequentialChain chain...
Sure, here is a Python function that implements the concept of softmax:

```python
import numpy as np

def softmax(x):
    """Compute softmax values for each sets of scores in x."""
    e_x = np.exp(x - np.max(x))
    return e_x / e_x.sum(axis=0)

# Test with some data
scores = [3.0, 1.0, 0.2]
print(softmax(scores))
```

This function takes as input a list of numbers (x) and returns a list of the same length where each value is the softmax of the corresponding input value. The softmax function is often used in machine learning, to convert a vector of real numbers into a probability distribution. Each output value is between 0 and 1 (inclusive), and the sum of all output values is 1.
The given Python function named `softmax` is used to compute the softmax values for each set of scores in `x`. The 'softmax' function applies the Softmax transformation/normalization to an input which results in continuous normalized probabilities for multi-class classification problems, typically used in the last operation of a machine learning model, such as a neural network  

The steps involved in the function are as follows:

1. First we import numpy, a popular python library that supports large multidimensional arrays and many high-level mathematical functions to operate on these arrays.

2. Define the `softmax` function which expects a list of numbers, denoted `x` as an argument.

3. Inside the function, the function `np.exp(x - np.max(x))` is used. The `np.exp()` function from the NumPy library stands for exponential. Thus, for each score `x` in the list `x`, we subtract the maximum element present in `x` to prevent overflow. With `np.exp(x)`, we are applying the exponential (exp) functionality to each of the entries in the sequence of values.

4. Then, the output (a new list of exponential values) is then divided by the sum of this output list (computed with `e_x.sum(axis=0)`), ensuring that the sum of all probabilities is 1. The `axis=0` refers to the column axis. This process effectively generates probabilities from a list of numbers.

The function usage is demonstrated by defining a list of raw scores, `[3.0, 1.0, 0.2]`. We pass this list to the `softmax` function and print the result. 

Finally, this Python function converts a vector/array/list of raw scores into a probabilistic form- making it suitable for multi-class classification problems. Larger scores reflect higher probability. 

All the scores returned in the list by the `softmax` function ranges between `0` and `1`, such sums to `1`. This helps emphasizes the highest values and suppress values one of which are significantly below the maximum values.

> Finished chain.

from langchain import hub
from langchain.agents import AgentExecutor
from langchain_experimental.tools import PythonREPLTool

tools = [PythonREPLTool()]

from langchain.agents import create_openai_functions_agent
from langchain_openai import ChatOpenAI

instructions = """You are an agent designed to write and execute python code to answer questions.
You have access to a python REPL, which you can use to execute python code.
If you get an error, debug your code and try again.
Only use the output of your code to answer the question. 
You might know the answer without running any code, but you should still run the code to get the answer.
If it does not seem like you can write code to answer the question, just return "I don't know" as the answer.
"""
base_prompt = hub.pull("langchain-ai/openai-functions-template")
prompt = base_prompt.partial(instructions=instructions)

agent = create_openai_functions_agent(ChatOpenAI(temperature=0), tools, prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
agent_executor.invoke({"input": "What is the 8th digit of Pi?"})