date_collected
stringclasses 1
value | repo_name
stringlengths 6
116
| file_name
stringlengths 2
220
| file_contents
stringlengths 13
357k
| prompts
sequence |
|---|---|---|---|---|
2024-01-10 | cliffpyles/Helpers | apps~madi-cli~madi_cli.py | #!/usr/bin/env python3
import os
import openai
import pyaudio
import io
import wave
from playsound import playsound
import boto3
# Set up OpenAI client
openai.api_key = os.getenv("OPENAI_API_KEY")
# Constants
CHUNK = 1024
FORMAT = pyaudio.paInt16
CHANNELS = 1
RATE = 16000
RECORD_SECONDS = 5
WAVE_OUTPUT_FILENAME = "output.wav"
SYSTEM_MESSAGE = "I want you to act as a text based adventure game. I will give commands and you will reply with a description of what the character sees. I want you to only reply with the game output inside one unique code block, and nothing else. do not write explanations. do not type commands unless I instruct you to do so. at the start of each game, find out how many players are playing and give each of them a character. at the start of each game you should ask what type of adventure we want go on, and you should give examples. Make the game appropriate for a 9 year old. Make sure there is comedy in every game."
# Initialize PyAudio
p = pyaudio.PyAudio()
def record_audio():
print("Recording...")
stream = p.open(format=FORMAT,
channels=CHANNELS,
rate=RATE,
input=True,
frames_per_buffer=CHUNK)
frames = []
for i in range(0, int(RATE / CHUNK * RECORD_SECONDS)):
data = stream.read(CHUNK)
frames.append(data)
print("Finished recording")
stream.stop_stream()
stream.close()
# Save audio to a file
wf = wave.open(WAVE_OUTPUT_FILENAME, 'wb')
wf.setnchannels(CHANNELS)
wf.setsampwidth(p.get_sample_size(FORMAT))
wf.setframerate(RATE)
wf.writeframes(b''.join(frames))
wf.close()
def translate_audio_to_text():
audio_file = open(WAVE_OUTPUT_FILENAME, 'rb')
response = openai.Audio.translate(model="whisper-1", file=audio_file)
return response.text.strip()
def generate_response(user_message, messages):
messages.append({"role": "user", "content": user_message})
response = openai.ChatCompletion.create(
model="gpt-3.5-turbo",
messages=messages
)
return response.choices[0].message['content'].strip()
def play_audio(text):
polly_client = boto3.Session(
region_name="us-east-1" # Set the appropriate region for your use case
).client("polly")
response = polly_client.synthesize_speech(
Text=text,
OutputFormat="mp3",
VoiceId="Matthew"
)
with open("response.mp3", "wb") as f:
f.write(response["AudioStream"].read())
playsound("response.mp3")
os.remove("response.mp3")
if __name__ == "__main__":
try:
messages = [
{"role": "system", "content": SYSTEM_MESSAGE},
]
print("Assistant: Welcome to the role-playing game! I am your game master.")
play_audio("Welcome to the role-playing game! I am your game master.")
response = generate_response("Let's get started.", messages)
print(f"Assistant: {response}")
play_audio(response)
while True:
record_audio()
text = translate_audio_to_text()
print(f"You: {text}")
response = generate_response(text, messages)
print(f"Assistant: {response}")
play_audio(response)
except KeyboardInterrupt:
print("Exiting...")
p.terminate()
| [
"I want you to act as a text based adventure game. I will give commands and you will reply with a description of what the character sees. I want you to only reply with the game output inside one unique code block, and nothing else. do not write explanations. do not type commands unless I instruct you to do so. at the start of each game, find out how many players are playing and give each of them a character. at the start of each game you should ask what type of adventure we want go on, and you should give examples. Make the game appropriate for a 9 year old. Make sure there is comedy in every game."
] |
2024-01-10 | Lalith-Sagar-Devagudi/ChatBot-using-OpenAI-FastAPI | microservice.py | from typing import Optional
from fastapi import FastAPI, HTTPException
from fastapi.responses import FileResponse
from fastapi.middleware.cors import CORSMiddleware
from gtts import gTTS
import openai
import os
from pymongo import MongoClient
from pymongo.collection import Collection
from pydantic import BaseModel
import pyttsx3
tags_metadata = [
{
"name": "chat",
"description": "You can chat here.",
},
{
"name": "history",
"description": "History of conversations by the user.",
},
{
"name": "audio",
"description": "Download audio file of the most recent OpenAI Bot response.",
},
]
app = FastAPI( openapi_tags=tags_metadata, title="Chatbot Microservice API", description="API to chat with an AI chatbot", version="1.0.0")
origins = ["http://localhost:8001"] # adjust this to match your actual domain
# Configure CORS middleware
app.add_middleware(
CORSMiddleware,
allow_origins=origins,
allow_credentials=True,
allow_methods=["*"],
allow_headers=["*"],
)
# Initialize the speech engine
engine = pyttsx3.init()
class ChatInput(BaseModel):
"""Data model for chat input."""
user_id: str
message: str
audio: bool = False
# Set OpenAI API key
openai.api_key = "***********" # set your OpenAI API key in environment variables
# Connect to MongoDB client
client = MongoClient(os.getenv("MONGO_CONNECTION_STRING"))
db = client['chatbot'] # Replace with your database name
@app.get("/", include_in_schema=False)
async def root():
"""
Function to tell server is running whenevr the base URL http://127.0.0.1:8000 is opened.
"""
return {"message": "Chatbot is running and you can access it at http://127.0.0.1:8000/docs."}
@app.post("/chat", tags=["chat"])
async def chat( user_id: str ="Enter your User ID ", message: str ="Chat here", audio: bool = False ) -> dict:
"""
Function to handle chat with the bot.
It saves conversation to the database, calls the AI model to get response,
converts the response to speech and returns the AI response.
\n **Audio is False = OFF by default, True = ON**
"""
# Load conversation history from DB
history = db.conversations.find_one({"user_id": user_id})
if history is None:
history = {"user_id": user_id, "conversation": []}
# Use OpenAI API to generate a response
response = openai.ChatCompletion.create(
model="gpt-3.5-turbo",
messages=[{
"role": "system",
"content": "You are a helpful assistant."
}, {
"role": "user",
"content": message
}],
max_tokens=150
)
# Check if the response from OpenAI is empty or not
if response is None or len(response.choices) == 0:
raise HTTPException(status_code=500, detail="OpenAI response is empty")
# Store the new messages in the conversation history
new_messages = {
"user": message,
"assistant": response.choices[0].message['content'],
}
history['conversation'].append(new_messages)
db.conversations.update_one({"user_id": user_id}, {"$set": history}, upsert=True)
# Convert text to speech and speak the response only if audio was requested
if audio:
tts = gTTS(text=response.choices[0].message['content'], lang='en')
tts.save("outputs/output.mp3")
# Speak the response
engine.say(response.choices[0].message['content'])
engine.runAndWait()
return {"message": response.choices[0].message['content']} # return the AI response
@app.get("/history/{user_id}", tags=["history"])
async def get_history(user_id: str) -> FileResponse:
"""
Function to get chat history for a given user id.
It fetches the conversation from database, converts it to text file and returns as FileResponse.
"""
history = db.conversations.find_one({"user_id": user_id})
if history is None:
raise HTTPException(status_code=404, detail="No conversation history found for this user")
# Convert the conversation list into a single string, each message on a new line
history_string = "\n".join([f"User: {msg['user']}\nAssistant: {msg['assistant']}" for msg in history["conversation"]])
# Write the history string to a text file
with open("outputs/history.txt", "w") as file:
file.write(history_string)
# Return the file as a response
return FileResponse("outputs/history.txt", media_type="text/plain", filename=f"{user_id}_history.txt")
@app.get("/audio", tags=["audio"])
async def get_audio() -> FileResponse:
"""
Function to return the most recent AI response as audio file.
"""
return FileResponse("outputs/output.mp3", media_type="audio/mpeg", filename="output.mp3")
| [
"You are a helpful assistant."
] |
2024-01-10 | boluknursena/deep-Q-networks | common~wrappers.py | # Taken from OpenAI Baselines
# https://github.com/openai/baselines
# PyTorch Wrappers taken from Higgsfield:
# https://github.com/higgsfield/RL-Adventure/blob/master/common/wrappers.py
import numpy as np
import os
os.environ.setdefault('PATH', '')
from collections import deque
import gym
from gym import spaces
import cv2
cv2.ocl.setUseOpenCL(False)
class TimeLimit(gym.Wrapper):
def __init__(self, env, max_episode_steps=None):
super(TimeLimit, self).__init__(env)
self._max_episode_steps = max_episode_steps
self._elapsed_steps = 0
def step(self, ac):
observation, reward, done, info = self.env.step(ac)
self._elapsed_steps += 1
if self._elapsed_steps >= self._max_episode_steps:
done = True
info['TimeLimit.truncated'] = True
return observation, reward, done, info
def reset(self, **kwargs):
self._elapsed_steps = 0
return self.env.reset(**kwargs)
class ClipActionsWrapper(gym.Wrapper):
def step(self, action):
import numpy as np
action = np.nan_to_num(action)
action = np.clip(action, self.action_space.low, self.action_space.high)
return self.env.step(action)
def reset(self, **kwargs):
return self.env.reset(**kwargs)
class NoopResetEnv(gym.Wrapper):
def __init__(self, env, noop_max=30):
"""Sample initial states by taking random number of no-ops on reset.
No-op is assumed to be action 0.
"""
gym.Wrapper.__init__(self, env)
self.noop_max = noop_max
self.override_num_noops = None
self.noop_action = 0
assert env.unwrapped.get_action_meanings()[0] == 'NOOP'
def reset(self, **kwargs):
""" Do no-op action for a number of steps in [1, noop_max]."""
self.env.reset(**kwargs)
if self.override_num_noops is not None:
noops = self.override_num_noops
else:
noops = self.unwrapped.np_random.randint(1, self.noop_max + 1) #pylint: disable=E1101
assert noops > 0
obs = None
for _ in range(noops):
obs, _, done, _ = self.env.step(self.noop_action)
if done:
obs = self.env.reset(**kwargs)
return obs
def step(self, ac):
return self.env.step(ac)
class FireResetEnv(gym.Wrapper):
def __init__(self, env):
"""Take action on reset for environments that are fixed until firing."""
gym.Wrapper.__init__(self, env)
assert env.unwrapped.get_action_meanings()[1] == 'FIRE'
assert len(env.unwrapped.get_action_meanings()) >= 3
def reset(self, **kwargs):
self.env.reset(**kwargs)
obs, _, done, _ = self.env.step(1)
if done:
self.env.reset(**kwargs)
obs, _, done, _ = self.env.step(2)
if done:
self.env.reset(**kwargs)
return obs
def step(self, ac):
return self.env.step(ac)
class EpisodicLifeEnv(gym.Wrapper):
def __init__(self, env):
"""Make end-of-life == end-of-episode, but only reset on true game over.
Done by DeepMind for the DQN and co. since it helps value estimation.
"""
gym.Wrapper.__init__(self, env)
self.lives = 0
self.was_real_done = True
def step(self, action):
obs, reward, done, info = self.env.step(action)
self.was_real_done = done
# check current lives, make loss of life terminal,
# then update lives to handle bonus lives
lives = self.env.unwrapped.ale.lives()
if lives < self.lives and lives > 0:
# for Qbert sometimes we stay in lives == 0 condition for a few frames
# so it's important to keep lives > 0, so that we only reset once
# the environment advertises done.
done = True
self.lives = lives
return obs, reward, done, info
def reset(self, **kwargs):
"""Reset only when lives are exhausted.
This way all states are still reachable even though lives are episodic,
and the learner need not know about any of this behind-the-scenes.
"""
if self.was_real_done:
obs = self.env.reset(**kwargs)
else:
# no-op step to advance from terminal/lost life state
obs, _, _, _ = self.env.step(0)
self.lives = self.env.unwrapped.ale.lives()
return obs
class MaxAndSkipEnv(gym.Wrapper):
def __init__(self, env, skip=4):
"""Return only every `skip`-th frame"""
gym.Wrapper.__init__(self, env)
# most recent raw observations (for max pooling across time steps)
self._obs_buffer = np.zeros((2,)+env.observation_space.shape, dtype=np.uint8)
self._skip = skip
def step(self, action):
"""Repeat action, sum reward, and max over last observations."""
total_reward = 0.0
done = None
for i in range(self._skip):
obs, reward, done, info = self.env.step(action)
if i == self._skip - 2: self._obs_buffer[0] = obs
if i == self._skip - 1: self._obs_buffer[1] = obs
total_reward += reward
if done:
break
# Note that the observation on the done=True frame
# doesn't matter
max_frame = self._obs_buffer.max(axis=0)
return max_frame, total_reward, done, info
def reset(self, **kwargs):
return self.env.reset(**kwargs)
class ClipRewardEnv(gym.RewardWrapper):
def __init__(self, env):
gym.RewardWrapper.__init__(self, env)
def reward(self, reward):
"""Bin reward to {+1, 0, -1} by its sign."""
return np.sign(reward)
class WarpFrame(gym.ObservationWrapper):
def __init__(self, env, width=84, height=84, grayscale=True, dict_space_key=None):
"""
Warp frames to 84x84 as done in the Nature paper and later work.
If the environment uses dictionary observations, `dict_space_key` can be specified which indicates which
observation should be warped.
"""
super().__init__(env)
self._width = width
self._height = height
self._grayscale = grayscale
self._key = dict_space_key
if self._grayscale:
num_colors = 1
else:
num_colors = 3
new_space = gym.spaces.Box(
low=0,
high=255,
shape=(self._height, self._width, num_colors),
dtype=np.uint8,
)
if self._key is None:
original_space = self.observation_space
self.observation_space = new_space
else:
original_space = self.observation_space.spaces[self._key]
self.observation_space.spaces[self._key] = new_space
assert original_space.dtype == np.uint8 and len(original_space.shape) == 3
def observation(self, obs):
if self._key is None:
frame = obs
else:
frame = obs[self._key]
if self._grayscale:
frame = cv2.cvtColor(frame, cv2.COLOR_RGB2GRAY)
frame = cv2.resize(
frame, (self._width, self._height), interpolation=cv2.INTER_AREA
)
if self._grayscale:
frame = np.expand_dims(frame, -1)
if self._key is None:
obs = frame
else:
obs = obs.copy()
obs[self._key] = frame
return obs
class FrameStack(gym.Wrapper):
def __init__(self, env, k):
"""Stack k last frames.
Returns lazy array, which is much more memory efficient.
See Also
--------
baselines.common.atari_wrappers.LazyFrames
"""
gym.Wrapper.__init__(self, env)
self.k = k
self.frames = deque([], maxlen=k)
shp = env.observation_space.shape
self.observation_space = spaces.Box(low=0, high=255, shape=(shp[:-1] + (shp[-1] * k,)), dtype=env.observation_space.dtype)
def reset(self):
ob = self.env.reset()
for _ in range(self.k):
self.frames.append(ob)
return self._get_ob()
def step(self, action):
ob, reward, done, info = self.env.step(action)
self.frames.append(ob)
return self._get_ob(), reward, done, info
def _get_ob(self):
assert len(self.frames) == self.k
return LazyFrames(list(self.frames))
class ScaledFloatFrame(gym.ObservationWrapper):
def __init__(self, env):
gym.ObservationWrapper.__init__(self, env)
self.observation_space = gym.spaces.Box(low=0, high=1, shape=env.observation_space.shape, dtype=np.float32)
def observation(self, observation):
# careful! This undoes the memory optimization, use
# with smaller replay buffers only.
return np.array(observation).astype(np.float32) / 255.0
class LazyFrames(object):
def __init__(self, frames):
"""This object ensures that common frames between the observations are only stored once.
It exists purely to optimize memory usage which can be huge for DQN's 1M frames replay
buffers.
This object should only be converted to numpy array before being passed to the model.
You'd not believe how complex the previous solution was."""
self._frames = frames
self._out = None
def _force(self):
if self._out is None:
self._out = np.concatenate(self._frames, axis=-1)
self._frames = None
return self._out
def __array__(self, dtype=None):
out = self._force()
if dtype is not None:
out = out.astype(dtype)
return out
def __len__(self):
return len(self._force())
def __getitem__(self, i):
return self._force()[i]
def count(self):
frames = self._force()
return frames.shape[frames.ndim - 1]
def frame(self, i):
return self._force()[..., i]
def make_atari(env_id, max_episode_steps=None):
env = gym.make(env_id)
assert 'NoFrameskip' in env.spec.id
env = NoopResetEnv(env, noop_max=30)
env = MaxAndSkipEnv(env, skip=4)
if max_episode_steps is not None:
env = TimeLimit(env, max_episode_steps=max_episode_steps)
return env
def wrap_deepmind(env, episode_life=True, clip_rewards=True, frame_stack=False, scale=False):
"""Configure environment for DeepMind-style Atari.
"""
if episode_life:
env = EpisodicLifeEnv(env)
if 'FIRE' in env.unwrapped.get_action_meanings():
env = FireResetEnv(env)
env = WarpFrame(env)
if scale:
env = ScaledFloatFrame(env)
if clip_rewards:
env = ClipRewardEnv(env)
if frame_stack:
env = FrameStack(env, 4)
return env
class ImageToPyTorch(gym.ObservationWrapper):
"""
Image shape to num_channels x weight x height
"""
def __init__(self, env):
super(ImageToPyTorch, self).__init__(env)
old_shape = self.observation_space.shape
self.observation_space = gym.spaces.Box(low=0.0, high=1.0, shape=(old_shape[-1], old_shape[0], old_shape[1]), dtype=np.uint8)
def observation(self, observation):
return np.swapaxes(observation, 2, 0)
def wrap_pytorch(env):
return ImageToPyTorch(env) | [] |
2024-01-10 | saleha-muzammil/urdu-voice-chatbot | script.py | from flask import Flask, request, jsonify
from flask_cors import CORS
import openai
app = Flask(__name__)
CORS(app)
openai.api_key = "your key"
@app.route("/process_speech", methods=["POST"])
def process_speech():
print("received speech")
data = request.json
transcript = data["speech"]
messages = [
{"role": "user", "content": transcript},
{"role": "system", "content": "You are a chatbot who only replies in Urdu to the user."}
]
response = openai.ChatCompletion.create(
model="gpt-3.5-turbo",
messages=messages,
max_tokens=200,
n=1,
stop=None,
temperature=0.5
)
chatbot_response = response['choices'][0]['message']['content']
print(chatbot_response)
return jsonify({"response": chatbot_response})
if __name__ == "__main__":
app.run(debug=True)
| [
"You are a chatbot who only replies in Urdu to the user."
] |
2024-01-10 | RoboticsLabURJC/2019-tfm-ignacio-arranz | gym-gazebo~gym_gazebo~envs~gazebo_env.py | import gym
import rospy
#import roslaunch
import sys
import os
import signal
import subprocess
import time
from std_srvs.srv import Empty
import random
from rosgraph_msgs.msg import Clock
class GazeboEnv(gym.Env):
"""
Superclass for all Gazebo environments.
"""
metadata = {'render.modes': ['human']}
def __init__(self, launchfile):
self.last_clock_msg = Clock()
self.port = "11311" # str(random_number) #os.environ["ROS_PORT_SIM"]
self.port_gazebo = "11345" # str(random_number+1) #os.environ["ROS_PORT_SIM"]
# self.ros_master_uri = os.environ["ROS_MASTER_URI"];
print("\nROS_MASTER_URI = http://localhost:" + self.port + "\n")
print("GAZEBO_MASTER_URI =http://localhost:" + self.port_gazebo + "\n")
# self.port = os.environ.get("ROS_PORT_SIM", "11311")
ros_path = os.path.dirname(subprocess.check_output(["which", "roscore"]))
# NOTE: It doesn't make sense to launch a roscore because it will be done when spawing Gazebo, which also need
# to be the first node in order to initialize the clock.
# # start roscore with same python version as current script
# self._roscore = subprocess.Popen([sys.executable, os.path.join(ros_path, b"roscore"), "-p", self.port])
# time.sleep(1)
# print ("Roscore launched!")
if launchfile.startswith("/"):
fullpath = launchfile
else:
fullpath = os.path.join(os.path.dirname(__file__), "assets", "launch", launchfile)
if not os.path.exists(fullpath):
raise IOError("File "+fullpath+" does not exist")
self._roslaunch = subprocess.Popen([sys.executable, os.path.join(ros_path, b"roslaunch"), "-p", self.port, fullpath])
print ("Gazebo launched!")
self.gzclient_pid = 0
# Launch the simulation with the given launchfile name
rospy.init_node('gym', anonymous=True)
################################################################################################################
# r = rospy.Rate(1)
# self.clock_sub = rospy.Subscriber('/clock', Clock, self.callback, queue_size=1000000)
# while not rospy.is_shutdown():
# print("initialization: ", rospy.rostime.is_rostime_initialized())
# print("Wallclock: ", rospy.rostime.is_wallclock())
# print("Time: ", time.time())
# print("Rospyclock: ", rospy.rostime.get_rostime().secs)
# # print("/clock: ", str(self.last_clock_msg))
# last_ros_time_ = self.last_clock_msg
# print("Clock:", last_ros_time_)
# # print("Waiting for synch with ROS clock")
# # if wallclock == False:
# # break
# r.sleep()
################################################################################################################
# def callback(self, message):
# """
# Callback method for the subscriber of the clock topic
# :param message:
# :return:
# """
# # self.last_clock_msg = int(str(message.clock.secs) + str(message.clock.nsecs)) / 1e6
# # print("Message", message)
# self.last_clock_msg = message
# # print("Message", message)
def step(self, action):
# Implement this method in every subclass
# Perform a step in gazebo. E.g. move the robot
raise NotImplementedError
def reset(self):
# Implemented in subclass
raise NotImplementedError
def _render(self, mode="human", close=False):
if close:
tmp = os.popen("ps -Af").read()
proccount = tmp.count('gzclient')
if proccount > 0:
if self.gzclient_pid != 0:
os.kill(self.gzclient_pid, signal.SIGTERM)
os.wait()
return
tmp = os.popen("ps -Af").read()
proccount = tmp.count('gzclient')
if proccount < 1:
subprocess.Popen("gzclient")
self.gzclient_pid = int(subprocess.check_output(["pidof","-s","gzclient"]))
else:
self.gzclient_pid = 0
def _close(self):
# Kill gzclient, gzserver and roscore
tmp = os.popen("ps -Af").read()
gzclient_count = tmp.count('gzclient')
gzserver_count = tmp.count('gzserver')
roscore_count = tmp.count('roscore')
rosmaster_count = tmp.count('rosmaster')
if gzclient_count > 0:
os.system("killall -9 gzclient")
if gzserver_count > 0:
os.system("killall -9 gzserver")
if rosmaster_count > 0:
os.system("killall -9 rosmaster")
if roscore_count > 0:
os.system("killall -9 roscore")
if (gzclient_count or gzserver_count or roscore_count or rosmaster_count >0):
os.wait()
def _configure(self):
# TODO
# From OpenAI API: Provides runtime configuration to the enviroment
# Maybe set the Real Time Factor?
pass
def _seed(self):
# TODO
# From OpenAI API: Sets the seed for this env's random number generator(s)
pass
| [] |
2024-01-10 | Kodylow/chat-ln-final | flask_app.py |
from langchain.text_splitter import RecursiveCharacterTextSplitter
from flask import Flask, request, jsonify
import requests
import shutil
import os
import tempfile
import subprocess
from langchain.document_loaders import UnstructuredMarkdownLoader, PyPDFLoader, ReadTheDocsLoader, GitLoader
from langchain.vectorstores import Pinecone
from langchain.embeddings.openai import OpenAIEmbeddings
import pinecone
import glob
app = Flask(__name__)
OPENAI_API_KEY = os.environ.get('OPENAI_API_KEY')
PINECONE_API_KEY = os.environ.get('PINECONE_API_KEY')
PINECONE_API_ENV = 'us-east4-gcp'
pinecone.init(
api_key=PINECONE_API_KEY,
environment=PINECONE_API_ENV
)
embeddings = OpenAIEmbeddings(openai_api_key=OPENAI_API_KEY, model="text-embedding-ada-002")
index_name = "chatln"
def is_zero_content(content, threshold=0.9):
zero_count = content.count('0')
if zero_count / len(content) >= threshold:
print("Zero content detected")
return True
return False
def load_markdown_files(repo_path):
markdown_files = glob.glob(os.path.join(repo_path, "**/*.md"), recursive=True)
return markdown_files
@app.route('/load_documents', methods=['POST'])
def load_documents():
data = request.get_json()
url = data.get('url')
loader_type = data.get('loader_type')
branch = data.get('branch')
with tempfile.TemporaryDirectory() as temp_dir:
# subprocess.run(["git", "clone", url, temp_dir])
if loader_type == 'github':
print("Running git loader")
loader = GitLoader(
clone_url=url,
repo_path=temp_dir,
branch=branch,
file_filter=lambda file_path: file_path.endswith(".asciidoc")
)
print("Loading documents")
data = loader.load()
elif loader_type == 'pdf':
loader = PyPDFLoader(url)
data = loader.load()
elif loader_type == 'readTheDocs':
loader = ReadTheDocsLoader(url)
data = loader.load()
else:
return jsonify({'error': 'Invalid loader type'}), 400
print("Running text splitter")
text_splitter = RecursiveCharacterTextSplitter(chunk_size=8000, chunk_overlap=1000)
texts = text_splitter.split_documents(data)
# Filter out texts with too many zeros
texts = [t for t in texts if not is_zero_content(t.page_content)]
# Update metadata for each text
for text in texts:
text.metadata['url'] = url
print("Texts:", texts[0])
metadatas = [t.metadata for t in texts]
docsearch = Pinecone.from_texts([t.page_content for t in texts], embeddings, index_name=index_name, metadatas=metadatas)
return jsonify({'message': 'Documents loaded successfully'}), 200
if __name__ == '__main__':
app.run(debug=True)
| [] |
2024-01-10 | neale/alf | alf~examples~ac_breakout_conf.py | # Copyright (c) 2021 Horizon Robotics and ALF Contributors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import functools
import alf
from alf.algorithms.actor_critic_algorithm import ActorCriticAlgorithm
from alf.algorithms.agent import Agent
from alf.networks import ActorDistributionNetwork, CategoricalProjectionNetwork, ValueNetwork
from alf.examples import atari_conf
# From OpenAI gym wiki:
# "v0 vs v4: v0 has repeat_action_probability of 0.25
# (meaning 25% of the time the previous action will be used instead of the new action),
# while v4 has 0 (always follow your issued action)
# Because we already implements frame_skip in AtariPreprocessing, we should always
# use 'NoFrameSkip' Atari environments from OpenAI gym
alf.config(
'create_environment',
env_name='BreakoutNoFrameskip-v4',
num_parallel_environments=64)
# Neural Network Configuration
CONV_LAYER_PARAMS = ((32, 8, 4), (64, 4, 2), (64, 3, 1))
actor_network_cls = functools.partial(
ActorDistributionNetwork,
fc_layer_params=(512, ),
conv_layer_params=CONV_LAYER_PARAMS)
value_network_cls = functools.partial(
ValueNetwork, fc_layer_params=(512, ), conv_layer_params=CONV_LAYER_PARAMS)
alf.config('CategoricalProjectionNetwork', logits_init_output_factor=1e-10)
# Algorithm Configuration
alf.config(
'ActorCriticLoss',
entropy_regularization=0.01,
use_gae=True,
use_td_lambda_return=True,
td_lambda=0.95,
td_loss_weight=0.5,
advantage_clip=None)
alf.config(
'ActorCriticAlgorithm',
actor_network_ctor=actor_network_cls,
value_network_ctor=value_network_cls,
optimizer=alf.optimizers.Adam(lr=1e-3))
alf.config('Agent', rl_algorithm_cls=ActorCriticAlgorithm)
alf.config(
'TrainerConfig',
unroll_length=8,
algorithm_ctor=Agent,
num_iterations=0,
num_env_steps=5000000,
evaluate=False,
debug_summaries=1,
summarize_grads_and_vars=1,
summary_interval=10)
| [] |
2024-01-10 | kosovaniru/image-answer_bots | telegram_bot_progect~image%26answer_bot.py | import cohere
import telebot
import requests
import os
import base64
from dotenv import load_dotenv, find_dotenv
from telebot import types
import threading
import time
load_dotenv(find_dotenv())
class ImageBot:
def __init__(self):
self.tg_bot_image = telebot.TeleBot(os.getenv('TG_IMAGE_BOT'))
self.api_host = os.getenv('API_HOST')
self.api_key = os.getenv('API_KEY')
self.engine_id = os.getenv('ENGINE_ID')
@self.tg_bot_image.message_handler(commands=['start'])
def start(message):
self.tg_bot_image.send_message(message.chat.id, f'Hi, {message.from_user.first_name}! What do you want to generate?')
@self.tg_bot_image.message_handler(commands=['help'])
def to_help(message):
self.tg_bot_image.send_message(message.chat.id,'Hello! I am MustiCanvasBot, a bot that will help you generate photos. All you need to do is just tell me what you want, and I will try to generate it!')
@self.tg_bot_image.message_handler(content_types=['text'])
def get_photo(message):
message_user = message.text.lower()
response = requests.post(f"{self.api_host}/v1/generation/{self.engine_id}/text-to-image", headers={
"Content-Type": "application/json",
"Accept": "application/json",
"Authorization": f"Bearer {self.api_key}"
}, json={
"text_prompts": [
{
"text": message_user
}
],
"cfg_scale": 7,
"clip_guidance_preset": "FAST_BLUE",
"height": 512,
"width": 512,
"samples": 1,
"steps": 30,
})
data = response.json()
for i, image in enumerate(data["artifacts"]):
with open(f"./text_to_image_{i}.png", "wb") as f:
f.write(base64.b64decode(image["base64"]))
with open(f"./text_to_image_{i}.png", "rb") as photo:
markup = types.InlineKeyboardMarkup()
btn1 = types.InlineKeyboardButton('Delete image', callback_data='delete')
markup.row(btn1)
self.tg_bot_image.send_photo(message.chat.id, photo, reply_markup=markup)
@self.tg_bot_image.callback_query_handler(func=lambda callback: True)
def delete(callback):
if callback.data == 'delete':
self.tg_bot_image.delete_message(callback.message.chat.id, callback.message.message_id - 0)
def run_polling(self):
self.tg_bot_image.polling(none_stop=True)
class AnswerBot:
def __init__(self):
self.tg_bot_answer = telebot.TeleBot(os.getenv('TG_ANSWER_BOT'))
self.coherent = cohere.Client(os.getenv('COHERENT'))
@self.tg_bot_answer.message_handler(commands=['start'])
def send_hello(message):
self.tg_bot_answer.send_message(message.chat.id, f'Hi, {message.from_user.first_name}! What is your question?')
@self.tg_bot_answer.message_handler(commands=['help'])
def info(message):
self.tg_bot_answer.send_message(message.chat.id,
'Hello! I am InsightIQBot, a bot that will help you get answers to your questions! Just write your question to me, and I will generate an answer for you!"')
@self.tg_bot_answer.message_handler(content_types=['text'])
def get_info(message):
text_from_user = message.text.lower()
response = self.coherent.chat(
text_from_user,
model="command",
temperature=0.9
)
answer = response.text
self.tg_bot_answer.send_message(message.chat.id, answer)
def run_polling(self):
self.tg_bot_answer.polling(none_stop=True)
if __name__ == '__main__':
image_bot = ImageBot()
answer_bot = AnswerBot()
image_thread = threading.Thread(target=image_bot.run_polling)
answer_thread = threading.Thread(target=answer_bot.run_polling)
image_thread.start()
answer_thread.start()
image_thread.join()
answer_thread.join()
| [] |
2024-01-10 | meilymiji/justanoobprogrammie | jrwriter.py | import streamlit as st
import openai
import json
import pandas as pd
user_api_key = st.sidebar.text_input("OpenAI API key", type="password")
client = openai.OpenAI(api_key=user_api_key)
prompt1 = """Act as a high school student writing a paragraph in English. You will recieve a topic that contains the topic's objective and some background information. Write a paragraph that related to the topic. The paragraph should be at least 80 words. You can write more than one paragraph. The words should be at least 8 words."""
st.title('Your Junior Writer')
st.markdown('Input the topic. \n Do not forget to put an objective and some background information in the topic :)')
user_input = st.text_area("Enter an objective and some background information")
#ไม่อยู่ในกล่องข้อความ
if st.button('Submit'):
messages_so_far = [
{"role": "system", "content": prompt1},
{'role': 'user', 'content': user_input},
]
response1 = client.chat.completions.create(
model="gpt-3.5-turbo",
messages=messages_so_far
)
paragraph = response1.choices[0].message.content
prompt2 = """Act as a high school teacher. You will receive a paragraph. List the words that a high school student should know from the given paragraph in JSON array. Each word should have the part of speech of that word ,the difficulty of that word, the meaning of that word and the example usage in other context. The list should be at least 8 words."""
messages_so_far = [
{"role": "system", "content": prompt2},
{'role': 'user', 'content': paragraph},
]
response2 = client.chat.completions.create(
model="gpt-3.5-turbo",
messages=messages_so_far
)
st.write('**Paragraph:**')
st.write(paragraph)
st.markdown('**Vocabulary List:**')
vocab_dict = response2.choices[0].message.content
sd = json.loads(vocab_dict)
vocab_df = pd.DataFrame.from_dict(sd)
st.write(vocab_df)
st.write("**Please do not copy all of the paragraph, try to write it by yourself first. You can do it:)**") | [
"Act as a high school student writing a paragraph in English. You will recieve a topic that contains the topic's objective and some background information. Write a paragraph that related to the topic. The paragraph should be at least 80 words. You can write more than one paragraph. The words should be at least 8 words.",
"Act as a high school teacher. You will receive a paragraph. List the words that a high school student should know from the given paragraph in JSON array. Each word should have the part of speech of that word ,the difficulty of that word, the meaning of that word and the example usage in other context. The list should be at least 8 words."
] |
2024-01-10 | dengxinkai/cpanlp_streamlit | intelligent-report~kedu.py | import streamlit as st
import numpy as np
import pandas as pd
import tempfile
import re
import os
import time
import pinecone
from typing import List, Union,Callable,Dict, Optional, Any
from langchain.prompts import PromptTemplate
from langchain.document_loaders import PyPDFLoader,Docx2txtLoader,UnstructuredPowerPointLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.chains import RetrievalQA
from langchain import LLMChain
from langchain.embeddings import OpenAIEmbeddings
from langchain.chat_models import ChatOpenAI
from langchain.callbacks import get_openai_callback
from langchain.vectorstores import Pinecone
import asyncio
st.set_page_config(
page_title="ChatReport",
page_icon="https://raw.githubusercontent.com/dengxinkai/cpanlp_streamlit/main/app/%E6%9C%AA%E5%91%BD%E5%90%8D.png",
layout="wide",
initial_sidebar_state="expanded",
menu_items={
'Get Help': 'https://www.cpanlp.com/',
'Report a bug': "https://www.cpanlp.com/",
'About': "智能报告"
}
)
def web_file_pdf(input_text):
loader = PyPDFLoader(input_text)
documents = loader.load()
text_splitter = RecursiveCharacterTextSplitter(
chunk_size=chunk_size,
chunk_overlap=chunk_overlap,
length_function=len,
)
texts = text_splitter.split_documents(documents)
Pinecone.from_documents(texts, embeddings_cho, index_name="kedu",namespace=pinename)
st.success(f"已上传来自 PDF 文件的 {len(texts)} 个文档。”")
st.cache_data.clear()
def web_file_pptx(input_text):
loader = UnstructuredPowerPointLoader(input_text)
documents = loader.load()
text_splitter = RecursiveCharacterTextSplitter(
chunk_size=chunk_size,
chunk_overlap=chunk_overlap,
length_function=len,
)
texts = text_splitter.split_documents(documents)
Pinecone.from_documents(texts, embeddings_cho, index_name="kedu",namespace=pinename)
st.success(f"已上传来自 PPTX 文件的 {len(texts)} 个文档。”")
st.cache_data.clear()
def web_file_docx(input_text):
loader = Docx2txtLoader(input_text)
documents = loader.load()
text_splitter = RecursiveCharacterTextSplitter(
chunk_size=chunk_size,
chunk_overlap=chunk_overlap,
length_function=len,
)
texts = text_splitter.split_documents(documents)
Pinecone.from_documents(texts, embeddings_cho, index_name="kedu",namespace=pinename)
st.success(f"已上传来自 DOCX 文件的 {len(texts)} 个文档。”")
st.cache_data.clear()
# @st.cache_resource
def upload_file_pdf():
with tempfile.NamedTemporaryFile(delete=False) as tmp_file:
tmp_file.write(file.read())
tmp_file.flush()
loader = PyPDFLoader(tmp_file.name)
documents = loader.load()
text_splitter = RecursiveCharacterTextSplitter(
chunk_size=chunk_size,
chunk_overlap=chunk_overlap,
length_function=len,
)
texts = text_splitter.split_documents(documents)
Pinecone.from_documents(texts, embeddings_cho, index_name="kedu",namespace=pinename)
st.success(f"已上传来自 PDF 文件的 {len(texts)} 个文档。”")
st.cache_data.clear()
def upload_file_pptx():
with tempfile.NamedTemporaryFile(delete=False) as tmp_file:
tmp_file.write(file.read())
tmp_file.flush()
loader = UnstructuredPowerPointLoader(tmp_file.name)
documents = loader.load()
text_splitter = RecursiveCharacterTextSplitter(
chunk_size=chunk_size,
chunk_overlap=chunk_overlap,
length_function=len,
)
texts = text_splitter.split_documents(documents)
Pinecone.from_documents(texts, embeddings_cho, index_name="kedu",namespace=pinename)
st.success(f"已上传来自 PPTX 文件的 {len(texts)} 个文档。”")
st.cache_data.clear()
def upload_file_docx():
with tempfile.NamedTemporaryFile(delete=False) as tmp_file:
tmp_file.write(file.read())
tmp_file.flush()
loader = Docx2txtLoader(tmp_file.name)
documents = loader.load()
text_splitter = RecursiveCharacterTextSplitter(
chunk_size=chunk_size,
chunk_overlap=chunk_overlap,
length_function=len,
)
texts = text_splitter.split_documents(documents)
Pinecone.from_documents(texts, embeddings_cho, index_name="kedu",namespace=pinename)
st.success(f"已上传来自 DOCX 文件的 {len(texts)} 个文档。”")
st.cache_data.clear()
def upload_file():
file_ext = os.path.splitext(file.name)[1].lower()
if file_ext == ".pptx":
upload_file_pptx()
elif file_ext == ".pdf":
upload_file_pdf()
elif file_ext == ".docx":
upload_file_docx()
else:
st.warning("不支持的文件类型，请上传 PPTX、DOCX 或 PDF 文件。")
def web_file(input_text):
if input_text.lower().endswith('.pptx'):
web_file_pptx(input_text)
elif input_text.lower().endswith('.pdf'):
web_file_pdf(input_text)
elif input_text.lower().endswith('.docx'):
web_file_docx(input_text)
else:
st.warning("不支持的文件类型，请上传 PPTX 、DOCX 或 PDF 文件。")
def upload_query(input_file):
ww=""
pinecone.init(api_key="1ebbc1a4-f41e-43a7-b91e-24c03ebf0114", # find at app.pinecone.io
environment="us-west1-gcp-free",
namespace=pinename
)
index = pinecone.Index(index_name="kedu")
a=embeddings_cho.embed_query(input_file)
www=index.query(vector=a, top_k=top_k, namespace=pinename, include_metadata=True)
for i in range(top_k):
ww+=www["matches"][i]["metadata"]["text"]
return ww
logo_url = "https://raw.githubusercontent.com/dengxinkai/cpanlp_streamlit/main/app/%E6%9C%AA%E5%91%BD%E5%90%8D.png"
with st.sidebar:
with st.expander("👇 :blue[**第一步：输入 OpenAI API 密钥**]"):
if 'input_api' in st.session_state:
st.text_input("api-key",st.session_state["input_api"], key="input_api")
else:
st.info('请先输入正确的OpenAI API 密钥')
st.text_input('api-key','', key="input_api",type="password")
st.write("ChatOpenAI属性配置")
temperature = st.slider("`temperature`", 0.01, 0.99, 0.3,help="用于控制生成文本随机性和多样性的参数。较高的温度值通常适用于生成较为自由流畅的文本，而较低的温度值则适用于生成更加确定性的文本。")
frequency_penalty = st.slider("`frequency_penalty`", 0.01, 0.99, 0.3,help="用于控制生成文本中单词重复频率的技术。数值越大，模型对单词重复使用的惩罚就越严格，生成文本中出现相同单词的概率就越低；数值越小，生成文本中出现相同单词的概率就越高。")
presence_penalty = st.slider("`presence_penalty`", 0.01, 0.99, 0.3,help="用于控制语言生成模型生成文本时对输入提示的重视程度的参数。presence_penalty的值较低，模型生成的文本可能与输入提示非常接近，但缺乏创意或原创性。presence_penalty设置为较高的值，模型可能生成更多样化、更具原创性但与输入提示较远的文本。")
top_p = st.slider("`top_p`", 0.01, 0.99, 0.9,help="用于控制生成文本的多样性，较小的top_p值会让模型选择的词更加确定，生成的文本会更加一致，而较大的top_p值则会让模型选择的词更加多样，生成的文本则更加多样化。")
model = st.radio("`模型选择`",
("gpt-3.5-turbo",
"gpt-4"),
index=0,key="main_model")
llm=ChatOpenAI(
model_name=model,
temperature=temperature,
frequency_penalty=frequency_penalty,
presence_penalty=presence_penalty,
top_p=top_p,
openai_api_key=st.session_state.input_api
)
with st.expander("👇 :blue[**第二步：创建自己的数据库或连接到已有数据库**]"):
pinename = st.text_input('**数据库名称**','report',key="pinename",help="系统每天定期清理数据库")
pinecone.init(api_key="1ebbc1a4-f41e-43a7-b91e-24c03ebf0114", # find at app.pinecone.io
environment="us-west1-gcp-free",
namespace=pinename
)
index = pinecone.Index(index_name="kedu")
if st.button('删除数据库',key="deletepine"):
index = pinecone.Index(index_name="kedu")
index.delete(deleteAll='true', namespace=pinename)
st.warning("⬆️ 别忘了删除不再使用的数据库")
with st.expander("👇 :blue[**第三步：选择数据库文件上传方式**]"):
fileoption = st.radio('**数据库创建方式**',('本地上传', 'URL'),key="fileoption")
chunk_size = st.number_input('chunk_size',value=800,min_value=200,max_value=2500,step=100,key="chunk_size",help='每个文本数据块的大小。例如，如果将chunk_size设置为1000，则将输入文本数据分成1000个字符的块。')
chunk_overlap = st.number_input('chunk_overlap',value=0,min_value=0,max_value=500,step=50,key="chunk_overlap",help='每个文本数据块之间重叠的字符数。例如，如果将chunk_overlap设置为200，则相邻的两个块将有200个字符的重叠。这可以确保在块之间没有丢失的数据，同时还可以避免重复处理相邻块之间的数据。')
top_k = st.number_input('top_k',value=3,min_value=0,max_value=10,step=1,key="top_k",help="用于控制查询的结果数量，指定从数据库中返回的与查询向量最相似的前 k 个向量")
embeddings_cho = OpenAIEmbeddings(openai_api_key=st.session_state.input_api)
with st.expander("👇 :blue[**第四步：数据上传**]"):
if fileoption=="本地上传":
file = st.file_uploader("上传文件（支持格式包括：PPTX、DOCX和PDF）", type=("pptx",'pdf','docx'),key="upload")
if file is not None:
with st.spinner('Wait for it...'):
upload_file()
else:
input_text = st.text_input('文件网址（支持格式包括：PPTX、DOCX 和 PDF）', 'http://static.cninfo.com.cn/finalpage/2023-04-29/1216712300.PDF',key="webupload")
if st.button('载入数据库',key="pdfw"):
with st.spinner('Wait for it...'):
pinecone.init(api_key="1ebbc1a4-f41e-43a7-b91e-24c03ebf0114", # find at app.pinecone.io
environment="us-west1-gcp-free",
namespace=pinename
)
index = pinecone.Index(index_name="kedu")
web_file(input_text)
st.cache_data.clear()
@st.cache_data(persist="disk")
def convert_df(df):
return df.to_csv(index=False).encode('utf-8')
if st.button('刷新页面',key="rerun"):
st.experimental_rerun()
st.cache_data.clear()
if st.session_state.input_api:
do_question=[]
do_answer=[]
with get_openai_callback() as cb:
#主要功能
input_files = st.text_input('**批量查询**','#公司名称#公司产品',key="file_webss",help="不同问题用#隔开，比如：公司收入#公司名称#公司前景")
if st.button('数据库批量查询',key="file_uploads1"):
input_list = re.split(r'#', input_files)[1:]
async def upload_all_files_async(input_list):
do_question, do_answer = [], []
tasks = []
for input_file in input_list:
task = asyncio.create_task(upload_query_async(input_file))
tasks.append(task)
results = await asyncio.gather(*tasks)
with st.expander("数据库查询结果", expanded=True):
for key, inter_result in zip(input_list, results):
st.write(key)
st.success(inter_result)
do_question.append(key)
do_answer.append(inter_result)
return do_question,do_answer
async def upload_query_async(input_file):
ww=""
pinecone.init(api_key="1ebbc1a4-f41e-43a7-b91e-24c03ebf0114", # find at app.pinecone.io
environment="us-west1-gcp-free",
namespace=pinename
)
index = pinecone.Index(index_name="kedu")
a=embeddings_cho.embed_query(input_file)
www=index.query(vector=a, top_k=top_k, namespace=pinename, include_metadata=True)
for i in range(top_k):
ww+=www["matches"][i]["metadata"]["text"]
return ww
do_question, do_answer=asyncio.run(upload_all_files_async(input_list))
if st.button('AI批量查询',key="aifile_uploadss",type="primary"):
with st.spinner('Wait for it...'):
start_time = time.time()
input_list = re.split(r'#', input_files)[1:]
async def upload_all_files_async(input_list):
do_question, do_answer = [], []
tasks = []
for input_file in input_list:
task = asyncio.create_task(upload_query_async(input_file))
tasks.append(task)
results = await asyncio.gather(*tasks)
with st.expander("AI查询结果", expanded=True):
for key, inter_result in zip(input_list, results):
st.write(key)
st.success(inter_result)
do_question.append(key)
do_answer.append(inter_result)
return do_question,do_answer
async def upload_query_async(input_file):
ww=""
ww1=""
pinecone.init(api_key="1ebbc1a4-f41e-43a7-b91e-24c03ebf0114", # find at app.pinecone.io
environment="us-west1-gcp-free",
namespace='ceshi'
)
index = pinecone.Index(index_name="kedu")
start_time = time.time()
a=embeddings_cho.embed_query(input_file)
www=index.query(vector=a, top_k=top_k, namespace=pinename, include_metadata=True)
for i in range(top_k):
ww+=www["matches"][i]["metadata"]["text"]
template = """Use the following portion of a long document to see if any of the text is relevant to answer the question.
Return any relevant text verbatim.
Respond in Chinese.
QUESTION: {question}
=========
{summaries}
=========
FINAL ANSWER IN CHINESE:"""
prompt = PromptTemplate(
input_variables=["summaries", "question"],
template=template,
)
chain = LLMChain(prompt=prompt, llm=llm)
ww1=chain.predict(summaries=ww, question=input_file)
return ww1
do_question, do_answer=asyncio.run(upload_all_files_async(input_list))
end_time = time.time()
elapsed_time = end_time - start_time
st.write(f"项目完成所需时间: {elapsed_time:.2f} 秒")
with st.expander("费用"):
st.success(f"Total Tokens: {cb.total_tokens}")
st.success(f"Prompt Tokens: {cb.prompt_tokens}")
st.success(f"Completion Tokens: {cb.completion_tokens}")
st.success(f"Total Cost (USD): ${cb.total_cost}")
st.warning("⬆️ 使用数据库查询只需要通过 API 接口获取嵌入向量,使用 AI 查询需要使用 API 接口回答问题，并且会产生一定费用")
df_inter = pd.DataFrame({
'问题':do_question,
'回答':do_answer,
})
if do_answer:
with st.expander("回答记录"):
st.dataframe(df_inter, use_container_width=True)
csv_inter = convert_df(df_inter)
st.download_button(
"下载回答记录",
csv_inter,
"file.csv",
"text/csv",
key='download-csv_inter'
)
else:
st.header("请先输入正确的Openai api-key")
| [
"question",
"Use the following portion of a long document to see if any of the text is relevant to answer the question. \n Return any relevant text verbatim.\n Respond in Chinese.\n QUESTION: {question}\n =========\n {summaries}\n =========\n FINAL ANSWER IN CHINESE:"
] |
2024-01-10 | dengxinkai/cpanlp_streamlit | app4~app4.py | import streamlit as st
import wikipedia
import faiss
import numpy as np
import pandas as pd
import base64
import json
import os
import tempfile
import pinecone
import requests
import re
import time
from pydantic import BaseModel, Field
from collections import deque
from typing import List, Union,Callable,Dict, Optional, Any
from langchain.agents import ZeroShotAgent,AgentExecutor, LLMSingleActionAgent, AgentOutputParser,initialize_agent, Tool,AgentType,create_pandas_dataframe_agent
from langchain.prompts import StringPromptTemplate,PromptTemplate
from langchain import OpenAI, SerpAPIWrapper, LLMChain
from langchain.schema import AgentAction, AgentFinish,Document
from langchain.document_loaders import PyPDFLoader
from langchain.docstore import InMemoryDocstore
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.chains import RetrievalQA
from langchain.chains.base import Chain
from langchain.llms import OpenAI,BaseLLM
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import Chroma,FAISS
from langchain.vectorstores.base import VectorStore
from langchain.chains.mapreduce import MapReduceChain
from langchain.chains.summarize import load_summarize_chain
from langchain.chat_models import ChatOpenAI
from langchain.utilities import GoogleSearchAPIWrapper,WikipediaAPIWrapper,TextRequestsWrapper
from langchain.callbacks import get_openai_callback
from langchain.prompts.chat import (
ChatPromptTemplate,
HumanMessagePromptTemplate,
)
st.set_page_config(
page_title="可读-财报GPT",
page_icon="https://raw.githubusercontent.com/dengxinkai/cpanlp_streamlit/main/app/%E6%9C%AA%E5%91%BD%E5%90%8D.png",
layout="wide",
initial_sidebar_state="expanded",
menu_items={
'Get Help': 'https://www.cpanlp.com/',
'Report a bug': "https://www.cpanlp.com/",
'About': "可读-财报GPT"
}
)
显示 = ""
class TaskCreationChain(LLMChain):
@classmethod
def from_llm(cls, llm: BaseLLM, verbose: bool = True) -> LLMChain:
task_creation_template = (
"You are an task creation AI that uses the result of an execution agent"
" to create the main task with the following objective: {objective},"
" The last completed task has the result: {result}."
" This result was based on this task description: {task_description}."
" These are incomplete tasks: {incomplete_tasks}."
" Based on the result, create new tasks to be completed"
" by the AI system that do not overlap with incomplete tasks."
" Return the tasks as an array."
" Be careful,This model's maximum context length is 3900 tokens."
)
prompt = PromptTemplate(
template=task_creation_template,
input_variables=["result", "task_description", "incomplete_tasks", "objective"],
)
return cls(prompt=prompt, llm=llm, verbose=verbose)
class TaskPrioritizationChain(LLMChain):
@classmethod
def from_llm(cls, llm: BaseLLM, verbose: bool = True) -> LLMChain:
"""Get the response parser."""
task_prioritization_template = (
"You are an task prioritization AI tasked with cleaning the formatting of and reprioritizing"
" the following tasks: {task_names}."
" Consider the ultimate objective of your team: {objective}."
" Do not remove any tasks. Return the result as a numbered list, like:"
" 1"
" 2"
" Start the task list with number {next_task_id}."
" Be careful,This model's maximum context length is 3800 tokens."
)
prompt = PromptTemplate(
template=task_prioritization_template,
input_variables=["task_names", "next_task_id", "objective"],
)
return cls(prompt=prompt, llm=llm, verbose=verbose)
def get_next_task(task_creation_chain: LLMChain, result: Dict, task_description: str, task_list: List[str], objective: str) -> List[Dict]:
"""Get the next task."""
incomplete_tasks = ", ".join(task_list)
response = task_creation_chain.run(result=result, task_description=task_description, incomplete_tasks=incomplete_tasks, objective=objective)
new_tasks = response.split('\n')
return [{"task_name": task_name} for task_name in new_tasks if task_name.strip()]
def prioritize_tasks(task_prioritization_chain: LLMChain, this_task_id: int, task_list: List[Dict], objective: str) -> List[Dict]:
"""Prioritize tasks."""
task_names = [t["task_name"] for t in task_list]
next_task_id = int(this_task_id) + 1
response = task_prioritization_chain.run(task_names=task_names, next_task_id=next_task_id, objective=objective)
new_tasks = response.split('\n')
prioritized_task_list = []
for task_string in new_tasks:
if not task_string.strip():
continue
task_parts = task_string.strip().split(".", 1)
if len(task_parts) == 2:
task_id = task_parts[0].strip()
task_name = task_parts[1].strip()
prioritized_task_list.append({"task_id": task_id, "task_name": task_name})
return prioritized_task_list
def _get_top_tasks(vectorstore, query: str, k: int) -> List[str]:
"""Get the top k tasks based on the query."""
results = vectorstore.similarity_search_with_score(query, k=k)
if not results:
return []
sorted_results, _ = zip(*sorted(results, key=lambda x: x[1], reverse=True))
return [str(item.metadata['task']) for item in sorted_results]
def execute_task(vectorstore, execution_chain: LLMChain, objective: str, task: str, k: int = 5) -> str:
"""Execute a task."""
context = _get_top_tasks(vectorstore, query=objective, k=k)
return execution_chain.run(objective=objective, context=context, task=task)
class BabyAGI(Chain, BaseModel):
"""Controller model for the BabyAGI agent."""
task_list: deque = Field(default_factory=deque)
task_creation_chain: TaskCreationChain = Field(...)
task_prioritization_chain: TaskPrioritizationChain = Field(...)
execution_chain: AgentExecutor = Field(...)
task_id_counter: int = Field(1)
vectorstore: VectorStore = Field(init=False)
max_iterations: Optional[int] = None
class Config:
"""Configuration for this pydantic object."""
arbitrary_types_allowed = True
def add_task(self, task: Dict):
self.task_list.append(task)
def print_task_list(self):
print("\n*****TASK LIST*****\n")
for t in self.task_list:
print(str(t["task_id"]) + ": " + t["task_name"])
def print_next_task(self, task: Dict):
print("\n*****NEXT TASK*****\n")
print(str(task["task_id"]) + ": " + task["task_name"])
def print_task_result(self, result: str):
global 显示
print("\n*****TASK RESULT*****\n")
print(result)
显示+=result
@property
def input_keys(self) -> List[str]:
return ["objective"]
@property
def output_keys(self) -> List[str]:
return []
def _call(self, inputs: Dict[str, Any]) -> Dict[str, Any]:
"""Run the agent."""
objective = inputs['objective']
first_task = inputs.get("first_task", "Make a todo list")
self.add_task({"task_id": 1, "task_name": first_task})
num_iters = 0
while True:
if self.task_list:
self.print_task_list()
# Step 1: Pull the first task
task = self.task_list.popleft()
self.print_next_task(task)
# Step 2: Execute the task
result = execute_task(
self.vectorstore, self.execution_chain, objective, task["task_name"]
)
this_task_id = int(task["task_id"])
self.print_task_result(result)
# Step 3: Store the result in Pinecone
result_id = f"result_{task['task_id']}"
self.vectorstore.add_texts(
texts=[result],
metadatas=[{"task": task["task_name"]}],
ids=[result_id],
)
# Step 4: Create new tasks and reprioritize task list
new_tasks = get_next_task(
self.task_creation_chain, result, task["task_name"], [t["task_name"] for t in self.task_list], objective
)
for new_task in new_tasks:
self.task_id_counter += 1
new_task.update({"task_id": self.task_id_counter})
self.add_task(new_task)
self.task_list = deque(
prioritize_tasks(
self.task_prioritization_chain, this_task_id, list(self.task_list), objective
)
)
num_iters += 1
if self.max_iterations is not None and num_iters == self.max_iterations:
print("\n*****TASK ENDING*****\n")
break
return {}
@classmethod
def from_llm(
cls,
llm: BaseLLM,
vectorstore: VectorStore,
verbose: bool = False,
**kwargs
) -> "BabyAGI":
"""Initialize the BabyAGI Controller."""
task_creation_chain = TaskCreationChain.from_llm(
llm, verbose=verbose
)
task_prioritization_chain = TaskPrioritizationChain.from_llm(
llm, verbose=verbose
)
llm_chain = LLMChain(llm=llm, prompt=prompt)
tool_names = [tool.name for tool in tools]
agent = ZeroShotAgent(llm_chain=llm_chain, allowed_tools=tool_names)
agent_executor = AgentExecutor.from_agent_and_tools(agent=agent, tools=tools, verbose=True)
return cls(
task_creation_chain=task_creation_chain,
task_prioritization_chain=task_prioritization_chain,
execution_chain=agent_executor,
vectorstore=vectorstore,
**kwargs
)
wikipedia.set_lang("zh")
template3 = """尽量以少的token准确快速给出Final Answer,You have access to the following tools:
{tools}
Use the following format:
Question: the input question you must answer
Thought: you should always think about what to do,尽量少的token
Action: the action to take, should be one of [{tool_names}],尽量少的token
Action Input: the input to the action,尽量少的token
Observation: the result of the action,尽量少的token
Thought: I now know the final answer,尽量少的token
Final Answer: the final answer to the original input question,准确快速给出Final Answer
All inputs 、output and context tokens are totally limited to 3800.
Question: {input}
{agent_scratchpad}
都用中文表示，除了格式中的Question:Thought:Action:Action Input:Observation:Thought:Final Answer
"""
with st.sidebar:
st.info('请先输入正确的openai api-key')
st.text_input('api-key','', key="input_api")
with st.expander("ChatOpenAI属性设置"):
temperature = st.slider("`temperature`", 0.01, 0.99, 0.3)
frequency_penalty = st.slider("`frequency_penalty`", 0.01, 0.99, 0.3,help="在OpenAI GPT语言模型中，温度（temperature）是一个用于控制生成文本随机性和多样性的参数。它可以被理解为对下一个词的概率分布进行重新加权的因子，其中较高的温度值将导致更多的随机性和不确定性，而较低的温度值将导致更少的随机性和更高的确定性。通过调整温度值，可以控制生成文本的风格和多样性，以满足特定的应用需求。较高的温度值通常适用于生成较为自由流畅的文本，而较低的温度值则适用于生成更加确定性的文本。")
presence_penalty = st.slider("`presence_penalty`", 0.01, 0.99, 0.3)
top_p = st.slider("`top_p`", 0.01, 0.99, 0.3)
model = st.radio("`模型选择`",
("gpt-3.5-turbo",
"gpt-4"),
index=0)
st.title('智能财报（中国上市公司）')
tab1, tab2 = st.tabs(["问答模式(QA)", "任务模式（BabyAGI）"])
wikipedia = WikipediaAPIWrapper()
search = GoogleSearchAPIWrapper(google_api_key="AIzaSyCLKh_M6oShQ6rUJiw8UeQ74M39tlCUa9M",google_cse_id="c147e3f22fbdb4316")
logo_url = "https://raw.githubusercontent.com/dengxinkai/cpanlp_streamlit/main/app/%E6%9C%AA%E5%91%BD%E5%90%8D.png"
if st.session_state.input_api:
llm=ChatOpenAI(
model_name=model,
temperature=temperature,
frequency_penalty=frequency_penalty,
presence_penalty=presence_penalty,
top_p=top_p,
openai_api_key=st.session_state.input_api
)
embeddings = OpenAIEmbeddings(openai_api_key=st.session_state.input_api)
def 中国平安年报查询(input_text):
pinecone.init(api_key="bd20d2c3-f100-4d24-954b-c17928d1c2da", # find at app.pinecone.io
environment="us-east4-gcp", # next to api key in console
namespace="ZGPA_601318")
index = pinecone.Index(index_name="kedu")
a=embeddings.embed_query(input_text)
www=index.query(vector=a, top_k=1, namespace='ZGPA_601318', include_metadata=True)
c = [x["metadata"]["text"] for x in www["matches"]]
return c
def 双汇发展年报查询(input_text):
namespace="ShHFZ_000895"
pinecone.init(api_key="bd20d2c3-f100-4d24-954b-c17928d1c2da", # find at app.pinecone.io
environment="us-east4-gcp", # next to api key in console
namespace=namespace)
index = pinecone.Index(index_name="kedu")
a=embeddings.embed_query(input_text)
www=index.query(vector=a, top_k=1, namespace=namespace, include_metadata=True)
c = [x["metadata"]["text"] for x in www["matches"]]
return c
wiki_tool = Tool(
name="维基",
func=wikipedia.run,
description="当您需要搜索百科全书时，这个工具非常有用。输入转换为英文，输出转换为中文"
)
search_tool = Tool(
name = "Google",
func=search.run,
description="当您需要搜索互联网时，这个工具非常有用。"
)
zgpa_tool = Tool(
name = "ZGPA",
func=中国平安年报查询,
description="当您需要回答有关中国平安(601318)中文问题时，这个工具非常有用。"
)
shhfz_tool = Tool(
name = "ShHFZ",
func=双汇发展年报查询,
description="当您需要回答有关双汇发展(000895)中文问题时，这个工具非常有用。"
)
ALL_TOOLS = [zgpa_tool,shhfz_tool,search_tool,wiki_tool]
docs = [Document(page_content=t.description, metadata={"index": i}) for i, t in enumerate(ALL_TOOLS)]
vector_store = FAISS.from_documents(docs, embeddings)
retriever = vector_store.as_retriever()
def get_tools(query):
docs = retriever.get_relevant_documents(query)
return [ALL_TOOLS[d.metadata["index"]] for d in docs]
global qa
prompt_template = """Use the following pieces of context to answer the question at the end. If you don't know the answer, just say that you don't know, don't try to make up an answer.
{context}
Question: {question}
Answer in Chinese:"""
PROMPT = PromptTemplate(
template=prompt_template, input_variables=["context", "question"]
)
chain_type_kwargs = {"prompt": PROMPT}
# Set up a prompt template
class CustomPromptTemplate(StringPromptTemplate):
# The template to use
template: str
# The list of tools available
tools_getter: Callable
def format(self, **kwargs) -> str:
# Get the intermediate steps (AgentAction, Observation tuples)
# Format them in a particular way
intermediate_steps = kwargs.pop("intermediate_steps")
thoughts = ""
for action, observation in intermediate_steps:
thoughts += action.log
thoughts += f"\nObservation: {observation}\nThought: "
# Set the agent_scratchpad variable to that value
kwargs["agent_scratchpad"] = thoughts
tools = self.tools_getter(kwargs["input"])
# Create a tools variable from the list of tools provided
kwargs["tools"] = "\n".join([f"{tool.name}: {tool.description}" for tool in tools])
# Create a list of tool names for the tools provided
kwargs["tool_names"] = ", ".join([tool.name for tool in tools])
return self.template.format(**kwargs)
class CustomPromptTemplate_Upload(StringPromptTemplate):
# The template to use
template: str
# The list of tools available
tools: List[Tool]
def format(self, **kwargs) -> str:
# Get the intermediate steps (AgentAction, Observation tuples)
# Format them in a particular way
intermediate_steps = kwargs.pop("intermediate_steps")
thoughts = ""
for action, observation in intermediate_steps:
thoughts += action.log
thoughts += f"\nObservation: {observation}\nThought: "
# Set the agent_scratchpad variable to that value
kwargs["agent_scratchpad"] = thoughts
# Create a tools variable from the list of tools provided
kwargs["tools"] = "\n".join([f"{tool.name}: {tool.description}" for tool in self.tools])
# Create a list of tool names for the tools provided
kwargs["tool_names"] = ", ".join([tool.name for tool in self.tools])
return self.template.format(**kwargs)
class CustomOutputParser(AgentOutputParser):
def parse(self, llm_output: str) -> Union[AgentAction, AgentFinish]:
# Check if agent should finish
if "Final Answer:" in llm_output:
return AgentFinish(
# Return values is generally always a dictionary with a single `output` key
# It is not recommended to try anything else at the moment :)
return_values={"output": llm_output.split("Final Answer:")[-1].strip()},
log=llm_output,
)
# Parse out the action and action input
regex = r"Action: (.*?)[\n]*Action Input:[\s]*(.*)"
match = re.search(regex, llm_output, re.DOTALL)
action = match.group(1).strip()
action_input = match.group(2)
# Return the action and action input
return AgentAction(tool=action, tool_input=action_input.strip(" ").strip('"'), log=llm_output)
output_parser = CustomOutputParser()
@st.cache_resource
def 分析(input_text):
if file is not None:
with tempfile.NamedTemporaryFile(delete=False) as tmp_file:
tmp_file.write(file.read())
tmp_file.flush()
loader = PyPDFLoader(tmp_file.name)
elif input_text != "":
loader = PyPDFLoader(input_text)
else:
return None
documents = loader.load()
text_splitter = RecursiveCharacterTextSplitter(
# Set a really small chunk size, just to show.
chunk_size=200,
chunk_overlap=20,
length_function=len,
)
texts = text_splitter.split_documents(documents)
db = Chroma.from_documents(texts, embeddings)
retriever = db.as_retriever()
return RetrievalQA.from_chain_type(llm=llm, chain_type="stuff", retriever=retriever, chain_type_kwargs=chain_type_kwargs)
with tab1:
with get_openai_callback() as cb:
with st.expander("[可选]上传"):
file = st.file_uploader("PDF文件", type="pdf")
input_text = st.text_input('PDF网址', '')
qa = 分析(input_text)
input_text1 = st.text_input(':blue[查询]','')
if st.button('确认'):
start_time = time.time()
if not qa:
query = input_text1
prompt3 = CustomPromptTemplate(
template=template3,
tools_getter=get_tools,
input_variables=["input", "intermediate_steps"])
llm_chain = LLMChain(llm=llm, prompt=prompt3)
tools = [
Tool(
name = "ZGPA",
func=中国平安年报查询,
description="当您需要回答有关中国平安(601318)中文问题时，这个工具非常有用。输入是中文"
),
Tool(
name = "Google",
func=search.run,
description="当您需要搜索互联网时，这个工具非常有用。"
),
Tool(
name="维基",
func=wikipedia.run,
description="当您需要搜索百科全书时，这个工具非常有用。"
),
Tool(
name = "ShHFZ",
func=双汇发展年报查询,
description="当您需要回答有关双汇发展(000895)中文问题时，这个工具非常有用。输入是中文"
)]
tool_names = [tool.name for tool in tools]
agent3 = LLMSingleActionAgent(
llm_chain=llm_chain,
output_parser=output_parser,
stop=["\nObservation:"],
allowed_tools=tool_names
)
agent_executor = AgentExecutor.from_agent_and_tools(agent=agent3, tools=tools, verbose=True,return_intermediate_steps=True)
response = agent_executor({"input":query})
st.caption(response["output"])
with st.expander("查看过程"):
st.write(response["intermediate_steps"])
else:
query = input_text1
tools = [Tool(
name = "上传",
func=qa.run,
description="当您需要回答有关上传信息的问题时，这个工具非常有用。"
),
Tool(
name="维基",
func=wikipedia.run,
description="当您需要搜索百科全书时，这个工具非常有用。"
),
Tool(
name = "Google",
func=search.run,
description="当您需要搜索互联网时，这个工具非常有用。"
)
]
tool_names = [tool.name for tool in tools]
prompt_Upload = CustomPromptTemplate_Upload(
template=template3,
tools=tools,
input_variables=["input", "intermediate_steps"])
llm_chain = LLMChain(llm=llm, prompt=prompt_Upload)
agent3 = LLMSingleActionAgent(
llm_chain=llm_chain,
output_parser=output_parser,
stop=["\nObservation:"],
allowed_tools=tool_names
)
agent_executor = AgentExecutor.from_agent_and_tools(agent=agent3, tools=tools, verbose=True,return_intermediate_steps=True)
response = agent_executor({"input":query})
st.caption(response["output"])
with st.expander("查看过程"):
st.write(response["intermediate_steps"])
end_time = time.time()
elapsed_time = end_time - start_time
st.write(f"项目完成所需时间: {elapsed_time:.2f} 秒")
st.write(f"Total Tokens: {cb.total_tokens}")
st.write(f"Prompt Tokens: {cb.prompt_tokens}")
st.write(f"Completion Tokens: {cb.completion_tokens}")
st.write(f"Total Cost (USD): ${cb.total_cost}")
with tab2:
with get_openai_callback() as cb:
OBJECTIVE = st.text_input('提问','', key="name_input1_2")
todo_prompt = PromptTemplate.from_template("尽量以少的token准确快速给出这个目标最重要的待办事项： {objective}.")
todo_chain = LLMChain(llm=OpenAI(temperature=temperature,openai_api_key=st.session_state.input_api), prompt=todo_prompt)
tools = [
Tool(
name = "ZGPA",
func=中国平安年报查询,
description="当您需要回答有关中国平安(601318)中文问题时，这个工具非常有用。输入是中文"
),
Tool(
name = "Google",
func=search.run,
description="当您需要搜索互联网时，这个工具非常有用。"
),
Tool(
name="维基",
func=wikipedia.run,
description="当您需要搜索百科全书时，这个工具非常有用。"
),
Tool(
name = "ShHFZ",
func=双汇发展年报查询,
description="当您需要回答有关双汇发展(000895)中文问题时，这个工具非常有用。输入是中文"
),
Tool(
name = "TODO",
func=todo_chain.run,
description="此功能可用于创建待办事项清单。输入：要为其创建待办事项清单的目标。输出：该目标的最重要事项的待办事项。请非常清楚地说明目标是什么。!"
)
]
prefix = """准确快速给出任务的解答: {objective}. 考虑到先前完成的这些任务：{context}."""
suffix = """Question: {task}
{agent_scratchpad}
都用中文表示，除了格式中的提取前缀
All inputs、output and context tokens are in total limited to 3800.
最终结果用中文表示.
"""
prompt = ZeroShotAgent.create_prompt(
tools,
prefix=prefix,
suffix=suffix,
input_variables=["objective", "task", "context","agent_scratchpad"]
)
verbose=True
# If None, will keep on going forever
max_iterations: Optional[int] = 3
index = faiss.IndexFlatL2(1536)
vectorstore = FAISS(embeddings.embed_query, index, InMemoryDocstore({}), {})
baby_agi = BabyAGI.from_llm(
llm=llm,
vectorstore=vectorstore,
verbose=verbose,
max_iterations=max_iterations
)
if st.button('问答'):
start_time = time.time()
baby_agi({"objective": OBJECTIVE})
text_list = 显示.split('\n')
for i in text_list:
st.write(i)
end_time = time.time()
elapsed_time = end_time - start_time
st.write(f"项目完成所需时间: {elapsed_time:.2f} 秒")
st.write(f"Total Tokens: {cb.total_tokens}")
st.write(f"Prompt Tokens: {cb.prompt_tokens}")
st.write(f"Completion Tokens: {cb.completion_tokens}")
st.write(f"Total Cost (USD): ${cb.total_cost}")
| [
"You are an task creation AI that uses the result of an execution agent to create the main task with the following objective: {objective}, The last completed task has the result: {result}. This result was based on this task description: {task_description}. These are incomplete tasks: {incomplete_tasks}. Based on the result, create new tasks to be completed by the AI system that do not overlap with incomplete tasks. Return the tasks as an array. Be careful,This model's maximum context length is 3900 tokens.",
"task_description",
"incomplete_tasks",
"question",
"agent_scratchpad",
"尽量以少的token准确快速给出这个目标最重要的待办事项： {objective}.",
"task_names",
"尽量以少的token准确快速给出Final Answer,You have access to the following tools:\n {tools}\n Use the following format:\n Question: the input question you must answer\n Thought: you should always think about what to do,尽量少的token\n Action: the action to take, should be one of [{tool_names}],尽量少的token\n Action Input: the input to the action,尽量少的token\n Observation: the result of the action,尽量少的token\n Thought: I now know the final answer,尽量少的token\n Final Answer: the final answer to the original input question,准确快速给出Final Answer\n All inputs 、output and context tokens are totally limited to 3800.\n Question: {input}\n {agent_scratchpad}\n 都用中文表示，除了格式中的Question:Thought:Action:Action Input:Observation:Thought:Final Answer\n ",
"input",
"Use the following pieces of context to answer the question at the end. If you don't know the answer, just say that you don't know, don't try to make up an answer.\n {context}\n Question: {question}\n Answer in Chinese:",
"context",
"next_task_id",
"intermediate_steps",
"You are an task prioritization AI tasked with cleaning the formatting of and reprioritizing the following tasks: {task_names}. Consider the ultimate objective of your team: {objective}. Do not remove any tasks. Return the result as a numbered list, like: 1 2 Start the task list with number {next_task_id}. Be careful,This model's maximum context length is 3800 tokens."
] |
2024-01-10 | dengxinkai/cpanlp_streamlit | app~kedu.py | import streamlit as st
import wikipedia
import faiss
import numpy as np
import pandas as pd
import base64
import json
import os
import tempfile
import pinecone
import requests
import re
import time
from pydantic import BaseModel, Field
from collections import deque
from typing import List, Union,Callable,Dict, Optional, Any
from langchain.agents import ZeroShotAgent,AgentExecutor, LLMSingleActionAgent, AgentOutputParser,initialize_agent, Tool,AgentType,create_pandas_dataframe_agent
from langchain.prompts import StringPromptTemplate,PromptTemplate
from langchain import OpenAI, SerpAPIWrapper, LLMChain
from langchain.schema import AgentAction, AgentFinish,Document
from langchain.document_loaders import PyPDFLoader
from langchain.docstore import InMemoryDocstore
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.chains import RetrievalQA
from langchain.chains.base import Chain
from langchain.llms import OpenAI,BaseLLM
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import Chroma,FAISS
from langchain.vectorstores.base import VectorStore
from langchain.chains.mapreduce import MapReduceChain
from langchain.chains.summarize import load_summarize_chain
from langchain.chat_models import ChatOpenAI
from langchain.utilities import GoogleSearchAPIWrapper,WikipediaAPIWrapper,TextRequestsWrapper
from langchain.callbacks import get_openai_callback
from langchain.prompts.chat import (
ChatPromptTemplate,
HumanMessagePromptTemplate,
)
from utils import template3
st.set_page_config(
page_title="可读-财报GPT",
page_icon="https://raw.githubusercontent.com/dengxinkai/cpanlp_streamlit/main/app/%E6%9C%AA%E5%91%BD%E5%90%8D.png",
layout="wide",
initial_sidebar_state="expanded",
menu_items={
'Get Help': 'https://www.cpanlp.com/',
'Report a bug': "https://www.cpanlp.com/",
'About': "可读-财报GPT"
}
)
显示 = ""
st.title('智能财报（中国上市公司）')
| [] |
2024-01-10 | dengxinkai/cpanlp_streamlit | app3~app3.py | import streamlit as st
import asyncio
import faiss
import numpy as np
import pandas as pd
import re
import time
import math
from datetime import datetime, timedelta
from pydantic import BaseModel, Field
from typing import List, Union,Callable,Dict, Optional, Any, Tuple
from langchain.prompts import PromptTemplate
from langchain import LLMChain
from langchain.schema import BaseLanguageModel,Document
from langchain.docstore import InMemoryDocstore
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import FAISS
from langchain.chat_models import ChatOpenAI
from langchain.callbacks import get_openai_callback
from langchain.retrievers import TimeWeightedVectorStoreRetriever
import boto3
st.set_page_config(
page_title="数字人",
page_icon="https://raw.githubusercontent.com/dengxinkai/cpanlp_streamlit/main/app1/shuziren.jpg",
layout="wide",
initial_sidebar_state="expanded",
menu_items={
'Get Help': 'https://www.cpanlp.com/',
'Report a bug': "https://www.cpanlp.com/",
'About': '社科实验数字人'
}
)
@st.cache_resource
def load_digitalaws():
dynamodb = boto3.client(
'dynamodb',
region_name="ap-southeast-1",
aws_access_key_id=st.secrets["AWS_ACCESS_KEY_ID"],
aws_secret_access_key=st.secrets["AWS_SECRET_ACCESS_KEY"]
)
table_name = 'digit_human1'
response = dynamodb.scan(
TableName=table_name
)
items = response['Items']
dfaws = pd.DataFrame(items)
return dfaws
@st.cache_data(persist="disk")
def convert_df(df):
return df.to_csv(index=False).encode('utf-8')
with st.sidebar:
st.image("https://raw.githubusercontent.com/dengxinkai/cpanlp_streamlit/main/app1/shuziren.jpg")
with st.expander("👇 :blue[**第一步：输入 OpenAI API 密钥**]"):
if 'input_api' in st.session_state:
st.text_input(st.session_state["input_api"], key="input_api",label_visibility="collapsed")
else:
st.info('请先输入正确的openai api-key')
st.text_input('api-key','', key="input_api",type="password")
temperature = st.slider("`temperature`", 0.01, 0.99, 0.3,help="用于控制生成文本随机性和多样性的参数。较高的温度值通常适用于生成较为自由流畅的文本，而较低的温度值则适用于生成更加确定性的文本。")
frequency_penalty = st.slider("`frequency_penalty`", 0.01, 0.99, 0.3,help="用于控制生成文本中单词重复频率的技术。数值越大，模型对单词重复使用的惩罚就越严格，生成文本中出现相同单词的概率就越低；数值越小，生成文本中出现相同单词的概率就越高。")
presence_penalty = st.slider("`presence_penalty`", 0.01, 0.99, 0.3,help="用于控制语言生成模型生成文本时对输入提示的重视程度的参数。presence_penalty的值较低，模型生成的文本可能与输入提示非常接近，但缺乏创意或原创性。presence_penalty设置为较高的值，模型可能生成更多样化、更具原创性但与输入提示较远的文本。")
top_p = st.slider("`top_p`", 0.01, 0.99, 0.3,help="用于控制生成文本的多样性，较小的top_p值会让模型选择的词更加确定，生成的文本会更加一致，而较大的top_p值则会让模型选择的词更加多样，生成的文本则更加多样化。")
model = st.radio("`模型选择`",
("gpt-3.5-turbo",
"gpt-4"),
index=0)
USER_NAME = st.text_input("请填写创数人姓名","Person", key="user_name")
agent_keys = [key for key in st.session_state.keys() if key.startswith('agent')]
if st.button('刷新页面'):
st.experimental_rerun()
st.cache_data.clear()
if agent_keys:
do_traits=[]
with st.expander("当前数字人："):
for i,key in enumerate(agent_keys):
y=st.session_state[key]
col1, col2= st.columns([1, 1])
with col1:
do_traits.append(y.traits)
person=y.traits+"的人"
st.write(person)
with col2:
if st.button('删除',key=f"del_{key}"):
del st.session_state[key]
st.experimental_rerun()
df = pd.DataFrame({
'特征': do_traits
})
st.dataframe(df, use_container_width=True)
if st.button('删除所有数字人',key=f"delete_all"):
for i,key in enumerate(agent_keys):
del st.session_state[key]
st.experimental_rerun()
csv = convert_df(df)
st.download_button(
"下载数字人",
csv,
"file.csv",
"text/csv",
key='download-csv'
)
else:
st.warning("当前不存在数字人")
tab1, tab3 = st.tabs(["数字人创建", ":blue[**社科调查**]"])
LLM = ChatOpenAI(
model_name=model,
temperature=temperature,
frequency_penalty=frequency_penalty,
presence_penalty=presence_penalty,
top_p=top_p,
openai_api_key=st.session_state.input_api
)
agents={}
class GenerativeAgent(BaseModel):
traits: str
llm: BaseLanguageModel
class Config:
arbitrary_types_allowed = True
@staticmethod
def _parse_list(text: str) -> List[str]:
lines = re.split(r'\n', text.strip())
return [re.sub(r'^\s*\d+\.\s*', '', line).strip() for line in lines]
def generate_reaction(
self,
observation: str,
) -> str:
prompt = PromptTemplate.from_template(
"You are {traits} and must only give {traits} answers."
+"\nQuestion: {observation}"
+"\n{traits}answer:中文回答"
)
kwargs = dict(
traits=self.traits,
observation=observation
)
action_prediction_chain = LLMChain(llm=self.llm, prompt=prompt)
result = action_prediction_chain.run(**kwargs)
return result.strip()
def interview_agent(agent: GenerativeAgent, message: str) -> str:
new_message = f"{message}"
return (agent.traits+"的人觉得："+agent.generate_reaction(new_message))
with tab1:
with st.expander("单个创建"):
traits = st.text_input('特征','既内向也外向，渴望成功', key="name_input1_4",help="性格特征，不同特征用逗号分隔")
if st.button('创建',help="创建数字人"):
global agent1
global agentss
agent1 = GenerativeAgent(
traits=traits,
llm=LLM
)
st.session_state[f"agent_{traits}"] = agent1
st.experimental_rerun()
uploaded_file = st.file_uploader("csv文件上传批量建立", type=["csv"],help="csv格式：特征")
if uploaded_file is not None:
data = pd.read_csv(uploaded_file)
st.dataframe(data)
for index, row in data.iterrows():
traits = row['特征']
st.session_state[f"agent_{traits}"] = GenerativeAgent(
traits=traits,
llm=LLM,
)
with tab3:
if agent_keys:
do_inter_name=[]
do_inter_quesition=[]
do_inter_result=[]
interws = []
interview = st.text_input('采访','你怎么看待', key="interview")
if st.button('全部采访',help="全部采访",type="primary",key="quanbu"):
with st.expander("采访结果",expanded=True):
start_time = time.time()
with get_openai_callback() as cb:
async def interview_all_agents(agent_keys, interview):
tasks = []
for key in agent_keys:
task = asyncio.create_task(interview_agent_async(st.session_state[key], interview))
tasks.append(task)
results = await asyncio.gather(*tasks)
for key, inter_result in zip(agent_keys, results):
st.success(inter_result)
do_inter_name.append(st.session_state[key].traits)
do_inter_quesition.append(interview)
do_inter_result.append(inter_result)
return do_inter_name,do_inter_quesition, do_inter_result
async def interview_agent_async(agent, interview):
inter_result = await asyncio.to_thread(interview_agent, agent, interview)
return inter_result
do_inter_name, do_inter_quesition,do_inter_result = asyncio.run(interview_all_agents(agent_keys, interview))
st.success(f"Total Tokens: {cb.total_tokens}")
st.success(f"Prompt Tokens: {cb.prompt_tokens}")
st.success(f"Completion Tokens: {cb.completion_tokens}")
st.success(f"Total Cost (USD): ${cb.total_cost}")
end_time = time.time()
st.write(f"采访用时：{round(end_time-start_time,2)} 秒")
df_inter = pd.DataFrame({
'被采访人':do_inter_name,
'采访问题':do_inter_quesition,
'采访结果': do_inter_result,
})
if len(df_inter) > 1:
question = df_inter.loc[0, '采访问题']
merged_results = ''.join(df_inter['采访结果'])
summary_template = """用统计学的方法根据上述回答{answer},对关于{question}问题的回答进行总结，并分析结论是否有显著性?"""
summary_prompt = PromptTemplate(template=summary_template, input_variables=["answer", "question"])
llm_chain = LLMChain(prompt=summary_prompt, llm=LLM)
st.write(llm_chain.predict(answer=merged_results, question=question))
with st.expander("采访记录"):
st.dataframe(df_inter, use_container_width=True)
csv_inter = convert_df(df_inter)
st.download_button(
"下载采访记录",
csv_inter,
"file.csv",
"text/csv",
key='download-csv_inter'
)
if st.button('aws',key="aws"):
dfaws = load_digitalaws()
for index, row in dfaws.iterrows():
traits = row['特征'].get('S', '')
st.session_state[f"agent_{traits}"] = GenerativeAgent(
traits=traits,
llm=LLM,
)
| [
"\nQuestion: {observation}",
"You are {traits} and must only give {traits} answers.\nQuestion: {observation}\n{traits}answer:中文回答",
"question",
"\n{traits}answer:中文回答",
"You are {traits} and must only give {traits} answers.",
"answer",
"用统计学的方法根据上述回答{answer},对关于{question}问题的回答进行总结，并分析结论是否有显著性?"
] |
2024-01-10 | wispcarey/AutoKG | autoKG_full.py | import sys
import numpy as np
import openai
from annoy import AnnoyIndex
from scipy import sparse
from scipy.sparse import diags, csr_matrix
from sklearn.cluster import KMeans
from sklearn.metrics import pairwise_distances
from sklearn.neighbors import NearestNeighbors
import graphlearning as gl
import tiktoken
import string
import time
# graph visualization
import networkx as nx
import matplotlib.pyplot as plt
from langchain.embeddings.openai import OpenAIEmbeddings
from utils import *
class autoKG():
def __init__(self, texts: list, source: list, embedding_model: str, llm_model: str, openai_api_key: str,
main_topic: str,
embedding: bool = True):
openai.api_key = openai_api_key
self.texts = texts
self.embedding_model = embedding_model
self.llm_model = llm_model
self.source = source
self.embeddings = OpenAIEmbeddings(openai_api_key=openai_api_key)
if embedding:
self.vectors = np.array(self.embeddings.embed_documents(self.texts))
else:
self.vectors = None
self.weightmatrix = None
self.graph = None
self.encoding = tiktoken.encoding_for_model(llm_model)
if texts is None:
self.token_counts = None
else:
self.token_counts = get_num_tokens(texts, model=llm_model)
self.separator = "\n* "
self.main_topic = main_topic
# keywords graph
self.keywords = None
self.keyvectors = None
self.U_mat = None
self.pred_mat = None
self.A = None
self.dist_mat = None
# completion parameters
self.temperature = 0.1
self.top_p = 0.5
def get_embedding(self, text):
result = openai.Embedding.create(
model=self.embedding_model,
input=text
)
return result["data"][0]["embedding"]
def update_keywords(self, keyword_list):
self.keywords = keyword_list
self.keyvectors = np.array(self.embeddings.embed_documents(self.keywords))
def make_graph(self, k, method='annoy', similarity='angular', kernel='gaussian'):
knn_data = gl.weightmatrix.knnsearch(self.vectors, k, method, similarity)
W = gl.weightmatrix.knn(None, k, kernel, symmetrize=True, knn_data=knn_data)
self.weightmatrix = W
self.graph = gl.graph(W)
def remove_same_text(self, use_nn=True, n_neighbors=5, thresh=1e-6, update=True):
to_delete = set()
to_keep_set = set()
if use_nn:
nbrs = NearestNeighbors(n_neighbors=n_neighbors + 1, metric='cosine').fit(self.vectors)
distances, indices = nbrs.kneighbors(self.vectors)
for i in range(self.vectors.shape[0]):
for j, distance in zip(indices[i], distances[i]):
if i != j and distance < thresh and i not in to_delete and j not in to_delete:
if self.token_counts[i] >= self.token_counts[j]:
to_delete.add(i)
if i in to_keep_set:
to_keep_set.remove(i)
if j not in to_delete:
to_keep_set.add(j)
else:
to_delete.add(j)
if j in to_keep_set:
to_keep_set.remove(j)
if i not in to_delete:
to_keep_set.add(i)
else:
D = pairwise_distances(self.vectors, metric='cosine')
for i in range(self.vectors.shape[0]):
for j in range(i + 1, self.vectors.shape[0]):
if D[i, j] < thresh:
if self.token_counts[i] >= self.token_counts[j]:
to_delete.add(i)
if i in to_keep_set:
to_keep_set.remove(i)
if j not in to_delete:
to_keep_set.add(j)
else:
to_delete.add(j)
if j in to_keep_set:
to_keep_set.remove(j)
if i not in to_delete:
to_keep_set.add(i)
all_indices = set(range(self.vectors.shape[0]))
to_keep = np.array(list(all_indices - to_delete)).astype(int)
to_delete = np.array(list(to_delete)).astype(int)
remains = np.array(list(to_keep_set))
if update:
self.texts = [self.texts[i] for i in to_keep]
self.source = [self.source[i] for i in to_keep]
self.vectors = self.vectors[to_keep]
self.token_counts = [self.token_counts[i] for i in to_keep]
return to_keep, to_delete, remains
def core_text_filter(self, core_list, max_length):
if self.llm_model.startswith(("gpt-3.5")):
model = "gpt-3.5-turbo-16k"
else:
model = "gpt-4"
header = f"""
You are an advanced AI assistant, specialized in analyzing various pieces of information \
and providing precise summaries. In the following task, you will be provided with a list of keywords, \
each separated by a comma (,). You can split or reorganize the terms according to your understanding.
You should obey the following rules when doing this task:
1, Keywords in your answer should related to the topic {self.main_topic};
2, Remove duplicate or semantically similar terms;
3, Each keyword should be at most {max_length} words long;
4, Don't include any other symbols in each of your keyword;
"""
examples = f"""
Here are two examples as your reference:
Raw Keywords:
Mineral processing EPC,Mineral processing,EPC Mineral processing..,circulation,suction,hollow shaft.,alkali-acid purification
Processed Keywords:
Mineral processing EPC,circulation,suction,hollow shaft,alkali-acid purification
Raw Keywords:
1. Mineral processing EPC
2. Stoping methods
3. Open pit mining
4. Stripping ratio
5. Small-scale mining
Processed Keywords:
Mineral processing EPC,Stoping methods,Open pit mining,Stripping ratio,Small-scale mining
"""
prompt = f"""
{header}
{examples}
Your task is to process following raw keywords:
Raw Keywords:
{",".join(core_list)}
Processed Keywords:
"""
input_tokens = len(self.encoding.encode(",".join(core_list)))
response, _, tokens = get_completion(prompt,
model_name=model,
max_tokens=input_tokens,
temperature=self.temperature,
top_p=self.top_p)
response = response[:-1] if response.endswith(".") else response
process_keywords = response.strip().split(',')
return process_keywords, tokens
def sub_entry_filter(self):
# remove some keywords such that there is not any pair of keywords that one is the substring of the other
if self.keywords is None:
raise ValueError("Please extract keywords first.")
strings = self.keywords.copy()
i = 0
while i < len(strings):
for j in range(len(strings)):
if i != j and strings[i] in strings[j]:
strings.pop(j)
if j < i:
i -= 1
break
else:
i += 1
i = len(strings) - 1
while i >= 0:
for j in range(len(strings) - 1, -1, -1):
if i != j and strings[i] in strings[j]:
strings.pop(j)
if j < i:
i -= 1
break
else:
i -= 1
self.keywords = strings
self.keyvectors = np.array(self.embeddings.embed_documents(self.keywords))
return strings
def final_keywords_filter(self):
if self.keywords is None:
raise ValueError("Please extract keywords first.")
header = f"""
You have been provided a list of keywords, each separated by a comma. Your task is to process this list according to a set of guidelines designed to refine and improve the list's utility.
Upon completion of your task, the output should be a processed list of keywords. Each keyword should be separated by a comma.
It's crucial that you maintain the same formatting (separate keywords by comma) to ensure the usability of the processed list.
"""
task1 = f"""'Concentration and Deduplication':
Your task is to examine each keyword in the list and identify those that are either identical or extremely similar in meaning. These should be treated in two ways:
- For keywords that are closely related, expressing different aspects of the same core idea, you need to 'concentrate' them into a single term that best captures the overall concept. For instance, consider the keywords <Styrofoam recycling>, <Styrofoam packaging recycling>, <Styrofoam recycling machine>, <Foam recycling>, <recycled Styrofoam products>. These all relate to the central concept of 'Styrofoam recycling' and should be consolidated into this single keyword.
- For keywords that are identical or nearly identical in meaning, remove the duplicates so that only one instance remains. The guideline here is: if two keywords convey almost the same information, retain only one.
Remember, the objective of this step is to trim the list by eliminating redundancy and focusing on the core concepts each keyword represents.
"""
task2 = f"""'Splitting':
Sometimes, a keyword might be made up of an entity and another keyword, each of which independently conveys a meaningful concept. In these cases, you should split them into two separate keywords.
For instance, consider a keyword like 'Apple recycling'. Here, 'Apple' is a distinct entity, and 'recycling' is a separate concept. Therefore, it's appropriate to split this keyword into two: 'Apple' and 'recycling'.
However, when you split a keyword, be sure to check if the resulting terms are already present in the list you have generated. If they are, remove the duplicates to ensure the list remains concise and unique. Always aim to avoid redundancy in the list.
"""
task3 = f"""'Deletion':
You will encounter keywords that are either too vague or represent an overly broad concept. These should be removed from the list.
For instance, a keyword like 'things' or 'stuff' is generally too vague to be useful. Similarly, a keyword like 'technology' might be too broad unless it's used in a specific context or in conjunction with other terms.
"""
reminder = f"""
As you generate the processed list of keywords, constantly compare them with the original list and the keywords you've already processed, to ensure the integrity and consistency of your work.
Don't response anything other than processed keywords. Each of your processed keyword should have at most 3 words.
"""
keyword_string = ",".join(self.keywords)
if self.llm_model.startswith("gpt-3.5"):
model = "gpt-3.5-turbo-16k"
else:
model = self.llm_model
def quick_prompt(keyword_string, task):
return f"""
{header}
Input Keywords:
{keyword_string}
Instructions:
{task}
{reminder}
Your processed keywords:
"""
all_tokens = 0
num_tokens = len(self.encoding.encode(keyword_string))
keyword_string, _, tokens = get_completion(quick_prompt(keyword_string, task1),
model_name=model,
max_tokens=num_tokens,
temperature=self.temperature,
top_p=self.top_p)
all_tokens += tokens
num_tokens = len(self.encoding.encode(keyword_string))
keyword_string, _, tokens = get_completion(quick_prompt(keyword_string, task2),
model_name=model,
max_tokens=num_tokens,
temperature=self.temperature,
top_p=self.top_p)
all_tokens += tokens
num_tokens = len(self.encoding.encode(keyword_string))
keyword_string, _, tokens = get_completion(quick_prompt(keyword_string, task3),
model_name=model,
max_tokens=num_tokens,
temperature=self.temperature,
top_p=self.top_p)
all_tokens += tokens
self.keywords = keyword_string.split(",")
self.keyvectors = np.array(self.embeddings.embed_documents(self.keywords))
return keyword_string, all_tokens
def summary_contents(self, indx, sort_inds, avoid_content=None,
max_texts=5, prompt_language='English',
num_topics=3, max_length=3, show_prompt=False):
if avoid_content is None:
avoid_content = []
if self.llm_model.startswith("gpt-3.5"):
model = "gpt-3.5-turbo-16k"
else:
model = self.llm_model
if model.startswith("gpt-3.5"):
max_num_tokens = 11900
elif model.startswith("gpt-4"):
max_num_tokens = 7900
else:
raise ValueError("Model should be either GPT-3.5 or GPT-4.")
header = f"""
You are an advanced AI assistant, specialized in analyzing \
various pieces of information and providing precise summaries. Your task \
is to determine the core theme in the following series of *-separated \
information fragments, which is delimited by triple backticks. \
Ensure your answer focuses on the topic and avoids \
including unrelated content. DO NOT write complete sentences.
You should obey the following rules when doing this task:
1, Keywords in your answer should related to the topic {self.main_topic};
2, Your answer should include at most {num_topics} keywords;
3, Each keyword should be at most {max_length} words long;
4, avoid already appeared theme keywords, marked inside <>;
5, Write your answer in {prompt_language};
6, Separate your output keywords with commas (,);
7, Don't include any other symbols other than keywords.
"""
avoid_info = f"""
Please avoid the following already appeared theme terms:
<{",".join(avoid_content)}>
"""
chosen_texts = []
chosen_texts_len = 0
chosen_texts_len += len(self.encoding.encode(header))
chosen_texts_len += len(self.encoding.encode(avoid_info))
separator_len = len(self.encoding.encode(self.separator))
for i in range(min(max_texts, len(sort_inds))):
select_text = [self.texts[j] for j in indx][sort_inds[i]]
num_tokens = len(self.encoding.encode(select_text))
chosen_texts_len += num_tokens + separator_len
if chosen_texts_len > max_num_tokens - 500:
break
chosen_texts.append(self.separator + select_text)
prompt = f"""
{header}
Information:
'''{''.join(chosen_texts)}'''
{avoid_info}
Your response:
"""
if show_prompt:
print(prompt)
response, _, tokens = get_completion(prompt,
model_name=model,
max_tokens=200,
temperature=self.temperature,
top_p=self.top_p)
return response, tokens
### cluster function
def cluster(self, n_clusters, clustering_method='k_means', max_texts=5,
select_mtd='similarity', prompt_language='English', num_topics=3,
max_length=3, post_process=True, add_keywords=True, verbose=False):
if clustering_method == 'k_means':
kmeans_model = KMeans(n_clusters, init='k-means++', n_init=5)
kmeans = kmeans_model.fit(np.array(self.vectors))
elif clustering_method in ['combinatorial', 'ShiMalik', 'NgJordanWeiss']:
extra_dim = 5
if self.weightmatrix is None:
self.make_graph(k=20)
n = self.graph.num_nodes
if clustering_method == 'combinatorial':
vals, vec = self.graph.eigen_decomp(k=n_clusters + extra_dim)
elif clustering_method == 'ShiMalik':
vals, vec = self.graph.eigen_decomp(normalization='randomwalk', k=n_clusters + extra_dim)
elif clustering_method == 'NgJordanWeiss':
vals, vec = self.graph.eigen_decomp(normalization='normalized', k=n_clusters + extra_dim)
norms = np.sum(vec * vec, axis=1)
T = sparse.spdiags(norms ** (-1 / 2), 0, n, n)
vec = T @ vec # Normalize rows
kmeans = KMeans(n_clusters, init='k-means++', n_init=5).fit(vec)
else:
raise ValueError(
"Invalid clustering method. Choose 'k_means', 'combinatorial', 'ShiMalik' or 'NgJordanWeiss'.")
all_tokens = 0
cluster_names = []
for i in range(len(kmeans.cluster_centers_)):
center = kmeans.cluster_centers_[i]
indx = np.arange(len(self.texts))[kmeans.labels_ == i]
if select_mtd == 'similarity':
if clustering_method == 'k_means':
sim_vals = pairwise_distances(self.vectors[indx], center[np.newaxis, :],
metric='euclidean').flatten()
else:
sim_vals = pairwise_distances(vec[indx], center[np.newaxis, :], metric='euclidean').flatten()
sort_inds = np.argsort(sim_vals)
elif select_mtd == 'random':
sort_inds = np.random.permutation(len(indx))
# randomly sample some avoid names if it is too long
if len(cluster_names) > 300:
sample_ind = np.random.choice(len(cluster_names), 300, replace=False)
# verbose or not
if verbose and i % 10 == 0:
show_prompt = True
else:
show_prompt = False
summary_center, tokens = self.summary_contents(indx=indx,
sort_inds=sort_inds,
avoid_content=cluster_names,
max_texts=max_texts,
prompt_language=prompt_language,
num_topics=num_topics,
max_length=max_length,
show_prompt=show_prompt)
all_tokens += tokens
if verbose and i % 10 == 0:
print(f"Raw Keywords for center {i}:", summary_center)
processed_center, tokens = self.core_text_filter([summary_center], max_length)
all_tokens += tokens
if verbose and i % 10 == 0:
print(f"Processed Keywords for center {i}:", ",".join(processed_center))
cluster_names.extend(processed_center)
cluster_names = process_strings(cluster_names)
print('Before Post Process:', len(cluster_names))
if post_process:
cluster_names, tokens = self.core_text_filter(cluster_names, max_length)
all_tokens += tokens
print('After Post Process:', len(cluster_names))
cluster_names = list(set(cluster_names))
output_keywords = list(set(self.keywords or []) | set(cluster_names)) if add_keywords else cluster_names
self.keywords = process_strings(output_keywords)
self.keyvectors = np.array(self.embeddings.embed_documents(self.keywords))
return cluster_names, all_tokens
#################################### functions for knowledge graph construction
def distance_core_seg(self, core_texts, core_labels=None, k=20,
dist_metric='cosine', method='annoy', return_full=False, return_prob=False):
# consider to write coresearch into a subclass
core_ebds = np.array(self.embeddings.embed_documents(core_texts))
if core_labels is None:
core_labels = np.arange(len(core_ebds))
else:
core_labels = np.array(core_labels)
k = min(k, len(core_texts))
if method == 'annoy':
if dist_metric == 'cosine':
similarity = 'angular'
else:
similarity = dist_metric
knn_ind, knn_dist = autoKG.ANN_search(self.vectors, core_ebds, k, similarity=similarity)
elif method == 'dense':
dist_mat = pairwise_distances(self.vectors, core_ebds, metric=dist_metric)
knn_ind = []
knn_dist = []
for i in range(len(dist_mat)):
knn_ind.append(np.argsort(dist_mat[i])[:k])
knn_dist.append(dist_mat[i][knn_ind[i]])
knn_ind = np.array(knn_ind)
knn_dist = np.arccos(1 - np.array(knn_dist))
else:
sys.exit('Invalid choice of method ' + dist_metric)
knn_ind = autoKG.replace_labels(knn_ind, core_labels)
if return_prob:
D = knn_dist * knn_dist
eps = D[:, k - 1]
weights = np.exp(-4 * D / eps[:, None])
prob = weights / np.sum(weights, axis=1)[:, np.newaxis]
if return_full:
if return_prob:
return knn_ind, knn_dist, prob
else:
return knn_ind, knn_dist
else:
if return_prob:
return knn_ind[:, 0], knn_dist[:, 0], prob[:, 0]
else:
return knn_ind[:, 0], knn_dist[:, 0]
def laplace_diffusion(self, core_texts, trust_num=10, core_labels=None, k=20,
dist_metric='cosine', return_full=False):
# we need to update the graph based rather than making a new one
if self.weightmatrix is None:
self.make_graph(k=20)
knn_ind, knn_dist = self.distance_core_seg(core_texts, core_labels, k,
dist_metric, method='annoy', return_full=False, return_prob=False)
if core_labels is None:
core_labels = np.arange(len(core_texts))
else:
core_labels = np.array(core_labels)
select_inds = np.array([], dtype=np.int64)
select_labels = np.array([], dtype=np.int64)
all_inds = np.arange(len(self.vectors))
for i in range(len(core_texts)):
select_ind = all_inds[knn_ind == i][np.argsort(knn_dist[knn_ind == i])[:trust_num]]
select_inds = np.concatenate((select_inds, select_ind))
select_labels = np.concatenate((select_labels, core_labels[i] * np.ones(len(select_ind))))
model = gl.ssl.laplace(self.weightmatrix)
print(select_inds)
U = model._fit(select_inds, select_labels)
if return_full:
return U
else:
return np.argmax(U, axis=1)
def PosNNeg_seg(self, core_text, trust_num=5, k=20, dist_metric='cosine', negative_multiplier=3, seg_mtd='laplace'):
if self.weightmatrix is None:
self.make_graph(k=20)
knn_ind, knn_dist = self.distance_core_seg([core_text], [0], k,
dist_metric, method='dense', return_full=False, return_prob=False)
sort_ind = np.argsort(knn_dist)
select_inds = np.concatenate((sort_ind[:trust_num], sort_ind[-negative_multiplier * trust_num:]))
select_labels = np.concatenate((np.zeros(trust_num), np.ones(negative_multiplier * trust_num)))
if seg_mtd == 'kmeans':
sub_core_texts = [self.texts[i] for i in select_inds]
label_pred, U = self.distance_core_seg(sub_core_texts, select_labels, k,
dist_metric, method='dense', return_full=False, return_prob=False)
U = np.exp(- U / np.max(U, axis=0))
elif seg_mtd == 'laplace':
model = gl.ssl.laplace(self.weightmatrix)
U = model._fit(select_inds, select_labels)
label_pred = np.argmax(U, axis=1)
U = U[:, 0]
elif seg_mtd == 'poisson':
model = gl.ssl.poisson(self.weightmatrix)
U = model._fit(select_inds, select_labels)
label_pred = np.argmax(U, axis=1)
U = U[:, 0]
return label_pred, U
def coretexts_seg_individual(self, trust_num=5, core_labels=None, k=20,
dist_metric='cosine', negative_multiplier=3, seg_mtd='laplace',
return_mat=True, connect_threshold=1):
# we need to update the graph based rather than making a new one
if self.weightmatrix is None:
self.make_graph(k=20)
core_texts = self.keywords
if core_labels is None:
core_labels = np.arange(len(core_texts))
else:
core_labels = np.array(core_labels)
N_labels = np.max(core_labels) + 1
U_mat = np.zeros((len(self.texts), len(core_labels)))
pred_mat = np.zeros((len(self.texts), N_labels))
for core_ind, core_text in enumerate(core_texts):
label_pred, U = self.PosNNeg_seg(core_text, trust_num, k, dist_metric, negative_multiplier, seg_mtd)
# print(f"The number of data clustered as core text {core_ind} is {np.sum(label_pred==0)}")
U_mat[:, core_ind] = U
pred_mat[label_pred == 0, core_labels[core_ind]] = 1
if connect_threshold < 1:
num_conn = np.sum(pred_mat, axis=0)
N = len(self.texts)
large_inds = np.where(num_conn > N*connect_threshold)[0]
num_elements = int(N * connect_threshold)
for l_ind in large_inds:
threshold = np.partition(U_mat[:, l_ind], -num_elements)[-num_elements]
pred_mat[:, l_ind] = np.where(U_mat[:, l_ind] >= threshold, 1, 0)
if return_mat:
# A = autoKG.create_sparse_matrix_A(pred_mat, np.array(core_labels))
A = csr_matrix((pred_mat.T@pred_mat).astype(int))
A = A - diags(A.diagonal())
self.U_mat = U_mat
self.pred_mat = pred_mat
self.A = A
return pred_mat, U_mat, A
else:
self.U_mat = U_mat
self.pred_mat = pred_mat
return pred_mat, U_mat
#############################################
def content_check(self, include_keygraph=True, auto_embedding=False):
is_valid = True
if self.keywords is None:
print('Please set up keywords as self.keywords')
is_valid = False
if self.keyvectors is None:
if auto_embedding:
self.keyvectors = np.array(self.embeddings.embed_documents(self.keywords))
else:
print('Please set up keyword embedding vectors as self.keyvectors')
is_valid = False
if self.vectors is None:
if auto_embedding:
self.keyvectors = np.array(self.embeddings.embed_documents(self.texts))
else:
print('Please set up texts embedding vectors as self.vectors')
is_valid = False
if include_keygraph:
if self.U_mat is None:
print("Please calculate the U_mat using 'coretexts_seg_individual'.")
is_valid = False
if self.pred_mat is None:
print("Please calculate the pred_mat using 'coretexts_seg_individual'.")
is_valid = False
if self.A is None:
print("Please calculate the adjacency matrix A using 'coretexts_seg_individual'.")
is_valid = False
return is_valid
def get_dist_mat(self):
if not self.content_check(include_keygraph=True):
raise ValueError('Missing Contents')
self.dist_mat = np.arccos(1 - pairwise_distances(self.keyvectors, self.vectors, metric='cosine'))
################################ functions for search and chat
def angular_search(self, query, k=5, search_mtd='pair_dist', search_with='texts'):
if not self.content_check(include_keygraph=False):
raise ValueError('Missing Contents')
if isinstance(query, str):
query_vec = np.array(self.embeddings.embed_documents([query]))
elif isinstance(query, list):
query_vec = np.array(self.embeddings.embed_documents(query))
else:
raise ValueError("query should be either string or list")
if search_with == 'texts':
s_vecs = self.vectors
elif search_with == 'keywords':
s_vecs = self.keyvectors
else:
raise ValueError("You should search with either 'texts' or 'keywords'.")
if search_mtd == 'pair_dist':
dist_mat = np.arccos(1 - pairwise_distances(query_vec, s_vecs, metric='cosine'))
knn_ind = np.zeros((len(query_vec), k))
knn_dist = np.zeros((len(query_vec), k))
for i in range(len(knn_ind)):
knn_ind[i] = np.argsort(dist_mat[i])[:k]
knn_dist[i] = dist_mat[i, knn_ind[i].astype(int)]
elif search_mtd == 'knn':
knn_ind, knn_dist = autoKG.ANN_search(query_vec, s_vecs, k, similarity='angular')
else:
sys.exit('Invalid choice of method ' + search_mtd)
return knn_ind.astype(int), knn_dist
def keyword_related_text(self, keyind, k, use_u=True):
if not self.content_check(include_keygraph=True):
raise ValueError('Missing Contents')
if use_u:
text_ind = np.argsort(self.U_mat[:, keyind])[::-1][:k].astype(int).tolist()
else:
if self.dist_mat is None:
raise ValueError("dist_mat is None")
else:
text_ind = np.argsort(self.dist_mat[keyind, :])[:k].astype(int).tolist()
return text_ind
def top_k_indices_sparse(self, row_index, k):
row = self.A.getrow(row_index)
non_zero_indices = row.nonzero()[1]
if non_zero_indices.size < k:
return non_zero_indices
non_zero_values = np.array(row.data)
top_k_indices = non_zero_indices[np.argpartition(non_zero_values, -k)[-k:]]
return top_k_indices.astype(int).tolist()
#################################################################################################################
### main knowledge graph search function
def KG_prompt(self, query, search_nums=(10, 5, 2, 3, 1), search_mtd='pair_dist', use_u=False):
if not self.content_check(include_keygraph=True):
raise ValueError('Missing Contents')
text_ind = []
keyword_ind = []
adj_keyword_ind = []
# search similar texts
sim_text_ind, _ = self.angular_search(query, k=search_nums[0], search_mtd=search_mtd, search_with='texts')
text_ind.extend([(i, -1) for i in sim_text_ind.tolist()[0]])
# search similar keywords
sim_keyword_ind, _ = self.angular_search(query, k=search_nums[1], search_mtd=search_mtd,
search_with='keywords')
keyword_ind.extend(sim_keyword_ind.tolist()[0])
for k_ind in sim_keyword_ind.tolist()[0]:
t_ind = self.keyword_related_text(k_ind, k=search_nums[2], use_u=use_u)
text_ind.extend([(i, k_ind) for i in t_ind])
# adjacency search
adj_text_inds = self.top_k_indices_sparse(k_ind, k=search_nums[3])
adj_keyword_ind.extend([(i, k_ind) for i in adj_text_inds])
adj_keyword_ind = remove_duplicates(adj_keyword_ind)
adj_keyword_ind = [item for item in adj_keyword_ind if not item[0] in keyword_ind]
# texts related to adjacency keywords
for k_ind, _ in adj_keyword_ind:
t_ind = self.keyword_related_text(k_ind, k=search_nums[4], use_u=use_u)
text_ind.extend([(i, k_ind) for i in t_ind])
text_ind = remove_duplicates(text_ind)
record = {'query': query,
'text': text_ind,
'sim_keywords': keyword_ind,
'adj_keywords': adj_keyword_ind}
return record
def completion_from_record(self,
record,
output_tokens=1024,
prompt_language='English',
show_prompt=False,
prompt_keywords=True,
include_source=False):
if self.llm_model.startswith("gpt-3.5"):
model = "gpt-3.5-turbo-16k"
else:
model = self.llm_model
if model.startswith("gpt-3.5"):
max_num_tokens = 11900
elif model.startswith("gpt-4"):
max_num_tokens = 7900
else:
raise ValueError("Model should be either GPT-3.5 or GPT-4.")
if prompt_keywords:
header_part = """
You will be given a set of keywords directly related to a query, \
as well as adjacent keywords from the knowledge graph. \
Keywords will be separated by semicolons (;).
Relevant texts will be provided, enclosed within triple backticks. \
These texts contain information pertinent to the query and keywords.
"""
else:
header_part = """
Relevant texts will be provided, enclosed within triple backticks. \
These texts contain information pertinent to the query.
"""
header = f"""
I want you to do a task, deal with a query or answer a question \
with some information from a knowledge graph.
{header_part}
Please note, you should not invent any information. Stick to the facts provided in the keywords and texts.
These additional data are meant to assist you in accurately completing the task.
Your response should be written in {prompt_language}.
Avoid to show any personal information, like Name, Email, WhatsApp, Skype, and Website in your polished response.
"""
max_content_token = max_num_tokens - output_tokens - 150
query = record['query']
text_ind = record['text']
keyword_ind = record['sim_keywords']
adj_keyword_ind = record['adj_keywords']
keywords_info = "Keywords directly related to the query:\n\n" + "; ".join(
[f"{self.keywords[i]}" for i in keyword_ind]) + "\n\n"
keywords_info += "Adjacent keywords according to the knowledge graph:\n\n" + \
"; ".join([f"{self.keywords[i]}" for i, _ in adj_keyword_ind])
chosen_texts = []
chosen_texts_len = 0
separator_len = len(self.encoding.encode(self.separator))
if prompt_keywords:
chosen_texts_len += len(self.encoding.encode(keywords_info))
chosen_texts_len += len(self.encoding.encode(header))
chosen_texts_len += len(self.encoding.encode(query))
for t_ind, _ in text_ind:
select_text = self.texts[t_ind]
if include_source:
select_source = self.source[t_ind]
select_text = f"Source:{select_source}" + f"Content:{select_text}"
num_tokens = len(self.encoding.encode(select_text))
chosen_texts_len += num_tokens + separator_len
if chosen_texts_len > max_content_token:
break
chosen_texts.append(self.separator + select_text)
ref_info = "Selected reference texts:\n"
ref_info += ''.join(chosen_texts)
if prompt_keywords:
prompt = f"""
{header}
{keywords_info}
Texts:
'''{''.join(chosen_texts)}'''
Your task:
{query}
Your response:
"""
else:
prompt = f"""
{header}
Texts:
'''{''.join(chosen_texts)}'''
Your task:
{query}
Your response:
"""
if show_prompt:
print(prompt)
response, _, all_tokens = get_completion(prompt,
model_name=model,
max_tokens=output_tokens,
temperature=self.temperature,
top_p=self.top_p)
return response, keywords_info, ref_info, all_tokens
#################################################################################################################
### graph visualization
def draw_graph_from_record(self,
record,
node_colors=([0, 1, 1], [0, 1, 0.5], [1, 0.7, 0.75]),
node_shape='o',
edge_color='black',
edge_widths=(2, 0.5),
node_sizes=(500, 150, 50),
font_color='black',
font_size=6,
show_text=True,
save_fig=False,
save_path='Subgraph_vis.png'):
T = record['text']
K1 = record['sim_keywords']
K2 = record['adj_keywords']
N = [element.replace(" ", "\n") for element in self.keywords]
Q = 'Query'
G = nx.Graph()
G.add_node(Q)
for i in K1:
G.add_edge(Q, N[i])
for i in K1:
for j in K1:
if self.A[i, j] > 0:
G.add_edge(N[i], N[j])
for k, _ in K2:
if self.A[i, k] > 0:
G.add_edge(N[i], N[k])
# for i, L in K2:
# for j in L:
# G.add_edge(N[i], N[j])
if show_text:
for i, L in T:
new_node = f"Text {i}"
G.add_node(new_node)
for j in L:
if j == -1:
G.add_edge(new_node, Q)
else:
G.add_edge(new_node, N[j])
color_map = {}
color_map[Q] = node_colors[0]
node_size_map = {node: node_sizes[0] for node in G.nodes}
for node in N:
color_map[node] = node_colors[1]
node_size_map[node] = node_sizes[1]
if show_text:
for i, _ in T:
color_map[f"Text {i}"] = node_colors[2]
node_size_map[f"Text {i}"] = node_sizes[2]
edge_width_map = {edge: edge_widths[0] for edge in G.edges}
if show_text:
for i, L in T:
new_node = f"Text {i}"
for j in L:
if j == -1:
edge_width_map[(new_node, Q)] = edge_widths[1]
edge_width_map[(Q, new_node)] = edge_widths[1]
else:
edge_width_map[(new_node, N[j])] = edge_widths[1]
edge_width_map[(N[j], new_node)] = edge_widths[1]
# pos = nx.spring_layout(G, seed=42)
pos = nx.spring_layout(G, seed=42, k=0.15, iterations=50, scale=2.0)
nx.draw_networkx_edges(G, pos, alpha=0.4, edge_color=edge_color,
width=[edge_width_map[edge] for edge in G.edges])
nx.draw_networkx_nodes(G, pos, node_color=[color_map[node] for node in G.nodes],
node_size=[node_size_map[node] for node in G.nodes], node_shape=node_shape)
nx.draw_networkx_labels(G, pos, labels={node: node for node in G.nodes}, font_size=font_size,
font_color=font_color)
if save_fig:
plt.tight_layout()
plt.savefig(save_path, dpi=300)
plt.figure()
### save and load
def save_data(self, save_path, include_texts=False):
if include_texts:
keywords_dic = {'keywords': self.keywords, 'keyvectors': self.keyvectors,
'U_mat': self.U_mat, 'pred_mat': self.pred_mat, 'A': self.A,
'texts': self.texts, 'embedding_vectors': self.vectors,
'dist_mat': self.dist_mat, 'token_counts': self.token_counts,
'source': self.source}
else:
keywords_dic = {'keywords': self.keywords, 'keyvectors': self.keyvectors,
'U_mat': self.U_mat, 'pred_mat': self.pred_mat, 'A': self.A,
'dist_mat': self.dist_mat}
np.save(save_path, keywords_dic)
print(f"Successfully save to {save_path}")
def load_data(self, load_path, include_texts=False):
keywords_dic = np.load(load_path, allow_pickle=True).item()
self.keywords = keywords_dic.get('keywords')
self.keyvectors = keywords_dic.get('keyvectors')
self.U_mat = keywords_dic.get('U_mat')
self.pred_mat = keywords_dic.get('pred_mat')
self.A = keywords_dic.get('A')
self.dist_mat = keywords_dic.get('dist_mat')
if include_texts:
if "texts" in keywords_dic:
self.texts = keywords_dic.get('texts')
self.vectors = keywords_dic.get('embedding_vectors')
self.token_counts = keywords_dic.get('token_counts')
self.source = keywords_dic.get('source')
else:
print("Fails to load texts information. Please check if your data includes a key named 'text'.")
print(f"Successfully load from {load_path}")
def write_keywords(self, save_path):
if not self.content_check(include_keygraph=False):
raise ValueError('Missing Contents')
result = ''
for i in range(len(self.keywords)):
result += self.keywords[i]
if (i + 1) % 10 == 0:
result += '\n'
else:
result += '; '
with open(save_path, 'w') as f:
f.write(result)
def check_completion(self):
attributes_to_check = ['keywords', 'keyvectors', 'U_mat', 'pred_mat', 'A', 'dist_mat',
'texts', 'vectors', 'token_counts', 'source']
for attr in attributes_to_check:
if getattr(self, attr, None) is None:
return False
return True
## static methods
@staticmethod
def replace_labels(ind, labels):
ind_new = np.zeros_like(ind)
for i in range(len(labels)):
ind_new[ind == i] = labels[i]
return ind_new
@staticmethod
def ANN_search(X1, X2, k, similarity='euclidean'):
# annoy search function
# O(NlogN)
M, d1 = X1.shape
N, d2 = X2.shape
assert d1 == d2, "The dimensions of datasets X1 and X2 do not match"
if not similarity in ['euclidean', 'angular', 'manhattan', 'hamming', 'dot']:
sys.exit('Invalid choice of similarity ' + similarity)
d = d1
k = min(k, X2.shape[0])
t = AnnoyIndex(d, similarity)
for i in range(N):
t.add_item(i, X2[i])
t.build(5)
knn_dist = []
knn_ind = []
for x1 in X1:
indices, distances = t.get_nns_by_vector(x1, k, include_distances=True)
knn_ind.append(indices)
knn_dist.append(distances)
knn_ind = np.array(knn_ind)
knn_dist = np.array(knn_dist)
return knn_ind, knn_dist
| [
"False",
"True"
] |
2024-01-10 | AmineMekki01/rag_app_python | src~app~chat~services.py | import uuid
import openai
from openai import ChatCompletion
from starlette.responses import StreamingResponse
from src.app.chat.constants import ChatRolesEnum
from src.app.chat.models import BaseMessage, Message
from src.app.core.logs import logger
from src.app.settings import settings
from src.app.chat.streaming import stream_generator, format_to_event_stream
from src.app.chat.constants import ChatRolesEnum, NO_DOCUMENTS_FOUND
from src.app.chat.exceptions import RetrievalNoDocumentsFoundException
from src.app.chat.retrieval import process_retrieval
from src.app.db import messages_queries
from src.app.chat.models import BaseMessage, Message, ChatSummary
from uuid import UUID
class OpenAIService:
@classmethod
async def chat_completion_without_streaming(cls, input_message: BaseMessage) -> Message:
completion: openai.ChatCompletion = await openai.ChatCompletion.acreate(
model=input_message.model,
api_key=settings.OPENAI_API_KEY,
messages=[{"role": ChatRolesEnum.USER.value,
"content": input_message.augmented_message}]
)
completion = cls.extract_response_from_completion(
chat_completion=completion)
try:
message_id = uuid.uuid4()
messages_queries.insert_message(
id=str(message_id),
chat_id=str(input_message.chat_id),
model=str(input_message.model),
user_id=str(input_message.userId),
agent_role=str(ChatRolesEnum.ASSISTANT.value),
user_message=str(input_message.user_message),
answer=str(completion)
)
logger.info("Message inserted to db successfully")
except Exception as e:
logger.error("Error while inserting message to db: " + str(e))
return Message(
model=input_message.model,
message=completion,
role=ChatRolesEnum.ASSISTANT.value
)
@staticmethod
async def chat_completion_with_streaming(input_message: BaseMessage) -> StreamingResponse:
subscription: openai.ChatCompletion = await openai.ChatCompletion.acreate(
model=input_message.model,
api_key=settings.OPENAI_API_KEY,
messages=[{"role": ChatRolesEnum.USER.value,
"content": input_message.user_message}],
stream=True,
)
return StreamingResponse(stream_generator(subscription), media_type="text/event-stream")
@staticmethod
def extract_response_from_completion(chat_completion: ChatCompletion) -> str:
return chat_completion.choices[0]["message"]["content"]
@classmethod
async def qa_without_stream(cls, input_message: BaseMessage) -> Message:
try:
augmented_message = process_retrieval(
message=input_message)
logger.info("Context retrieved successfully.")
return await cls.chat_completion_without_streaming(input_message=augmented_message)
except RetrievalNoDocumentsFoundException:
return Message(model=input_message.model, message=NO_DOCUMENTS_FOUND, role=ChatRolesEnum.ASSISTANT.value)
@classmethod
async def qa_with_stream(cls, input_message: BaseMessage) -> StreamingResponse:
try:
augmented_message: BaseMessage = process_retrieval(
message=input_message)
logger.info("Context retrieved successfully.")
return await cls.chat_completion_with_streaming(input_message=augmented_message)
except RetrievalNoDocumentsFoundException:
return StreamingResponse(
(format_to_event_stream(y) for y in "Not found"),
media_type="text/event-stream",
)
class ChatServices:
@classmethod
def get_messages(cls, user_id: str) -> list[Message]:
return [Message(**message) for message in messages_queries.select_messages_by_user(user_id=user_id)]
@classmethod
def get_chats(cls, user_id: str) -> list[ChatSummary]:
return [ChatSummary(**chat) for chat in messages_queries.select_chats_by_user(user_id=user_id)]
@classmethod
def get_chat_messages(cls, chat_id) -> list[Message]:
return [Message(**message) for message in messages_queries.select_messages_by_chat(chat_id=chat_id)]
@classmethod
def get_chat(cls, chat_id) -> ChatSummary:
return ChatSummary(**messages_queries.select_chat_by_id(chat_id=chat_id))
@classmethod
async def create_chat(cls, chat: ChatSummary):
try:
messages_queries.insert_chat(
id=str(chat.id),
user_id=str(chat.user_id),
title=chat.title,
model=chat.model,
agent_role=str(ChatRolesEnum.ASSISTANT.value),
created_at=chat.created_at,
updated_at=chat.updated_at,
)
logger.info("chat before returning to frontend: " + str(chat))
return chat
except Exception as e:
logger.error(f"Error creating chat: {e}")
@classmethod
def create_message(cls, message) -> Message:
return Message(**messages_queries.insert_message(message=message))
| [] |
2024-01-10 | AmineMekki01/rag_app_python | src~app~chat~models.py | from pydantic import BaseModel, Field
from src.app.chat.constants import ChatRolesEnum, ModelsEnum
from src.app.core.models import TimestampAbstractModel
from src.app.chat.exceptions import OpenAIFailedProcessingException
from typing import Optional
from datetime import datetime
class BaseMessage(BaseModel):
id: str = Field(default="")
chat_id: str = Field(default="")
model: ModelsEnum = Field(default=ModelsEnum.GPT4.value)
userId: Optional[str] = None
agent_role: str = Field(default=ChatRolesEnum.ASSISTANT.value)
user_message: str = Field(default="")
answer: str = Field(default="")
augmented_message: str = Field(default="")
class Message(TimestampAbstractModel, BaseMessage):
role: Optional[ChatRolesEnum] = None
class Message(BaseMessage):
role: Optional[ChatRolesEnum] = None
class ChatSummary(BaseModel):
id: str
user_id: str
title: str
model: str
agent_role: str
created_at: datetime
updated_at: datetime
class Chunk(BaseModel):
id: str
created: int = Field(default=0)
model: ModelsEnum = Field(default="gpt-4-0613")
content: str
finish_reason: str | None = None
@classmethod
def from_chunk(cls, chunk):
delta_content: str = cls.get_chunk_delta_content(chunk=chunk)
return cls(
id=chunk["id"],
created=chunk["created"],
model=chunk["model"],
content=delta_content,
finish_reason=chunk["choices"][0].get("finish_reason", None),
)
@staticmethod
def get_chunk_delta_content(chunk: dict | str) -> str:
try:
match chunk:
case str(chunk):
return chunk
case dict(chunk):
return chunk["choices"][0]["delta"].get("content", "")
except Exception:
raise OpenAIFailedProcessingException
| [] |
2024-01-10 | truesoni/llama_index | llama_index~agent~react~step.py | """ReAct agent worker."""
import asyncio
import uuid
from itertools import chain
from threading import Thread
from typing import (
Any,
AsyncGenerator,
Dict,
Generator,
List,
Optional,
Sequence,
Tuple,
cast,
)
from llama_index.agent.react.formatter import ReActChatFormatter
from llama_index.agent.react.output_parser import ReActOutputParser
from llama_index.agent.react.types import (
ActionReasoningStep,
BaseReasoningStep,
ObservationReasoningStep,
ResponseReasoningStep,
)
from llama_index.agent.types import (
BaseAgentWorker,
Task,
TaskStep,
TaskStepOutput,
)
from llama_index.callbacks import (
CallbackManager,
CBEventType,
EventPayload,
trace_method,
)
from llama_index.chat_engine.types import (
AGENT_CHAT_RESPONSE_TYPE,
AgentChatResponse,
StreamingAgentChatResponse,
)
from llama_index.llms.base import ChatMessage, ChatResponse
from llama_index.llms.llm import LLM
from llama_index.llms.openai import OpenAI
from llama_index.llms.types import MessageRole
from llama_index.memory.chat_memory_buffer import ChatMemoryBuffer
from llama_index.memory.types import BaseMemory
from llama_index.objects.base import ObjectRetriever
from llama_index.tools import BaseTool, ToolOutput, adapt_to_async_tool
from llama_index.tools.types import AsyncBaseTool
from llama_index.utils import print_text, unit_generator
DEFAULT_MODEL_NAME = "gpt-3.5-turbo-0613"
def add_user_step_to_reasoning(
step: TaskStep,
memory: BaseMemory,
current_reasoning: List[BaseReasoningStep],
verbose: bool = False,
) -> None:
"""Add user step to memory."""
if "is_first" in step.step_state and step.step_state["is_first"]:
# add to new memory
memory.put(ChatMessage(content=step.input, role=MessageRole.USER))
step.step_state["is_first"] = False
else:
reasoning_step = ObservationReasoningStep(observation=step.input)
current_reasoning.append(reasoning_step)
if verbose:
print(f"Added user message to memory: {step.input}")
class ReActAgentWorker(BaseAgentWorker):
"""OpenAI Agent agent worker."""
def __init__(
self,
tools: Sequence[BaseTool],
llm: LLM,
max_iterations: int = 10,
react_chat_formatter: Optional[ReActChatFormatter] = None,
output_parser: Optional[ReActOutputParser] = None,
callback_manager: Optional[CallbackManager] = None,
verbose: bool = False,
tool_retriever: Optional[ObjectRetriever[BaseTool]] = None,
) -> None:
self._llm = llm
self.callback_manager = callback_manager or llm.callback_manager
self._max_iterations = max_iterations
self._react_chat_formatter = react_chat_formatter or ReActChatFormatter()
self._output_parser = output_parser or ReActOutputParser()
self._verbose = verbose
if len(tools) > 0 and tool_retriever is not None:
raise ValueError("Cannot specify both tools and tool_retriever")
elif len(tools) > 0:
self._get_tools = lambda _: tools
elif tool_retriever is not None:
tool_retriever_c = cast(ObjectRetriever[BaseTool], tool_retriever)
self._get_tools = lambda message: tool_retriever_c.retrieve(message)
else:
self._get_tools = lambda _: []
@classmethod
def from_tools(
cls,
tools: Optional[Sequence[BaseTool]] = None,
tool_retriever: Optional[ObjectRetriever[BaseTool]] = None,
llm: Optional[LLM] = None,
max_iterations: int = 10,
react_chat_formatter: Optional[ReActChatFormatter] = None,
output_parser: Optional[ReActOutputParser] = None,
callback_manager: Optional[CallbackManager] = None,
verbose: bool = False,
**kwargs: Any,
) -> "ReActAgentWorker":
"""Convenience constructor method from set of of BaseTools (Optional).
NOTE: kwargs should have been exhausted by this point. In other words
the various upstream components such as BaseSynthesizer (response synthesizer)
or BaseRetriever should have picked up off their respective kwargs in their
constructions.
Returns:
ReActAgent
"""
llm = llm or OpenAI(model=DEFAULT_MODEL_NAME)
if callback_manager is not None:
llm.callback_manager = callback_manager
return cls(
tools=tools or [],
tool_retriever=tool_retriever,
llm=llm,
max_iterations=max_iterations,
react_chat_formatter=react_chat_formatter,
output_parser=output_parser,
callback_manager=callback_manager,
verbose=verbose,
)
def initialize_step(self, task: Task, **kwargs: Any) -> TaskStep:
"""Initialize step from task."""
sources: List[ToolOutput] = []
current_reasoning: List[BaseReasoningStep] = []
# temporary memory for new messages
new_memory = ChatMemoryBuffer.from_defaults()
# initialize task state
task_state = {
"sources": sources,
"current_reasoning": current_reasoning,
"new_memory": new_memory,
}
task.extra_state.update(task_state)
return TaskStep(
task_id=task.task_id,
step_id=str(uuid.uuid4()),
input=task.input,
step_state={"is_first": True},
)
def get_tools(self, input: str) -> List[AsyncBaseTool]:
"""Get tools."""
return [adapt_to_async_tool(t) for t in self._get_tools(input)]
def _extract_reasoning_step(
self, output: ChatResponse, is_streaming: bool = False
) -> Tuple[str, List[BaseReasoningStep], bool]:
"""
Extracts the reasoning step from the given output.
This method parses the message content from the output,
extracts the reasoning step, and determines whether the processing is
complete. It also performs validation checks on the output and
handles possible errors.
"""
if output.message.content is None:
raise ValueError("Got empty message.")
message_content = output.message.content
current_reasoning = []
try:
reasoning_step = self._output_parser.parse(message_content, is_streaming)
except BaseException as exc:
raise ValueError(f"Could not parse output: {message_content}") from exc
if self._verbose:
print_text(f"{reasoning_step.get_content()}\n", color="pink")
current_reasoning.append(reasoning_step)
if reasoning_step.is_done:
return message_content, current_reasoning, True
reasoning_step = cast(ActionReasoningStep, reasoning_step)
if not isinstance(reasoning_step, ActionReasoningStep):
raise ValueError(f"Expected ActionReasoningStep, got {reasoning_step}")
return message_content, current_reasoning, False
def _process_actions(
self,
task: Task,
tools: Sequence[AsyncBaseTool],
output: ChatResponse,
is_streaming: bool = False,
) -> Tuple[List[BaseReasoningStep], bool]:
tools_dict: Dict[str, AsyncBaseTool] = {
tool.metadata.get_name(): tool for tool in tools
}
_, current_reasoning, is_done = self._extract_reasoning_step(
output, is_streaming
)
if is_done:
return current_reasoning, True
# call tool with input
reasoning_step = cast(ActionReasoningStep, current_reasoning[-1])
tool = tools_dict[reasoning_step.action]
with self.callback_manager.event(
CBEventType.FUNCTION_CALL,
payload={
EventPayload.FUNCTION_CALL: reasoning_step.action_input,
EventPayload.TOOL: tool.metadata,
},
) as event:
tool_output = tool.call(**reasoning_step.action_input)
event.on_end(payload={EventPayload.FUNCTION_OUTPUT: str(tool_output)})
task.extra_state["sources"].append(tool_output)
observation_step = ObservationReasoningStep(observation=str(tool_output))
current_reasoning.append(observation_step)
if self._verbose:
print_text(f"{observation_step.get_content()}\n", color="blue")
return current_reasoning, False
async def _aprocess_actions(
self,
task: Task,
tools: Sequence[AsyncBaseTool],
output: ChatResponse,
is_streaming: bool = False,
) -> Tuple[List[BaseReasoningStep], bool]:
tools_dict = {tool.metadata.name: tool for tool in tools}
_, current_reasoning, is_done = self._extract_reasoning_step(
output, is_streaming
)
if is_done:
return current_reasoning, True
# call tool with input
reasoning_step = cast(ActionReasoningStep, current_reasoning[-1])
tool = tools_dict[reasoning_step.action]
with self.callback_manager.event(
CBEventType.FUNCTION_CALL,
payload={
EventPayload.FUNCTION_CALL: reasoning_step.action_input,
EventPayload.TOOL: tool.metadata,
},
) as event:
tool_output = await tool.acall(**reasoning_step.action_input)
event.on_end(payload={EventPayload.FUNCTION_OUTPUT: str(tool_output)})
task.extra_state["sources"].append(tool_output)
observation_step = ObservationReasoningStep(observation=str(tool_output))
current_reasoning.append(observation_step)
if self._verbose:
print_text(f"{observation_step.get_content()}\n", color="blue")
return current_reasoning, False
def _get_response(
self,
current_reasoning: List[BaseReasoningStep],
sources: List[ToolOutput],
) -> AgentChatResponse:
"""Get response from reasoning steps."""
if len(current_reasoning) == 0:
raise ValueError("No reasoning steps were taken.")
elif len(current_reasoning) == self._max_iterations:
raise ValueError("Reached max iterations.")
if isinstance(current_reasoning[-1], ResponseReasoningStep):
response_step = cast(ResponseReasoningStep, current_reasoning[-1])
response_str = response_step.response
else:
response_str = current_reasoning[-1].get_content()
# TODO: add sources from reasoning steps
return AgentChatResponse(response=response_str, sources=sources)
def _get_task_step_response(
self, agent_response: AGENT_CHAT_RESPONSE_TYPE, step: TaskStep, is_done: bool
) -> TaskStepOutput:
"""Get task step response."""
if is_done:
new_steps = []
else:
new_steps = [
step.get_next_step(
step_id=str(uuid.uuid4()),
# NOTE: input is unused
input=None,
)
]
return TaskStepOutput(
output=agent_response,
task_step=step,
is_last=is_done,
next_steps=new_steps,
)
def _infer_stream_chunk_is_final(self, chunk: ChatResponse) -> bool:
"""Infers if a chunk from a live stream is the start of the final
reasoning step. (i.e., and should eventually become
ResponseReasoningStep — not part of this function's logic tho.).
Args:
chunk (ChatResponse): the current chunk stream to check
Returns:
bool: Boolean on whether the chunk is the start of the final response
"""
latest_content = chunk.message.content
if latest_content:
if not latest_content.startswith(
"Thought"
): # doesn't follow thought-action format
return True
else:
if "Answer: " in latest_content:
return True
return False
def _add_back_chunk_to_stream(
self, chunk: ChatResponse, chat_stream: Generator[ChatResponse, None, None]
) -> Generator[ChatResponse, None, None]:
"""Helper method for adding back initial chunk stream of final response
back to the rest of the chat_stream.
Args:
chunk (ChatResponse): the chunk to add back to the beginning of the
chat_stream.
Return:
Generator[ChatResponse, None, None]: the updated chat_stream
"""
updated_stream = chain.from_iterable( # need to add back partial response chunk
[
unit_generator(chunk),
chat_stream,
]
)
# use cast to avoid mypy issue with chain and Generator
updated_stream_c: Generator[ChatResponse, None, None] = cast(
Generator[ChatResponse, None, None], updated_stream
)
return updated_stream_c
async def _async_add_back_chunk_to_stream(
self, chunk: ChatResponse, chat_stream: AsyncGenerator[ChatResponse, None]
) -> AsyncGenerator[ChatResponse, None]:
"""Helper method for adding back initial chunk stream of final response
back to the rest of the chat_stream.
NOTE: this itself is not an async function.
Args:
chunk (ChatResponse): the chunk to add back to the beginning of the
chat_stream.
Return:
AsyncGenerator[ChatResponse, None]: the updated async chat_stream
"""
yield chunk
async for item in chat_stream:
yield item
def _run_step(
self,
step: TaskStep,
task: Task,
) -> TaskStepOutput:
"""Run step."""
if step.input is not None:
add_user_step_to_reasoning(
step,
task.extra_state["new_memory"],
task.extra_state["current_reasoning"],
verbose=self._verbose,
)
# TODO: see if we want to do step-based inputs
tools = self.get_tools(task.input)
input_chat = self._react_chat_formatter.format(
tools,
chat_history=task.memory.get() + task.extra_state["new_memory"].get_all(),
current_reasoning=task.extra_state["current_reasoning"],
)
# send prompt
chat_response = self._llm.chat(input_chat)
# given react prompt outputs, call tools or return response
reasoning_steps, is_done = self._process_actions(
task, tools, output=chat_response
)
task.extra_state["current_reasoning"].extend(reasoning_steps)
agent_response = self._get_response(
task.extra_state["current_reasoning"], task.extra_state["sources"]
)
if is_done:
task.extra_state["new_memory"].put(
ChatMessage(content=agent_response.response, role=MessageRole.ASSISTANT)
)
return self._get_task_step_response(agent_response, step, is_done)
async def _arun_step(
self,
step: TaskStep,
task: Task,
) -> TaskStepOutput:
"""Run step."""
if step.input is not None:
add_user_step_to_reasoning(
step,
task.extra_state["new_memory"],
task.extra_state["current_reasoning"],
verbose=self._verbose,
)
# TODO: see if we want to do step-based inputs
tools = self.get_tools(task.input)
input_chat = self._react_chat_formatter.format(
tools,
chat_history=task.memory.get() + task.extra_state["new_memory"].get_all(),
current_reasoning=task.extra_state["current_reasoning"],
)
# send prompt
chat_response = await self._llm.achat(input_chat)
# given react prompt outputs, call tools or return response
reasoning_steps, is_done = await self._aprocess_actions(
task, tools, output=chat_response
)
task.extra_state["current_reasoning"].extend(reasoning_steps)
agent_response = self._get_response(
task.extra_state["current_reasoning"], task.extra_state["sources"]
)
if is_done:
task.extra_state["new_memory"].put(
ChatMessage(content=agent_response.response, role=MessageRole.ASSISTANT)
)
return self._get_task_step_response(agent_response, step, is_done)
def _run_step_stream(
self,
step: TaskStep,
task: Task,
) -> TaskStepOutput:
"""Run step."""
if step.input is not None:
add_user_step_to_reasoning(
step,
task.extra_state["new_memory"],
task.extra_state["current_reasoning"],
verbose=self._verbose,
)
# TODO: see if we want to do step-based inputs
tools = self.get_tools(task.input)
input_chat = self._react_chat_formatter.format(
tools,
chat_history=task.memory.get() + task.extra_state["new_memory"].get_all(),
current_reasoning=task.extra_state["current_reasoning"],
)
chat_stream = self._llm.stream_chat(input_chat)
# iterate over stream, break out if is final answer after the "Answer: "
full_response = ChatResponse(
message=ChatMessage(content=None, role="assistant")
)
is_done = False
for latest_chunk in chat_stream:
full_response = latest_chunk
is_done = self._infer_stream_chunk_is_final(latest_chunk)
if is_done:
break
if not is_done:
# given react prompt outputs, call tools or return response
reasoning_steps, _ = self._process_actions(
task, tools=tools, output=full_response, is_streaming=True
)
task.extra_state["current_reasoning"].extend(reasoning_steps)
# use _get_response to return intermediate response
agent_response: AGENT_CHAT_RESPONSE_TYPE = self._get_response(
task.extra_state["current_reasoning"], task.extra_state["sources"]
)
else:
# Get the response in a separate thread so we can yield the response
response_stream = self._add_back_chunk_to_stream(
chunk=latest_chunk, chat_stream=chat_stream
)
agent_response = StreamingAgentChatResponse(
chat_stream=response_stream,
sources=task.extra_state["sources"],
)
thread = Thread(
target=agent_response.write_response_to_history,
args=(task.extra_state["new_memory"],),
)
thread.start()
return self._get_task_step_response(agent_response, step, is_done)
async def _arun_step_stream(
self,
step: TaskStep,
task: Task,
) -> TaskStepOutput:
"""Run step."""
if step.input is not None:
add_user_step_to_reasoning(
step,
task.extra_state["new_memory"],
task.extra_state["current_reasoning"],
verbose=self._verbose,
)
# TODO: see if we want to do step-based inputs
tools = self.get_tools(task.input)
input_chat = self._react_chat_formatter.format(
tools,
chat_history=task.memory.get() + task.extra_state["new_memory"].get_all(),
current_reasoning=task.extra_state["current_reasoning"],
)
chat_stream = await self._llm.astream_chat(input_chat)
# iterate over stream, break out if is final answer after the "Answer: "
full_response = ChatResponse(
message=ChatMessage(content=None, role="assistant")
)
is_done = False
async for latest_chunk in chat_stream:
full_response = latest_chunk
is_done = self._infer_stream_chunk_is_final(latest_chunk)
if is_done:
break
if not is_done:
# given react prompt outputs, call tools or return response
reasoning_steps, _ = self._process_actions(
task, tools=tools, output=full_response, is_streaming=True
)
task.extra_state["current_reasoning"].extend(reasoning_steps)
# use _get_response to return intermediate response
agent_response: AGENT_CHAT_RESPONSE_TYPE = self._get_response(
task.extra_state["current_reasoning"], task.extra_state["sources"]
)
else:
# Get the response in a separate thread so we can yield the response
response_stream = self._async_add_back_chunk_to_stream(
chunk=latest_chunk, chat_stream=chat_stream
)
agent_response = StreamingAgentChatResponse(
achat_stream=response_stream,
sources=task.extra_state["sources"],
)
# create task to write chat response to history
asyncio.create_task(
agent_response.awrite_response_to_history(
task.extra_state["new_memory"]
)
)
# wait until response writing is done
await agent_response._is_function_false_event.wait()
return self._get_task_step_response(agent_response, step, is_done)
@trace_method("run_step")
def run_step(self, step: TaskStep, task: Task, **kwargs: Any) -> TaskStepOutput:
"""Run step."""
return self._run_step(step, task)
@trace_method("run_step")
async def arun_step(
self, step: TaskStep, task: Task, **kwargs: Any
) -> TaskStepOutput:
"""Run step (async)."""
return await self._arun_step(step, task)
@trace_method("run_step")
def stream_step(self, step: TaskStep, task: Task, **kwargs: Any) -> TaskStepOutput:
"""Run step (stream)."""
# TODO: figure out if we need a different type for TaskStepOutput
return self._run_step_stream(step, task)
@trace_method("run_step")
async def astream_step(
self, step: TaskStep, task: Task, **kwargs: Any
) -> TaskStepOutput:
"""Run step (async stream)."""
return await self._arun_step_stream(step, task)
def finalize_task(self, task: Task, **kwargs: Any) -> None:
"""Finalize task, after all the steps are completed."""
# add new messages to memory
task.memory.set(task.memory.get() + task.extra_state["new_memory"].get_all())
# reset new memory
task.extra_state["new_memory"].reset()
| [
"None"
] |
2024-01-10 | truesoni/llama_index | llama_index~agent~openai_assistant_agent.py | """OpenAI Assistant Agent."""
import asyncio
import json
import logging
import time
from typing import Any, Dict, List, Optional, Tuple, Union, cast
from llama_index.agent.openai.utils import get_function_by_name
from llama_index.agent.types import BaseAgent
from llama_index.callbacks import (
CallbackManager,
CBEventType,
EventPayload,
trace_method,
)
from llama_index.chat_engine.types import (
AGENT_CHAT_RESPONSE_TYPE,
AgentChatResponse,
ChatResponseMode,
StreamingAgentChatResponse,
)
from llama_index.llms.types import ChatMessage, MessageRole
from llama_index.tools import BaseTool, ToolOutput, adapt_to_async_tool
logger = logging.getLogger(__name__)
logger.setLevel(logging.WARNING)
def from_openai_thread_message(thread_message: Any) -> ChatMessage:
"""From OpenAI thread message."""
from openai.types.beta.threads import MessageContentText, ThreadMessage
thread_message = cast(ThreadMessage, thread_message)
# we don't have a way of showing images, just do text for now
text_contents = [
t for t in thread_message.content if isinstance(t, MessageContentText)
]
text_content_str = " ".join([t.text.value for t in text_contents])
return ChatMessage(
role=thread_message.role,
content=text_content_str,
additional_kwargs={
"thread_message": thread_message,
"thread_id": thread_message.thread_id,
"assistant_id": thread_message.assistant_id,
"id": thread_message.id,
"metadata": thread_message.metadata,
},
)
def from_openai_thread_messages(thread_messages: List[Any]) -> List[ChatMessage]:
"""From OpenAI thread messages."""
return [
from_openai_thread_message(thread_message) for thread_message in thread_messages
]
def call_function(
tools: List[BaseTool], fn_obj: Any, verbose: bool = False
) -> Tuple[ChatMessage, ToolOutput]:
"""Call a function and return the output as a string."""
from openai.types.beta.threads.required_action_function_tool_call import Function
fn_obj = cast(Function, fn_obj)
# TMP: consolidate with other abstractions
name = fn_obj.name
arguments_str = fn_obj.arguments
if verbose:
print("=== Calling Function ===")
print(f"Calling function: {name} with args: {arguments_str}")
tool = get_function_by_name(tools, name)
argument_dict = json.loads(arguments_str)
output = tool(**argument_dict)
if verbose:
print(f"Got output: {output!s}")
print("========================")
return (
ChatMessage(
content=str(output),
role=MessageRole.FUNCTION,
additional_kwargs={
"name": fn_obj.name,
},
),
output,
)
async def acall_function(
tools: List[BaseTool], fn_obj: Any, verbose: bool = False
) -> Tuple[ChatMessage, ToolOutput]:
"""Call an async function and return the output as a string."""
from openai.types.beta.threads.required_action_function_tool_call import Function
fn_obj = cast(Function, fn_obj)
# TMP: consolidate with other abstractions
name = fn_obj.name
arguments_str = fn_obj.arguments
if verbose:
print("=== Calling Function ===")
print(f"Calling function: {name} with args: {arguments_str}")
tool = get_function_by_name(tools, name)
argument_dict = json.loads(arguments_str)
async_tool = adapt_to_async_tool(tool)
output = await async_tool.acall(**argument_dict)
if verbose:
print(f"Got output: {output!s}")
print("========================")
return (
ChatMessage(
content=str(output),
role=MessageRole.FUNCTION,
additional_kwargs={
"name": fn_obj.name,
},
),
output,
)
def _process_files(client: Any, files: List[str]) -> Dict[str, str]:
"""Process files."""
from openai import OpenAI
client = cast(OpenAI, client)
file_dict = {}
for file in files:
file_obj = client.files.create(file=open(file, "rb"), purpose="assistants")
file_dict[file_obj.id] = file
return file_dict
class OpenAIAssistantAgent(BaseAgent):
"""OpenAIAssistant agent.
Wrapper around OpenAI assistant API: https://platform.openai.com/docs/assistants/overview
"""
def __init__(
self,
client: Any,
assistant: Any,
tools: Optional[List[BaseTool]],
callback_manager: Optional[CallbackManager] = None,
thread_id: Optional[str] = None,
instructions_prefix: Optional[str] = None,
run_retrieve_sleep_time: float = 0.1,
file_dict: Dict[str, str] = {},
verbose: bool = False,
) -> None:
"""Init params."""
from openai import OpenAI
from openai.types.beta.assistant import Assistant
self._client = cast(OpenAI, client)
self._assistant = cast(Assistant, assistant)
self._tools = tools or []
if thread_id is None:
thread = self._client.beta.threads.create()
thread_id = thread.id
self._thread_id = thread_id
self._instructions_prefix = instructions_prefix
self._run_retrieve_sleep_time = run_retrieve_sleep_time
self._verbose = verbose
self.file_dict = file_dict
self.callback_manager = callback_manager or CallbackManager([])
@classmethod
def from_new(
cls,
name: str,
instructions: str,
tools: Optional[List[BaseTool]] = None,
openai_tools: Optional[List[Dict]] = None,
thread_id: Optional[str] = None,
model: str = "gpt-4-1106-preview",
instructions_prefix: Optional[str] = None,
run_retrieve_sleep_time: float = 0.1,
files: Optional[List[str]] = None,
callback_manager: Optional[CallbackManager] = None,
verbose: bool = False,
file_ids: Optional[List[str]] = None,
api_key: Optional[str] = None,
) -> "OpenAIAssistantAgent":
"""From new assistant.
Args:
name: name of assistant
instructions: instructions for assistant
tools: list of tools
openai_tools: list of openai tools
thread_id: thread id
model: model
run_retrieve_sleep_time: run retrieve sleep time
files: files
instructions_prefix: instructions prefix
callback_manager: callback manager
verbose: verbose
file_ids: list of file ids
api_key: OpenAI API key
"""
from openai import OpenAI
# this is the set of openai tools
# not to be confused with the tools we pass in for function calling
openai_tools = openai_tools or []
tools = tools or []
tool_fns = [t.metadata.to_openai_tool() for t in tools]
all_openai_tools = openai_tools + tool_fns
# initialize client
client = OpenAI(api_key=api_key)
# process files
files = files or []
file_ids = file_ids or []
file_dict = _process_files(client, files)
all_file_ids = list(file_dict.keys()) + file_ids
# TODO: openai's typing is a bit sus
all_openai_tools = cast(List[Any], all_openai_tools)
assistant = client.beta.assistants.create(
name=name,
instructions=instructions,
tools=cast(List[Any], all_openai_tools),
model=model,
file_ids=all_file_ids + file_ids,
)
return cls(
client,
assistant,
tools,
callback_manager=callback_manager,
thread_id=thread_id,
instructions_prefix=instructions_prefix,
file_dict=file_dict,
run_retrieve_sleep_time=run_retrieve_sleep_time,
verbose=verbose,
)
@classmethod
def from_existing(
cls,
assistant_id: str,
tools: Optional[List[BaseTool]] = None,
thread_id: Optional[str] = None,
instructions_prefix: Optional[str] = None,
run_retrieve_sleep_time: float = 0.1,
callback_manager: Optional[CallbackManager] = None,
api_key: Optional[str] = None,
verbose: bool = False,
) -> "OpenAIAssistantAgent":
"""From existing assistant id.
Args:
assistant_id: id of assistant
tools: list of BaseTools Assistant can use
thread_id: thread id
run_retrieve_sleep_time: run retrieve sleep time
instructions_prefix: instructions prefix
callback_manager: callback manager
api_key: OpenAI API key
verbose: verbose
"""
from openai import OpenAI
# initialize client
client = OpenAI(api_key=api_key)
# get assistant
assistant = client.beta.assistants.retrieve(assistant_id)
# assistant.tools is incompatible with BaseTools so have to pass from params
return cls(
client,
assistant,
tools=tools,
callback_manager=callback_manager,
thread_id=thread_id,
instructions_prefix=instructions_prefix,
run_retrieve_sleep_time=run_retrieve_sleep_time,
verbose=verbose,
)
@property
def assistant(self) -> Any:
"""Get assistant."""
return self._assistant
@property
def client(self) -> Any:
"""Get client."""
return self._client
@property
def thread_id(self) -> str:
"""Get thread id."""
return self._thread_id
@property
def files_dict(self) -> Dict[str, str]:
"""Get files dict."""
return self.file_dict
@property
def chat_history(self) -> List[ChatMessage]:
raw_messages = self._client.beta.threads.messages.list(
thread_id=self._thread_id, order="asc"
)
return from_openai_thread_messages(list(raw_messages))
def reset(self) -> None:
"""Delete and create a new thread."""
self._client.beta.threads.delete(self._thread_id)
thread = self._client.beta.threads.create()
thread_id = thread.id
self._thread_id = thread_id
def get_tools(self, message: str) -> List[BaseTool]:
"""Get tools."""
return self._tools
def upload_files(self, files: List[str]) -> Dict[str, Any]:
"""Upload files."""
return _process_files(self._client, files)
def add_message(self, message: str, file_ids: Optional[List[str]] = None) -> Any:
"""Add message to assistant."""
file_ids = file_ids or []
return self._client.beta.threads.messages.create(
thread_id=self._thread_id,
role="user",
content=message,
file_ids=file_ids,
)
def _run_function_calling(self, run: Any) -> List[ToolOutput]:
"""Run function calling."""
tool_calls = run.required_action.submit_tool_outputs.tool_calls
tool_output_dicts = []
tool_output_objs: List[ToolOutput] = []
for tool_call in tool_calls:
fn_obj = tool_call.function
_, tool_output = call_function(self._tools, fn_obj, verbose=self._verbose)
tool_output_dicts.append(
{"tool_call_id": tool_call.id, "output": str(tool_output)}
)
tool_output_objs.append(tool_output)
# submit tool outputs
# TODO: openai's typing is a bit sus
self._client.beta.threads.runs.submit_tool_outputs(
thread_id=self._thread_id,
run_id=run.id,
tool_outputs=cast(List[Any], tool_output_dicts),
)
return tool_output_objs
async def _arun_function_calling(self, run: Any) -> List[ToolOutput]:
"""Run function calling."""
tool_calls = run.required_action.submit_tool_outputs.tool_calls
tool_output_dicts = []
tool_output_objs: List[ToolOutput] = []
for tool_call in tool_calls:
fn_obj = tool_call.function
_, tool_output = await acall_function(
self._tools, fn_obj, verbose=self._verbose
)
tool_output_dicts.append(
{"tool_call_id": tool_call.id, "output": str(tool_output)}
)
tool_output_objs.append(tool_output)
# submit tool outputs
self._client.beta.threads.runs.submit_tool_outputs(
thread_id=self._thread_id,
run_id=run.id,
tool_outputs=cast(List[Any], tool_output_dicts),
)
return tool_output_objs
def run_assistant(
self, instructions_prefix: Optional[str] = None
) -> Tuple[Any, Dict]:
"""Run assistant."""
instructions_prefix = instructions_prefix or self._instructions_prefix
run = self._client.beta.threads.runs.create(
thread_id=self._thread_id,
assistant_id=self._assistant.id,
instructions=instructions_prefix,
)
from openai.types.beta.threads import Run
run = cast(Run, run)
sources = []
while run.status in ["queued", "in_progress", "requires_action"]:
run = self._client.beta.threads.runs.retrieve(
thread_id=self._thread_id, run_id=run.id
)
if run.status == "requires_action":
cur_tool_outputs = self._run_function_calling(run)
sources.extend(cur_tool_outputs)
time.sleep(self._run_retrieve_sleep_time)
if run.status == "failed":
raise ValueError(
f"Run failed with status {run.status}.\n" f"Error: {run.last_error}"
)
return run, {"sources": sources}
async def arun_assistant(
self, instructions_prefix: Optional[str] = None
) -> Tuple[Any, Dict]:
"""Run assistant."""
instructions_prefix = instructions_prefix or self._instructions_prefix
run = self._client.beta.threads.runs.create(
thread_id=self._thread_id,
assistant_id=self._assistant.id,
instructions=instructions_prefix,
)
from openai.types.beta.threads import Run
run = cast(Run, run)
sources = []
while run.status in ["queued", "in_progress", "requires_action"]:
run = self._client.beta.threads.runs.retrieve(
thread_id=self._thread_id, run_id=run.id
)
if run.status == "requires_action":
cur_tool_outputs = await self._arun_function_calling(run)
sources.extend(cur_tool_outputs)
await asyncio.sleep(self._run_retrieve_sleep_time)
if run.status == "failed":
raise ValueError(
f"Run failed with status {run.status}.\n" f"Error: {run.last_error}"
)
return run, {"sources": sources}
@property
def latest_message(self) -> ChatMessage:
"""Get latest message."""
raw_messages = self._client.beta.threads.messages.list(
thread_id=self._thread_id, order="desc"
)
messages = from_openai_thread_messages(list(raw_messages))
return messages[0]
def _chat(
self,
message: str,
chat_history: Optional[List[ChatMessage]] = None,
function_call: Union[str, dict] = "auto",
mode: ChatResponseMode = ChatResponseMode.WAIT,
) -> AGENT_CHAT_RESPONSE_TYPE:
"""Main chat interface."""
# TODO: since chat interface doesn't expose additional kwargs
# we can't pass in file_ids per message
added_message_obj = self.add_message(message)
run, metadata = self.run_assistant(
instructions_prefix=self._instructions_prefix,
)
latest_message = self.latest_message
# get most recent message content
return AgentChatResponse(
response=str(latest_message.content),
sources=metadata["sources"],
)
async def _achat(
self,
message: str,
chat_history: Optional[List[ChatMessage]] = None,
function_call: Union[str, dict] = "auto",
mode: ChatResponseMode = ChatResponseMode.WAIT,
) -> AGENT_CHAT_RESPONSE_TYPE:
"""Asynchronous main chat interface."""
self.add_message(message)
run, metadata = await self.arun_assistant(
instructions_prefix=self._instructions_prefix,
)
latest_message = self.latest_message
# get most recent message content
return AgentChatResponse(
response=str(latest_message.content),
sources=metadata["sources"],
)
@trace_method("chat")
def chat(
self,
message: str,
chat_history: Optional[List[ChatMessage]] = None,
function_call: Union[str, dict] = "auto",
) -> AgentChatResponse:
with self.callback_manager.event(
CBEventType.AGENT_STEP,
payload={EventPayload.MESSAGES: [message]},
) as e:
chat_response = self._chat(
message, chat_history, function_call, mode=ChatResponseMode.WAIT
)
assert isinstance(chat_response, AgentChatResponse)
e.on_end(payload={EventPayload.RESPONSE: chat_response})
return chat_response
@trace_method("chat")
async def achat(
self,
message: str,
chat_history: Optional[List[ChatMessage]] = None,
function_call: Union[str, dict] = "auto",
) -> AgentChatResponse:
with self.callback_manager.event(
CBEventType.AGENT_STEP,
payload={EventPayload.MESSAGES: [message]},
) as e:
chat_response = await self._achat(
message, chat_history, function_call, mode=ChatResponseMode.WAIT
)
assert isinstance(chat_response, AgentChatResponse)
e.on_end(payload={EventPayload.RESPONSE: chat_response})
return chat_response
@trace_method("chat")
def stream_chat(
self,
message: str,
chat_history: Optional[List[ChatMessage]] = None,
function_call: Union[str, dict] = "auto",
) -> StreamingAgentChatResponse:
raise NotImplementedError("stream_chat not implemented")
@trace_method("chat")
async def astream_chat(
self,
message: str,
chat_history: Optional[List[ChatMessage]] = None,
function_call: Union[str, dict] = "auto",
) -> StreamingAgentChatResponse:
raise NotImplementedError("astream_chat not implemented")
| [] |
2024-01-10 | truesoni/llama_index | llama_index~finetuning~types.py | """Finetuning Engine."""
from abc import ABC, abstractmethod
from typing import Any
from llama_index.embeddings.base import BaseEmbedding
from llama_index.llms.llm import LLM
from llama_index.postprocessor import CohereRerank, SentenceTransformerRerank
class BaseLLMFinetuneEngine(ABC):
"""Base LLM finetuning engine."""
@abstractmethod
def finetune(self) -> None:
"""Goes off and does stuff."""
@abstractmethod
def get_finetuned_model(self, **model_kwargs: Any) -> LLM:
"""Gets finetuned model."""
class BaseEmbeddingFinetuneEngine(ABC):
"""Base Embedding finetuning engine."""
@abstractmethod
def finetune(self) -> None:
"""Goes off and does stuff."""
@abstractmethod
def get_finetuned_model(self, **model_kwargs: Any) -> BaseEmbedding:
"""Gets finetuned model."""
class BaseCrossEncoderFinetuningEngine(ABC):
"""Base Cross Encoder Finetuning Engine."""
@abstractmethod
def finetune(self) -> None:
"""Goes off and does stuff."""
@abstractmethod
def get_finetuned_model(
self, model_name: str, top_n: int = 3
) -> SentenceTransformerRerank:
"""Gets fine-tuned Cross-Encoder model as re-ranker."""
class BaseCohereRerankerFinetuningEngine(ABC):
"""Base Cohere Reranker Finetuning Engine."""
@abstractmethod
def finetune(self) -> None:
"""Goes off and does stuff."""
@abstractmethod
def get_finetuned_model(self, top_n: int = 5) -> CohereRerank:
"""Gets finetuned model."""
| [] |
2024-01-10 | truesoni/llama_index | llama_index~llms~openrouter.py | from typing import Any, Dict, Optional
from llama_index.bridge.pydantic import Field
from llama_index.constants import (
DEFAULT_CONTEXT_WINDOW,
DEFAULT_NUM_OUTPUTS,
DEFAULT_TEMPERATURE,
)
from llama_index.llms.generic_utils import get_from_param_or_env
from llama_index.llms.openai_like import OpenAILike
from llama_index.llms.types import LLMMetadata
DEFAULT_API_BASE = "https://openrouter.ai/api/v1"
DEFAULT_MODEL = "gryphe/mythomax-l2-13b"
class OpenRouter(OpenAILike):
model: str = Field(
description="The OpenRouter model to use. See https://openrouter.ai/models for options."
)
context_window: int = Field(
default=DEFAULT_CONTEXT_WINDOW,
description="The maximum number of context tokens for the model. See https://openrouter.ai/models for options.",
gt=0,
)
is_chat_model: bool = Field(
default=True,
description=LLMMetadata.__fields__["is_chat_model"].field_info.description,
)
def __init__(
self,
model: str = DEFAULT_MODEL,
temperature: float = DEFAULT_TEMPERATURE,
max_tokens: int = DEFAULT_NUM_OUTPUTS,
additional_kwargs: Optional[Dict[str, Any]] = None,
max_retries: int = 5,
api_base: Optional[str] = DEFAULT_API_BASE,
api_key: Optional[str] = None,
**kwargs: Any,
) -> None:
additional_kwargs = additional_kwargs or {}
api_base = get_from_param_or_env("api_base", api_base, "OPENROUTER_API_BASE")
api_key = get_from_param_or_env("api_key", api_key, "OPENROUTER_API_KEY")
super().__init__(
model=model,
temperature=temperature,
max_tokens=max_tokens,
api_base=api_base,
api_key=api_key,
additional_kwargs=additional_kwargs,
max_retries=max_retries,
**kwargs,
)
@classmethod
def class_name(cls) -> str:
return "OpenRouter_LLM"
| [] |
2024-01-10 | truesoni/llama_index | llama_index~agent~legacy~context_retriever_agent.py | """Context retriever agent."""
from typing import List, Optional, Type, Union
from llama_index.agent.legacy.openai_agent import (
DEFAULT_MAX_FUNCTION_CALLS,
DEFAULT_MODEL_NAME,
BaseOpenAIAgent,
)
from llama_index.callbacks import CallbackManager
from llama_index.chat_engine.types import (
AgentChatResponse,
)
from llama_index.core import BaseRetriever
from llama_index.llms.llm import LLM
from llama_index.llms.openai import OpenAI
from llama_index.llms.openai_utils import is_function_calling_model
from llama_index.llms.types import ChatMessage
from llama_index.memory import BaseMemory, ChatMemoryBuffer
from llama_index.prompts import PromptTemplate
from llama_index.schema import NodeWithScore
from llama_index.tools import BaseTool
from llama_index.utils import print_text
# inspired by DEFAULT_QA_PROMPT_TMPL from llama_index/prompts/default_prompts.py
DEFAULT_QA_PROMPT_TMPL = (
"Context information is below.\n"
"---------------------\n"
"{context_str}\n"
"---------------------\n"
"Given the context information and not prior knowledge, "
"either pick the corresponding tool or answer the function: {query_str}\n"
)
DEFAULT_QA_PROMPT = PromptTemplate(DEFAULT_QA_PROMPT_TMPL)
class ContextRetrieverOpenAIAgent(BaseOpenAIAgent):
"""ContextRetriever OpenAI Agent.
This agent performs retrieval from BaseRetriever before
calling the LLM. Allows it to augment user message with context.
NOTE: this is a beta feature, function interfaces might change.
Args:
tools (List[BaseTool]): A list of tools.
retriever (BaseRetriever): A retriever.
qa_prompt (Optional[PromptTemplate]): A QA prompt.
context_separator (str): A context separator.
llm (Optional[OpenAI]): An OpenAI LLM.
chat_history (Optional[List[ChatMessage]]): A chat history.
prefix_messages: List[ChatMessage]: A list of prefix messages.
verbose (bool): Whether to print debug statements.
max_function_calls (int): Maximum number of function calls.
callback_manager (Optional[CallbackManager]): A callback manager.
"""
def __init__(
self,
tools: List[BaseTool],
retriever: BaseRetriever,
qa_prompt: PromptTemplate,
context_separator: str,
llm: OpenAI,
memory: BaseMemory,
prefix_messages: List[ChatMessage],
verbose: bool = False,
max_function_calls: int = DEFAULT_MAX_FUNCTION_CALLS,
callback_manager: Optional[CallbackManager] = None,
) -> None:
super().__init__(
llm=llm,
memory=memory,
prefix_messages=prefix_messages,
verbose=verbose,
max_function_calls=max_function_calls,
callback_manager=callback_manager,
)
self._tools = tools
self._qa_prompt = qa_prompt
self._retriever = retriever
self._context_separator = context_separator
@classmethod
def from_tools_and_retriever(
cls,
tools: List[BaseTool],
retriever: BaseRetriever,
qa_prompt: Optional[PromptTemplate] = None,
context_separator: str = "\n",
llm: Optional[LLM] = None,
chat_history: Optional[List[ChatMessage]] = None,
memory: Optional[BaseMemory] = None,
memory_cls: Type[BaseMemory] = ChatMemoryBuffer,
verbose: bool = False,
max_function_calls: int = DEFAULT_MAX_FUNCTION_CALLS,
callback_manager: Optional[CallbackManager] = None,
system_prompt: Optional[str] = None,
prefix_messages: Optional[List[ChatMessage]] = None,
) -> "ContextRetrieverOpenAIAgent":
"""Create a ContextRetrieverOpenAIAgent from a retriever.
Args:
retriever (BaseRetriever): A retriever.
qa_prompt (Optional[PromptTemplate]): A QA prompt.
context_separator (str): A context separator.
llm (Optional[OpenAI]): An OpenAI LLM.
chat_history (Optional[ChatMessageHistory]): A chat history.
verbose (bool): Whether to print debug statements.
max_function_calls (int): Maximum number of function calls.
callback_manager (Optional[CallbackManager]): A callback manager.
"""
qa_prompt = qa_prompt or DEFAULT_QA_PROMPT
chat_history = chat_history or []
llm = llm or OpenAI(model=DEFAULT_MODEL_NAME)
if not isinstance(llm, OpenAI):
raise ValueError("llm must be a OpenAI instance")
if callback_manager is not None:
llm.callback_manager = callback_manager
memory = memory or memory_cls.from_defaults(chat_history=chat_history, llm=llm)
if not is_function_calling_model(llm.model):
raise ValueError(
f"Model name {llm.model} does not support function calling API."
)
if system_prompt is not None:
if prefix_messages is not None:
raise ValueError(
"Cannot specify both system_prompt and prefix_messages"
)
prefix_messages = [ChatMessage(content=system_prompt, role="system")]
prefix_messages = prefix_messages or []
return cls(
tools=tools,
retriever=retriever,
qa_prompt=qa_prompt,
context_separator=context_separator,
llm=llm,
memory=memory,
prefix_messages=prefix_messages,
verbose=verbose,
max_function_calls=max_function_calls,
callback_manager=callback_manager,
)
def _get_tools(self, message: str) -> List[BaseTool]:
"""Get tools."""
return self._tools
def _build_formatted_message(self, message: str) -> str:
# augment user message
retrieved_nodes_w_scores: List[NodeWithScore] = self._retriever.retrieve(
message
)
retrieved_nodes = [node.node for node in retrieved_nodes_w_scores]
retrieved_texts = [node.get_content() for node in retrieved_nodes]
# format message
context_str = self._context_separator.join(retrieved_texts)
return self._qa_prompt.format(context_str=context_str, query_str=message)
def chat(
self,
message: str,
chat_history: Optional[List[ChatMessage]] = None,
tool_choice: Union[str, dict] = "auto",
) -> AgentChatResponse:
"""Chat."""
formatted_message = self._build_formatted_message(message)
if self._verbose:
print_text(formatted_message + "\n", color="yellow")
return super().chat(
formatted_message, chat_history=chat_history, tool_choice=tool_choice
)
async def achat(
self,
message: str,
chat_history: Optional[List[ChatMessage]] = None,
tool_choice: Union[str, dict] = "auto",
) -> AgentChatResponse:
"""Chat."""
formatted_message = self._build_formatted_message(message)
if self._verbose:
print_text(formatted_message + "\n", color="yellow")
return await super().achat(
formatted_message, chat_history=chat_history, tool_choice=tool_choice
)
def get_tools(self, message: str) -> List[BaseTool]:
"""Get tools."""
return self._get_tools(message)
| [
"Context information is below.\n---------------------\n{context_str}\n---------------------\nGiven the context information and not prior knowledge, either pick the corresponding tool or answer the function: {query_str}\n"
] |
2024-01-10 | truesoni/llama_index | llama_index~evaluation~multi_modal~faithfulness.py | """Faithfulness evaluation."""
from __future__ import annotations
from typing import Any, List, Optional, Sequence, Union
from llama_index.evaluation.base import BaseEvaluator, EvaluationResult
from llama_index.multi_modal_llms.base import MultiModalLLM
from llama_index.multi_modal_llms.openai import OpenAIMultiModal
from llama_index.prompts import BasePromptTemplate, PromptTemplate
from llama_index.prompts.mixin import PromptDictType
from llama_index.schema import ImageNode
DEFAULT_EVAL_TEMPLATE = PromptTemplate(
"Please tell if a given piece of information "
"is supported by the visual as well as textual context information.\n"
"You need to answer with either YES or NO.\n"
"Answer YES if any of the image(s) and textual context supports the information, even "
"if most of the context is unrelated. "
"Some examples are provided below with only text context, but please do use\n"
"any images for context if they are provided.\n\n"
"Information: Apple pie is generally double-crusted.\n"
"Context: An apple pie is a fruit pie in which the principal filling "
"ingredient is apples. \n"
"Apple pie is often served with whipped cream, ice cream "
"('apple pie à la mode'), custard or cheddar cheese.\n"
"It is generally double-crusted, with pastry both above "
"and below the filling; the upper crust may be solid or "
"latticed (woven of crosswise strips).\n"
"Answer: YES\n"
"Information: Apple pies tastes bad.\n"
"Context: An apple pie is a fruit pie in which the principal filling "
"ingredient is apples. \n"
"Apple pie is often served with whipped cream, ice cream "
"('apple pie à la mode'), custard or cheddar cheese.\n"
"It is generally double-crusted, with pastry both above "
"and below the filling; the upper crust may be solid or "
"latticed (woven of crosswise strips).\n"
"Answer: NO\n"
"Information: {query_str}\n"
"Context: {context_str}\n"
"Answer: "
)
DEFAULT_REFINE_TEMPLATE = PromptTemplate(
"We want to understand if the following information is present "
"in the context information: {query_str}\n"
"We have provided an existing YES/NO answer: {existing_answer}\n"
"We have the opportunity to refine the existing answer "
"(only if needed) with some more context below.\n"
"------------\n"
"{context_msg}\n"
"------------\n"
"If the existing answer was already YES, still answer YES. "
"If the information is present in the new context, answer YES. "
"Otherwise answer NO.\n"
)
class MultiModalFaithfulnessEvaluator(BaseEvaluator):
"""Multi-Modal Faithfulness evaluator.
Evaluates whether a response is faithful to the contexts
(i.e. whether the response is supported by the contexts or hallucinated.)
This evaluator only considers the response string and the list of context strings.
Args:
multi_modal_llm(Optional[MultiModalLLM]):
The Multi-Modal LLM Judge to use for evaluations.
raise_error(bool): Whether to raise an error when the response is invalid.
Defaults to False.
eval_template(Optional[Union[str, BasePromptTemplate]]):
The template to use for evaluation.
refine_template(Optional[Union[str, BasePromptTemplate]]):
The template to use for refining the evaluation.
"""
def __init__(
self,
multi_modal_llm: Optional[MultiModalLLM] = None,
raise_error: bool = False,
eval_template: Union[str, BasePromptTemplate, None] = None,
refine_template: Union[str, BasePromptTemplate, None] = None,
) -> None:
"""Init params."""
self._multi_modal_llm = multi_modal_llm or OpenAIMultiModal(
model="gpt-4-vision-preview", max_new_tokens=1000
)
self._raise_error = raise_error
self._eval_template: BasePromptTemplate
if isinstance(eval_template, str):
self._eval_template = PromptTemplate(eval_template)
else:
self._eval_template = eval_template or DEFAULT_EVAL_TEMPLATE
self._refine_template: BasePromptTemplate
if isinstance(refine_template, str):
self._refine_template = PromptTemplate(refine_template)
else:
self._refine_template = refine_template or DEFAULT_REFINE_TEMPLATE
def _get_prompts(self) -> PromptDictType:
"""Get prompts."""
return {
"eval_template": self._eval_template,
"refine_template": self._refine_template,
}
def _update_prompts(self, prompts: PromptDictType) -> None:
"""Update prompts."""
if "eval_template" in prompts:
self._eval_template = prompts["eval_template"]
if "refine_template" in prompts:
self._refine_template = prompts["refine_template"]
def evaluate(
self,
query: Union[str, None] = None,
response: Union[str, None] = None,
contexts: Union[Sequence[str], None] = None,
image_paths: Union[List[str], None] = None,
image_urls: Union[List[str], None] = None,
**kwargs: Any,
) -> EvaluationResult:
"""Evaluate whether the response is faithful to the multi-modal contexts."""
del query # Unused
del kwargs # Unused
if contexts is None or response is None:
raise ValueError("contexts and response must be provided")
context_str = "\n\n".join(contexts)
fmt_prompt = self._eval_template.format(
context_str=context_str, query_str=response
)
if image_paths:
image_nodes = [
ImageNode(image_path=image_path) for image_path in image_paths
]
if image_urls:
image_nodes = [ImageNode(image_url=image_url) for image_url in image_urls]
response_obj = self._multi_modal_llm.complete(
prompt=fmt_prompt,
image_documents=image_nodes,
)
raw_response_txt = str(response_obj)
if "yes" in raw_response_txt.lower():
passing = True
else:
passing = False
if self._raise_error:
raise ValueError("The response is invalid")
return EvaluationResult(
response=response,
contexts=contexts,
passing=passing,
score=1.0 if passing else 0.0,
feedback=raw_response_txt,
)
async def aevaluate(
self,
query: Union[str, None] = None,
response: Union[str, None] = None,
contexts: Union[Sequence[str], None] = None,
image_paths: Union[List[str], None] = None,
image_urls: Union[List[str], None] = None,
**kwargs: Any,
) -> EvaluationResult:
"""Async evaluate whether the response is faithful to the multi-modal contexts."""
del query # Unused
del kwargs # Unused
if contexts is None or response is None:
raise ValueError("contexts and response must be provided")
context_str = "\n\n".join(contexts)
fmt_prompt = self._eval_template.format(
context_str=context_str, query_str=response
)
if image_paths:
image_nodes = [
ImageNode(image_path=image_path) for image_path in image_paths
]
if image_urls:
image_nodes = [ImageNode(image_url=image_url) for image_url in image_urls]
response_obj = await self._multi_modal_llm.acomplete(
prompt=fmt_prompt,
image_documents=image_nodes,
)
raw_response_txt = str(response_obj)
if "yes" in raw_response_txt.lower():
passing = True
else:
passing = False
if self._raise_error:
raise ValueError("The response is invalid")
return EvaluationResult(
response=response,
contexts=contexts,
passing=passing,
score=1.0 if passing else 0.0,
feedback=raw_response_txt,
)
| [
"(only if needed) with some more context below.\n",
"Answer: NO\n",
"Information: {query_str}\n",
"It is generally double-crusted, with pastry both above ",
"Some examples are provided below with only text context, but please do use\n",
"Please tell if a given piece of information is supported by the visual as well as textual context information.\nYou need to answer with either YES or NO.\nAnswer YES if any of the image(s) and textual context supports the information, even if most of the context is unrelated. Some examples are provided below with only text context, but please do use\nany images for context if they are provided.\n\nInformation: Apple pie is generally double-crusted.\nContext: An apple pie is a fruit pie in which the principal filling ingredient is apples. \nApple pie is often served with whipped cream, ice cream ('apple pie à la mode'), custard or cheddar cheese.\nIt is generally double-crusted, with pastry both above and below the filling; the upper crust may be solid or latticed (woven of crosswise strips).\nAnswer: YES\nInformation: Apple pies tastes bad.\nContext: An apple pie is a fruit pie in which the principal filling ingredient is apples. \nApple pie is often served with whipped cream, ice cream ('apple pie à la mode'), custard or cheddar cheese.\nIt is generally double-crusted, with pastry both above and below the filling; the upper crust may be solid or latticed (woven of crosswise strips).\nAnswer: NO\nInformation: {query_str}\nContext: {context_str}\nAnswer: ",
"We have provided an existing YES/NO answer: {existing_answer}\n",
"{context_msg}\n",
"Answer: YES\n",
"Answer: ",
"We have the opportunity to refine the existing answer ",
"You need to answer with either YES or NO.\n",
"and below the filling; the upper crust may be solid or ",
"is supported by the visual as well as textual context information.\n",
"We want to understand if the following information is present ",
"Information: Apple pie is generally double-crusted.\n",
"Context: An apple pie is a fruit pie in which the principal filling ",
"Answer YES if any of the image(s) and textual context supports the information, even ",
"Otherwise answer NO.\n",
"We want to understand if the following information is present in the context information: {query_str}\nWe have provided an existing YES/NO answer: {existing_answer}\nWe have the opportunity to refine the existing answer (only if needed) with some more context below.\n------------\n{context_msg}\n------------\nIf the existing answer was already YES, still answer YES. If the information is present in the new context, answer YES. Otherwise answer NO.\n",
"Information: Apple pies tastes bad.\n",
"If the information is present in the new context, answer YES. ",
"------------\n",
"Context: {context_str}\n",
"If the existing answer was already YES, still answer YES. ",
"in the context information: {query_str}\n",
"any images for context if they are provided.\n\n",
"latticed (woven of crosswise strips).\n",
"if most of the context is unrelated. ",
"ingredient is apples. \n",
"Apple pie is often served with whipped cream, ice cream ",
"('apple pie à la mode'), custard or cheddar cheese.\n",
"Please tell if a given piece of information "
] |
2024-01-10 | truesoni/llama_index | llama_index~llms~azure_openai.py | from typing import Any, Callable, Dict, Optional, Sequence
import httpx
from openai import AsyncAzureOpenAI
from openai import AzureOpenAI as SyncAzureOpenAI
from llama_index.bridge.pydantic import Field, PrivateAttr, root_validator
from llama_index.callbacks import CallbackManager
from llama_index.llms.generic_utils import get_from_param_or_env
from llama_index.llms.openai import OpenAI
from llama_index.llms.openai_utils import (
refresh_openai_azuread_token,
resolve_from_aliases,
)
from llama_index.llms.types import ChatMessage
from llama_index.types import BaseOutputParser, PydanticProgramMode
class AzureOpenAI(OpenAI):
"""
Azure OpenAI.
To use this, you must first deploy a model on Azure OpenAI.
Unlike OpenAI, you need to specify a `engine` parameter to identify
your deployment (called "model deployment name" in Azure portal).
- model: Name of the model (e.g. `text-davinci-003`)
This in only used to decide completion vs. chat endpoint.
- engine: This will correspond to the custom name you chose
for your deployment when you deployed a model.
You must have the following environment variables set:
- `OPENAI_API_VERSION`: set this to `2023-05-15`
This may change in the future.
- `AZURE_OPENAI_ENDPOINT`: your endpoint should look like the following
https://YOUR_RESOURCE_NAME.openai.azure.com/
- `AZURE_OPENAI_API_KEY`: your API key if the api type is `azure`
More information can be found here:
https://learn.microsoft.com/en-us/azure/cognitive-services/openai/quickstart?tabs=command-line&pivots=programming-language-python
"""
engine: str = Field(description="The name of the deployed azure engine.")
azure_endpoint: Optional[str] = Field(
default=None, description="The Azure endpoint to use."
)
azure_deployment: Optional[str] = Field(
default=None, description="The Azure deployment to use."
)
use_azure_ad: bool = Field(
description="Indicates if Microsoft Entra ID (former Azure AD) is used for token authentication"
)
_azure_ad_token: Any = PrivateAttr()
_client: SyncAzureOpenAI = PrivateAttr()
_aclient: AsyncAzureOpenAI = PrivateAttr()
_http_client: Optional[httpx.Client] = PrivateAttr()
def __init__(
self,
model: str = "gpt-35-turbo",
engine: Optional[str] = None,
temperature: float = 0.1,
max_tokens: Optional[int] = None,
additional_kwargs: Optional[Dict[str, Any]] = None,
max_retries: int = 3,
timeout: float = 60.0,
reuse_client: bool = True,
api_key: Optional[str] = None,
api_version: Optional[str] = None,
# azure specific
azure_endpoint: Optional[str] = None,
azure_deployment: Optional[str] = None,
use_azure_ad: bool = False,
callback_manager: Optional[CallbackManager] = None,
# aliases for engine
deployment_name: Optional[str] = None,
deployment_id: Optional[str] = None,
deployment: Optional[str] = None,
# custom httpx client
http_client: Optional[httpx.Client] = None,
# base class
system_prompt: Optional[str] = None,
messages_to_prompt: Optional[Callable[[Sequence[ChatMessage]], str]] = None,
completion_to_prompt: Optional[Callable[[str], str]] = None,
pydantic_program_mode: PydanticProgramMode = PydanticProgramMode.DEFAULT,
output_parser: Optional[BaseOutputParser] = None,
**kwargs: Any,
) -> None:
engine = resolve_from_aliases(
engine, deployment_name, deployment_id, deployment, azure_deployment
)
if engine is None:
raise ValueError("You must specify an `engine` parameter.")
azure_endpoint = get_from_param_or_env(
"azure_endpoint", azure_endpoint, "AZURE_OPENAI_ENDPOINT", ""
)
# Use the custom httpx client if provided.
# Otherwise the value will be None.
self._http_client = http_client
super().__init__(
engine=engine,
model=model,
temperature=temperature,
max_tokens=max_tokens,
additional_kwargs=additional_kwargs,
max_retries=max_retries,
timeout=timeout,
reuse_client=reuse_client,
api_key=api_key,
azure_endpoint=azure_endpoint,
azure_deployment=azure_deployment,
use_azure_ad=use_azure_ad,
api_version=api_version,
callback_manager=callback_manager,
system_prompt=system_prompt,
messages_to_prompt=messages_to_prompt,
completion_to_prompt=completion_to_prompt,
pydantic_program_mode=pydantic_program_mode,
output_parser=output_parser,
**kwargs,
)
@root_validator(pre=True)
def validate_env(cls, values: Dict[str, Any]) -> Dict[str, Any]:
"""Validate necessary credentials are set."""
if (
values["api_base"] == "https://api.openai.com/v1"
and values["azure_endpoint"] is None
):
raise ValueError(
"You must set OPENAI_API_BASE to your Azure endpoint. "
"It should look like https://YOUR_RESOURCE_NAME.openai.azure.com/"
)
if values["api_version"] is None:
raise ValueError("You must set OPENAI_API_VERSION for Azure OpenAI.")
return values
def _get_client(self) -> SyncAzureOpenAI:
if not self.reuse_client:
return SyncAzureOpenAI(**self._get_credential_kwargs())
if self._client is None:
self._client = SyncAzureOpenAI(
**self._get_credential_kwargs(),
)
return self._client
def _get_aclient(self) -> AsyncAzureOpenAI:
if not self.reuse_client:
return AsyncAzureOpenAI(**self._get_credential_kwargs())
if self._aclient is None:
self._aclient = AsyncAzureOpenAI(
**self._get_credential_kwargs(),
)
return self._aclient
def _get_credential_kwargs(self, **kwargs: Any) -> Dict[str, Any]:
if self.use_azure_ad:
self._azure_ad_token = refresh_openai_azuread_token(self._azure_ad_token)
self.api_key = self._azure_ad_token.token
return {
"api_key": self.api_key,
"max_retries": self.max_retries,
"timeout": self.timeout,
"azure_endpoint": self.azure_endpoint,
"azure_deployment": self.azure_deployment,
"api_version": self.api_version,
"default_headers": self.default_headers,
"http_client": self._http_client,
}
def _get_model_kwargs(self, **kwargs: Any) -> Dict[str, Any]:
model_kwargs = super()._get_model_kwargs(**kwargs)
model_kwargs["model"] = self.engine
return model_kwargs
@classmethod
def class_name(cls) -> str:
return "azure_openai_llm"
| [] |
2024-01-10 | truesoni/llama_index | llama_index~agent~openai~step.py | """OpenAI agent worker."""
import asyncio
import json
import logging
import uuid
from threading import Thread
from typing import Any, Dict, List, Optional, Tuple, Union, cast, get_args
from llama_index.agent.openai.utils import resolve_tool_choice
from llama_index.agent.types import (
BaseAgentWorker,
Task,
TaskStep,
TaskStepOutput,
)
from llama_index.agent.utils import add_user_step_to_memory
from llama_index.callbacks import (
CallbackManager,
CBEventType,
EventPayload,
trace_method,
)
from llama_index.chat_engine.types import (
AGENT_CHAT_RESPONSE_TYPE,
AgentChatResponse,
ChatResponseMode,
StreamingAgentChatResponse,
)
from llama_index.llms.base import ChatMessage, ChatResponse
from llama_index.llms.llm import LLM
from llama_index.llms.openai import OpenAI
from llama_index.llms.openai_utils import OpenAIToolCall
from llama_index.llms.types import MessageRole
from llama_index.memory import BaseMemory, ChatMemoryBuffer
from llama_index.memory.types import BaseMemory
from llama_index.objects.base import ObjectRetriever
from llama_index.tools import BaseTool, ToolOutput, adapt_to_async_tool
logger = logging.getLogger(__name__)
logger.setLevel(logging.WARNING)
DEFAULT_MAX_FUNCTION_CALLS = 5
DEFAULT_MODEL_NAME = "gpt-3.5-turbo-0613"
def get_function_by_name(tools: List[BaseTool], name: str) -> BaseTool:
"""Get function by name."""
name_to_tool = {tool.metadata.name: tool for tool in tools}
if name not in name_to_tool:
raise ValueError(f"Tool with name {name} not found")
return name_to_tool[name]
def call_tool_with_error_handling(
tool: BaseTool,
input_dict: Dict,
error_message: Optional[str] = None,
raise_error: bool = False,
) -> ToolOutput:
"""Call tool with error handling.
Input is a dictionary with args and kwargs
"""
try:
return tool(**input_dict)
except Exception as e:
if raise_error:
raise
error_message = error_message or f"Error: {e!s}"
return ToolOutput(
content=error_message,
tool_name=tool.metadata.name,
raw_input={"kwargs": input_dict},
raw_output=e,
)
def call_function(
tools: List[BaseTool],
tool_call: OpenAIToolCall,
verbose: bool = False,
) -> Tuple[ChatMessage, ToolOutput]:
"""Call a function and return the output as a string."""
# validations to get passed mypy
assert tool_call.id is not None
assert tool_call.function is not None
assert tool_call.function.name is not None
assert tool_call.function.arguments is not None
id_ = tool_call.id
function_call = tool_call.function
name = tool_call.function.name
arguments_str = tool_call.function.arguments
if verbose:
print("=== Calling Function ===")
print(f"Calling function: {name} with args: {arguments_str}")
tool = get_function_by_name(tools, name)
argument_dict = json.loads(arguments_str)
# Call tool
# Use default error message
output = call_tool_with_error_handling(tool, argument_dict, error_message=None)
if verbose:
print(f"Got output: {output!s}")
print("========================\n")
return (
ChatMessage(
content=str(output),
role=MessageRole.TOOL,
additional_kwargs={
"name": name,
"tool_call_id": id_,
},
),
output,
)
async def acall_function(
tools: List[BaseTool], tool_call: OpenAIToolCall, verbose: bool = False
) -> Tuple[ChatMessage, ToolOutput]:
"""Call a function and return the output as a string."""
# validations to get passed mypy
assert tool_call.id is not None
assert tool_call.function is not None
assert tool_call.function.name is not None
assert tool_call.function.arguments is not None
id_ = tool_call.id
function_call = tool_call.function
name = tool_call.function.name
arguments_str = tool_call.function.arguments
if verbose:
print("=== Calling Function ===")
print(f"Calling function: {name} with args: {arguments_str}")
tool = get_function_by_name(tools, name)
async_tool = adapt_to_async_tool(tool)
argument_dict = json.loads(arguments_str)
output = await async_tool.acall(**argument_dict)
if verbose:
print(f"Got output: {output!s}")
print("========================\n")
return (
ChatMessage(
content=str(output),
role=MessageRole.TOOL,
additional_kwargs={
"name": name,
"tool_call_id": id_,
},
),
output,
)
class OpenAIAgentWorker(BaseAgentWorker):
"""OpenAI Agent agent worker."""
def __init__(
self,
tools: List[BaseTool],
llm: OpenAI,
prefix_messages: List[ChatMessage],
verbose: bool = False,
max_function_calls: int = DEFAULT_MAX_FUNCTION_CALLS,
callback_manager: Optional[CallbackManager] = None,
tool_retriever: Optional[ObjectRetriever[BaseTool]] = None,
):
self._llm = llm
self._verbose = verbose
self._max_function_calls = max_function_calls
self.prefix_messages = prefix_messages
self.callback_manager = callback_manager or self._llm.callback_manager
if len(tools) > 0 and tool_retriever is not None:
raise ValueError("Cannot specify both tools and tool_retriever")
elif len(tools) > 0:
self._get_tools = lambda _: tools
elif tool_retriever is not None:
tool_retriever_c = cast(ObjectRetriever[BaseTool], tool_retriever)
self._get_tools = lambda message: tool_retriever_c.retrieve(message)
else:
# no tools
self._get_tools = lambda _: []
@classmethod
def from_tools(
cls,
tools: Optional[List[BaseTool]] = None,
tool_retriever: Optional[ObjectRetriever[BaseTool]] = None,
llm: Optional[LLM] = None,
verbose: bool = False,
max_function_calls: int = DEFAULT_MAX_FUNCTION_CALLS,
callback_manager: Optional[CallbackManager] = None,
system_prompt: Optional[str] = None,
prefix_messages: Optional[List[ChatMessage]] = None,
**kwargs: Any,
) -> "OpenAIAgentWorker":
"""Create an OpenAIAgent from a list of tools.
Similar to `from_defaults` in other classes, this method will
infer defaults for a variety of parameters, including the LLM,
if they are not specified.
"""
tools = tools or []
llm = llm or OpenAI(model=DEFAULT_MODEL_NAME)
if not isinstance(llm, OpenAI):
raise ValueError("llm must be a OpenAI instance")
if callback_manager is not None:
llm.callback_manager = callback_manager
if not llm.metadata.is_function_calling_model:
raise ValueError(
f"Model name {llm.model} does not support function calling API. "
)
if system_prompt is not None:
if prefix_messages is not None:
raise ValueError(
"Cannot specify both system_prompt and prefix_messages"
)
prefix_messages = [ChatMessage(content=system_prompt, role="system")]
prefix_messages = prefix_messages or []
return cls(
tools=tools,
tool_retriever=tool_retriever,
llm=llm,
prefix_messages=prefix_messages,
verbose=verbose,
max_function_calls=max_function_calls,
callback_manager=callback_manager,
)
def get_all_messages(self, task: Task) -> List[ChatMessage]:
return (
self.prefix_messages
+ task.memory.get()
+ task.extra_state["new_memory"].get_all()
)
def get_latest_tool_calls(self, task: Task) -> Optional[List[OpenAIToolCall]]:
chat_history: List[ChatMessage] = task.extra_state["new_memory"].get_all()
return (
chat_history[-1].additional_kwargs.get("tool_calls", None)
if chat_history
else None
)
def _get_llm_chat_kwargs(
self,
task: Task,
openai_tools: List[dict],
tool_choice: Union[str, dict] = "auto",
) -> Dict[str, Any]:
llm_chat_kwargs: dict = {"messages": self.get_all_messages(task)}
if openai_tools:
llm_chat_kwargs.update(
tools=openai_tools, tool_choice=resolve_tool_choice(tool_choice)
)
return llm_chat_kwargs
def _process_message(
self, task: Task, chat_response: ChatResponse
) -> AgentChatResponse:
ai_message = chat_response.message
task.extra_state["new_memory"].put(ai_message)
return AgentChatResponse(
response=str(ai_message.content), sources=task.extra_state["sources"]
)
def _get_stream_ai_response(
self, task: Task, **llm_chat_kwargs: Any
) -> StreamingAgentChatResponse:
chat_stream_response = StreamingAgentChatResponse(
chat_stream=self._llm.stream_chat(**llm_chat_kwargs),
sources=task.extra_state["sources"],
)
# Get the response in a separate thread so we can yield the response
thread = Thread(
target=chat_stream_response.write_response_to_history,
args=(task.extra_state["new_memory"],),
)
thread.start()
# Wait for the event to be set
chat_stream_response._is_function_not_none_thread_event.wait()
# If it is executing an openAI function, wait for the thread to finish
if chat_stream_response._is_function:
thread.join()
# if it's false, return the answer (to stream)
return chat_stream_response
async def _get_async_stream_ai_response(
self, task: Task, **llm_chat_kwargs: Any
) -> StreamingAgentChatResponse:
chat_stream_response = StreamingAgentChatResponse(
achat_stream=await self._llm.astream_chat(**llm_chat_kwargs),
sources=task.extra_state["sources"],
)
# create task to write chat response to history
asyncio.create_task(
chat_stream_response.awrite_response_to_history(
task.extra_state["new_memory"]
)
)
# wait until openAI functions stop executing
await chat_stream_response._is_function_false_event.wait()
# return response stream
return chat_stream_response
def _get_agent_response(
self, task: Task, mode: ChatResponseMode, **llm_chat_kwargs: Any
) -> AGENT_CHAT_RESPONSE_TYPE:
if mode == ChatResponseMode.WAIT:
chat_response: ChatResponse = self._llm.chat(**llm_chat_kwargs)
return self._process_message(task, chat_response)
elif mode == ChatResponseMode.STREAM:
return self._get_stream_ai_response(task, **llm_chat_kwargs)
else:
raise NotImplementedError
async def _get_async_agent_response(
self, task: Task, mode: ChatResponseMode, **llm_chat_kwargs: Any
) -> AGENT_CHAT_RESPONSE_TYPE:
if mode == ChatResponseMode.WAIT:
chat_response: ChatResponse = await self._llm.achat(**llm_chat_kwargs)
return self._process_message(task, chat_response)
elif mode == ChatResponseMode.STREAM:
return await self._get_async_stream_ai_response(task, **llm_chat_kwargs)
else:
raise NotImplementedError
def _call_function(
self,
tools: List[BaseTool],
tool_call: OpenAIToolCall,
memory: BaseMemory,
sources: List[ToolOutput],
) -> None:
function_call = tool_call.function
# validations to get passed mypy
assert function_call is not None
assert function_call.name is not None
assert function_call.arguments is not None
with self.callback_manager.event(
CBEventType.FUNCTION_CALL,
payload={
EventPayload.FUNCTION_CALL: function_call.arguments,
EventPayload.TOOL: get_function_by_name(
tools, function_call.name
).metadata,
},
) as event:
function_message, tool_output = call_function(
tools, tool_call, verbose=self._verbose
)
event.on_end(payload={EventPayload.FUNCTION_OUTPUT: str(tool_output)})
sources.append(tool_output)
memory.put(function_message)
async def _acall_function(
self,
tools: List[BaseTool],
tool_call: OpenAIToolCall,
memory: BaseMemory,
sources: List[ToolOutput],
) -> None:
function_call = tool_call.function
# validations to get passed mypy
assert function_call is not None
assert function_call.name is not None
assert function_call.arguments is not None
with self.callback_manager.event(
CBEventType.FUNCTION_CALL,
payload={
EventPayload.FUNCTION_CALL: function_call.arguments,
EventPayload.TOOL: get_function_by_name(
tools, function_call.name
).metadata,
},
) as event:
function_message, tool_output = await acall_function(
tools, tool_call, verbose=self._verbose
)
event.on_end(payload={EventPayload.FUNCTION_OUTPUT: str(tool_output)})
sources.append(tool_output)
memory.put(function_message)
def initialize_step(self, task: Task, **kwargs: Any) -> TaskStep:
"""Initialize step from task."""
sources: List[ToolOutput] = []
# temporary memory for new messages
new_memory = ChatMemoryBuffer.from_defaults()
# initialize task state
task_state = {
"sources": sources,
"n_function_calls": 0,
"new_memory": new_memory,
}
task.extra_state.update(task_state)
return TaskStep(
task_id=task.task_id,
step_id=str(uuid.uuid4()),
input=task.input,
)
def _should_continue(
self, tool_calls: Optional[List[OpenAIToolCall]], n_function_calls: int
) -> bool:
if n_function_calls > self._max_function_calls:
return False
if not tool_calls:
return False
return True
def get_tools(self, input: str) -> List[BaseTool]:
"""Get tools."""
return self._get_tools(input)
def _run_step(
self,
step: TaskStep,
task: Task,
mode: ChatResponseMode = ChatResponseMode.WAIT,
tool_choice: Union[str, dict] = "auto",
) -> TaskStepOutput:
"""Run step."""
if step.input is not None:
add_user_step_to_memory(
step, task.extra_state["new_memory"], verbose=self._verbose
)
# TODO: see if we want to do step-based inputs
tools = self.get_tools(task.input)
openai_tools = [tool.metadata.to_openai_tool() for tool in tools]
llm_chat_kwargs = self._get_llm_chat_kwargs(task, openai_tools, tool_choice)
agent_chat_response = self._get_agent_response(
task, mode=mode, **llm_chat_kwargs
)
# TODO: implement _should_continue
latest_tool_calls = self.get_latest_tool_calls(task) or []
if not self._should_continue(
latest_tool_calls, task.extra_state["n_function_calls"]
):
is_done = True
new_steps = []
# TODO: return response
else:
is_done = False
for tool_call in latest_tool_calls:
# Some validation
if not isinstance(tool_call, get_args(OpenAIToolCall)):
raise ValueError("Invalid tool_call object")
if tool_call.type != "function":
raise ValueError("Invalid tool type. Unsupported by OpenAI")
# TODO: maybe execute this with multi-threading
self._call_function(
tools,
tool_call,
task.extra_state["new_memory"],
task.extra_state["sources"],
)
# change function call to the default value, if a custom function was given
# as an argument (none and auto are predefined by OpenAI)
if tool_choice not in ("auto", "none"):
tool_choice = "auto"
task.extra_state["n_function_calls"] += 1
new_steps = [
step.get_next_step(
step_id=str(uuid.uuid4()),
# NOTE: input is unused
input=None,
)
]
# attach next step to task
return TaskStepOutput(
output=agent_chat_response,
task_step=step,
is_last=is_done,
next_steps=new_steps,
)
async def _arun_step(
self,
step: TaskStep,
task: Task,
mode: ChatResponseMode = ChatResponseMode.WAIT,
tool_choice: Union[str, dict] = "auto",
) -> TaskStepOutput:
"""Run step."""
if step.input is not None:
add_user_step_to_memory(
step, task.extra_state["new_memory"], verbose=self._verbose
)
# TODO: see if we want to do step-based inputs
tools = self.get_tools(task.input)
openai_tools = [tool.metadata.to_openai_tool() for tool in tools]
llm_chat_kwargs = self._get_llm_chat_kwargs(task, openai_tools, tool_choice)
agent_chat_response = await self._get_async_agent_response(
task, mode=mode, **llm_chat_kwargs
)
# TODO: implement _should_continue
latest_tool_calls = self.get_latest_tool_calls(task) or []
if not self._should_continue(
latest_tool_calls, task.extra_state["n_function_calls"]
):
is_done = True
else:
is_done = False
for tool_call in latest_tool_calls:
# Some validation
if not isinstance(tool_call, get_args(OpenAIToolCall)):
raise ValueError("Invalid tool_call object")
if tool_call.type != "function":
raise ValueError("Invalid tool type. Unsupported by OpenAI")
# TODO: maybe execute this with multi-threading
await self._acall_function(
tools,
tool_call,
task.extra_state["new_memory"],
task.extra_state["sources"],
)
# change function call to the default value, if a custom function was given
# as an argument (none and auto are predefined by OpenAI)
if tool_choice not in ("auto", "none"):
tool_choice = "auto"
task.extra_state["n_function_calls"] += 1
# generate next step, append to task queue
new_steps = (
[
step.get_next_step(
step_id=str(uuid.uuid4()),
# NOTE: input is unused
input=None,
)
]
if not is_done
else []
)
return TaskStepOutput(
output=agent_chat_response,
task_step=step,
is_last=is_done,
next_steps=new_steps,
)
@trace_method("run_step")
def run_step(self, step: TaskStep, task: Task, **kwargs: Any) -> TaskStepOutput:
"""Run step."""
tool_choice = kwargs.get("tool_choice", "auto")
return self._run_step(
step, task, mode=ChatResponseMode.WAIT, tool_choice=tool_choice
)
@trace_method("run_step")
async def arun_step(
self, step: TaskStep, task: Task, **kwargs: Any
) -> TaskStepOutput:
"""Run step (async)."""
tool_choice = kwargs.get("tool_choice", "auto")
return await self._arun_step(
step, task, mode=ChatResponseMode.WAIT, tool_choice=tool_choice
)
@trace_method("run_step")
def stream_step(self, step: TaskStep, task: Task, **kwargs: Any) -> TaskStepOutput:
"""Run step (stream)."""
# TODO: figure out if we need a different type for TaskStepOutput
tool_choice = kwargs.get("tool_choice", "auto")
return self._run_step(
step, task, mode=ChatResponseMode.STREAM, tool_choice=tool_choice
)
@trace_method("run_step")
async def astream_step(
self, step: TaskStep, task: Task, **kwargs: Any
) -> TaskStepOutput:
"""Run step (async stream)."""
tool_choice = kwargs.get("tool_choice", "auto")
return await self._arun_step(
step, task, mode=ChatResponseMode.STREAM, tool_choice=tool_choice
)
def finalize_task(self, task: Task, **kwargs: Any) -> None:
"""Finalize task, after all the steps are completed."""
# add new messages to memory
task.memory.set(task.memory.get() + task.extra_state["new_memory"].get_all())
# reset new memory
task.extra_state["new_memory"].reset()
def undo_step(self, task: Task, **kwargs: Any) -> Optional[TaskStep]:
"""Undo step from task.
If this cannot be implemented, return None.
"""
raise NotImplementedError("Undo is not yet implemented")
# if len(task.completed_steps) == 0:
# return None
# # pop last step output
# last_step_output = task.completed_steps.pop()
# # add step to the front of the queue
# task.step_queue.appendleft(last_step_output.task_step)
# # undo any `step_state` variables that have changed
# last_step_output.step_state["n_function_calls"] -= 1
# # TODO: we don't have memory pop capabilities yet
# # # now pop the memory until we get to the state
# # last_step_response = cast(AgentChatResponse, last_step_output.output)
# # while last_step_response != task.memory.:
# # last_message = last_step_output.task_step.memory.pop()
# # if last_message == cast(AgentChatResponse, last_step_output.output).response:
# # break
# # while cast(AgentChatResponse, last_step_output.output).response !=
| [] |
2024-01-10 | kaaydin/automatic-notebook-documentation | comment_generator.py | ## Importing relevant modules
import openai
## Setting API_KEY access - downloaded from: https://platform.openai.com/account/api-keys
API_KEY = ""
openai.api_key = API_KEY
## Selecting GPT-3.5 model to generate documentation
MODEL = "gpt-3.5-turbo"
## Setting instruction / prompt for GPT-3.5 to generate documentation
INSTRUCTION = {"role": "system", "content": """"
You are a helpful coding assistant that will take as input a cell from a Jupyter notebook and generate
an appropriate comment for the cell at the beginning. Some further instructions to keep in mind: Please keep the
generated comment to a maximum of 30 words. Ensure that the comments start with a '#' character and provide
clear explanations without modifying the code itself. Also, very important, include the code as part of the output. """}
def run_api(message, chosen_model=MODEL, instruction=INSTRUCTION):
"""
This function runs an OpenAI chat completion model with the given message and instruction. The chosen model can be specified,
otherwise a default model is used. The output is the generated text from the model with a temperature of 0. The code creates
an instance of the ChatCompletion class and returns the content of the first message in the first choice of the output.
"""
## Retrieving output from GPT based on selected model, messages, and temperature
output = openai.ChatCompletion.create(
model = chosen_model,
messages=[instruction,
message],
temperature = 0,
)
## Retrieving output text from GPT output
output_text = output.choices[0]["message"]["content"]
return output_text
def query_message_list(messages):
"""
This function takes a list of messages and queries an API with each message, returning a list of the API's responses.
The API is called with a chosen model and instruction, and the message is formatted as a dictionary with a "role" key
set to "user" and a "content" key set to the message. The API response is then appended to a list and returned.
"""
documented_messages = []
## Iterating over all code blocks and running API call to generate output via GPT
for message in messages:
queried_message = {"role": "user", "content": f'{message}'}
documented_message = run_api(chosen_model = MODEL, instruction = INSTRUCTION, message = queried_message)
documented_messages.append(documented_message)
return documented_messages
| [
"PLACEHOLDER",
"[PLACEHOLDER, PLACEHOLDER]",
"\"\n You are a helpful coding assistant that will take as input a cell from a Jupyter notebook and generate \n an appropriate comment for the cell at the beginning. Some further instructions to keep in mind: Please keep the \n generated comment to a maximum of 30 words. Ensure that the comments start with a '#' character and provide \n clear explanations without modifying the code itself. Also, very important, include the code as part of the output. "
] |
2024-01-10 | Solidlucho83/python-gpt-audio | openia.py | import os
import openai
import speech_recognition as sr
from gtts import gTTS
from playsound import playsound
from termcolor import colored
LANGUAGE = "es" # define audio language
ENGINE_IA = "text-davinci-003"
AUDIO_FILE = "response.mp3"
openai.api_key = "" # you api-key here
def voice():
r = sr.Recognizer()
with sr.Microphone() as source:
r.adjust_for_ambient_noise(source, duration=1)
print("Ask me a question, speak clearly and slowly please => ")
audio = r.listen(source)
try:
text = r.recognize_google(audio, language="es-AR")
print(text)
new_question(LANGUAGE, ENGINE_IA, AUDIO_FILE, text)
except:
print("sorry, could not recognise")
def new_question(LANGUAGE, ENGINE_IA, AUDIO_FILE, text):
try:
print("Wait Moment....")
completion = openai.Completion.create(
engine=ENGINE_IA, prompt=text, n=1, max_tokens=2048)
response_text = completion.choices[0].text
print(response_text)
tts = gTTS(response_text, lang=LANGUAGE, slow=False)
tts.save(AUDIO_FILE)
playsound(AUDIO_FILE)
os.remove(AUDIO_FILE)
print()
print("Press Enter to continue...")
input() # Espera hasta que se presione Enter
except Exception as e:
print(colored("Sorry, error:", "red"))
print(colored(str(e), "red"))
print()
if __name__ == "__main__":
while True:
voice()
| [] |
2024-01-10 | habibzadeh/unstructured | unstructured~embed~bedrock.py | from typing import List
import numpy as np
from unstructured.documents.elements import (
Element,
)
from unstructured.embed.interfaces import BaseEmbeddingEncoder
from unstructured.ingest.error import EmbeddingEncoderConnectionError
from unstructured.utils import requires_dependencies
class BedrockEmbeddingEncoder(BaseEmbeddingEncoder):
def __init__(
self,
aws_access_key_id: str,
aws_secret_access_key: str,
region_name: str = "us-west-2",
):
self.aws_access_key_id = aws_access_key_id
self.aws_secret_access_key = aws_secret_access_key
self.region_name = region_name
self.initialize()
def initialize(self):
self.bedrock_client = self.get_bedrock_client()
def num_of_dimensions(self):
return np.shape(self.examplary_embedding)
def is_unit_vector(self):
return np.isclose(np.linalg.norm(self.examplary_embedding), 1.0)
def embed_query(self, query):
return np.array(self.bedrock_client.embed_query(query))
def embed_documents(self, elements: List[Element]) -> List[Element]:
embeddings = self.bedrock_client.embed_documents([str(e) for e in elements])
elements_with_embeddings = self._add_embeddings_to_elements(elements, embeddings)
return elements_with_embeddings
def _add_embeddings_to_elements(self, elements, embeddings) -> List[Element]:
assert len(elements) == len(embeddings)
elements_w_embedding = []
for i, element in enumerate(elements):
element.embeddings = embeddings[i]
elements_w_embedding.append(element)
return elements
@EmbeddingEncoderConnectionError.wrap
@requires_dependencies(
["boto3", "numpy", "langchain"],
extras="bedrock",
)
def get_bedrock_client(self):
if getattr(self, "bedrock_client", None):
return self.bedrock_client
# delay import only when needed
import boto3
from langchain.embeddings import BedrockEmbeddings
bedrock_runtime = boto3.client(
service_name="bedrock-runtime",
aws_access_key_id=self.aws_access_key_id,
aws_secret_access_key=self.aws_secret_access_key,
region_name=self.region_name,
)
bedrock_client = BedrockEmbeddings(client=bedrock_runtime)
self.examplary_embedding = np.array(bedrock_client.embed_query("Q"))
return bedrock_client
| [] |
2024-01-10 | nrb171/Automatic-Publication-Summarization | semanticSearch.py | import openai
import os
import tiktoken
import pandas as pd
from scipy import spatial
import numpy as np
import argparse
from flask import Flask, render_template, request, send_from_directory, session
import json
from flaskext.markdown import Markdown
import webbrowser
app = Flask(__name__)
Markdown(app) # This initializes the Flask-Markdown extension.
app.secret_key = 'PeterJacksonIsTheBestDirectorOfAllTime'
def similaritySearch(
query: str,
df: pd.DataFrame,
relatedness_fn=lambda x, y: 1 - spatial.distance.cosine(x, y),
top_n: int = 100
) :
"""Returns a list of strings and relatednesses, sorted from most related to least."""
embeddingModel = "text-embedding-ada-002"
query_embedding_response = openai.Embedding.create(
model=embeddingModel,
input=query
)
query_embedding = query_embedding_response["data"][0]["embedding"]
strings_and_relatednesses = []
lastPaper = ""
for i in range(len(df)):
embedding = df["embedding"][i]
embedding = embedding[1:-2].split(", ")
embedding = [float(i) for i in embedding]
relatedness = relatedness_fn(query_embedding, embedding)
if df["name"][i] == lastPaper:
if relatedness > strings_and_relatednesses[-1]["relatedness"]:
strings_and_relatednesses[-1]["relatedness"] = max(strings_and_relatednesses[-1]["relatedness"], relatedness)
strings_and_relatednesses[-1]["string"] = df["string"][i]
continue
else:
continue
strings_and_relatednesses.append({"name": df["name"][i][:-3], "relatedness": relatedness,"string": df["string"][i]})
lastPaper = df["name"][i]
# combine and average relatednesses for duplicate strings
string_to_relatedness = {}
for string_and_relatedness in strings_and_relatednesses:
string = string_and_relatedness["string"]
relatedness = string_and_relatedness["relatedness"]
if string in string_to_relatedness:
string_to_relatedness[string].append(relatedness)
else:
string_to_relatedness[string] = [relatedness]
for string in string_to_relatedness:
relatednesses = string_to_relatedness[string]
string_to_relatedness[string] = np.mean(relatednesses)
# sort by relatedness
strings_and_relatednesses.sort(key=lambda x: x["relatedness"], reverse=True)
return strings_and_relatednesses[:top_n]
@app.route('/')
def index():
return render_template('index.html')
@app.route('/search', methods=['POST'])
def search():
query = request.form['query']
directory = request.form['directory']
session['directory'] = directory
top_n = int(request.form['top_n'])
# Load data into array
df = pd.read_csv(directory + "/.embeddings/embeddings.csv")
# Get results
similaritySearchResults = similaritySearch(query, df, top_n=top_n)
return render_template('index.html', results=similaritySearchResults,prev_query=query, prev_directory=directory, prev_top_n=top_n)
@app.route('/<filename>', methods=['GET'])
def serve_pdf(filename):
directory = session.get('directory') # Assuming you store the directory in a session variable
files = os.listdir(directory)
file = files[files[0].split(".")[0][:-3] == filename.split(".")[0]]
if not directory:
return "Directory not set!", 400
return send_from_directory(directory, file, as_attachment=False)
if __name__ == '__main__':
embeddingModel = "text-embedding-ada-002"
encodingName="cl100k_base"
with open("key.ini", "r") as f:
openai.api_key = f.read().strip()
webbrowser.open("http://127.0.0.1:5000/")
app.run(debug=True)
| [] |
2024-01-10 | nrb171/Automatic-Publication-Summarization | APS.py | import openai
import os
from PyPDF2 import PdfReader
import tiktoken
import pandas as pd
from scipy import spatial
import argparse
import time
import numpy as np
from grobid_client.grobid_client import GrobidClient
client = GrobidClient(config_path="../grobid/grobid_client_pythonconfig.json")
client.process("processFulltextDocument", "/mnt/data/covid/pdfs", n=20)
import json
parser = argparse.ArgumentParser(description="Automatic Paper Summarization")
parser.add_argument("-d", "--directory", type=str, default="../", help="Path to directory containing PDF files")
args = parser.parse_args()
def num_tokens_from_string(string: str, encoding_name: str) -> int:
"""Returns the number of tokens in a text string."""
encoding = tiktoken.get_encoding(encoding_name)
num_tokens = len(encoding.encode(string))
return num_tokens
def iterativeDensification(text, gptModel, metadata):
costIn = 0.003/1000
costOut = 0.004/1000
totalCost = 0
history = []
questions = [
"What is the main goal of this paper?",
"What are the key concepts, techniques, methodologies, and/or theories introduced in this paper?",
"What are the findings, conclusions, and/or results of this paper?",
"what is the methodology/technique used in this paper?",
"what is the source of the data used in this paper?",
"what does this paper say about the main goal?",
"What does this paper say about potential issues, problems, or concerns regarding the methodology or results of their study?",
"What does this paper say about possible future work?",
]
history.append({"role": "system", "content": "You answer questions about academic literature."})
# gather questions and answers
for question in questions:
history.append({"role": "user", "content": question})
print(history[-1])
response = openai.ChatCompletion.create(
model=gptModel,
temperature=0,
messages=[
{"role": "system", "content": "You answer questions about academic literature."},
{"role": "user", "content": "Answer the following in less than"+str(350)+"words:\n\n"+question+": "+text}
]
)
totalCost += response["usage"]["prompt_tokens"]*costIn
totalCost += response["usage"]["completion_tokens"]*costOut
history.append({"role": "system", "content": response["choices"][0]["message"]["content"]})
print(history[-1])
history.append({"role": "user", "content": "Now, you will write a plaintext summary of the paper based on what you have learned above. Your goal is to write a concise summary of this paper, focusing primarily on the main goal and each key concept or entity introduced in the paper. Keep the summary brief and to the point."})
densificationProtocol = [
"Step 1: Instruction: Based on the initial sumary/list/keywords, refine it by incorporating 1-2 additional key entities or concepts from the document without increasing the overall length. Focus on significant elements or information in the document, and ensure the list remains coherent and concise.",
"Step 2: Instruction: Further refine the list by searching for and adding 1-2 more salient entities or details from the document, elements a curious and smart reader would note down, without increasing the overall length. Maintain clarity and conciseness while enhancing the informativeness of the summary/list/keywords.",
"Repeat Step 2"]
for instruction in densificationProtocol:
history.append({"role": "user", "content": instruction})
print(history[-1])
response = openai.ChatCompletion.create(
model=gptModel,
temperature=0,
messages=history
)
totalCost += response["usage"]["prompt_tokens"]*costIn
totalCost += response["usage"]["completion_tokens"]*costOut
response_message = response["choices"][0]["message"]["content"]
history.append({"role": "system", "content": response_message})
print(history[-1])
history.insert(2, {"role": "user", "content": "Here is the paper: "+text})
history.append({"role": "user", "content": "Using what you know about the paper. You will fill out the following form:\n\n---\nAuthors:\n - FirstName LastName\nYearOfPublication:\"YYYY\"\nTitle: \"\"\n---\n\n#Summary\nPLACE THE SUMMARY HERE. THIS SHOULD INCLUDE THE GOAL, METHODOLOGIES, RESULTS, AND NECESSARY COMMENTARY.\n\n#Data and Methodology\nDESCRIBE THE DATA SOURCE AND TYPE (E.G., SIMULATION OR OBSERVATION). ALSO DISCUSS THE METHODOLOGIES/TECHNIQUES - SPECIFICALLY MENTION NOVEL METHODOLOGIES. \n\n#Results/Conclusions/Findings\nLIST ALL RESULTS/CONCLUSIONS/FINDINGS. ALSO MENTION ANY POTENTIAL SHORTCOMINGS/ISSUES WITH THE STUDY."})
print(history[-1])
finalResponse = openai.ChatCompletion.create(
model="gpt-4",
temperature=0,
messages=history
)
totalCost += finalResponse["usage"]["prompt_tokens"]*0.03/1000
totalCost += finalResponse["usage"]["completion_tokens"]*0.06/1000
finalResponse = finalResponse["choices"][0]["message"]["content"]
history.append({"role": "system", "content": finalResponse})
print(history[-1])
return history, totalCost
def pdfTranscription(pdfPath):
costIn = 0.0015/1000
costOut = 0.002/1000
totalCost = 0
pdf_reader = PdfReader(pdfPath)
text = ""
for page in pdf_reader.pages:
text += page.extract_text()
#remove all newlines
text = text.replace("\n", " ")
#chunk into 8000 token chunks
text = splitString(text, "text-embedding-ada-002", 2056,False)
messages = [
{"role": "system", "content": "You read parts of pdfs and return summarized transcriptions. Be detailed and concise. You will make sure that words are separated by spaces and that there are no extra spaces. If you cannot read the file, return nothing."}]
messages.append({})
messages.append({"role": "system", "content": "Here is the summarized transcription of the excerpt:"})
transcripion=""
for i, page in enumerate(text):
messages[1] = ({"role":"user", "content": "Read and provide a summarized transcription the following. Keep your response to less than "+str(np.ceil((9000/len(text)*0.66)/100)*100)+" words.\n\n"+ page})
errorCount = 0
while True:
try:
response = openai.ChatCompletion.create(
model = "gpt-3.5-turbo",
temperature=0,
messages=messages,
max_tokens=int(np.round(9000/len(text)))
)
break
except:
errorCount += 1
time.sleep(errorCount**2)
print("Error in paper transcription:\nRetrying again in "+str(errorCount**2)+" seconds")
if errorCount > 5:
raise TooManyErrorsException("Too many errors in paper transcription")
continue
totalCost += response["usage"]["prompt_tokens"]*costIn
totalCost += response["usage"]["completion_tokens"]*costOut
print(response["choices"][0]["message"]["content"])
print(totalCost)
transcripion += "["+str(i+1)+"] "+response["choices"][0]["message"]["content"]
return transcripion, totalCost
def paperInterrogation(text, gptModel):
totalCost = 0
costIn = 0.003/1000
costOut = 0.006/1000
prompts = [
"What is the main goal of this paper?",
"What are the key concepts, techniques, methodologies, and/or theories introduced in this paper?",
"What are the findings, conclusions, and/or results of this paper?",
"what is the methodology/technique used in this paper?",
"what is the source of the data used in this paper?",
"what does this paper say about the main goal?",
"What does this paper say about potential issues, problems, or concerns regarding the methodology or results of their study?",
"What does this paper say about possible future work?"
]
messages = [
{"role": "system", "content": "You summarize an academic paper."},
{"role": "user", "content": "You will be summarizing and answering questions about the following paper. This is a summarized transcript of the paper: "+text},
{"role": "system", "content": "Great! Let's get started, what questions do you want answered?"}
]
messages.append({})
queryResponse=""
qNum = 0
errorCount = 0
while True:
try:
question = prompts[qNum]
messages[-1] = {"role": "user", "content": "Please keep your response to less than "+str(np.ceil((5000/len(prompts)*0.66)/100)*100)+"words:\n"+question}
response = openai.ChatCompletion.create(
model="gpt-3.5-turbo-16k",
messages=messages,
max_tokens=int(np.round(5000/len(prompts)))
)
queryResponse += "\n#####"+question+"\n"+response["choices"][0]["message"]["content"]
totalCost += response["usage"]["prompt_tokens"]*costIn
totalCost += response["usage"]["completion_tokens"]*costOut
qNum += 1
if qNum >= len(prompts)-1:
break
except Exception as e:
errorCount += 1
time.sleep(errorCount**2)
print("Error in paper interrogation:\nRetrying again in "+str(errorCount**2)+" seconds")
if errorCount > 5:
raise TooManyErrorsException("Too many errors in paper interrogation")
continue
errorCount = 0
while True:
try:
response = openai.ChatCompletion.create(
model="gpt-3.5-turbo-16k",
messages=[
{"role": "system", "content": "You read and answer questions about an academic paper. Previously, you had this to say about this paper: "+queryResponse},
{"role": "user", "content": "Summarize your findings in less than 500 words. Use plain language and be concise and detailed. Use this format for your response. \"###Summary\n\nYOUR SUMMARY HERE\n\n---\n\n\""}
]
)
break
except:
errorCount += 1
time.sleep(errorCount**2)
print("Error in paper summarization:\nRetrying again in "+str(errorCount**2)+" seconds")
if errorCount > 5:
raise TooManyErrorsException("Too many errors in paper summarization")
continue
totalCost += response["usage"]["prompt_tokens"]*costIn
totalCost += response["usage"]["completion_tokens"]*costOut
summaryResponse = response["choices"][0]["message"]["content"]
return summaryResponse+"\n\n"+queryResponse, totalCost
def generateEmbeddings(text, model, encoding):
text = text.replace("\n", " ")
embedding = openai.Embedding.create(input = text, model=model)['data'][0]['embedding']
return embedding
def splitString(
string: str,
model: str,
max_tokens: int,
print_warning: bool = True,
) -> list[str]:
splitStrings = []
"""splits a string to a maximum number of tokens."""
encoding = tiktoken.encoding_for_model(model)
encoded_string = encoding.encode(string)
start = 0
while len(encoded_string) >= start+max_tokens:
if print_warning:
print(
f"Warning: truncating string of length {len(encoded_string)} to {max_tokens} tokens"
)
truncated_string = encoding.decode(encoded_string[start:min([start+max_tokens, len(encoded_string)])])
splitStrings.append(truncated_string)
start += max_tokens
return splitStrings
def main():
# OpenAI API Key
#get API key from ./key.ini
with open("key.ini", "r") as f:
openai.api_key = f.read()
embeddingModel = "text-embedding-ada-002"
encodingName="cl100k_base"
gptModelTranscription = "gpt-3.5-turbo"
gptModelInterrogation = "gpt-3.5-turbo-16k"
costIn = 0.0015/1000
costOut = 0.002/1000
totalCost = 0
# Take the directory as a command line argument
directory = args.directory
#get array of all files in directory
files = os.listdir(directory)
#loop through all files in directory
for i in range(len(files)):
# extract text from pdf
if files[i].endswith(".pdf"):
try:
if not os.path.exists(directory+"/.embeddings/"+files[i][:-4]+".md"):
errorFree = False
attempts = 0
while errorFree == False:
try:
text, transcriptinCost = pdfTranscription(directory+files[i])
errorFree = True
except Exception as e:
print(e)
attempts += 1
if attempts > 3:
raise("Too many attempts")
continue
#history, densificationCost = iterativeDensification(text, gptModel, metadata)
interrogation=""
interrogation, interrogationCost = paperInterrogation(text, "gpt-4")
totalCost = interrogationCost + transcriptinCost
print(totalCost)
# save the text to a file
with open(directory+"/.embeddings/"+files[i][:-4]+".md", 'w') as f:
f.write(interrogation)
# get the embedding
embeddings = generateEmbeddings(interrogation, embeddingModel, encodingName)
df = pd.DataFrame({"text": interrogation, "embedding": [embeddings], "filename": files[i]})
# add to end of embeddings file
with open(directory+"/.embeddings/embeddings.csv", 'a') as f:
df.to_csv(f, header=False)
except EmptyTextException as e:
continue
except TooManyErrorsException as e:
continue
else:
continue
class TooManyErrorsException(BaseException):
pass
class EmptyTextException(BaseException):
pass
text=main()
| [
"Using what you know about the paper. You will fill out the following form:\n\n---\nAuthors:\n - FirstName LastName\nYearOfPublication:\"YYYY\"\nTitle: \"\"\n---\n\n#Summary\nPLACE THE SUMMARY HERE. THIS SHOULD INCLUDE THE GOAL, METHODOLOGIES, RESULTS, AND NECESSARY COMMENTARY.\n\n#Data and Methodology\nDESCRIBE THE DATA SOURCE AND TYPE (E.G., SIMULATION OR OBSERVATION). ALSO DISCUSS THE METHODOLOGIES/TECHNIQUES - SPECIFICALLY MENTION NOVEL METHODOLOGIES. \n\n#Results/Conclusions/Findings\nLIST ALL RESULTS/CONCLUSIONS/FINDINGS. ALSO MENTION ANY POTENTIAL SHORTCOMINGS/ISSUES WITH THE STUDY.",
"['What is the main goal of this paper?', 'What are the key concepts, techniques, methodologies, and/or theories introduced in this paper?', 'What are the findings, conclusions, and/or results of this paper?', 'what is the methodology/technique used in this paper?', 'what is the source of the data used in this paper?', 'what does this paper say about the main goal?', 'What does this paper say about potential issues, problems, or concerns regarding the methodology or results of their study?', 'What does this paper say about possible future work?']",
"Now, you will write a plaintext summary of the paper based on what you have learned above. Your goal is to write a concise summary of this paper, focusing primarily on the main goal and each key concept or entity introduced in the paper. Keep the summary brief and to the point.",
"You summarize an academic paper.",
"Great! Let's get started, what questions do you want answered?",
"You read parts of pdfs and return summarized transcriptions. Be detailed and concise. You will make sure that words are separated by spaces and that there are no extra spaces. If you cannot read the file, return nothing.",
"Please keep your response to less than ",
"words:\n",
"Here is the paper: PLACEHOLDER",
"You will be summarizing and answering questions about the following paper. This is a summarized transcript of the paper: PLACEHOLDER",
" words.\n\n",
"Answer the following in less than350words:\n\nPLACEHOLDER: PLACEHOLDER",
"Summarize your findings in less than 500 words. Use plain language and be concise and detailed. Use this format for your response. \"###Summary\n\nYOUR SUMMARY HERE\n\n---\n\n\"",
"You answer questions about academic literature.",
"Here is the summarized transcription of the excerpt:",
"content",
"You read and answer questions about an academic paper. Previously, you had this to say about this paper: PLACEHOLDER",
"Read and provide a summarized transcription the following. Keep your response to less than "
] |
2024-01-10 | nrb171/Automatic-Publication-Summarization | keywordGenerator.py | import openai
from sklearn.manifold import TSNE
import matplotlib
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans
# imports
import numpy as np
import pandas as pd
from ast import literal_eval
import tiktoken
import time
with open("key.ini", "r") as f:
openai.api_key = f.read()
# load data
datafile_path = "/Users/nrb171/Library/CloudStorage/OneDrive-ThePennsylvaniaStateUniversity/PSU/Didlake Group-PSU/Papers/embeddings/embeddings.csv"
df = pd.read_csv(datafile_path, header=None)
df["embedding"] = df[2].apply(literal_eval).apply(np.array) # convert string to numpy array
matrix = np.vstack(df.embedding.values)
matrix.shape
n_clusters = 4
kmeans = KMeans(n_clusters=n_clusters, init="k-means++", random_state=42)
kmeans.fit(matrix)
labels = kmeans.labels_
df["Cluster"] = labels
df.groupby("Cluster").Score.mean().sort_values()
tsne = TSNE(n_components=2, perplexity=15, random_state=42, init="random", learning_rate=200)
vis_dims2 = tsne.fit_transform(matrix)
x = [x for x, y in vis_dims2]
y = [y for x, y in vis_dims2]
for category, color in enumerate(["purple", "green", "red", "blue"]):
xs = np.array(x)[df.Cluster == category]
ys = np.array(y)[df.Cluster == category]
plt.scatter(xs, ys, color=color, alpha=0.3)
avg_x = xs.mean()
avg_y = ys.mean()
plt.scatter(avg_x, avg_y, marker="x", color=color, s=100)
plt.title("Clusters identified visualized in language 2d using t-SNE")
plt.savefig("clusters.png")
# Reading a review which belong to each group.
rev_per_cluster = 4
for i in range(n_clusters):
print(f"Cluster {i} Theme:", end=" ")
papers = np.array(df[1][df["Cluster"] == i])
for j,paper in enumerate(papers):
papers[j] = paper[:paper.find("###",100)]
papers = "\n".join(papers)
response = openai.ChatCompletion.create(
model="gpt-3.5-turbo-16k",
messages=[{"role":"user","content":"What do the following academic papers have in common?\n\nPaper summaries:\n\n"+papers+"\n\nTheme:"}],
temperature=0,
top_p=1,
frequency_penalty=0,
presence_penalty=0,
)
print(response["choices"][0]["message"]["content"]) | [
"What do the following academic papers have in common?\n\nPaper summaries:\n\nPLACEHOLDER\n\nTheme:"
] |
2024-01-10 | neulab/gemini-benchmark | benchmarking~utils~reasoning_utils.py | import openai
import asyncio
from typing import Any, Callable, Iterable, Match, Optional, Pattern, Protocol, Sequence, Union
import base64
import requests
from io import BytesIO
from PIL import Image
import json
import os
import re
import torch as th
from tqdm import tqdm
from openai import AsyncOpenAI
from torch.utils.data import DataLoader
from litellm import acompletion
import yaml
import click
from litellm import Router
import litellm
import time
# litellm.set_verbose = True
os.environ["OPENAI_API_KEY"] = "##"
os.environ["TOGETHERAI_API_KEY"] = "##"
os.environ["HF_TOKEN"] = "##"
API_URL = "https://api-inference.huggingface.co/models/DiscoResearch/DiscoLM-mixtral-8x7b-v2"
ANS_RE = re.compile(r"#### (\-?[0-9\.\,]+)")
INVALID_ANS = "[invalid]"
PATTERN = r"(?:\(|\s)([A-Z])\.?(?:\)|\s|$)"
def set_router(model):
if model == "mixtral":
model = "together_ai/mistralai/Mixtral-8x7B-Instruct-v0.1"
model_list = [{
"model_name": model,
"litellm_params": {
"model": model,
}
}]
router = Router(model_list=model_list)
return router
TASKS = [
"boolean_expressions",
"geometric_shapes",
"reasoning_about_colored_objects",
"tracking_shuffled_objects_seven_objects",
"movie_recommendation",
"logical_deduction_five_objects",
"salient_translation_error_detection",
"logical_deduction_three_objects",
"temporal_sequences",
"disambiguation_qa",
"object_counting",
"causal_judgement",
"ruin_names",
"formal_fallacies",
"penguins_in_a_table",
"web_of_lies",
"sports_understanding",
"navigate",
"date_understanding",
"logical_deduction_seven_objects",
"snarks",
"tracking_shuffled_objects_five_objects",
"word_sorting",
"dyck_languages",
"multistep_arithmetic_two",
"hyperbaton",
"tracking_shuffled_objects_three_objects"
]
def read_jsonl(path: str):
with open(path) as fh:
return [json.loads(line) for line in fh.readlines() if line]
def extract_answer(completion):
match = ANS_RE.search(completion)
if match:
match_str = match.group(1).strip()
match_str = match_str.replace(",", "")
return match_str
else:
return INVALID_ANS
def is_correct(model_completion, gt_example):
gt_answer = extract_answer(gt_example["answer"])
assert gt_answer != INVALID_ANS
return extract_answer(model_completion) == gt_answer
async def dispatch_openai_requests(
router: Router,
messages_list: list,
model: str,
temperature: float,
max_tokens: int,
top_p: float
):
"""Dispatches requests to OpenAI API asynchronously.
Args:
messages_list: List of messages to be sent to OpenAI ChatCompletion API.
model: OpenAI model to use.
temperature: Temperature to use for the model.
max_tokens: Maximum number of tokens to generate.
top_p: Top p to use for the model.
Returns:
List of responses from OpenAI API.
"""
if model == "mixtral":
model = "together_ai/mistralai/Mixtral-8x7B-Instruct-v0.1"
async_responses = [
await router.acompletion(
model=model,
messages=x,
temperature=temperature,
max_tokens=max_tokens,
top_p=top_p
)
for x in messages_list
]
return async_responses
def get_examples_gsm8k(split, lr=0, rr=-1):
path = os.path.join("data/", f"{split}.jsonl")
examples = read_jsonl(path)
for ex in examples:
ex.update(question=ex["question"] + "\n")
ex.update(answer=ex["answer"] + "<|endoftext|>")
if rr == -1:
examples = examples[lr:len(examples)]
else:
examples = examples[lr:rr]
print(f"{len(examples)} {split} examples")
return examples
def get_examples_svamp(split, lr=0, rr=-1):
path = os.path.join("data/", f"{split}.jsonl")
examples = read_jsonl(path)
for ex in examples:
ex.update(question=ex["input"] + "\n")
ex.update(answer=str(ex["target"]))
del ex['input']
del ex["target"]
if rr == -1:
examples = examples[lr:len(examples)]
else:
examples = examples[lr:rr]
print(f"{len(examples)} {split} examples")
return examples
def get_examples(split, model, lr=0, rr=-1):
path = os.path.join("data/bbh/", f"{split}.jsonl")
examples = read_jsonl(path)
for ex in examples:
ex.update(question=ex["input"]+ "\n")
ex.update(answer=ex["target"])
del ex['input']
del ex["target"]
if rr == -1:
examples = examples[lr:len(examples)]
else:
examples = examples[lr:rr]
new_examples = []
for ex in examples:
if os.path.exists(f'gemini-benchmark/outputs/bbh/{model}/{split}/all_jsons'):
qid = ex['qid']
result_path = f'gemini-benchmark/outputs/bbh/{model}/{split}/all_jsons/{qid}.json'
if os.path.isfile(result_path):
continue
new_examples.append(ex)
print(f"{len(new_examples)} {split} examples")
return new_examples
def find_numbers(x: str) -> list[str]:
numbers = re.compile(
r'-?[\d,]*\.?\d+',
re.MULTILINE | re.DOTALL | re.IGNORECASE,
).findall(x)
return numbers
def find_number(x: str, answer_delimiter: Optional[str] = 'Answer:') -> str:
if answer_delimiter in x:
answer = x.split(answer_delimiter)[-1]
numbers = find_numbers(answer)
if numbers:
return numbers[0]
numbers = find_numbers(x)
if numbers:
return numbers[-1]
return ''
def is_float(s):
try:
float(s)
return True
except ValueError:
return False
def maybe_remove_comma(x: str) -> str:
if is_float(x):
return x
return x.replace(',', '')
def return_predicted_answer(question_answer_list):
correct = 0
for out in question_answer_list:
soln = out['generated_text'].split('\nQ:')[0]
short_responses = maybe_remove_comma(find_number(soln))
if short_responses != '':
correct += float(maybe_remove_comma(find_number(out['answer']))) == float(short_responses)
out['is_correct'] = int(float(maybe_remove_comma(find_number(out['answer']))) == float(short_responses))
out['predict'] = short_responses
else:
out['is_correct'] = 0
out['predict'] = "-10000000000"
print('Accuracy: ', correct/(1.0*len(question_answer_list)))
return question_answer_list
def get_answer(question_answer_list):
for out in question_answer_list:
soln = out['generated_text']
exact = out['answer']
prob_ans = re.findall(r"(?<=the answer is )(.*)(?=.)", soln)
if len(prob_ans) > 0 and exact == prob_ans[-1]:
out['predict'] = out['answer']
out['is_correct'] = 1
else:
if len(prob_ans) > 0: out['predict'] = str(prob_ans[-1])
else: out['predict'] = "-10000000000"
out['is_correct'] = 0
if exact.startswith('(') and exact.endswith(')'):
prob_ans = re.findall(PATTERN, out['generated_text'])
prob_ans = ['('+x+')' for x in prob_ans]
if len(prob_ans) > 0 and exact == prob_ans[-1]:
out['predict_last'] = out['answer']
out['is_correct_last'] = 1
else:
if len(prob_ans) > 0: out['predict_last'] = str(prob_ans[-1])
else: out['predict_last'] = "-10000000000"
out['is_correct_last'] = 0
for out in question_answer_list:
if 'is_correct_last' not in out:
out['is_correct_last'] = out['is_correct']
out['predict_last'] = out['predict']
return question_answer_list
def get_response(prompt):
response = litellm.completion(
model="gemini-pro",
messages=[
{
"role": "system",
"content": "Follow the given examples and answer the question.",
},
{"role": "user", "content": prompt},
],
max_retries=3,
safety_settings=[
{
"category": "HARM_CATEGORY_HARASSMENT",
"threshold": "BLOCK_NONE",
},
{
"category": "HARM_CATEGORY_HATE_SPEECH",
"threshold": "BLOCK_NONE",
},
{
"category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
"threshold": "BLOCK_NONE",
},
{
"category": "HARM_CATEGORY_DANGEROUS_CONTENT",
"threshold": "BLOCK_NONE",
},
]
)
return response | [
"Follow the given examples and answer the question."
] |
2024-01-10 | neulab/gemini-benchmark | benchmarking~bbh~bbh_gemini.py | # NOTE:
# You can find an updated, more robust and feature-rich implementation
# in Zeno Build
# - Zeno Build: https://github.com/zeno-ml/zeno-build/
# - Implementation: https://github.com/zeno-ml/zeno-build/blob/main/zeno_build/models/providers/openai_utils.py
import openai
import asyncio
from typing import Any
import base64
import requests
from io import BytesIO
from PIL import Image
import json
import os
import re
import torch as th
from tqdm import tqdm
from openai import AsyncOpenAI
from torch.utils.data import DataLoader
from litellm import acompletion
import yaml
import click
import sys
from reasoning_utils import *
import litellm
import time
litellm.vertex_project = "##" # Your Project ID
litellm.vertex_location = "##" # proj location
os.environ["OPENAI_API_KEY"] = "##"
class BBHDataset(th.utils.data.Dataset):
def __init__(self, examples):
self.examples = examples
self.qns = [ex["question"] for ex in self.examples]
self.ans = [ex["answer"] for ex in self.examples]
self.ids = [ex["qid"] for ex in self.examples]
def __len__(self):
return len(self.examples)
def __getitem__(self, idx):
qn = self.qns[idx]
ans = self.ans[idx]
qid = self.ids[idx]
return qid, qn, ans
@click.command()
@click.option("--task", default='object_counting', type=str)
@click.option("--model", default='gpt-3.5-turbo', type=str)
@click.option("--lr", default=0, type=int)
@click.option("--rr", default=-1, type=int)
def main(task, model, lr, rr):
if task == 'all_tasks':
all_tasks = TASKS
else:
all_tasks = [task]
results_all_tasks = []
router = set_router(model)
for task in all_tasks:
print('Starting task: ', task)
with open(f"gemini_benchmark/cot_fewshot/{task}.yaml", 'r') as stream:
data_loaded = yaml.safe_load(stream)
prompt = data_loaded['doc_to_text']
question_answer_list = []
test_examples = get_examples(task, lr=lr, rr=rr)
test_dset = BBHDataset(test_examples)
test_loader = DataLoader(test_dset, batch_size=1, shuffle=False)
if not os.path.exists(f'gemini_benchmark/outputs/bbh/{model}'):
os.makedirs(f'gemini_benchmark/outputs/bbh/{model}')
if not os.path.exists(f'gemini_benchmark/outputs/bbh/{model}/{task}'):
os.makedirs(f'gemini_benchmark/outputs/bbh/{model}/{task}')
if not os.path.exists(f'gemini_benchmark/outputs/bbh/{model}/{task}/all_jsons'):
os.makedirs(f'gemini_benchmark/outputs/bbh/{model}/{task}/all_jsons')
for idx, (qid, qn, ans) in tqdm(enumerate(test_loader), total=len(test_loader)):
mlist = []
result_path = f'gemini_benchmark/outputs/bbh/{model}/{task}/all_jsons/{qid[0]}.json'
if os.path.isfile(result_path):
with open(result_path) as f:
d = json.load(f)
if d['generated_text'] != "-1000000":
continue
for q, qi in zip(qn, qid):
if task == 'dyck_languages': q_prompt = prompt.replace("{{input}}", q)
else: q_prompt = prompt.replace("{{input}}", "{input}").format(input=q)
mlist.append([{"role": "system", "content": "Follow the given examples and answer the question."},
{"role": "user", "content": q_prompt}])
predictions = []
for q, qi in zip(qn, qid):
if task == 'dyck_languages': q_prompt = prompt.replace("{{input}}", q)
else: q_prompt = prompt.replace("{{input}}", "{input}").format(input=q)
try:
response = get_response(q_prompt.strip())
predictions.append(response)
except Exception as e:
print(q_prompt.strip())
print(qi)
predictions.append(str(e))
for i, (response, qi, q, a) in enumerate(zip(predictions, qid, qn, ans)):
if task == 'dyck_languages': q_prompt = prompt.replace("{{input}}", q)
else: q_prompt = prompt.replace("{{input}}", "{input}").format(input=q)
al = {'task': task,
'qid': qi.item(),
'prompt': q_prompt,
'question': q,
'answer': a}
if isinstance(response, str):
al['generated_text'] = response
else:
al['generated_text'] = response.choices[0].message.content
question_answer_list.append(al)
result_path = f'gemini_benchmark/outputs/bbh/{model}/{task}/all_jsons/{qi}.json'
if os.path.isfile(result_path):
with open(result_path) as f:
d = json.load(f)
if d['generated_text'] != "-1000000":
continue
with open(result_path, 'w') as fp:
json.dump(al, fp)
question_answer_list = get_answer(question_answer_list)
results_all_tasks.extend(question_answer_list)
with open(f'gemini_benchmark/outputs/bbh/{model}/{task}/output.jsonl', 'w') as f:
for d in question_answer_list:
json.dump(d, f)
f.write('\n')
with open(f'gemini_benchmark/outputs/bbh/{model}/output.jsonl', 'w') as f:
for d in results_all_tasks:
json.dump(d, f)
f.write('\n')
return
if __name__ == "__main__":
main()
| [
"{{input}}",
"doc_to_text",
"Follow the given examples and answer the question.",
"{input}"
] |
2024-01-10 | neulab/gemini-benchmark | benchmarking~math_reasoning~math_reasoning.py | # NOTE:
# You can find an updated, more robust and feature-rich implementation
# in Zeno Build
# - Zeno Build: https://github.com/zeno-ml/zeno-build/
# - Implementation: https://github.com/zeno-ml/zeno-build/blob/main/zeno_build/models/providers/openai_utils.py
import openai
import asyncio
from typing import Any
import base64
import requests
from io import BytesIO
from PIL import Image
import json
import os
import re
import torch as th
from tqdm import tqdm
from openai import AsyncOpenAI
from torch.utils.data import DataLoader
from litellm import acompletion
import yaml
import click
import sys
from litellm import Router
from prompts import *
sys.path.append('../utils')
from reasoning_utils import *
os.environ["OPENAI_API_KEY"] = "##"
os.environ["TOGETHERAI_API_KEY"] = "##"
class GSMDataset(th.utils.data.Dataset):
def __init__(self, examples):
self.examples = examples
self.qns = [ex["question"] for ex in self.examples]
self.ans = [ex["answer"] for ex in self.examples]
self.ids = [ex["qid"] for ex in self.examples]
def __len__(self):
return len(self.examples)
def __getitem__(self, idx):
qn = self.qns[idx]
ans = self.ans[idx]
qid = self.ids[idx]
return qid, qn, ans
@click.command()
@click.option("--task", default='gsm8k', type=str)
@click.option("--model", default='gpt-3.5-turbo', type=str)
@click.option("--lr", default=0, type=int)
@click.option("--rr", default=-1, type=int)
def main(task, model, lr, rr):
# with open("gsm8k-cot.yaml", 'r') as stream:
# data_loaded = yaml.safe_load(stream)
# prompt = data_loaded['doc_to_text']
question_answer_list = []
if task == 'gsm8k':
test_examples = get_examples_gsm8k("gsm8k", lr=lr, rr=rr)
elif task == 'svamp':
test_examples = get_examples_svamp("svamp", lr=lr, rr=rr)
elif task == 'asdiv':
test_examples = get_examples_svamp("asdiv", lr=lr, rr=rr)
elif task == 'mawpsmultiarith':
test_examples = get_examples_svamp("mawpsmultiarith", lr=lr, rr=rr)
test_dset = GSMDataset(test_examples)
test_loader = DataLoader(test_dset, batch_size=8, shuffle=True)
router = set_router(model)
if not os.path.exists(f'gemini-benchmark/outputs/{task}'):
os.makedirs(f'gemini-benchmark/outputs/{task}')
if not os.path.exists(f'gemini-benchmark/outputs/{task}/{model}'):
os.makedirs(f'gemini-benchmark/outputs/{task}/{model}')
if not os.path.exists(f'gemini-benchmark/outputs/{task}/{model}/all_jsons'):
os.makedirs(f'gemini-benchmark/outputs/{task}/{model}/all_jsons')
for idx, (qid, qn, ans) in tqdm(enumerate(test_loader), total=len(test_loader)):
mlist = []
for q in qn:
# q_prompt = prompt.replace("{{question}}", "{question}").format(question=q)
q_prompt = (PROMPT + '\n' + TEMPLATE.format(question=q))
mlist.append([{"role": "system", "content": "Follow the given examples and answer the question."},
{"role": "user", "content": q_prompt}])
predictions = asyncio.run(
dispatch_openai_requests(
router=router,
messages_list=mlist,
model=model,
temperature=0.0,
max_tokens=512,
top_p=1.0,
)
)
for i, (response, qi, q, a) in enumerate(zip(predictions, qid, qn, ans)):
al = {'qid': qi.item(),
'prompt': prompt.replace("{{question}}", "{question}").format(question=q),
'question': q,
'generated_text': response.choices[0].message.content}
if task == 'gsm8k':
only_a = extract_answer(a)
al['answer'] = only_a
al['answer_text'] = a
else:
al['answer'] = a
question_answer_list.append(al)
result_path = f'gemini-benchmark/outputs/{task}/{model}/all_jsons/{qi}.json'
if os.path.isfile(result_path):
continue
with open(result_path, 'w') as fp:
json.dump(al, fp)
question_answer_list = return_predicted_answer(question_answer_list)
with open(f'gemini-benchmark/outputs/{task}/{model}/output.jsonl', 'w') as f:
for d in question_answer_list:
json.dump(d, f)
f.write('\n')
return
if __name__ == "__main__":
main() | [
"\n",
"Follow the given examples and answer the question."
] |
2024-01-10 | neulab/gemini-benchmark | benchmarking~math_reasoning~math_reasoning_gemini.py | import openai
import asyncio
from typing import Any
import base64
import requests
from io import BytesIO
from PIL import Image
import json
import os
import re
import torch as th
from tqdm import tqdm
from openai import AsyncOpenAI
from torch.utils.data import DataLoader
from litellm import acompletion
import yaml
import click
import sys
import time
from litellm import Router
from prompts import *
sys.path.append('../utils')
from reasoning_utils import *
import litellm
litellm.vertex_project = "####" # Your Project ID
litellm.vertex_location = "####" # proj location
os.environ["OPENAI_API_KEY"] = "OPENAI_API_KEY"
os.environ["TOGETHERAI_API_KEY"] = "TOGETHERAI_API_KEY"
class GSMDataset(th.utils.data.Dataset):
def __init__(self, examples):
self.examples = examples
self.qns = [ex["question"] for ex in self.examples]
self.ans = [ex["answer"] for ex in self.examples]
self.ids = [ex["qid"] for ex in self.examples]
def __len__(self):
return len(self.examples)
def __getitem__(self, idx):
qn = self.qns[idx]
ans = self.ans[idx]
qid = self.ids[idx]
return qid, qn, ans
@click.command()
@click.option("--task", default='gsm8k', type=str)
@click.option("--model", default='gpt-3.5-turbo', type=str)
@click.option("--lr", default=0, type=int)
@click.option("--rr", default=-1, type=int)
def main(task, model, lr, rr):
# with open("gsm8k-cot.yaml", 'r') as stream:
# data_loaded = yaml.safe_load(stream)
# prompt = data_loaded['doc_to_text']
question_answer_list = []
if task == 'gsm8k':
test_examples = get_examples_gsm8k("gsm8k", lr=lr, rr=rr)
elif task == 'svamp':
test_examples = get_examples_svamp("svamp", lr=lr, rr=rr)
elif task == 'asdiv':
test_examples = get_examples_svamp("asdiv", lr=lr, rr=rr)
elif task == 'mawpsmultiarith':
test_examples = get_examples_svamp("mawpsmultiarith", lr=lr, rr=rr)
test_dset = GSMDataset(test_examples)
test_loader = DataLoader(test_dset, batch_size=1, shuffle=False)
router = set_router(model)
if not os.path.exists(f'gemini-benchmark/outputs/{task}'):
os.makedirs(f'gemini-benchmark/outputs/{task}')
if not os.path.exists(f'gemini-benchmark/outputs/{task}/{model}'):
os.makedirs(f'gemini-benchmark/outputs/{task}/{model}')
if not os.path.exists(f'gemini-benchmark/outputs/{task}/{model}/all_jsons'):
os.makedirs(f'gemini-benchmark/outputs/{task}/{model}/all_jsons')
for idx, (qid, qn, ans) in tqdm(enumerate(test_loader), total=len(test_loader)):
result_path = f'gemini-benchmark/outputs/{task}/{model}/all_jsons/{qid[0]}.json'
if os.path.isfile(result_path):
continue
predictions = []
for q, qi in zip(qn, qid):
# q_prompt = prompt.replace("{{question}}", "{question}").format(question=q)
q_prompt = (PROMPT + '\n' + TEMPLATE.format(question=q))
response = get_response(q_prompt)
predictions.append(response)
for i, (response, qi, q, a) in enumerate(zip(predictions, qid, qn, ans)):
al = {'qid': qi.item(),
# 'prompt': prompt.replace("{{question}}", "{question}").format(question=q),
'prompt': (PROMPT + '\n' + TEMPLATE.format(question=q)),
'question': q}
if isinstance(response, str):
al['generated_text'] = response
else:
al['generated_text'] = response.choices[0].message.content
if task == 'gsm8k':
only_a = extract_answer(a)
al['answer'] = only_a
al['answer_text'] = a
else:
al['answer'] = a
question_answer_list.append(al)
result_path = f'gemini-benchmark/outputs/{task}/{model}/all_jsons/{qi}.json'
if os.path.isfile(result_path):
continue
with open(result_path, 'w') as fp:
json.dump(al, fp)
question_answer_list = return_predicted_answer(question_answer_list)
with open(f'gemini-benchmark/outputs/{task}/{model}/output.jsonl', 'w') as f:
for d in question_answer_list:
json.dump(d, f)
f.write('\n')
return
if __name__ == "__main__":
main()
| [
"\n"
] |
2024-01-10 | neulab/gemini-benchmark | benchmarking~bbh~bbh.py | # NOTE:
# You can find an updated, more robust and feature-rich implementation
# in Zeno Build
# - Zeno Build: https://github.com/zeno-ml/zeno-build/
# - Implementation: https://github.com/zeno-ml/zeno-build/blob/main/zeno_build/models/providers/openai_utils.py
import openai
import asyncio
from typing import Any
import base64
import requests
from io import BytesIO
from PIL import Image
import json
import os
import re
import torch as th
from tqdm import tqdm
from openai import AsyncOpenAI
from torch.utils.data import DataLoader
from litellm import acompletion
import yaml
import click
import sys
sys.path.append('../utils')
from reasoning_utils import *
import litellm
os.environ["OPENAI_API_KEY"] = "##"
os.environ["TOGETHERAI_API_KEY"] = "##"
os.environ["HF_TOKEN"] = "##"
class BBHDataset(th.utils.data.Dataset):
def __init__(self, examples):
self.examples = examples
self.qns = [ex["question"] for ex in self.examples]
self.ans = [ex["answer"] for ex in self.examples]
self.ids = [ex["qid"] for ex in self.examples]
def __len__(self):
return len(self.examples)
def __getitem__(self, idx):
qn = self.qns[idx]
ans = self.ans[idx]
qid = self.ids[idx]
return qid, qn, ans
@click.command()
@click.option("--task", default='object_counting', type=str)
@click.option("--model", default='gpt-3.5-turbo', type=str)
@click.option("--lr", default=0, type=int)
@click.option("--rr", default=-1, type=int)
def main(task, model, lr, rr):
if task == 'all_tasks':
all_tasks = TASKS
else:
all_tasks = [task]
results_all_tasks = []
router = set_router(model)
for task in all_tasks:
print('Starting task: ', task)
with open(f"lm-evaluation-harness/lm_eval/tasks/bbh/cot_fewshot/{task}.yaml", 'r') as stream:
data_loaded = yaml.safe_load(stream)
prompt = data_loaded['doc_to_text']
question_answer_list = []
test_examples = get_examples(task, model, lr=lr, rr=rr)
test_dset = BBHDataset(test_examples)
test_loader = DataLoader(test_dset, batch_size=8, shuffle=False)
if not os.path.exists(f'gemini-benchmark/outputs/bbh/{model}'):
os.makedirs(f'gemini-benchmark/outputs/bbh/{model}')
if not os.path.exists(f'gemini-benchmark/outputs/bbh/{model}/{task}'):
os.makedirs(f'gemini-benchmark/outputs/bbh/{model}/{task}')
if not os.path.exists(f'gemini-benchmark/outputs/bbh/{model}/{task}/all_jsons'):
os.makedirs(f'gemini-benchmark/outputs/bbh/{model}/{task}/all_jsons')
for idx, (qid, qn, ans) in tqdm(enumerate(test_loader), total=len(test_loader)):
mlist = []
for q in qn:
if task == 'dyck_languages': q_prompt = prompt.replace("{{input}}", q)
else: q_prompt = prompt.replace("{{input}}", "{input}").format(input=q)
mlist.append([{"role": "system", "content": "Follow the given examples and answer the question."},
{"role": "user", "content": q_prompt}])
predictions = asyncio.run(
dispatch_openai_requests(
router=router,
messages_list=mlist,
model=model,
temperature=0.0,
max_tokens=512,
top_p=1.0,
)
)
for i, (response, qi, q, a) in enumerate(zip(predictions, qid, qn, ans)):
if task == 'dyck_languages': q_prompt = prompt.replace("{{input}}", q)
else: q_prompt = prompt.replace("{{input}}", "{input}").format(input=q)
al = {'task': task,
'qid': qi.item(),
'prompt': q_prompt,
'question': q,
'answer': a,
'generated_text': response.choices[0].message.content}
question_answer_list.append(al)
result_path = f'gemini-benchmark/outputs/bbh/{model}/{task}/all_jsons/{qi}.json'
if os.path.isfile(result_path):
continue
with open(result_path, 'w') as fp:
json.dump(al, fp)
question_answer_list = get_answer(question_answer_list)
results_all_tasks.extend(question_answer_list)
with open(f'gemini-benchmark/outputs/bbh/{model}/{task}/output.jsonl', 'w') as f:
for d in question_answer_list:
json.dump(d, f)
f.write('\n')
return
if __name__ == "__main__":
main()
| [
"{{input}}",
"doc_to_text",
"Follow the given examples and answer the question.",
"{input}"
] |
2024-01-10 | BhanuKedhar09/Obesity-Classification | Ai_model.py | import openai
import pandas as pd
import json
import time
import os
import sys
import chromadb
import openai
import requests
import pandas as pd
import numpy as np
import config
from langchain.docstore.document import Document
from langchain.document_loaders import CSVLoader
from langchain.document_loaders import TextLoader
from langchain.document_loaders import CSVLoader
from langchain.document_loaders import DirectoryLoader
from langchain.indexes import VectorstoreIndexCreator
from langchain.chat_models import ChatOpenAI
from langchain.llms import OpenAI
from langchain.chat_models import ChatOpenAI
from langchain.agents.agent_types import AgentType
from langchain.agents import create_csv_agent
from typing import List
from langchain.docstore.document import Document
from langchain.retrievers import ChatGPTPluginRetriever
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from sklearn.metrics import confusion_matrix
from sklearn.metrics import classification_report
from sklearn.metrics import f1_score
from sklearn.metrics import precision_score
from sklearn.metrics import recall_score
openai.api_key = config.api_key
columns = {"Gender": "Gender",
"Age": "Age",
"Height": "Height",
"Weight": "Weight",
"family_history_with_overweight": "family_history_with_overweight",
"FAVC": "Frequent consumption of high caloric food",
"FCVC": "Frequency of consumption of vegetables",
"NCP": "Number of main meals",
"CAEC": "Consumption of food between meals",
"SMOKE": "SMOKE",
"CH2O": "Consumption of water daily",
"SCC": "Calories consumption monitoring",
"FAF": "Physical activity frequency",
"TUE": "Time using technology devices",
"CALC": "Consumption of alcohol",
"MTRANS": "Transportation used",
"Category_type": "Category_type"}
original_data = pd.read_csv("ObesityDataSet_raw_and_data_sinthetic.csv")
category_mapping = {
'Obesity_Type_I': 'obesity',
'Obesity_Type_II': 'obesity',
'Obesity_Type_III': 'obesity',
'Overweight_Level_I': 'overweight',
'Overweight_Level_II': 'overweight',
'Normal_Weight': 'normal_weight',
'Insufficient_Weight': 'underweight'
}
encoding = {
"normal_weight" : 0,
"obesity" : 1,
"overweight" : 2,
"underweight" : 3
}
original_data['Category_type'] = (
original_data['NObeyesdad'].map(category_mapping))
# original_data["category_encoding"] = original_data["Category_type"].map(encoding)
original_data.drop("NObeyesdad", axis=1, inplace=True)
data_80_percent, data_20_percent = train_test_split(
original_data, test_size=0.2, random_state=42)
train_df, validate_df = train_test_split(
data_80_percent, test_size=0.3, random_state=42)
test_df = data_20_percent
print("Train data shape: ", train_df.shape)
print("Validate data shape: ", validate_df.shape)
print("Test data shape: ", test_df.shape)
print("-" * 150)
train_df.to_csv('train_data.csv', index=False)
validate_df.to_csv('validate_data.csv', index=False)
test_df.to_csv('test_data.csv', index=False)
r_train_data = []
r_test_data = []
r_validate_data = []
def train_data_write_jsonl(path: str, documents: List[Document]) -> None:
for d in documents:
data_dict = {}
for k in d.page_content.split("\n"):
if k.split(": ")[0] != "Category_type":
key, value = k.split(": ")
ke = columns[key]
# print(ke)
data_dict[ke] = value
r_train_data.append([str(data_dict), d.metadata["source"]])
messages = []
for line in r_train_data:
msg = {"messages": [{"role": "system", "content": "You are a very helpful assistant that classifies obesity levels"}, {
"role": "user", "content": line[0]}, {"role": "assistant", "content": str(line[1])}]}
messages.append(msg)
with open(path, "w") as f:
for line in messages:
json.dump(line, f)
f.write("\n")
def validate_data_write_jsonl(path: str, documents: List[Document]) -> None:
for d in documents:
data_dict = {}
for k in d.page_content.split("\n"):
if k.split(": ")[0] != "Category_type":
key, value = k.split(": ")
ke = columns[key]
# print(ke)
data_dict[ke] = value
r_validate_data.append([str(data_dict), d.metadata["source"]])
messages = []
for line in r_validate_data:
msg = {"messages": [{"role": "system", "content": "You are a very helpful assistant that classifies obesity levels"}, {
"role": "user", "content": line[0]}, {"role": "assistant", "content": str(line[1])}]}
messages.append(msg)
with open(path, "w") as f:
for line in messages:
json.dump(line, f)
f.write("\n")
def test_data_write_jsonl(path: str, documents: List[Document]) -> None:
for d in documents:
data_dict = {}
for k in d.page_content.split("\n"):
if k.split(": ")[0] != "Category_type":
key, value = k.split(": ")
ke = columns[key]
# print(ke)
data_dict[ke] = value
r_test_data.append([str(data_dict).replace(
"}", "").replace("{", "").replace("'", ""), d.metadata["source"]])
messages = []
for line in r_test_data:
msg = {"messages": [{"role": "system", "content": "You are a very helpful assistant that classifies obesity levels only based on training data"}, {
"role": "user", "content": "Please classify the following patient data as normal_weight/obesity/overweight/underweight only based on the provided training data:"}, {"role": "user", "content": str(line[0])}]}
messages.append(msg)
with open(path, "w") as f:
for line in messages:
json.dump(line, f)
f.write("\n")
# print(original_data.columns)
train_loader = CSVLoader("./train_data.csv", source_column="Category_type")
validate_loader = CSVLoader("./validate_data.csv",
source_column="Category_type")
test_loader = CSVLoader("./test_data.csv", source_column="Category_type")
train_data_write_jsonl("obesity_train.jsonl", train_loader.load())
validate_data_write_jsonl("obesity_validate.jsonl", validate_loader.load())
test_data_write_jsonl("obesity_test.jsonl", test_loader.load())
status_good = ["uploaded", "processed", "pending", "succeeded"]
status_bad = ["error", "deleting", "deleted"]
all_uploded_files = openai.files.list()
print("files in the repo: ", all_uploded_files.data)
print("-" * 150)
for file in all_uploded_files.data:
try:
openai.files.delete(file.id)
except Exception as e:
print(f"Failed to delete file {file}: {e}")
training_file = openai.files.create(
file=open("obesity_train.jsonl", "rb"),
purpose="fine-tune"
)
while training_file.status not in status_good:
print(training_file.status)
print("Train File processed")
print("-" * 150)
validation_file = openai.files.create(
file=open("obesity_validate.jsonl", "rb"),
purpose='fine-tune'
)
while validation_file.status not in status_good:
print(validation_file.status)
print("Validation File processed")
print("-" * 150)
current_exsiting_files = (openai.files.list()).data
print("Current Existing files in the openai account:")
print(current_exsiting_files)
print("-" * 150)
all_models = (openai.models.list()).data
models_in_my_org = []
print(all_models)
print("-" * 150)
for model in all_models:
if model.owned_by == "user-flnu6eg6zogaqvaydrcywn39":
models_in_my_org.append(model.id)
print("Models in my org: ", models_in_my_org)
print("-"*150)
models_to_be_deleted = list(set(models_in_my_org) - set(config.my_models_list))
print("Models to be deleted", models_to_be_deleted, )
print("-"*150)
for model in models_to_be_deleted:
try:
openai.models.delete(model)
except Exception as e:
print(f"Failed to delete model {model}: {e}")
print("Available models after Deletion", models_to_be_deleted)
print("-"*150)
if openai.models.retrieve("ft:gpt-3.5-turbo-0613:personal::8SBEArVW") is None:
obesity_fine_tune_model = openai.fine_tuning.jobs.create(
training_file=training_file.id,
validation_file=validation_file.id,
model="gpt-3.5-turbo-1106",
hyperparameters= {
"n_epochs": "auto"
},
suffix = "obesity_model",
)
else:
obesity_fine_tune_model = openai.models.retrieve(
"ft:gpt-3.5-turbo-0613:personal::8SBEArVW"
)
print("The Obesity Model: ")
print(obesity_fine_tune_model)
print("-"*150)
predicted_output = []
with open("obesity_test.jsonl", "r") as f:
for line in f:
data = json.loads(line)
messages = data["messages"]
response = openai.chat.completions.create(
model="ft:gpt-3.5-turbo-0613:personal::8SBEArVW",
messages=messages,
)
predicted_output.append(response)
print(predicted_output[0])
print("-"*150)
AI_fine_tuned_pred = []
for response in predicted_output :
if "normal" in ((response.choices[0]).message.content).lower():
AI_fine_tuned_pred.append(0)
elif "overweight" in ((response.choices[0]).message.content).lower():
AI_fine_tuned_pred.append(2)
elif "obes" in ((response.choices[0]).message.content).lower():
AI_fine_tuned_pred.append(1)
elif "underweight" in ((response.choices[0]).message.content).lower():
AI_fine_tuned_pred.append(3)
else:
AI_fine_tuned_pred.append((response.choices[0]).message.content)
print("AI_fine_tuned_pred: ")
print(AI_fine_tuned_pred)
print("-"*150)
test_df["category_encoding"] = test_df["Category_type"].map(encoding)
print("test_df: ")
print(test_df["category_encoding"].values, len(test_df["category_encoding"].values))
print("-"*150)
print("length of prediction encoded and number of responses back : ", len(AI_fine_tuned_pred), len(predicted_output))
print("-" * 150)
print("Accuracy of the model: ", accuracy_score(test_df["category_encoding"].values, AI_fine_tuned_pred))
print("-" * 150)
print("Confusion Matrix: ", confusion_matrix(test_df["category_encoding"].values, AI_fine_tuned_pred))
print("-" * 150)
print("Classification Report: ", classification_report(test_df["category_encoding"].values, AI_fine_tuned_pred))
print("-" * 150)
| [
"You are a very helpful assistant that classifies obesity levels only based on training data",
"You are a very helpful assistant that classifies obesity levels",
"Please classify the following patient data as normal_weight/obesity/overweight/underweight only based on the provided training data:"
] |
2024-01-10 | qwIvan/shazhou-tts | tts-web.py | import os
import requests
import tempfile
import xmltodict
import openai
from concurrent.futures import ThreadPoolExecutor, as_completed
from pydub import AudioSegment
from pywebio import config
from pywebio.platform.tornado_http import start_server
from pywebio.input import input, textarea, input_group, radio, actions
from pywebio.output import put_text, put_file, put_processbar, set_processbar, put_markdown, put_collapse, put_success
headers = {
'content-type': 'application/ssml+xml; charset=utf-8',
'ocp-apim-subscription-key': '09dd983c815c4ef7aca1b01146b41b37',
'x-microsoft-outputformat': 'audio-16khz-128kbitrate-mono-mp3',
}
config(title='沙洲之歌 - 沙洲书社的论文音频合成工具')
def split_text(content, size=1500):
chunks = []
start = 0
while start < len(content):
end = start + size if start + size < len(content) else len(content)
last_period = content.rfind('。', start, end)
if last_period != -1:
end = last_period + 1
chunks.append(content[start:end])
start = end
return chunks
def generate_audio(content, voice_name):
data_dict = {
'speak': {
'@version': '1.0',
'@xml:lang': 'zh-CN',
'voice': {
'@name': voice_name,
'#text': content
}
}
}
data = xmltodict.unparse(data_dict).encode()
response = requests.post(
'https://southeastasia.tts.speech.microsoft.com/cognitiveservices/v1', headers=headers, data=data,
)
temp_file_path = tempfile.mktemp(suffix=".mp3")
with open(temp_file_path, 'wb') as temp_file:
temp_file.write(response.content)
return AudioSegment.from_mp3(temp_file_path)
def generate_article_audio(contents):
combined = AudioSegment.empty()
for i, content in enumerate(contents):
data_dict = {
'speak': {
'@version': '1.0',
'@xml:lang': 'zh-CN',
'voice': {
'@name': 'zh-CN-YunzeNeural',
'#text': format(content)
}
}
}
data = xmltodict.unparse(data_dict).encode()
response = requests.post(
'https://southeastasia.tts.speech.microsoft.com/cognitiveservices/v1', headers=headers, data=data,
)
temp_file_path = tempfile.mktemp(suffix=".mp3")
with open(temp_file_path, 'wb') as temp_file:
temp_file.write(response.content)
audio_segment = AudioSegment.from_mp3(temp_file_path)
combined += audio_segment
# set_processbar(process_id, (i + 1) / len(contents)) # 更新进度条
return combined
def main():
# set_env(auto_scroll_bottom=True)
put_markdown('# 沙洲之歌')
put_markdown('> 沙洲书社的论文音频合成工具')
voice_options = [('云泽', 'zh-CN-YunzeNeural'), ('晓秋', 'zh-CN-XiaoqiuNeural')]
data = input_group("请输入论文信息", [
input("论文的标题：", name='title', required=True),
input("作者的名称：", name='author', required=True),
input("作者的简介：", name='author_intro', required=True),
input("论文的来源：", name='source', required=True),
#radio("开头的语音：", options=voice_options, name='head-voice', inline=True, value='zh-CN-XiaoqiuNeural'),
#radio("正文的语音：", options=voice_options, name='body-voice', inline=True, value='zh-CN-YunzeNeural'),
#radio("结尾的语音：", options=voice_options, name='foot-voice', inline=True, value='zh-CN-XiaoqiuNeural'),
textarea("论文的内容：", name='article', rows=10, placeholder="请将论文内容粘贴到这里", required=True),
textarea("论文的结尾：", name='outro_text', rows=3, value='以上内容，由沙洲书社淡定洲同志制作，仅供学术研究使用。'),
radio("格式化：", options=[('自动格式化', True), ('不格式化', False)], inline=True, name='formatting', value=True),
])
title = data['title']
author = data['author']
author_intro = data['author_intro']
source = data['source']
formatting = data['formatting']
#head_voice = data['head-voice']
#body_voice = data['body-voice']
#foot_voice = data['foot-voice']
article = data['article']
article = article.strip()
head_voice = 'zh-CN-XiaoqiuNeural'
body_voice = 'zh-CN-YunzeNeural'
foot_voice = 'zh-CN-XiaoqiuNeural'
## 再次让用户编辑
# article = textarea(value=article, rows=20)
intro_text = f"标题：{title}\n作者：{author}，{author_intro}\n来源：{source}"
outro_text = data['outro_text'].strip()
article_contents = split_text(article)
put_text("正在进行语音合成...")
process_id = 'generate_audio'
put_processbar(process_id) # 初始化进度条
# article_audio = generate_article_audio(article_contents, process_id)
while True:
try:
combined_text, article_audio = process_contents_parallel(article_contents, body_voice, process_id, formatting)
except:
import traceback
traceback.print_exc()
# 询问用户是否想要重试
retry = actions(label="发生错误，是否重试？", buttons=[{'label': '重试', 'value': 'retry'}, {'label': '取消', 'value': 'cancel'}])
if retry == 'cancel':
return
else:
break
put_text("正在生成音频文件...")
intro_audio = generate_audio(intro_text, head_voice)
combined_audio = intro_audio + article_audio
if outro_text:
combined_audio += generate_audio(outro_text, foot_voice)
temp_combined_audio_path = tempfile.mktemp(suffix=".mp3")
combined_audio.export(temp_combined_audio_path, format='mp3')
with open(temp_combined_audio_path, "rb") as f:
content = f.read()
put_success("音频文件已生成")
put_file(f'{title}_{author}.mp3', content) # 提供下载链接
if formatting:
put_collapse('整理好的论文', combined_text)
def format(raw_text):
response = openai.ChatCompletion.create(
model="gpt-3.5-turbo-16k",
messages=[
{
"role": "system",
"content": "我给你一段文字，你帮我去掉文中的脚注编号，其他的保留原文不变，不改变原文的文字"
},
{
"role": "user",
"content": "权力总是存在\n于权力主体和权力客体的相互作用之中。“理解 ‘权力’概念的最好的方法是将其视为冲突的意志\n之间的关系”。⑤\n"
},
{
"role": "assistant",
"content": "权力总是存在于权力主体和权力客体的相互作用之中。“理解 ‘权力’概念的最好的方法是将其视为冲突的意志之间的关系”。"
},
{
"role": "user",
"content": raw_text,
}
],
temperature=0,
top_p=1,
frequency_penalty=0,
presence_penalty=0
)
return response['choices'][0]['message']['content']
pool_size = 10 # 线程池的大小，你可以根据你的机器情况调整这个值
pool = ThreadPoolExecutor(pool_size) # 创建线程池
def process_content(raw_text, voice_name, formatting=True):
formatted_text = format(raw_text) if formatting else raw_text
audio_segment = generate_audio(formatted_text, voice_name)
return formatted_text, audio_segment
def process_contents_parallel(contents, voice_name, process_id, formatting=True):
futures = [pool.submit(process_content, content, voice_name, formatting) for content in contents]
audio_results = [None] * len(contents) # 创建一个空列表来存储音频结果
text_results = [''] * len(contents) # 创建一个空列表来存储文本结果
for future in as_completed(futures): # 在每个 future 完成时更新进度条
done_count = len([f for f in futures if f.done()])
set_processbar(process_id, done_count / len(futures))
for i, future in enumerate(futures): # 按提交顺序获取任务的结果并存储
text_results[i], audio_results[i] = future.result()
combined_audio = AudioSegment.empty()
for result in audio_results: # 按原始文本的顺序合并音频
combined_audio += result
combined_text = "\n".join(text_results) # 按原始文本的顺序合并文本
return combined_text, combined_audio
if __name__ == "__main__":
start_server(main)
| [
"我给你一段文字，你帮我去掉文中的脚注编号，其他的保留原文不变，不改变原文的文字",
"权力总是存在\n于权力主体和权力客体的相互作用之中。“理解 ‘权力’概念的最好的方法是将其视为冲突的意志\n之间的关系”。⑤\n",
"权力总是存在于权力主体和权力客体的相互作用之中。“理解 ‘权力’概念的最好的方法是将其视为冲突的意志之间的关系”。"
] |
2024-01-10 | weixi-feng/LayoutGPT | run_layoutgpt_3d.py | import os
import os.path as op
import json
import pdb
import clip
import torch
import numpy as np
from tqdm import tqdm
import time
import random
from PIL import Image
import argparse
import openai
from utils import *
from transformers import GPT2TokenizerFast
from parse_llm_output import parse_3D_layout
openai.organization = ""
openai.api_key = ""
tokenizer = GPT2TokenizerFast.from_pretrained("gpt2")
parser = argparse.ArgumentParser(prog='LayoutGPT for scene synthesis', description='Use GPTs to predict 3D layout for indoor scenes.')
parser.add_argument('--room', type=str, default='bedroom', choices=['bedroom','livingroom'])
parser.add_argument('--dataset_dir', type=str)
parser.add_argument('--gpt_type', type=str, default='gpt4', choices=['gpt3.5', 'gpt3.5-chat', 'gpt4'])
parser.add_argument('--icl_type', type=str, default='k-similar', choices=['fixed-random', 'k-similar'])
parser.add_argument('--base_output_dir', type=str, default='./llm_output/3D/')
parser.add_argument('--K', type=int, default=8)
parser.add_argument('--gpt_input_length_limit', type=int, default=7000)
parser.add_argument('--unit', type=str, choices=['px', 'm', ''], default='px')
parser.add_argument("--n_iter", type=int, default=1)
parser.add_argument("--test", action='store_true')
parser.add_argument('--verbose', default=False, action='store_true')
parser.add_argument("--suffix", type=str, default="")
parser.add_argument("--normalize", action='store_true')
parser.add_argument("--regular_floor_plan", action='store_true')
parser.add_argument("--temperature", type=float, default=0.7)
args = parser.parse_args()
# GPT Type
gpt_name = {
'gpt3.5': 'text-davinci-003',
'gpt3.5-chat': 'gpt-3.5-turbo',
'gpt4': 'gpt-4',
}
def load_room_boxes(prefix, id, stats, unit):
data = np.load(op.join(prefix, id, 'boxes.npz'))
x_c, y_c = data['floor_plan_centroid'][0], data['floor_plan_centroid'][2]
x_offset = min(data['floor_plan_vertices'][:,0])
y_offset = min(data['floor_plan_vertices'][:,2])
room_length = max(data['floor_plan_vertices'][:,0]) - min(data['floor_plan_vertices'][:,0])
room_width = max(data['floor_plan_vertices'][:,2]) - min(data['floor_plan_vertices'][:,2])
vertices = np.stack((data['floor_plan_vertices'][:,0]-x_offset, data['floor_plan_vertices'][:,2]-y_offset), axis=1)
vertices = np.asarray([list(nxy) for nxy in set(tuple(xy) for xy in vertices)])
# normalize
if args.normalize:
norm = min(room_length, room_width)
room_length, room_width = room_length/norm, room_width/norm
vertices /= norm
if unit in ['px', '']:
scale_factor = 256
room_length, room_width = int(room_length*scale_factor), int(room_width*scale_factor)
vertices = [f'({v[0]:.2f}, {v[1]:.2f})' for v in vertices]
if unit in ['px', '']:
condition = f"Condition:\n"
if args.room == 'livingroom':
if 'dining' in id.lower():
condition += f"Room Type: living room & dining room\n"
else:
condition += f"Room Type: living room\n"
else:
condition += f"Room Type: {args.room}\n"
condition += f"Room Size: max length {room_length}{unit}, max width {room_width}{unit}\n"
else:
condition = f"Condition:\n" \
f"Room Type: {args.room}\n" \
f"Room Size: max length {room_length:.2f}{unit}, max width {room_width:.2f}{unit}\n"
layout = 'Layout:\n'
for label, size, angle, loc in zip(data['class_labels'], data['sizes'], data['angles'], data['translations']):
label_idx = np.where(label)[0][0]
if label_idx >= len(stats['object_types']): # NOTE:
continue
cat = stats['object_types'][label_idx]
length, height, width = size # NOTE: half the actual size
length, height, width = length*2, height*2, width*2
orientation = round(angle[0] / 3.1415926 * 180)
dx,dz,dy = loc # NOTE: center point
dx = dx+x_c-x_offset
dy = dy+y_c-y_offset
# normalize
if args.normalize:
length, width, height = length/norm, width/norm, height/norm
dx, dy, dz = dx/norm, dy/norm, dz/norm
if unit in ['px', '']:
length, width, height = int(length*scale_factor), int(width*scale_factor), int(height*scale_factor)
dx, dy, dz = int(dx*scale_factor), int(dy*scale_factor), int(dz*scale_factor)
if unit in ['px', '']:
layout += f"{cat} {{length: {length}{unit}; " \
f"width: {width}{unit}; " \
f"height: {height}{unit}; " \
f"left: {dx}{unit}; " \
f"top: {dy}{unit}; " \
f"depth: {dz}{unit};" \
f"orientation: {orientation} degrees;}}\n"
else:
layout += f"{cat} {{length: {length:.2f}{unit}; " \
f"height: {height:.2f}{unit}; " \
f"width: {width:.2f}{unit}; " \
f"orientation: {orientation} degrees; " \
f"left: {dx:.2f}{unit}; " \
f"top: {dy:.2f}{unit}; " \
f"depth: {dz:.2f}{unit};}}\n"
return condition, layout, dict(data)
def load_set(prefix, ids, stats, unit):
id2prompt = {}
meta_data = {}
for id in tqdm(ids):
condition, layout, data = load_room_boxes(prefix, id, stats, unit)
id2prompt[id] = [condition, layout]
meta_data[id] = data
return id2prompt, meta_data
def load_features(meta_data, floor_plan=True):
features = {}
for id, data in meta_data.items():
if floor_plan:
features[id] = np.asarray(Image.fromarray(data['room_layout'].squeeze()).resize((64,64)))
else:
room_length = max(data['floor_plan_vertices'][:,0]) - min(data['floor_plan_vertices'][:,0])
room_width = max(data['floor_plan_vertices'][:,2]) - min(data['floor_plan_vertices'][:,2])
features[id] = np.asarray([room_length, room_width])
return features
def get_closest_room(train_features, val_feature):
'''
train_features
'''
distances = [[id, ((feat-val_feature)**2).mean()] for id, feat in train_features.items()]
distances = sorted(distances, key=lambda x: x[1])
sorted_ids, _ = zip(*distances)
return sorted_ids
def create_prompt(sample):
return sample[0] + sample[1] + "\n\n"
def form_prompt_for_gpt3(text_input, top_k, stats, supporting_examples,
train_features=None, val_feature=None):
unit_name = 'pixel' if args.unit in ['px', ''] else 'meters'
class_freq = [f"{obj}: {round(stats['class_frequencies'][obj], 4)}" for obj in stats['object_types']]
rtn_prompt = 'Instruction: synthesize the 3D layout of an indoor scene. ' \
'The generated 3D layout should follow the CSS style, where each line starts with the furniture category ' \
'and is followed by the 3D size, orientation and absolute position. ' \
"Formally, each line should follow the template: \n" \
f"FURNITURE {{length: ?{args.unit}: width: ?{args.unit}; height: ?{args.unit}; left: ?{args.unit}; top: ?{args.unit}; depth: ?{args.unit}; orientation: ? degrees;}}\n" \
f'All values are in {unit_name} but the orientation angle is in degrees.\n\n' \
f"Available furnitures: {', '.join(stats['object_types'])} \n" \
f"Overall furniture frequencies: ({'; '.join(class_freq)})\n\n"
last_example = f'{text_input[0]}Layout:\n'
prompting_examples = ''
total_length = len(tokenizer(rtn_prompt + last_example)['input_ids'])
if args.icl_type == 'k-similar':
assert train_features is not None
sorted_ids = get_closest_room(train_features, val_feature)
supporting_examples = [supporting_examples[id] for id in sorted_ids[:top_k]]
if args.test:
print("retrieved examples:")
print("\n".join(sorted_ids[:top_k]))
pdb.set_trace()
# loop through the related supporting examples, check if the prompt length exceed limit
for i, supporting_example in enumerate(supporting_examples[:top_k]):
current_prompting_example = create_prompt(supporting_example)
cur_len = len(tokenizer(current_prompting_example)['input_ids'])
if total_length + cur_len > args.gpt_input_length_limit: # won't take the input that is too long
print(f"{i+1}th exemplar exceed max length")
break
prompting_examples = current_prompting_example + prompting_examples
total_length += cur_len
prompting_examples += last_example
rtn_prompt += prompting_examples
return rtn_prompt
def form_prompt_for_chatgpt(text_input, top_k, stats, supporting_examples,
train_features=None, val_feature=None):
message_list = []
unit_name = 'pixel' if args.unit in ['px', ''] else 'meters'
class_freq = [f"{obj}: {round(stats['class_frequencies'][obj], 4)}" for obj in stats['object_types']]
rtn_prompt = 'You are a 3D indoor scene designer. \nInstruction: synthesize the 3D layout of an indoor scene. ' \
'The generated 3D layout should follow the CSS style, where each line starts with the furniture category ' \
'and is followed by the 3D size, orientation and absolute position. ' \
"Formally, each line should follow the template: \n" \
f"FURNITURE {{length: ?{args.unit}: width: ?{args.unit}; height: ?{args.unit}; orientation: ? degrees; left: ?{args.unit}; top: ?{args.unit}; depth: ?{args.unit};}}\n" \
f'All values are in {unit_name} but the orientation angle is in degrees.\n\n' \
f"Available furnitures: {', '.join(stats['object_types'])} \n" \
f"Overall furniture frequencies: ({'; '.join(class_freq)})\n\n"
message_list.append({'role': 'system', 'content': rtn_prompt})
last_example = f'{text_input[0]}Layout:\n'
total_length = len(tokenizer(rtn_prompt + last_example)['input_ids'])
if args.icl_type == 'k-similar':
assert train_features is not None
sorted_ids = get_closest_room(train_features, val_feature)
supporting_examples = [supporting_examples[id] for id in sorted_ids[:top_k]]
if args.test:
print("retrieved examples:")
print("\n".join(sorted_ids[:top_k]))
# loop through the related supporting examples, check if the prompt length exceed limit
for i, supporting_example in enumerate(supporting_examples[:top_k]):
cur_len = len(tokenizer(supporting_example[0]+supporting_example[1])['input_ids'])
if total_length + cur_len > args.gpt_input_length_limit: # won't take the input that is too long
print(f"{i+1}th exemplar exceed max length")
break
total_length += cur_len
current_messages = [
{'role': 'user', 'content': supporting_example[0]+"Layout:\n"},
{'role': 'assistant', 'content': supporting_example[1].lstrip("Layout:\n")},
]
message_list = message_list + current_messages
# concatename prompts for gpt4
message_list.append({'role': 'user', 'content': last_example})
return message_list
def _main(args):
dataset_prefix = f"{args.dataset_dir}"
with open(f"dataset/3D/{args.room}_splits.json", "r") as file:
splits = json.load(file)
with open(f"{args.dataset_dir}/dataset_stats.txt", "r") as file:
stats = json.load(file)
if args.regular_floor_plan:
args.suffix += '_regular'
# check if have been processed
args.output_dir = args.base_output_dir
os.makedirs(args.output_dir, exist_ok=True)
output_filename = os.path.join(args.output_dir, f'{args.gpt_type}.{args.room}.{args.icl_type}.k_{args.K}.{args.unit}{args.suffix}.json')
os.makedirs(os.path.join(args.output_dir, 'raw'), exist_ok=True)
raw_output_filename = os.path.join(args.output_dir, 'raw', f'raw_{args.gpt_type}.{args.room}.{args.icl_type}.k_{args.K}.{args.unit}{args.suffix}.json')
# load train examples
train_ids = splits['rect_train'] if args.regular_floor_plan else splits['train']
train_data, meta_train_data = load_set(dataset_prefix, train_ids, stats, args.unit)
# load val examples
val_ids = splits['rect_test'] if args.regular_floor_plan else splits['test']
val_data, meta_val_data = load_set(dataset_prefix, val_ids, stats, args.unit)
val_features = load_features(meta_val_data)
print(f"Loaded {len(train_data)} train samples and {len(val_data)} validation samples")
if args.test:
val_data = {k:v for k, v in list(val_data.items())[:5]}
args.verbose = True
args.n_iter = 1
if args.icl_type == 'fixed-random':
# load fixed supporting examples
all_supporting_examples = list(train_data.values())
supporting_examples = all_supporting_examples[:args.K]
train_features = None
elif args.icl_type == 'k-similar':
supporting_examples = train_data
train_features = load_features(meta_train_data)
# GPT-3 prediction process
args.gpt_name = gpt_name[args.gpt_type]
all_prediction_list = []
all_responses = []
top_k = args.K
n_lines = []
n_furnitures = []
for val_id, val_example in tqdm(val_data.items(), total=len(val_data), desc='gpt3'):
# predict
while True:
if args.gpt_type == 'gpt3.5':
prompt_for_gpt3 = form_prompt_for_gpt3(
text_input=val_example,
top_k=top_k,
stats=stats,
supporting_examples=supporting_examples,
train_features=train_features,
val_feature=val_features[val_id]
)
elif args.gpt_type in ['gpt3.5-chat', 'gpt4']:
prompt_for_gpt3 = form_prompt_for_chatgpt(
text_input=val_example,
top_k=top_k,
stats=stats,
supporting_examples=supporting_examples,
train_features=train_features,
val_feature=val_features[val_id]
)
else:
raise NotImplementedError
if args.verbose:
print(val_id)
print(prompt_for_gpt3)
print('\n' + '-'*30)
pdb.set_trace()
if op.exists(op.join(args.output_dir, 'tmp', args.gpt_type, f"{val_id}.json")):
response = json.load(open(op.join(args.output_dir, 'tmp', args.gpt_type, f"{val_id}.json")))
break
try:
if args.gpt_type == 'gpt3.5':
response = openai.Completion.create( # use openai.ChatCompletion for GPT-4
model=args.gpt_name,
prompt=prompt_for_gpt3,
temperature=args.temperature,
max_tokens=1024 if args.room=='livingroom' else 512,
top_p=1.0,
frequency_penalty=0.0,
presence_penalty=0.0,
stop="Condition:",
n=args.n_iter,
)
elif args.gpt_type in ['gpt3.5', 'gpt4']:
response = openai.ChatCompletion.create(
model=args.gpt_name,
messages=prompt_for_gpt3,
temperature=0.7,
max_tokens=1024 if args.room=='livingroom' else 512,
top_p=1.0,
frequency_penalty=0.0,
presence_penalty=0.0,
stop="Condition:",
n=args.n_iter,
)
else:
raise NotImplementedError
break
except openai.error.ServiceUnavailableError:
print('OpenAI ServiceUnavailableError.\tWill try again in 5 seconds.')
time.sleep(5)
except openai.error.RateLimitError:
print('OpenAI RateLimitError.\tWill try again in 5 seconds.')
time.sleep(5)
except openai.error.InvalidRequestError as e:
print(e)
print('Input too long. Will shrink the prompting examples.')
top_k -= 1
except openai.error.APIError as e:
print('OpenAI Bad Gateway Error.\tWill try again in 5 seconds.')
time.sleep(5)
os.makedirs(op.join(args.output_dir, 'tmp', args.gpt_type), exist_ok=True)
write_json(op.join(args.output_dir, 'tmp', args.gpt_type, f"{val_id}.json"), response)
response['prompt'] = prompt_for_gpt3
all_responses.append(response)
for i_iter in range(args.n_iter):
# parse output
if args.verbose:
try:
print(response['choices'][i_iter]['text'])
except:
print(response['choices'][i_iter]['message']['content'])
predicted_object_list = []
if args.gpt_type == 'gpt3.5':
line_list = response['choices'][i_iter]['text'].split('\n')
else:
line_list = response['choices'][i_iter]['message']['content'].split('\n')
n_lines.append(len(line_list))
for line in line_list:
if line == '':
continue
try:
selector_text, bbox = parse_3D_layout(line, args.unit)
if selector_text == None:
print(line)
continue
predicted_object_list.append([selector_text, bbox])
except ValueError as e:
pass
n_furnitures.append(len(predicted_object_list))
all_prediction_list.append({
'query_id': val_id,
'iter': i_iter,
'prompt': val_example[0],
'object_list': predicted_object_list,
})
if args.gpt_type in ['gpt4']:
time.sleep(3)
# # save output
with open(raw_output_filename, 'w') as fout:
json.dump(all_responses, fout, indent=4, sort_keys=True)
with open(output_filename, 'w') as fout:
json.dump(all_prediction_list, fout, indent=4, sort_keys=True)
print(f'GPT-3 ({args.gpt_type}) prediction results written to {output_filename}')
print(f"{np.mean(n_lines)}, {np.mean(n_furnitures)}")
if __name__ == '__main__':
_main(args)
| [
"; ",
"{}",
"and is followed by the 3D size, orientation and absolute position. ",
"You are a 3D indoor scene designer. \nInstruction: synthesize the 3D layout of an indoor scene. ",
"PLACEHOLDERPLACEHOLDER",
"All values are in PLACEHOLDER but the orientation angle is in degrees.\n\n",
"Instruction: synthesize the 3D layout of an indoor scene. ",
"Formally, each line should follow the template: \n",
"Layout:\n",
"Available furnitures: P, L, A, C, E, H, O, L, D, E, R \n",
"PLACEHOLDERLayout:\n",
"object_types",
", ",
"The generated 3D layout should follow the CSS style, where each line starts with the furniture category "
] |
2024-01-10 | weixi-feng/LayoutGPT | run_layoutgpt_2d.py | import os
import os.path as op
import json
import pdb
import clip
import torch
import numpy as np
from tqdm import tqdm
import time
import random
import argparse
import openai
from transformers import GPT2TokenizerFast, LlamaForCausalLM, LlamaTokenizer
import transformers
from utils import *
openai.organization = ""
openai.api_key = ""
# GPT-3 Type
llm_name2id = {
'llama-7b': 'meta-llama/Llama-2-7b-hf',
'llama-13b': 'meta-llama/Llama-2-13b-hf',
'llama-70b': 'meta-llama/Llama-2-70b-hf',
'gpt3.5': 'text-davinci-003',
'gpt3.5-chat': 'gpt-3.5-turbo',
'gpt4': 'gpt-4',
}
parser = argparse.ArgumentParser(prog='LayoutGPT: text-based image layout planning', description='Use LayoutGPT to generate image layouts.')
parser.add_argument('--input_info_dir', type=str, default='./dataset/NSR-1K')
parser.add_argument('--base_output_dir', type=str, default='./llm_output')
parser.add_argument('--setting', type=str, default='counting', choices=['counting', 'spatial'])
parser.add_argument('--matching_content_type', type=str, default='visual')
parser.add_argument('--llm_type', type=str, default='gpt4', choices=list(llm_name2id.keys()))
parser.add_argument('--icl_type', type=str, default='k-similar', choices=['fixed-random', 'k-similar'])
parser.add_argument('--K', type=int, default=8)
parser.add_argument('--gpt_input_length_limit', type=int, default=3000)
parser.add_argument('--canvas_size', type=int, default=256)
parser.add_argument("--n_iter", type=int, default=1)
parser.add_argument("--test", action='store_true')
parser.add_argument('--verbose', default=False, action='store_true')
args = parser.parse_args()
if args.icl_type == 'k-similar':
# Load CLIP model
clip_feature_name = 'ViT-L/14'.lower().replace('/', '-')
device = "cuda" if torch.cuda.is_available() else "cpu"
clip_model, preprocess = clip.load('ViT-L/14', device=device)
clip_model = clip_model.to(device)
def load_features(content):
"""Load visual/text features from npz file"""
np_filename = os.path.join(
args.input_info_dir, args.setting,
f'train.{args.setting}.{clip_feature_name}.{content}.npz',
)
feature_list = np.load(np_filename)['feature_list']
features = torch.HalfTensor(feature_list).to(device)
features /= features.norm(dim=-1, keepdim=True)
return features
def create_exemplar_prompt(caption, object_list, canvas_size, is_chat=False):
if is_chat:
prompt = ''
else:
prompt = f'\nPrompt: {caption}\nLayout:\n'
for obj_info in object_list:
category, bbox = obj_info
coord_list = [int(i*canvas_size) for i in bbox]
x, y, w, h = coord_list
prompt += f'{category} {{height: {h}px; width: {w}px; top: {y}px; left: {x}px; }}\n'
return prompt
def form_prompt_for_chatgpt(text_input, top_k, tokenizer, supporting_examples=None, features=None):
message_list = []
system_prompt = 'Instruction: Given a sentence prompt that will be used to generate an image, plan the layout of the image.' \
'The generated layout should follow the CSS style, where each line starts with the object description ' \
'and is followed by its absolute position. ' \
'Formally, each line should be like "object {{width: ?px; height: ?px; left: ?px; top: ?px; }}". ' \
'The image is {}px wide and {}px high. ' \
'Therefore, all properties of the positions should not exceed {}px, ' \
'including the addition of left and width and the addition of top and height. \n'.format(args.canvas_size, args.canvas_size, args.canvas_size)
message_list.append({'role': 'system', 'content': system_prompt})
final_prompt = f'Prompt: {text_input}\nLayout:'
total_length = len(tokenizer(system_prompt + final_prompt)['input_ids'])
if args.icl_type == 'k-similar':
# find most related supporting examples
text_inputs = clip.tokenize(text_input, truncate=True).to(device)
text_features = clip_model.encode_text(text_inputs)
text_features /= text_features.norm(dim=-1, keepdim=True)
similarity = (100.0 * text_features @ features.T).softmax(dim=-1)
_, indices = similarity[0].topk(top_k)
supporting_examples = [supporting_examples[idx] for idx in indices]
# loop through the related supporting examples, check if the prompt length exceed limit
for supporting_example in supporting_examples:
user_prompt = f'Prompt: {supporting_example["prompt"]}\nLayout:'
if args.setting == 'counting':
answer = create_exemplar_prompt(
caption=supporting_example['prompt'],
object_list=supporting_example['object_list'],
canvas_size=args.canvas_size,
is_chat=True
)
else:
answer = create_exemplar_prompt(
caption=supporting_example['prompt'],
object_list=[supporting_example['obj1'], supporting_example['obj2']],
canvas_size=args.canvas_size,
is_chat=True
)
cur_len = len(tokenizer(user_prompt+answer)['input_ids'])
if total_length + cur_len > args.gpt_input_length_limit: # won't take the input that is too long
break
total_length += cur_len
cur_messages = [
{'role': 'user', 'content': user_prompt},
{'role': 'assistant', 'content': answer},
]
message_list = message_list[:1] + cur_messages + message_list[1:]
# add final question
message_list.append({'role': 'user', 'content': final_prompt})
return message_list
def form_prompt_for_gpt3(text_input, top_k, tokenizer, supporting_examples=None, features=None):
rtn_prompt = 'Instruction: Given a sentence prompt that will be used to generate an image, plan the layout of the image.' \
'The generated layout should follow the CSS style, where each line starts with the object description ' \
'and is followed by its absolute position. ' \
'Formally, each line should be like "object {{width: ?px; height: ?px; left: ?px; top: ?px; }}". ' \
'The image is {}px wide and {}px high. ' \
'Therefore, all properties of the positions should not exceed {}px, ' \
'including the addition of left and width and the addition of top and height. \n'.format(args.canvas_size, args.canvas_size, args.canvas_size)
last_example = f'\nPrompt: {text_input}\nLayout:'
prompting_examples = ''
total_length = len(tokenizer(rtn_prompt + last_example)['input_ids'])
if args.icl_type == 'k-similar':
# find most related supporting examples
text_inputs = clip.tokenize(text_input, truncate=True).to(device)
text_features = clip_model.encode_text(text_inputs)
text_features /= text_features.norm(dim=-1, keepdim=True)
similarity = (100.0 * text_features @ features.T).softmax(dim=-1)
_, indices = similarity[0].topk(top_k)
supporting_examples = [supporting_examples[idx] for idx in indices]
# loop through the related supporting examples, check if the prompt length exceed limit
for supporting_example in supporting_examples:
if args.setting == 'counting':
current_prompting_example = create_exemplar_prompt(
caption=supporting_example['prompt'],
object_list=supporting_example['object_list'],
canvas_size=args.canvas_size,
)
else:
current_prompting_example = create_exemplar_prompt(
caption=supporting_example['prompt'],
object_list=[supporting_example['obj1'], supporting_example['obj2']],
canvas_size=args.canvas_size,
)
cur_len = len(tokenizer(current_prompting_example)['input_ids'])
if total_length + cur_len > args.gpt_input_length_limit: # won't take the input that is too long
break
prompting_examples = current_prompting_example + prompting_examples # most similar example appear first
total_length += cur_len
# concatename prompts
prompting_examples += last_example
rtn_prompt += prompting_examples
return rtn_prompt
class StoppingCriteriaICL(transformers.StoppingCriteria):
def __init__(self, stops=[],) -> None:
super().__init__()
self.stops = [s.to('cuda') for s in stops]
def __call__(self, input_ids, scores, **kwargs):
for stop in self.stops:
if torch.all(stop == input_ids[0][-len(stop):]):
return True
return False
def llama_generation(prompt_for_llama, model, args, eos_token_id=2, stop_criteria=None):
# can't make stopping criteria apply to each sample
# can't do sampling using logits processor
responses = []
for _ in range(args.n_iter):
responses += model(
prompt_for_llama,
do_sample=True,
num_return_sequences=1,
eos_token_id=eos_token_id,
temperature=0.7,
)
response_text = [r['generated_text'] for r in responses]
return response_text, responses
def gpt_generation(prompt_for_gpt, f_gpt_create, args, **kwargs):
input_kwargs = {
"model": args.llm_id,
"temperature": 0.7,
"max_tokens": 256,
"top_p": 1.0,
"frequency_penalty": 0.0,
"presence_penalty": 0.0,
"stop": "Prompt:",
"n": args.n_iter,
}
if args.llm_type == 'gpt3.5':
input_kwargs["prompt"] = prompt_for_gpt
else:
input_kwargs["messages"] = prompt_for_gpt
response = f_gpt_create(**input_kwargs)
if args.llm_type == 'gpt3.5':
response_text = [r["text"] for r in response.choices]
else:
response_text = [r["message"]["content"] for r in response.choices]
return response_text, response
def _main(args):
# check if have been processed
args.output_dir = os.path.join(args.base_output_dir, args.setting)
os.makedirs(args.output_dir, exist_ok=True)
output_filename = os.path.join(args.output_dir, f'{args.llm_type}.{args.setting}.{args.icl_type}.k_{args.K}.px_{args.canvas_size}.json')
if os.path.exists(output_filename):
print(f'{output_filename} have been processed.')
return
# load val examples
val_example_files = os.path.join(
args.input_info_dir, args.setting,
f'{args.setting}.val.json',
)
val_example_list = json.load(open(val_example_files))
if args.test:
val_example_list = val_example_list[:3]
# load all training examples
train_example_files = os.path.join(
args.input_info_dir, args.setting,
f'{args.setting}.train.json',
)
train_examples = json.load(open(train_example_files))
if args.icl_type == 'fixed-random':
random.seed(42)
random.shuffle(train_examples)
supporting_examples = train_examples[:args.K]
features = None
elif args.icl_type == 'k-similar':
supporting_examples = train_examples
features = load_features(args.matching_content_type)
# GPT/LLAMA prediction process
args.llm_id = llm_name2id[args.llm_type]
all_prediction_list = []
all_responses = []
if 'llama' in args.llm_type:
f_form_prompt = form_prompt_for_gpt3
tokenizer = LlamaTokenizer.from_pretrained(args.llm_id)
stop_ids = [tokenizer(w, return_tensors="pt", add_special_tokens=False).input_ids.squeeze()[1:] for w in ["\n\n"]] # tokenization issue
stop_criteria = transformers.StoppingCriteriaList([StoppingCriteriaICL(stop_ids)])
model = transformers.pipeline(
"text-generation",
model=args.llm_id,
torch_dtype=torch.float16,
device_map="auto",
max_new_tokens=512,
return_full_text=False,
stopping_criteria=stop_criteria
)
f_llm_generation = llama_generation
elif 'gpt' in args.llm_type:
tokenizer = GPT2TokenizerFast.from_pretrained("gpt2")
if args.llm_type == 'gpt3.5':
f_form_prompt = form_prompt_for_gpt3
model = openai.Completion.create
else:
f_form_prompt = form_prompt_for_chatgpt
model = openai.ChatCompletion.create
f_llm_generation = gpt_generation
else:
raise NotImplementedError
for val_example in tqdm(val_example_list, total=len(val_example_list), desc='test'):
top_k = args.K
prompt_for_gpt = f_form_prompt(
text_input=val_example['prompt'],
top_k=top_k,
tokenizer=tokenizer,
supporting_examples=supporting_examples,
features=features
)
if args.verbose:
print(prompt_for_gpt)
print('\n' + '-'*30)
while True:
try:
response, raw_response = f_llm_generation(prompt_for_gpt, model, args, eos_token_id=tokenizer.eos_token_id)
break
except openai.error.ServiceUnavailableError:
print('OpenAI ServiceUnavailableError.\tWill try again in 5 seconds.')
time.sleep(5)
except openai.error.RateLimitError:
print('OpenAI RateLimitError.\tWill try again in 5 seconds.')
time.sleep(5)
except openai.error.InvalidRequestError as e:
print(e)
print('Input too long. Will shrink the prompting examples.')
top_k -= 1
prompt_for_gpt = f_form_prompt(
text_input=val_example['prompt'],
top_k=top_k,
supporting_examples=supporting_examples,
features=features
)
except RuntimeError as e:
if "out of memeory" in str(e):
top_k -= 1
prompt_for_gpt = f_form_prompt(
text_input=val_example['prompt'],
top_k=top_k,
tokenizer=tokenizer,
supporting_examples=supporting_examples,
features=features
)
else:
raise e
all_responses.append(response)
for i_iter in range(args.n_iter):
# parse output
predicted_object_list = []
line_list = response[i_iter].split('\n')
for line in line_list:
if line == '':
continue
try:
selector_text, bbox = parse_layout(line, canvas_size=args.canvas_size)
if selector_text == None:
print(line)
continue
predicted_object_list.append([selector_text, bbox])
except ValueError as e:
pass
all_prediction_list.append({
'query_id': val_example['id'],
'iter': i_iter,
'prompt': val_example['prompt'],
'object_list': predicted_object_list,
})
# save output
with open(output_filename, 'w') as fout:
json.dump(all_prediction_list, fout, indent=4, sort_keys=True)
print(f'LayoutGPT ({args.llm_type}) prediction results written to {output_filename}')
if __name__ == '__main__':
_main(args)
| [
"Prompt: PLACEHOLDER\nLayout:",
"object_list",
"Instruction: Given a sentence prompt that will be used to generate an image, plan the layout of the image.",
"The image is {}px wide and {}px high. ",
"PLACEHOLDERPLACEHOLDER",
"Formally, each line should be like \"object {{width: ?px; height: ?px; left: ?px; top: ?px; }}\". ",
"The generated layout should follow the CSS style, where each line starts with the object description ",
"including the addition of left and width and the addition of top and height. \n",
"Therefore, all properties of the positions should not exceed {}px, ",
"PLACEHOLDER {height: PLACEHOLDERpx; width: PLACEHOLDERpx; top: PLACEHOLDERpx; left: PLACEHOLDERpx; }\n",
"and is followed by its absolute position. ",
"\nPrompt: PLACEHOLDER\nLayout:\n"
] |
2024-01-10 | lanceshih/ChatGPT | src~revChatGPT~V1.py | """
Standard ChatGPT
"""
from __future__ import annotations
import base64
import contextlib
import json
import logging
import os
import os.path as osp
import time
import uuid
from functools import wraps
from os import environ
from os import getenv
from typing import NoReturn
import requests
from httpx import AsyncClient
from OpenAIAuth import Authenticator
from OpenAIAuth import Error as AuthError
from . import typings as t
from .utils import create_completer
from .utils import create_session
from .utils import get_input
if __name__ == "__main__":
logging.basicConfig(
format="%(asctime)s - %(name)s - %(levelname)s - %(funcName)s - %(message)s",
)
log = logging.getLogger(__name__)
def logger(is_timed: bool):
"""Logger decorator
Args:
is_timed (bool): Whether to include function running time in exit log
Returns:
_type_: decorated function
"""
def decorator(func):
wraps(func)
def wrapper(*args, **kwargs):
log.debug(
"Entering %s with args %s and kwargs %s",
func.__name__,
args,
kwargs,
)
start = time.time()
out = func(*args, **kwargs)
end = time.time()
if is_timed:
log.debug(
"Exiting %s with return value %s. Took %s seconds.",
func.__name__,
out,
end - start,
)
else:
log.debug("Exiting %s with return value %s", func.__name__, out)
return out
return wrapper
return decorator
BASE_URL = environ.get("CHATGPT_BASE_URL") or "https://bypass.churchless.tech/api/"
bcolors = t.colors()
class Chatbot:
"""
Chatbot class for ChatGPT
"""
@logger(is_timed=True)
def __init__(
self,
config: dict[str, str],
conversation_id: str | None = None,
parent_id: str | None = None,
session_client=None,
lazy_loading: bool = False,
) -> None:
"""Initialize a chatbot
Args:
config (dict[str, str]): Login and proxy info. Example:
{
"email": "OpenAI account email",
"password": "OpenAI account password",
"session_token": "<session_token>"
"access_token": "<access_token>"
"proxy": "<proxy_url_string>",
"paid": True/False, # whether this is a plus account
}
More details on these are available at https://github.com/acheong08/ChatGPT#configuration
conversation_id (str | None, optional): Id of the conversation to continue on. Defaults to None.
parent_id (str | None, optional): Id of the previous response message to continue on. Defaults to None.
session_client (_type_, optional): _description_. Defaults to None.
Raises:
Exception: _description_
"""
user_home = getenv("HOME")
if user_home is None:
self.cache_path = osp.join(os.getcwd(), ".chatgpt_cache.json")
else:
# mkdir ~/.config/revChatGPT
if not osp.exists(osp.join(user_home, ".config")):
os.mkdir(osp.join(user_home, ".config"))
if not osp.exists(osp.join(user_home, ".config", "revChatGPT")):
os.mkdir(osp.join(user_home, ".config", "revChatGPT"))
self.cache_path = osp.join(user_home, ".config", "revChatGPT", "cache.json")
self.config = config
self.session = session_client() if session_client else requests.Session()
try:
cached_access_token = self.__get_cached_access_token(
self.config.get("email", None),
)
except t.Error as error:
if error.code == 5:
raise error
cached_access_token = None
if cached_access_token is not None:
self.config["access_token"] = cached_access_token
if "proxy" in config:
if not isinstance(config["proxy"], str):
error = TypeError("Proxy must be a string!")
raise error
proxies = {
"http": config["proxy"],
"https": config["proxy"],
}
if isinstance(self.session, AsyncClient):
proxies = {
"http://": config["proxy"],
"https://": config["proxy"],
}
self.session = AsyncClient(proxies=proxies)
else:
self.session.proxies.update(proxies)
self.conversation_id = conversation_id
self.parent_id = parent_id
self.conversation_mapping = {}
self.conversation_id_prev_queue = []
self.parent_id_prev_queue = []
self.lazy_loading = lazy_loading
self.__check_credentials()
@logger(is_timed=True)
def __check_credentials(self) -> None:
"""Check login info and perform login
Any one of the following is sufficient for login. Multiple login info can be provided at the same time and they will be used in the order listed below.
- access_token
- session_token
- email + password
Raises:
Exception: _description_
AuthError: _description_
"""
if "access_token" in self.config:
self.set_access_token(self.config["access_token"])
elif "session_token" in self.config:
pass
elif "email" not in self.config or "password" not in self.config:
error = t.AuthenticationError("Insufficient login details provided!")
raise error
if "access_token" not in self.config:
try:
self.login()
except AuthError as error:
raise error
@logger(is_timed=False)
def set_access_token(self, access_token: str) -> None:
"""Set access token in request header and self.config, then cache it to file.
Args:
access_token (str): access_token
"""
self.session.headers.clear()
self.session.headers.update(
{
"Accept": "text/event-stream",
"Authorization": f"Bearer {access_token}",
"Content-Type": "application/json",
"X-Openai-Assistant-App-Id": "",
"Connection": "close",
"Accept-Language": "en-US,en;q=0.9",
"Referer": "https://chat.openai.com/chat",
},
)
self.session.cookies.update(
{
"library": "revChatGPT",
},
)
self.config["access_token"] = access_token
email = self.config.get("email", None)
if email is not None:
self.__cache_access_token(email, access_token)
@logger(is_timed=False)
def __get_cached_access_token(self, email: str | None) -> str | None:
"""Read access token from cache
Args:
email (str | None): email of the account to get access token
Raises:
Error: _description_
Error: _description_
Error: _description_
Returns:
str | None: access token string or None if not found
"""
email = email or "default"
cache = self.__read_cache()
access_token = cache.get("access_tokens", {}).get(email, None)
# Parse access_token as JWT
if access_token is not None:
try:
# Split access_token into 3 parts
s_access_token = access_token.split(".")
# Add padding to the middle part
s_access_token[1] += "=" * ((4 - len(s_access_token[1]) % 4) % 4)
d_access_token = base64.b64decode(s_access_token[1])
d_access_token = json.loads(d_access_token)
except base64.binascii.Error:
error = t.Error(
source="__get_cached_access_token",
message="Invalid access token",
code=t.ErrorType.INVALID_ACCESS_TOKEN_ERROR,
)
raise error from None
except json.JSONDecodeError:
error = t.Error(
source="__get_cached_access_token",
message="Invalid access token",
code=t.ErrorType.INVALID_ACCESS_TOKEN_ERROR,
)
raise error from None
exp = d_access_token.get("exp", None)
if exp is not None and exp < time.time():
error = t.Error(
source="__get_cached_access_token",
message="Access token expired",
code=t.ErrorType.EXPIRED_ACCESS_TOKEN_ERROR,
)
raise error
return access_token
@logger(is_timed=False)
def __cache_access_token(self, email: str, access_token: str) -> None:
"""Write an access token to cache
Args:
email (str): account email
access_token (str): account access token
"""
email = email or "default"
cache = self.__read_cache()
if "access_tokens" not in cache:
cache["access_tokens"] = {}
cache["access_tokens"][email] = access_token
self.__write_cache(cache)
@logger(is_timed=False)
def __write_cache(self, info: dict) -> None:
"""Write cache info to file
Args:
info (dict): cache info, current format
{
"access_tokens":{"[email protected]": 'this account's access token', }
}
"""
dirname = osp.dirname(self.cache_path) or "."
os.makedirs(dirname, exist_ok=True)
json.dump(info, open(self.cache_path, "w", encoding="utf-8"), indent=4)
@logger(is_timed=False)
def __read_cache(self):
try:
cached = json.load(open(self.cache_path, encoding="utf-8"))
except (FileNotFoundError, json.decoder.JSONDecodeError):
cached = {}
return cached
@logger(is_timed=True)
def login(self) -> None:
if (
"email" not in self.config or "password" not in self.config
) and "session_token" not in self.config:
log.error("Insufficient login details provided!")
error = t.AuthenticationError("Insufficient login details provided!")
raise error
auth = Authenticator(
email_address=self.config.get("email"),
password=self.config.get("password"),
proxy=self.config.get("proxy"),
)
if self.config.get("session_token"):
log.debug("Using session token")
auth.session_token = self.config["session_token"]
auth.get_access_token()
if auth.access_token is None:
del self.config["session_token"]
self.login()
return
else:
log.debug("Using authenticator to get access token")
auth.begin()
self.config["session_token"] = auth.session_token
auth.get_access_token()
self.set_access_token(auth.access_token)
@logger(is_timed=True)
def ask(
self,
prompt: str,
conversation_id: str | None = None,
parent_id: str | None = None,
timeout: float = 360,
) -> str:
"""Ask a question to the chatbot
Args:
prompt (str): The question
conversation_id (str | None, optional): UUID for the conversation to continue on. Defaults to None.
parent_id (str | None, optional): UUID for the message to continue on. Defaults to None.
timeout (float, optional): Timeout for getting the full response, unit is second. Defaults to 360.
Raises:
Error: _description_
Exception: _description_
Error: _description_
Error: _description_
Error: _description_
Yields:
_type_: _description_
"""
if parent_id is not None and conversation_id is None:
log.error("conversation_id must be set once parent_id is set")
error = t.Error(
source="User",
message="conversation_id must be set once parent_id is set",
code=t.ErrorType.USER_ERROR,
)
raise error
if conversation_id is not None and conversation_id != self.conversation_id:
log.debug("Updating to new conversation by setting parent_id to None")
self.parent_id = None
conversation_id = conversation_id or self.conversation_id
parent_id = parent_id or self.parent_id
if conversation_id is None and parent_id is None:
parent_id = str(uuid.uuid4())
log.debug("New conversation, setting parent_id to new UUID4: %s", parent_id)
if conversation_id is not None and parent_id is None:
if conversation_id not in self.conversation_mapping:
if self.lazy_loading:
log.debug(
"Conversation ID %s not found in conversation mapping, try to get conversation history for the given ID",
conversation_id,
)
with contextlib.suppress(Exception):
history = self.get_msg_history(conversation_id)
self.conversation_mapping[conversation_id] = history[
"current_node"
]
else:
log.debug(
"Conversation ID %s not found in conversation mapping, mapping conversations",
conversation_id,
)
self.__map_conversations()
if conversation_id in self.conversation_mapping:
log.debug(
"Conversation ID %s found in conversation mapping, setting parent_id to %s",
conversation_id,
self.conversation_mapping[conversation_id],
)
parent_id = self.conversation_mapping[conversation_id]
else: # invalid conversation_id provided, treat as a new conversation
conversation_id = None
parent_id = str(uuid.uuid4())
data = {
"action": "next",
"messages": [
{
"id": str(uuid.uuid4()),
"role": "user",
"author": {"role": "user"},
"content": {"content_type": "text", "parts": [prompt]},
},
],
"conversation_id": conversation_id,
"parent_message_id": parent_id,
"model": self.config.get("model")
or (
"text-davinci-002-render-paid"
if self.config.get("paid")
else "text-davinci-002-render-sha"
),
}
log.debug("Sending the payload")
log.debug(json.dumps(data, indent=2))
self.conversation_id_prev_queue.append(
data["conversation_id"],
)
self.parent_id_prev_queue.append(data["parent_message_id"])
response = self.session.post(
url=f"{BASE_URL}conversation",
data=json.dumps(data),
timeout=timeout,
stream=True,
)
self.__check_response(response)
done: bool = False
for line in response.iter_lines():
# remove b' and ' at the beginning and end and ignore case
line = str(line)[2:-1]
if line.lower() == "internal server error":
log.error("Internal Server Error: %s", line)
error = t.Error(
source="ask",
message="Internal Server Error",
code=t.ErrorType.SERVER_ERROR,
)
raise error
if not line or line is None:
continue
if "data: " in line:
line = line[6:]
if line == "[DONE]":
done = True
break
line = line.replace('\\"', '"')
line = line.replace("\\'", "'")
line = line.replace("\\\\", "\\")
try:
line = json.loads(line)
except json.decoder.JSONDecodeError:
continue
if not self.__check_fields(line) or response.status_code != 200:
log.error("Field missing", exc_info=True)
log.error(response.text)
if response.status_code == 401:
error = t.Error(
source="ask",
message="Permission denied",
code=t.ErrorType.AUTHENTICATION_ERROR,
)
raise error
elif response.status_code == 403:
error = t.Error(
source="ask",
message="Cloudflare triggered a 403 error",
code=t.ErrorType.CLOUDFLARE_ERROR,
)
raise error
elif response.status_code == 429:
error = t.Error(
source="ask",
message="Rate limit exceeded",
code=t.ErrorType.RATE_LIMIT_ERROR,
)
raise error
else:
error = t.Error(
source="ask",
message=line,
code=t.ErrorType.SERVER_ERROR,
)
raise error
message: str = line["message"]["content"]["parts"][0]
if message == prompt:
continue
conversation_id = line["conversation_id"]
parent_id = line["message"]["id"]
try:
model = line["message"]["metadata"]["model_slug"]
except KeyError:
model = None
log.debug("Received message: %s", message)
log.debug("Received conversation_id: %s", conversation_id)
log.debug("Received parent_id: %s", parent_id)
yield {
"message": message.strip("\n"),
"conversation_id": conversation_id,
"parent_id": parent_id,
"model": model,
}
if not done:
pass
self.conversation_mapping[conversation_id] = parent_id
if parent_id is not None:
self.parent_id = parent_id
if conversation_id is not None:
self.conversation_id = conversation_id
@logger(is_timed=False)
def __check_fields(self, data: dict) -> bool:
try:
data["message"]["content"]
except (TypeError, KeyError):
return False
return True
@logger(is_timed=False)
def __check_response(self, response: requests.Response) -> None:
"""Make sure response is success
Args:
response (_type_): _description_
Raises:
Error: _description_
"""
if response.status_code != 200:
print(response.text)
error = t.Error(
source="OpenAI",
message=response.text,
code=response.status_code,
)
raise error
@logger(is_timed=True)
def get_conversations(
self,
offset: int = 0,
limit: int = 20,
encoding: str | None = None,
) -> list:
"""
Get conversations
:param offset: Integer
:param limit: Integer
"""
url = f"{BASE_URL}conversations?offset={offset}&limit={limit}"
response = self.session.get(url)
self.__check_response(response)
if encoding is not None:
response.encoding = encoding
data = json.loads(response.text)
return data["items"]
@logger(is_timed=True)
def get_msg_history(self, convo_id: str, encoding: str | None = None) -> list:
"""
Get message history
:param id: UUID of conversation
:param encoding: String
"""
url = f"{BASE_URL}conversation/{convo_id}"
response = self.session.get(url)
self.__check_response(response)
if encoding is not None:
response.encoding = encoding
return json.loads(response.text)
@logger(is_timed=True)
def gen_title(self, convo_id: str, message_id: str) -> str:
"""
Generate title for conversation
"""
response = self.session.post(
f"{BASE_URL}conversation/gen_title/{convo_id}",
data=json.dumps(
{"message_id": message_id, "model": "text-davinci-002-render"},
),
)
self.__check_response(response)
return response.json().get("title", "Error generating title")
@logger(is_timed=True)
def change_title(self, convo_id: str, title: str) -> None:
"""
Change title of conversation
:param id: UUID of conversation
:param title: String
"""
url = f"{BASE_URL}conversation/{convo_id}"
response = self.session.patch(url, data=json.dumps({"title": title}))
self.__check_response(response)
@logger(is_timed=True)
def delete_conversation(self, convo_id: str) -> None:
"""
Delete conversation
:param id: UUID of conversation
"""
url = f"{BASE_URL}conversation/{convo_id}"
response = self.session.patch(url, data='{"is_visible": false}')
self.__check_response(response)
@logger(is_timed=True)
def clear_conversations(self) -> None:
"""
Delete all conversations
"""
url = f"{BASE_URL}conversations"
response = self.session.patch(url, data='{"is_visible": false}')
self.__check_response(response)
@logger(is_timed=False)
def __map_conversations(self) -> None:
conversations = self.get_conversations()
histories = [self.get_msg_history(x["id"]) for x in conversations]
for x, y in zip(conversations, histories):
self.conversation_mapping[x["id"]] = y["current_node"]
@logger(is_timed=False)
def reset_chat(self) -> None:
"""
Reset the conversation ID and parent ID.
:return: None
"""
self.conversation_id = None
self.parent_id = str(uuid.uuid4())
@logger(is_timed=False)
def rollback_conversation(self, num: int = 1) -> None:
"""
Rollback the conversation.
:param num: Integer. The number of messages to rollback
:return: None
"""
for _ in range(num):
self.conversation_id = self.conversation_id_prev_queue.pop()
self.parent_id = self.parent_id_prev_queue.pop()
class AsyncChatbot(Chatbot):
"""
Async Chatbot class for ChatGPT
"""
def __init__(
self,
config: dict,
conversation_id: str | None = None,
parent_id: str | None = None,
) -> None:
super().__init__(
config=config,
conversation_id=conversation_id,
parent_id=parent_id,
session_client=AsyncClient,
)
async def ask(
self,
prompt: str,
conversation_id: str | None = None,
parent_id: str | None = None,
timeout: int = 360,
) -> dict:
"""
Ask a question to the chatbot
"""
if parent_id is not None and conversation_id is None:
error = t.Error(
source="User",
message="conversation_id must be set once parent_id is set",
code=t.ErrorType.SERVER_ERROR,
)
raise error
if conversation_id is not None and conversation_id != self.conversation_id:
self.parent_id = None
conversation_id = conversation_id or self.conversation_id
parent_id = parent_id or self.parent_id
if conversation_id is None and parent_id is None:
parent_id = str(uuid.uuid4())
if conversation_id is not None and parent_id is None:
if conversation_id not in self.conversation_mapping:
await self.__map_conversations()
parent_id = self.conversation_mapping[conversation_id]
data = {
"action": "next",
"messages": [
{
"id": str(uuid.uuid4()),
"role": "user",
"content": {"content_type": "text", "parts": [prompt]},
},
],
"conversation_id": conversation_id,
"parent_message_id": parent_id,
"model": self.config.get("model")
or (
"text-davinci-002-render-paid"
if self.config.get("paid")
else "text-davinci-002-render-sha"
),
}
self.conversation_id_prev_queue.append(
data["conversation_id"],
)
self.parent_id_prev_queue.append(data["parent_message_id"])
async with self.session.stream(
method="POST",
url=f"{BASE_URL}conversation",
data=json.dumps(data),
timeout=timeout,
) as response:
self.__check_response(response)
async for line in response.aiter_lines():
if not line or line is None:
continue
if "data: " in line:
line = line[6:]
if "[DONE]" in line:
break
try:
line = json.loads(line)
except json.decoder.JSONDecodeError:
continue
if not self.__check_fields(line):
raise ValueError(f"Field missing. Details: {str(line)}")
message = line["message"]["content"]["parts"][0]
conversation_id = line["conversation_id"]
parent_id = line["message"]["id"]
model = (
line["message"]["metadata"]["model_slug"]
if "model_slug" in line["message"]["metadata"]
else None
)
yield {
"message": message,
"conversation_id": conversation_id,
"parent_id": parent_id,
"model": model,
}
self.conversation_mapping[conversation_id] = parent_id
if parent_id is not None:
self.parent_id = parent_id
if conversation_id is not None:
self.conversation_id = conversation_id
async def get_conversations(self, offset: int = 0, limit: int = 20) -> list:
"""
Get conversations
:param offset: Integer
:param limit: Integer
"""
url = f"{BASE_URL}conversations?offset={offset}&limit={limit}"
response = await self.session.get(url)
self.__check_response(response)
data = json.loads(response.text)
return data["items"]
async def get_msg_history(
self,
convo_id: str,
encoding: str | None = "utf-8",
) -> dict:
"""
Get message history
:param id: UUID of conversation
"""
url = f"{BASE_URL}conversation/{convo_id}"
response = await self.session.get(url)
if encoding is not None:
response.encoding = encoding
self.__check_response(response)
return json.loads(response.text)
return None
async def gen_title(self, convo_id: str, message_id: str) -> None:
"""
Generate title for conversation
"""
url = f"{BASE_URL}conversation/gen_title/{convo_id}"
response = await self.session.post(
url,
data=json.dumps(
{"message_id": message_id, "model": "text-davinci-002-render"},
),
)
await self.__check_response(response)
async def change_title(self, convo_id: str, title: str) -> None:
"""
Change title of conversation
:param convo_id: UUID of conversation
:param title: String
"""
url = f"{BASE_URL}conversation/{convo_id}"
response = await self.session.patch(url, data=f'{{"title": "{title}"}}')
self.__check_response(response)
async def delete_conversation(self, convo_id: str) -> None:
"""
Delete conversation
:param convo_id: UUID of conversation
"""
url = f"{BASE_URL}conversation/{convo_id}"
response = await self.session.patch(url, data='{"is_visible": false}')
self.__check_response(response)
async def clear_conversations(self) -> None:
"""
Delete all conversations
"""
url = f"{BASE_URL}conversations"
response = await self.session.patch(url, data='{"is_visible": false}')
self.__check_response(response)
async def __map_conversations(self) -> None:
conversations = await self.get_conversations()
histories = [await self.get_msg_history(x["id"]) for x in conversations]
for x, y in zip(conversations, histories):
self.conversation_mapping[x["id"]] = y["current_node"]
def __check_fields(self, data: dict) -> bool:
try:
data["message"]["content"]
except (TypeError, KeyError):
return False
return True
def __check_response(self, response) -> None:
response.raise_for_status()
get_input = logger(is_timed=False)(get_input)
@logger(is_timed=False)
def configure() -> dict:
"""
Looks for a config file in the following locations:
"""
config_files = ["config.json"]
if xdg_config_home := getenv("XDG_CONFIG_HOME"):
config_files.append(f"{xdg_config_home}/revChatGPT/config.json")
if user_home := getenv("HOME"):
config_files.append(f"{user_home}/.config/revChatGPT/config.json")
if config_file := next((f for f in config_files if osp.exists(f)), None):
with open(config_file, encoding="utf-8") as f:
config = json.load(f)
else:
print("No config file found.")
raise FileNotFoundError("No config file found.")
return config
@logger(is_timed=False)
def main(config: dict) -> NoReturn:
"""
Main function for the chatGPT program.
"""
chatbot = Chatbot(
config,
conversation_id=config.get("conversation_id"),
parent_id=config.get("parent_id"),
)
def handle_commands(command: str) -> bool:
if command == "!help":
print(
"""
!help - Show this message
!reset - Forget the current conversation
!config - Show the current configuration
!rollback x - Rollback the conversation (x being the number of messages to rollback)
!exit - Exit this program
!setconversation - Changes the conversation
""",
)
elif command == "!reset":
chatbot.reset_chat()
print("Chat session successfully reset.")
elif command == "!config":
print(json.dumps(chatbot.config, indent=4))
elif command.startswith("!rollback"):
try:
rollback = int(command.split(" ")[1])
except IndexError:
logging.exception(
"No number specified, rolling back 1 message",
stack_info=True,
)
rollback = 1
chatbot.rollback_conversation(rollback)
print(f"Rolled back {rollback} messages.")
elif command.startswith("!setconversation"):
try:
chatbot.conversation_id = chatbot.config[
"conversation_id"
] = command.split(" ")[1]
print("Conversation has been changed")
except IndexError:
log.exception(
"Please include conversation UUID in command",
stack_info=True,
)
print("Please include conversation UUID in command")
elif command == "!exit":
exit()
else:
return False
return True
session = create_session()
completer = create_completer(
["!help", "!reset", "!config", "!rollback", "!exit", "!setconversation"],
)
print()
try:
while True:
print(f"{bcolors.OKBLUE + bcolors.BOLD}You: {bcolors.ENDC}")
prompt = get_input(session=session, completer=completer)
if prompt.startswith("!") and handle_commands(prompt):
continue
print()
print(f"{bcolors.OKGREEN + bcolors.BOLD}Chatbot: {bcolors.ENDC}")
prev_text = ""
for data in chatbot.ask(prompt):
message = data["message"][len(prev_text) :]
print(message, end="", flush=True)
prev_text = data["message"]
print(bcolors.ENDC)
print()
except (KeyboardInterrupt, EOFError):
exit()
except Exception as e:
error = t.CLIError("command line program unknown error")
raise error from e
if __name__ == "__main__":
print(
"""
ChatGPT - A command-line interface to OpenAI's ChatGPT (https://chat.openai.com/chat)
Repo: github.com/acheong08/ChatGPT
""",
)
print("Type '!help' to show a full list of commands")
print(
f"{bcolors.BOLD}{bcolors.WARNING}Press Esc followed by Enter or Alt+Enter to send a message.{bcolors.ENDC}",
)
main(configure())
| [
"text",
"content_type"
] |
2024-01-10 | orsnaro/Discord-Bot-Ai | init_bot.py | """
Coder : Omar
Version : v2.5.5B
version Date : 8 / 11 / 2023
Code Type : python | Discrod | BARD | GPT | HTTP | ASYNC
Title : Initialization of Discord Bot
Interpreter : cPython v3.11.0 [Compiler : MSC v.1933 AMD64]
"""
import discord
from discord.ext import commands , tasks
import utils_bot as util
import asyncio as aio
import random
import random2
from bardapi import BardAsync , Bard , BardCookies , SESSION_HEADERS
from openai import AsyncOpenAI
import openai
from inspect import getmembers , isfunction
import aiohttp
import requests
from pyrandmeme2 import pyrandmeme2
from pyrandmeme2 import palestina_free
# from quote_async.quote import quote #TODO ( complete your quote lib fork and make it fully async )
from quote import quote
from random_word import RandomWords
from datetime import datetime
import re
import pytz
import asyncforismatic.asyncforismatic as foris
import logging
import contextlib
import os
import keys
import sys
# from bard_key_refresh import regenerate_cookie #TODO:
#------------------------------------------------------------------------------------------------------------------------------------------#
#USER MODULES
#------------------------------------------------------------------------------------------------------------------------------------------#
def init_gpt_session():
#by default checks keys in sys. env variables check func docstring
gpt = AsyncOpenAI(api_key= keys.openaiAPI_KEY, organization= keys.openaiAPI_ORG_ID)
return gpt
gpt = init_gpt_session()
#------------------------------------------------------------------------------------------------------------------------------------------#
def init_bard_session () :
# session = requests.Session()
# session.headers = {
# "Host": "bard.google.com",
# "X-Same-Domain": "1",
# "User-Agent": "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.114 Safari/537.36",
# "Content-Type": "application/x-www-form-urlencoded;charset=UTF-8",
# "Origin": "https://bard.google.com",
# "Referer": "https://bard.google.com/",
# }
# session.cookies.set("__Secure-1PSID", bardAPI_KEY)
# bard = Bard(token=bardAPI_KEY , session=session, timeout=30)
bard = BardAsync(token=keys.bardAPI_KEY) #add -> language= 'ar' to respond in arabic only (experimental)
# while True:
# try :
# bard = BardAsync(token= bardAPI_KEY ) #add -> language= 'ar' to respond in arabic only (experimental)
# break;
# except Exception as e :
# regenerate_cookie()
# print ( e.__str__() + " TESTING NOTE : this is manual error message from init_bard_session() function")
return bard
bard = init_bard_session()
# regarding mentions for all discrod objects : messages , users , rules .. etc : https://discord.com/developers/docs/reference#message-formatting
admins_room_id = 889999601350881390
wizy_voice_channel = 890209823898107904
memes_highlights_ch_id = 1137242260203909151
narols_island_wizard_channel_id = 1118953370510696498
testing_wizard_channel_id = 1133103993942462577
wizard_channels = (narols_island_wizard_channel_id , testing_wizard_channel_id )
wizard_bot_id = 1117540489365827594
chat_chill_ch_id = 889535812167938088
proxy_sites = ["https://Proxy.server:3128" ,"https://95.217.167.241:8080"]#first one is the only proxy server available for free in pythonanywhere for more servers: https://hidemyna.me/en/proxy-list/?type=s#list
default_help_msg = f"""
GPTEOUS HELP MESSAGE```
**I'M MIGHTY GPTEOUS !** the first GPT-Spirit in Narol's island Volcan guardian , Island's Master right hand and the begining of Island's new ERA etcetera etcetera... I mean you get it am very special here :man_mage:
** :sparkles: __COMMAND GROUP 1: ASK , I shall Answer! __:sparkles: **
:label: Ask me any where in the Island and I shall INDEED answer you
:label: The question must start start with mentioning me e.g.( <@{wizard_bot_id}> )
:label: if you want to speak with me more freely with no mentions/commands
just type anything in my channel <#{narols_island_wizard_channel_id}> and I shall respond !
** :sparkles: __COMMAND GROUP 2: Wise Quotes & Deep memes __:sparkles: **
:label: to get random meme at any time use 'BoringWizard'
:label: to get random quote at any time use 'wisewiz'
:inbox_tray: _Aditional Functionalities and SPELLS coming soon ..._:inbox_tray:
__COMANDS LIST__
```fix
1. @WizardSpirit "your_question"
2. `wiz` "your_question"
3. `bard` "your_question"
4. `wizard` "your_question"
5. `wizardspirit` "your_question"
6. `~ <any_of_prev_CMDs>` "your_question"
7. `wisewiz`
8. `BoringWizard`
_(all of them is case INsensitive)_
```
```fix
**WARNING**: sometimes I won't respond this is mainly due to exceeding max embed char limit
i.e.(6000chars)
```
```fix
"""
override_help_msgP1 = f"""
> ***MIGHTY GPTEOUS I AM:man_mage:! *** `The first GPT-Spirit in Narol's island. Volcan guardian. Island Master's right hand. The begining of Island's new ERA etcetera etcetera... I mean you get it am very special here` :fire_hashira:
:inbox_tray: __Invite ME:__ https://discord.com/api/oauth2/authorize?client_id=1117540489365827594&permissions=8&scope=bot%20applications.commands
:label: Ask me any where in the Island and I shall INDEED answer you
:label: The question must start start with mentioning me e.g.( <@{wizard_bot_id}> ) or just `wizy` <:shyomen:1014210603969171526>
:label: if you want to speak with me more freely with `chat-mode` instead of `single-prompt` mode
just type anything in my channel <#{narols_island_wizard_channel_id}> and I shall respond! _(if my creds :key: and :cookie: still valid and fresh!)_
:label: to get a random meme at any time use `BoringWizard` :ghost:
:label: to get random quote at any time use `wisewiz` :man_mage:
:label: to make me join a voice channel use `wizyjoin` :green_circle: _(you must be inside it first)_
:label: to make me leave a voice channel use `wizyleave` :o:
:inbox_tray: ***PLUS Additional Functionalities and SPELLS coming soon ...*** :inbox_tray: \n\n\n
\n
"""
override_help_msgP2 = f"""
* __FULL COMANDS LIST & ALIASES__
1. Ask The wizard (GPT)
```fix
• `wizyGPT` "your_question"
• `wizy` "your_question"
• `wizardspirit` "your_question"
• `~ <any_of_prev_CMDs>` "your_question"
```
2. Get a Wizardy Quote
```fix
• wisewiz
```
3. Get a Wizardy Meme
```fix
• boringwizard
```
4. Check Status & Latency
```fix
• ping (gets your message latency)
• wiz_ping (gets bots latency)
```
5. Control Commands _(only specific roles are eligible to use)_
```fix
• quotesz <new size> (defaulted to 200 chars and max is ~5070 chars)
• togglerandom (control activity of #memes-highlights channel: `pass nothin` toggles, `0` disable, `1` enable normal mode, `2+` enable special events mode )
• wizyaimode (controls the AI model used in wizard chat channel. `ai_name` values : `gpt` or `bard`)
```
6. Voice Activity
```fix
• wizyjoin
• wizyleave
• wizyplay <url> (with no url he plays default wizy mmo chill track)
• wizypause
• wizyresume
• wizystop
```
7. Special
```fix
• wizyawakened
```
(ALL COMMANDS ARE CASE INsensitive :man_mage:!)\n\n
__for known issues/bugs and planned updates please check wizy's GitHub repo. So long Isalnder :man_mage: !__
* <https://github.com/orsnaro/Discord-Bot-Ai/tree/production-AWS> \n\n
`END OF WIZARD HELP MESSAGE`
"""
#------------------------------------------------------------------------------------------------------------------------------------------#
#NOTE: in order to go away from on_ready() issues override Bot class and move all on ready to it's setup_hook()
class CustomBot(commands.Bot):
async def setup_hook(self):
self.is_auto_memequote_state = 1 if len(sys.argv) <= 1 else int(sys.argv[1]) #0 off | 1 on normal mode | 2 on special mode
self.default_voice_channel: int = wizy_voice_channel
self.wizy_chat_ch_ai_type: str = 'gpt'
self.guilds_not_playing_timer: dict[discord.guild.id, int] = {}
self.resume_chill_if_free.start()
self.auto_memequote_sender_task.start()
self.play_chill_loop.start()
async def on_ready(self):
#next line needed to enable slash commands (slash commands are type of interactions not ctx or message or normal command any more)
await self.tree.sync()
print(f"Bot info: \n (magic and dunder attrs. excluded) ")
for attr in dir(bot.user):
if not (attr.startswith('__') or attr.startswith('_')) :
value = getattr(bot.user, attr)
print(f'{attr}: {value}')
print(f"\n\n Bot '{bot.user}' Sucessfully connected to Discord!\n\n")
@tasks.loop(seconds= 5)
async def resume_chill_if_free(self):
for guild in self.guilds:
increment_val_sec = 5
if guild.id in self.guilds_not_playing_timer:
# check happens once every 5 secs so increment every time by 5 secs
self.guilds_not_playing_timer[guild.id] += increment_val_sec
else:
self.guilds_not_playing_timer[guild.id] = increment_val_sec
if guild.voice_client != None and guild.voice_client.is_connected():
if not guild.voice_client.is_playing():
threshold_sec = 180 #3 minutes
if self.guilds_not_playing_timer[guild.id] >= threshold_sec:
#if there is any user in channel besides wizy the bot play chill music else stay silent
connected_users_cnt = len( guild.voice_client.channel.members ) - 1
if connected_users_cnt >= 1 :
await guild.voice_client.channel.send("*3+ minutes of Silence:pleading_face: resuming* **MMO Chill Track** ...")
await util.play_chill_track(guild)
else:
#TESTING
print("\n\n\n\n\n\n TESTING########################## \n\n\n\n\n there is only the bot in voice channel: don't start track... \n\n\n\n\n\n######################\n\n\n\n")
#TESTING
self.guilds_not_playing_timer[guild.id] = 0
else :
self.guilds_not_playing_timer[guild.id] = 0
else:
self.guilds_not_playing_timer[guild.id] = 0
@resume_chill_if_free.before_loop
async def wait_bot_ready(self):
await self.wait_until_ready()
@tasks.loop(hours=2)
async def auto_memequote_sender_task(self):
await util.send_rand_quote_meme(is_special= True if self.is_auto_memequote_state >= 2 else False)
@auto_memequote_sender_task.before_loop
async def before_start_auto_memequote_sender(self):
#TESTING
print(f"\n\n\n\n\n TESTING##################### \n\n\n you auto_memequote_sender state is : {self.is_auto_memequote_state} \n\n\n\n ######################")
#TESTING
await self.wait_until_ready()
async def toggle_auto_memequote_sender_state(self, state:int = None ) -> bool :
if state is None:
if self.is_auto_memequote_state > 0 :
self.auto_memequote_sender_task.cancel()
self.is_auto_memequote_state = 0
else:
self.auto_memequote_sender_task.start()
self.is_auto_memequote_state = 1
elif state == 0:
if self.auto_memequote_sender_task.is_running():
self.auto_memequote_sender_task.cancel()
self.is_auto_memequote_state = 0
elif state == 1:
if not self.auto_memequote_sender_task.is_running():
self.auto_memequote_sender_task.start()
self.is_auto_memequote_state = 1
elif state == 2: #special eventof type: FREE Palestine!
self.is_auto_memequote_state = 2
return self.is_auto_memequote_state
@tasks.loop(hours= 3)
async def play_chill_loop(self, target_ch: discord.VoiceChannel= None):
#when booting up bot make him join admin room (only for my server wizy home!)
targetVchannel = self.get_channel(self.default_voice_channel) if target_ch == None else target_ch
server = targetVchannel.guild
if server.voice_client is not None :
server.voice_client.disconnect()
await targetVchannel.connect()
if not server.voice_client.is_playing() :
await util.play_chill_track(server)
@play_chill_loop.before_loop
async def before_play_chill(self):
await self.wait_until_ready()
async def stop_play_chill_loop(self):
self.play_chill_loop.cancel()
async def start_play_chill_loop(self):
self.play_chill_loop.start()
#------------------------------------------------------------------------------------------------------------------------------------------#
bot = CustomBot(
command_prefix= ("~", '', ' '),
case_insensitive= True,
strip_after_prefix= True,
intents=discord.Intents.all(),
allowed_mentions= discord.AllowedMentions(everyone= False),
description= default_help_msg,
status= discord.Status.online,
activity= discord.Game("/help"),
help_command= None,
)
#------------------------------------------------------------------------------------------------------------------------------------------#
def get_last_conv_id() : ... #TODO
#------------------------------------------------------------------------------------------------------------------------------------------#
def boot_bot() :
log_std = open("std.log" , 'a') #logs all stderr and stdout and discord.py msgs
log_discord = logging.FileHandler(filename='discord.log', encoding='utf-8', mode='a')#logs only discord.py msgs
if 'IS_PRODUTCION' in os.environ and os.environ['IS_PRODUCTION'] == '1' :
with contextlib.redirect_stdout(log_std):
with contextlib.redirect_stderr(log_std):
bot.run(keys.Token_gpteousBot , log_handler= log_discord)#default logging level is info
else :
bot.run(keys.Token_gpteousBot , log_level= logging.DEBUG) #default handler is stdout , debug log level is more verbose!
#------------------------------------------------------------------------------------------------------------------------------------------# | [] |
2024-01-10 | ggurjar333/chatmydocs | backend~sources~pdfword.py | from llama_index import SimpleDirectoryReader, VectorStoreIndex
from llama_index.prompts import Prompt
from langchain.chat_models import ChatOpenAI
from llama_index import ServiceContext
class PdfWord:
def __init__(self):
self._folder_name = ""
self._prompt = ""
def analyze(self, temp_dir, user_prompt_text):
self._folder_name = temp_dir + '/'
self._prompt = user_prompt_text
documents = SimpleDirectoryReader(self._folder_name).load_data()
index = VectorStoreIndex.from_documents(documents)
# query_engine = index.as_query_engine()
chat_engine = index.as_chat_engine(chat_mode='react', verbose=True)
response = chat_engine.chat('Use the tool to answer: ' + self._prompt)
# response = query_engine.query(
# "You're an intelligent subject expert and humorist, Respond the following query the data "
# + self._prompt)
return str(response)
# if __name__ == "__main__":
# pw = PdfWord()
# documents = SimpleDirectoryReader('tmp/').load_data()
# index = VectorStoreIndex.from_documents(documents)
# chat_engine = index.as_chat_engine(verbose=True)
# pw.analyze(temp_dir='tmp', user_prompt_text=chat_engine.chat_repl())
| [
"Use the tool to answer: "
] |
2024-01-10 | ggurjar333/chatmydocs | backend~setup.py | from dotenv import load_dotenv
import streamlit as st
import os
from helpers.s3helpers import S3helpers
from helpers.utilities import Utility
import boto3
import openai
from sources.website import Website
from sources.pdfword import PdfWord
from streamlit_chat import message
from llama_index import SimpleDirectoryReader, VectorStoreIndex
load_dotenv()
title = st.title(os.environ['APP_NAME'])
c1, c2 = st.columns(2)
#with st.sidebar:
# openai_key = st.text_input('OpenAI API Key', key='chatbot_api_key')
# sbtn = st.button('Save')
# if sbtn:
# openai.api_key = os.environ['OPENAI_API_KEY']
openai.api_key = os.environ['OPENAI_API_KEY']
s3 = boto3.resource('s3')
# Set up cloud and openai key using UI
# c1, c2, c3 = st.columns(3)
# with c3:
# open_ai_key = st.text_input("OpenAI API Key")
# cloud_box = st.selectbox('Select cloud service provider', ('AWS', 'GCP', 'Azure'))
# if cloud_box == 'AWS':
# access_key = st.text_input('AWS Access Key ID')
# secret_key = st.text_input('AWS Secret Access Key')
# sbutton = st.button('Save')
# if sbutton:
# openai.api_key = open_ai_key
# cloud = AWS()
# obj = cloud.setup(access_key=access_key, secret_key=secret_key)
with c1:
option = st.selectbox('Select Data Source', ('PDF/Word', 'Website', 'Chat'))
if option == 'PDF/Word':
uploaded_files = st.file_uploader("Choose a PDF/Word file")
if uploaded_files is not None:
# Uploading the input file to S3 Bucket
storage = S3helpers()
storage.upload(file_obj=uploaded_files)
# st.write('File Uploaded to S3.')
storage.download(file_obj=uploaded_files, temp_folder='tmp')
documents = SimpleDirectoryReader('tmp/').load_data()
index = VectorStoreIndex.from_documents(documents)
chat_engine = index.as_chat_engine()
# query_engine = index.as_query_engine()
###################################################################
if "messages" not in st.session_state:
st.session_state["messages"] = [{"role": "assistant", "content": "How can I help you?"}]
with st.form("chat_input", clear_on_submit=True):
a, b = st.columns([4, 1])
user_input = a.text_input(
label="Your message:",
placeholder="What would you like to say?",
label_visibility="collapsed",
)
b.form_submit_button("Send", use_container_width=True)
for idx, msg in enumerate(st.session_state.messages):
message(msg["content"], is_user=msg["role"] == "user", key=idx)
# message(msg["content"], is_user=msg["role"], key=idx)
if user_input and not os.environ['OPENAI_API_KEY']:
st.info("Please add your OpenAI API key to continue.")
pw = PdfWord()
if user_input and os.environ['OPENAI_API_KEY']:
openai.api_key = os.environ['OPENAI_API_KEY']
st.session_state.messages.append({"role": "user", "content": user_input})
message(user_input, is_user=True)
response = pw.analyze(temp_dir='tmp', user_prompt_text=user_input)
st.session_state.messages.append({"role": "assistant", "content": response})
message(response, is_user=False)
# Deleting the temporary files and folders created. # CODE Under PROGRESS
ut = Utility()
ut.delete_tmp_folder(folder_name='tmp', file_name=uploaded_files.name)
###################################################################
# PDF/Word Prompt Box
# query = st.text_area('Enter your prompt query')
# st.write(query)
# Parsing and analyzing PDF/Word
# analyze_profile = st.button('Analyze')
# if analyze_profile:
# with st.spinner('Analyzing ...'):
# pw = PdfWord()
# result = pw.analyze(temp_dir='tmp', user_prompt_text=query)
# st.write(result)
# object = s3.Object(
# bucket_name=os.environ['AWS_S3BUCKET_PROCESSED'],
# key=os.environ['APP_NAME'] +'/'+ uploaded_files.name + '.txt'
# )
# object.put(Body=result)
# st.write(f'Saved {option} analysis..')
if option == "Website":
url_link = st.text_input('URL')
query = st.text_area('Enter your prompt query')
analyze_profile = st.button('Analyze')
if analyze_profile:
with st.spinner('Analyzing...'):
li = Website()
result = li.analyze(user_website_link=url_link, user_prompt_text=query)
if result:
with c2:
st.write(result)
else:
st.write('Something went wrong')
| [
"How can I help you?"
] |
2024-01-10 | MaheshSQL/openai-vector-search-demo | modules~utilities.py | #------------Imports---------------
import os
from langchain.document_loaders import PyPDFLoader
from langchain.document_loaders import UnstructuredWordDocumentLoader
from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.schema import Document
from langchain.llms.openai import AzureOpenAI
from langchain.chains.qa_with_sources import load_qa_with_sources_chain
import openai
from dotenv import load_dotenv
import redis
from redis.commands.search.field import VectorField, TagField, TextField, NumericField
from redis.commands.search.indexDefinition import IndexDefinition, IndexType
from redis.commands.search.query import Query
import hashlib
import numpy as np
import logging
logging.basicConfig(level=logging.ERROR)
#------------Functions---------------
'''Read PDF documents and return the list of langchain documents
'''
def readPDF(source_url):
try:
document_pages_lc = None
document_pages_lc = PyPDFLoader(source_url).load()
# for page in document_pages_lc:
# print(f'Source: {str(page.metadata["source"])}')
# print(f'Page: {str(int(page.metadata["page"])+1)}')
# print(page.page_content)
return document_pages_lc
except Exception as e:
logging.error(f'Error readPDF(): {e}')
return None
'''Read MS Word documents and return the list of langchain documents
'''
def readMSWord(source_url):
try:
one_page_size = 300 #IMP: How many words per split page of whole doc.
document_pages_lc = None
document_pages_lc = UnstructuredWordDocumentLoader(source_url).load() #Note: This method does not return same object as PDf loader, e.g. Doc pages not recognized. So below custom logic is built.
document_pages_lc_list = []
# UnstructuredWordDocumentLoader returns whole doc as a single page, so need to impelement custom splitting
for page in document_pages_lc:
page_words = page.page_content.split(' ') #Split doc into words
#Split document into pages of one_page_size words each
for i in range((len(page_words) // one_page_size)+1):
# print(i)
# Note: Replaced below with Document object as in code below this section.
# document_pages_lc_dict = {} #{"page_content":"",metadata={"source": "..doc", "page": 4}}
# document_pages_lc_dict["page_content"] = ' '.join(page_words[i*one_page_size:(i+1)*one_page_size])
# document_pages_lc_dict["metadata"] = {"source":page.metadata["source"], "page":i}
# document_pages_lc_list.append(document_pages_lc_dict)
doc = Document(page_content=' '.join(page_words[i*one_page_size:(i+1)*one_page_size]),
metadata={"source":page.metadata["source"], "page":i})
document_pages_lc_list.append(doc)
return document_pages_lc_list
except Exception as e:
logging.error(f'Error readMSWord_old(): {e}')
return None
'''
Initialise environment variables
'''
def setEnv():
try:
openai.api_type = os.getenv('OPENAI_API_TYPE')
openai.api_base = os.getenv('OPENAI_API_BASE')
openai.api_version = os.getenv('API_VERSION')
openai.api_key = os.getenv("OPENAI_API_KEY")
return True
except Exception as e:
logging.error(f'Error setEnv(): {e}')
return False
'''
input_text: input text
'''
def encode(input_text):
return str(hashlib.sha1(f'{input_text}'.encode('utf-8')).hexdigest())
'''
txt_data: input data
aoai_embedding_model: Azure OpenAI deployment name
chunk_size: Maximum number of texts to embed in each batch
max_retries: Maximum number of retries to make when generating.
'''
def getEmbedding(txt_data, aoai_embedding_model, chunk_size=1, max_retries = 3):
try:
embeddings = OpenAIEmbeddings(model=aoai_embedding_model, chunk_size=chunk_size, max_retries=max_retries)
query_result = embeddings.embed_query(txt_data)
return query_result
except Exception as e:
logging.info(f'txt_data: {txt_data}')
logging.error(f'Error getEmbedding(): {e}')
return None
'''
documentPath: Path to document (pdf/word/etc.)
'''
def getDocumentExtension(documentPath):
try:
return os.path.basename(documentPath).split('.')[len(os.path.basename(documentPath).split('.'))-1]
except Exception as e:
logging.error(f'Error getDocumentExtension(): {e}')
return None
'''
Removes new line characters, double spaces
input_text: Piece of text
'''
def cleanseText(input_text):
try:
input_text_cleansed = None
input_text_cleansed = input_text.replace('\n',' ') #Remove new line characters
input_text_cleansed = input_text_cleansed.replace(' ',' ') #Remove double space
return input_text_cleansed
except Exception as e:
logging.error(f'Error cleanseText(): {e}')
return None
'''
Generate embedding for entire doc
documentPath: Path to the document
'''
def getEmbeddingEntireDoc(documentPath, aoai_embedding_model, chunk_size=1):
try:
docType = None
document_pages_lc = None
document_page_embedding_list = []
document_page_content_list = []
document_page_no_list = []
#Get document type
docType = getDocumentExtension(documentPath).lower()
if docType == 'pdf':
document_pages_lc = readPDF(documentPath)
# Custom word doc processing as there's not page metadata like PDF loader,
# also the doc is not split into pages like PDF does out of the box. Please review readMSWord() method for more details.
elif docType == 'docx' or docType == 'doc':
document_pages_lc = readMSWord(documentPath)
for document_page in document_pages_lc:
# print(document_page)
# print(document_page.page_content)
# print(document_page.metadata["source"])
# print(document_page.metadata["page"])
source_doc_path = None
source_doc_page_no = None
source_doc_page_content = None
embedding_result = None
# if docType == 'pdf':
# source_doc_path = document_page.metadata["source"]
# source_doc_page_no = int(document_page.metadata["page"])
# source_doc_page_content = document_page.page_content
# elif docType == 'docx' or docType == 'doc':
# source_doc_path = document_page["metadata"]["source"]
# source_doc_page_no = int(document_page["metadata"]["page"])
# source_doc_page_content = document_page["page_content"]
source_doc_path = document_page.metadata["source"]
source_doc_page_no = int(document_page.metadata["page"])
source_doc_page_content = document_page.page_content
# print(source_doc_path)
# print(source_doc_page_no)
# print(source_doc_page_content)
source_doc_page_content_cleansed = cleanseText(source_doc_page_content)
if (source_doc_page_content_cleansed) is not None and (len(source_doc_page_content_cleansed)>0) and (source_doc_page_content_cleansed.strip != ''):
embedding_result = getEmbedding(source_doc_page_content_cleansed, aoai_embedding_model, chunk_size=1, max_retries = 3)
# print(embedding_result)
if embedding_result is not None:
document_page_content_list.append(source_doc_page_content) #Retain formatting
document_page_embedding_list.append(embedding_result)
document_page_no_list.append(source_doc_page_no)
else:
print(f'Unable to embed text:{source_doc_page_content}, moving to next.')
return document_page_content_list, document_page_embedding_list, document_page_no_list
except Exception as e:
logging.error(f'Error getEmbeddingEntireDoc(): {e}')
return None, None, None
'''
host: Azure redis cache host (Azure redis resource -> Properties -> Host name) or url of ACI if deployed in as container
access_key: Azure redis cache access key or password if deployed as container
port: Azure redis port (defaults to 6380)
ssl: True/False
'''
def getRedisConnection(host, access_key, port=6380, ssl=True):
try:
az_redis = redis.Redis(host=host,
port=port,
password=access_key,
ssl=ssl)
return az_redis
except Exception as e:
logging.error(f'Error getRedisConnection(): {e}')
return None
def checkRedisIndexExists(index_name, az_redis_connection, encrypt_index_name=False):
try:
if encrypt_index_name:
index_name = encode(index_name)
az_redis_connection.ft(index_name).info()
return True
except:
return False
def dropRedisIndex(az_redis_connection, index_name='page_embeddings_index', encrypt_index_name=False):
try:
if encrypt_index_name:
index_name = encode(index_name)
az_redis_connection.ft(index_name).dropindex(delete_documents=False)
return True
except Exception as e:
logging.error(f'Error dropRedisIndex(): {e}')
return False
'''
az_redis_connection: Connection object to Azure Redis Cache, with Search enabled (Stack / enterprise)
index_name: Redis index name
prefix: Key prefix
distance_metric: Vector field distance metrics
'''
def createRedisIndex(az_redis_connection, index_name='page_embeddings_index' , prefix = 'doc', distance_metric='COSINE', DIM = 1536, vec_type = 'HNSW', encrypt_index_name=False):
try:
response = None
if encrypt_index_name:
index_name = encode(index_name)
if checkRedisIndexExists(index_name, az_redis_connection)==False:
#Define fields
page_content = TextField(name="page_content")
page_number = NumericField(name="page_number")
document_path = TextField(name="document_path")
page_content_vector = VectorField("page_content_vector",
vec_type, {
"TYPE": "FLOAT32",
"DIM": DIM,
"DISTANCE_METRIC": distance_metric,
"INITIAL_CAP": 1000
})
# create search index
response = az_redis_connection.ft(index_name).create_index(
fields = [page_content,page_number,document_path,page_content_vector],
definition = IndexDefinition(
prefix=[f'{prefix}:'], #Sqaure bracket important!
index_type=IndexType.HASH)
)
else:
print('Index already exists.')
return response
except Exception as e:
logging.error(f'Error createRedisIndex(): {e}')
return None
def addRedisIndexRecord(az_redis_connection, id, page_content, page_content_vector, page_number, documentPath, prefix = 'doc'):
try:
# Super Important to include dtype parameter. Otherwise the record gets added but not seen by index!!!
page_content_vector = np.array(page_content_vector, dtype=np.float32)
# print(f'page_content_vector.shape:{page_content_vector.shape}')
az_redis_connection.hset(name=f'{prefix}:{str(id)}', mapping={"page_content": str(page_content),
"page_number":int(page_number),
"document_path": str(documentPath),
"page_content_vector": page_content_vector.tobytes()
}
)
# az_redis_connection.hset(name=f'{prefix}:{str(id)}', items= ["page_content", str(page_content),
# "page_number", int(page_number),
# "document_path", str(documentPath),
# "page_content_vector", page_content_vector.tobytes()
# ])
# pipe = az_redis_connection.pipeline(transaction=False)
# pipe.hset(name=f'{prefix}:{str(id)}', mapping={"page_content": str(page_content),
# "page_number":int(page_number),
# "page_content_vector": page_content_vector.tobytes()
# }
# )
# pipe.execute()
return True
except Exception as e:
logging.error(f'Error addRedisIndexRecord(): {e}')
return False
'''
Iterate over read document and add it to the index
'''
def addDocumentToRedis(az_redis_connection, documentPath, document_page_content_list, document_page_embedding_list, document_page_no_list, prefix, encrypt_prefix=False):
try:
if encrypt_prefix:
prefix = encode(prefix)
# Iterate through pages
for i, embedding in enumerate(document_page_embedding_list):
hash_key = hashlib.sha1(f'{documentPath}_{i}'.encode('utf-8')).hexdigest()
addRedisIndexRecord(az_redis_connection = az_redis_connection,
id = hash_key,
page_content = document_page_content_list[i],
page_content_vector = document_page_embedding_list[i],
page_number = document_page_no_list[i],
prefix = prefix,
documentPath = documentPath
)
return True
except Exception as e:
logging.error(f'Error addDocumentToRedis(): {e}')
return False
'''
az_redis_connection: Connection to Redis, with Search enabled (Stack / enterprise)
prompt: User query
aoai_embedding_model: Azure OpenAI model for prompt embedding
index_name: Redis index name
top_n: Return top_n close matches
'''
def queryRedis(az_redis_connection, prompt, aoai_embedding_model, index_name, top_n, encrypt_index_name=False):
try:
document_lc_list = []
if encrypt_index_name:
index_name = encode(index_name)
vec_prompt = getEmbedding(txt_data=prompt, aoai_embedding_model=aoai_embedding_model, chunk_size=1, max_retries = 3)
vec_prompt = np.array(vec_prompt, dtype=np.float32) #Super important to specify dtype, otherwise vector share mismatch error.
# base_query = f'*=>[KNN {str(top_n)} @page_content_vector $prompt_vector AS __page_content_vector_score]'
base_query = f'*=>[KNN {str(top_n)} @page_content_vector $prompt_vector AS __page_content_vector_score]'
query = (
Query(base_query)
.sort_by("__page_content_vector_score") #asc = False, relevance in desc order.
.paging(0,top_n)
.return_fields('__page_content_vector_score','page_content','page_number', 'document_path')
.dialect(2)
)
query_result = az_redis_connection.ft(index_name).search(query, {"prompt_vector": vec_prompt.tobytes()})
# print(type(query_result))
#Create lc document, for use with lc
for item in query_result.docs:
document_lc = Document(page_content=item.page_content,metadata={"source":item.document_path, "page":item.page_number, "similarity":1-float(item.__page_content_vector_score)})
document_lc_list.append(document_lc)
return query_result, document_lc_list
except Exception as e:
logging.error(f'Error queryRedis(): {e}')
return None, None
#-----------------------------------
# Functions end here.
#-----------------------------------
#For cmd background colour
class bcolors:
HEADER = '\033[95m'
OKBLUE = '\033[94m'
OKCYAN = '\033[96m'
OKGREEN = '\033[92m'
WARNING = '\033[93m'
FAIL = '\033[91m'
ENDC = '\033[0m'
BOLD = '\033[1m'
UNDERLINE = '\033[4m'
#-----------------------------------
aoai_embedding_models = {
"text-search-ada-doc-001":{
"version":{
"1":{
"deployment_name": "text-search-ada-doc-001-v1",
"dim": 1024
}
}
},
"text-search-babbage-doc-001":{
"version":{
"1":{
"deployment_name": "text-search-babbage-doc-001-v1",
"dim": 2048
}
}
},
"text-search-curie-doc-001":{
"version":{
"1":{
"deployment_name": "text-search-curie-doc-001-v1",
"dim": 4096
}
}
},
"text-search-davinci-doc-001":{
"version":{
"1":{
"deployment_name": "text-search-davinci-doc-001-v1",
"dim": 12288
}
}
},
"text-embedding-ada-002":{
"version":{
"1":{
"deployment_name": "text-embedding-ada-002-v1",
"dim": 1536
}
}
},
"text-davinci-003":{
"version":{
"1":{
"deployment_name": "text-davinci-003-v1"
}
}
}
} | [] |
2024-01-10 | sappyb/llmmemory | questionmaker.py | from langchain import LLMChain, PromptTemplate
from langchain.chat_models import ChatOpenAI
class NoOpLLMChain(LLMChain):
"""No-op LLM chain."""
def __init__(self, llm):
"""Initialize."""
super().__init__(llm=llm, prompt=PromptTemplate(template="", input_variables=[]))
def run(self, question: str, *args, **kwargs) -> str:
return question | [] |
2024-01-10 | TIAcode/LLMShellAutoComplete | completer.py | from collections import defaultdict
import json
from typing import Dict, List
import openai
import subprocess
import sys
import sqlite3
import os
import logging
import argparse
import asyncio
import random
import re
import tiktoken
MAX_TOKENS = 3500
log_filename = os.path.join(os.path.dirname(__file__), ".completer.log")
logging.basicConfig(
level=logging.DEBUG,
format="%(asctime)s %(levelname)-8s %(message)s",
datefmt="%Y-%m-%d %H:%M:%S.%f",
filename=log_filename,
filemode="w",
)
REMOVE_PATTERNS = [
# sometimes GPT replies with
# 1. commandline
# 2. commandline
(re.compile(r"^\d+\.\s*(.*)$"), r"\1"),
]
def open_atuin_db(filename: str):
conn = sqlite3.connect(filename)
conn.row_factory = sqlite3.Row
return conn
def remove_extra_unicode_characters(content):
clean_content = "".join([c for c in content if ord(c) < 128])
return clean_content
def filter_paths(possibilities: List[str]) -> List[str]:
return [os.path.normpath(p) for p in possibilities if os.path.exists(p)]
def count_text_tokens(content: str, model="gpt-4") -> int:
"""
Counts the number of tokens required to send the given text.
:param content: the text
:return: the number of tokens required
"""
try:
encoding = tiktoken.encoding_for_model(model)
except KeyError:
encoding = tiktoken.get_encoding("gpt-3.5-turbo")
return len(encoding.encode(content))
def count_tokens(messages, model="gpt-4") -> int:
"""
Counts the number of tokens required to send the given messages.
:param messages: the messages to send
:return: the number of tokens required
"""
# Thanks for https://github.com/n3d1117/chatgpt-telegram-bot/blob/main/bot/openai_helper.py
try:
encoding = tiktoken.encoding_for_model(model)
except KeyError:
encoding = tiktoken.get_encoding("gpt-3.5-turbo")
if "gpt-3.5" in model:
tokens_per_message = (
4 # every message follows <|start|>{role/name}\n{content}<|end|>\n
)
tokens_per_name = -1 # if there's a name, the role is omitted
else:
tokens_per_message = 3
tokens_per_name = 1
num_tokens = 0
for message in messages:
num_tokens += tokens_per_message
for key, value in message.items():
num_tokens += len(encoding.encode(value))
if key == "name":
num_tokens += tokens_per_name
num_tokens += 3 # every reply is primed with <|start|>assistant<|message|>
return num_tokens
async def main():
# Get OS user name for this user
user = os.getlogin()
default_atuin_db = "/home/" + user + "/.local/share/atuin/history.db"
parser = argparse.ArgumentParser()
parser.add_argument(
"--atuin",
"-a",
type=str,
default=default_atuin_db,
help="Path to atuin history.db",
)
parser.add_argument("--dunst",action="store_true", help="Use dunstify to show notifications")
# parser.add_argument(
# "--max-files",
# "-f",
# type=int,
# help="Maximum number of files to send in prompt (per directory)",
# )
# parser.add_argument(
# "--max-dirs",
# "-d",
# type=int,
# help="Maximum number of directories to send in prompt (per directory)",
# )
parser.add_argument(
"--cwd-history",
"-ch",
type=int,
default=10,
help="Maximum number of cwd history to send in prompt",
)
parser.add_argument(
"--process-history",
"-ph",
type=int,
default=10,
help="Maximum number of history entries for the same process to send in prompt",
)
parser.add_argument(
"--session-history",
"-sh",
type=int,
default=10,
help="Maximum number of history entries for the same session to send in prompt",
)
parser.add_argument(
"--cwd-process-history",
"-cph",
type=int,
default=5,
help="Maximum number of history entries for the same process in the same cwd to send in prompt",
)
# parser.add_argument(
# "--cwd-process-session-history",
# "-cpsh",
# type=int,
# default=10,
# help="Maximum number of history entries for the same process in the same cwd in the same session to send in prompt",
# )
parser.add_argument("--shell", "-s", type=str, default="nushell", help="Shell name. Only given to GPT")
parser.add_argument("--wezterm", "-w", action="store_true")
# parser.add_argument("--kitty", "-k", action="store_true")
parser.add_argument("--model", "-m", default="gpt-3.5-turbo", help="GPT model to use, gpt-4 or got-3.5-turbo")
parser.add_argument("commandline", nargs=argparse.REMAINDER)
args = parser.parse_args()
ATUIN_SESSION = os.environ.get("ATUIN_SESSION")
assert ATUIN_SESSION is not None, "ATUIN_SESSION is not set"
dunst_id = random.randint(2183, 1000000)
cwd = os.getcwd()
cmdline = " ".join(args.commandline)
target_process = cmdline.split(maxsplit=1)[0] if len(sys.argv) > 1 else ""
term_content = ""
if args.wezterm:
wezterm_capture_process = subprocess.run(
["wezterm", "cli", "get-text"], capture_output=True
)
term_content = wezterm_capture_process.stdout.decode("utf-8")
# elif args.kitty:
# kitty_capture_process = subprocess.run(
# ["kitty", "@", "get-text"], capture_output=True
# )
# term_content = kitty_capture_process.stdout.decode("utf-8")
if term_content:
cleaned_term_content = remove_extra_unicode_characters(term_content)
logging.info(f"cleaned_term_content from {len(term_content)} -> {cleaned_term_content}")
# Log token count as well
logging.info(f"term_content token count: {count_text_tokens(term_content)}")
logging.info(f"cleaned_term_content token count: {count_text_tokens(cleaned_term_content)}")
term_content = "Terminal content:\n" + cleaned_term_content + "\n\n"
# cwd = os.path.normpath(sys.argv[1])
# TODO: doesn't handle paths with spaces
target_paths = None
# if args.max_files or args.max_dirs:
# target_paths = filter_paths(cmdline.split())
# if os.path.abspath(cwd) not in [os.path.abspath(p) for p in target_paths]:
# logging.debug("Adding cwd to target_paths")
# target_paths.append(cwd)
# path_files: Dict[str, List[str]] = defaultdict(list)
# for path in target_paths:
# logging.debug(f"Looking for files in {path}")
# for root, dirs, files in os.walk(path):
# for file in files:
# path_files[path].append(file)
# for dir in dirs:
# path_files[path].append(dir + "/")
# logging.debug(f"Files: {path_files[path]}")
logging.info(f"target_process: {target_process}")
logging.info(f"cwd: {cwd}")
logging.info(f"cmdline: {cmdline}")
logging.info(f"target_paths: {target_paths}")
db = open_atuin_db(args.atuin)
cursor = db.cursor()
same_process_str = same_cwd_str = same_session_str = ""
same_cwd_process1_str = same_cwd_process_session_str = ""
if args.process_history > 0:
same_process = []
for entry in cursor.execute(
"SELECT DISTINCT(command) as command FROM history WHERE command LIKE ? ORDER BY timestamp DESC LIMIT ?",
(target_process + "%", args.process_history),
):
same_process.append(entry["command"])
if same_process:
same_process_str = "Latest calls for the same executable:\n"
same_process_str += "\n".join(same_process) + "\n\n"
if args.cwd_history:
same_cwd = []
for entry in cursor.execute(
"SELECT * FROM history WHERE cwd = ? ORDER BY timestamp DESC LIMIT ?",
(cwd, args.cwd_history),
):
same_cwd.append(entry["command"])
if same_cwd:
same_cwd_str = "Latest calls in the same directory:\n"
same_cwd_str += "\n".join(same_cwd) + "\n\n"
if args.session_history:
same_session = []
for entry in cursor.execute(
"SELECT * FROM history WHERE session = ? ORDER BY timestamp DESC LIMIT ?",
(ATUIN_SESSION, args.session_history),
):
same_session.append(entry["command"])
if same_session:
same_session_str = "Latest calls in the same session:\n"
same_session_str += "\n".join(same_session) + "\n\n"
if args.cwd_process_history:
same_cwd_process = []
for entry in cursor.execute(
"SELECT * FROM history WHERE cwd = ? AND command LIKE ? ORDER BY timestamp DESC LIMIT ?",
(cwd, target_process + "%", args.cwd_process_history),
):
same_cwd_process.append(entry["command"])
if same_cwd_process:
same_cwd_process_str = (
"Latest calls in the same directory for the same process:\n"
)
same_cwd_process_str += "\n".join(same_cwd_process) + "\n\n"
# if args.cwd_process_session_history:
# same_cwd_process_session = []
# for entry in cursor.execute(
# "SELECT * FROM history WHERE cwd = ? AND command LIKE ? AND session = ? ORDER BY timestamp DESC LIMIT ?",
# (
# cwd,
# target_process + "%",
# ATUIN_SESSION,
# args.cwd_process_session_history,
# ),
# ):
# same_cwd_process_session.append(entry["command"])
# if same_cwd_process_session:
# same_cwd_process_session_str = "Latest calls in the same directory for the same process in the same session:\n"
# same_cwd_process_session_str += "\n".join(same_cwd_process_session) + "\n\n"
prompt_text = f"""User terminal information:
Shell: {args.shell}
{term_content}{same_session_str}{same_cwd_str}{same_process_str}{same_cwd_process_str}{same_cwd_process_session_str}
CWD: {cwd}
Current command line: {cmdline}"""
prompt = [
{
"role": "system",
"content": """You are an AI autocompleting for user's terminal session."""},
{
"role": "user",
"content": """I will give you information from user's terminal - screen content and history of related commands ran. You can use this information to complete the current command line.
You have to reply with only the full command lines, do not output anything else. Do not prepend the lines with line numbers. Reply with 1-5 completions. The returned lines should contain the user command line input, and you can also change the user input if needed.""",
},
# {
# "role": "user",
# "name": "example_user",
# "content": ""
# }
{"role": "user", "content": prompt_text},
]
# print(prompt_text)
logging.debug(f"Prompt: {prompt_text}")
tokens = count_tokens(prompt, args.model)
logging.info(f"Request tokens: {tokens}")
if tokens > MAX_TOKENS:
logging.error(f"Request tokens: {tokens} > {MAX_TOKENS}")
if args.dunst:
subprocess.run(
["dunstify", "-r", str(dunst_id), f"Too many tokens, {tokens} > {MAX_TOKENS}", f"{cwd}\n\n{cmdline}"]
)
return
if args.dunst:
subprocess.run(
["dunstify", "-r", str(dunst_id), f"Completing, {tokens} tokens", f"{cwd}\n\n{cmdline}"]
)
response = await openai.ChatCompletion.acreate(
model=args.model, messages=prompt, stream=True
)
async def gen():
async for chunk in response:
if "choices" not in chunk or len(chunk["choices"]) == 0:
continue
yield chunk["choices"][0]["delta"].get("content", "")
yield "\n"
current_data = ""
async for chunk in gen():
# logging.info("ChunkResponse:\n",chunk)
current_data += chunk
while "\n" in current_data:
line, current_data = current_data.split("\n", 1)
if line:
logging.debug(f"Response line: {line}")
for pattern in REMOVE_PATTERNS:
line = pattern[0].sub(pattern[1], line)
line=line.strip("`")
logging.debug(f"Response line after patterns: {line}")
print(line, flush=True)
if not current_data:
current_data = ""
if current_data:
line = current_data
for pattern in REMOVE_PATTERNS:
line = pattern[0].sub(pattern[1], line)
line=line.strip("`")
print(line, flush=True)
# logging.info("Response:\n",response)
# result = json.loads(response["choices"][0]["message"]["content"])
# for x in response:
# logging.info("Response:\n","y"+x+"z")
# result = json.loads(x["choices"][0]["message"]["content"])
# if result:
# break
if args.dunst:
subprocess.run(
["dunstify", "-r", str(dunst_id), f"Completion finished", f"{cmdline}"]
)
exit()
result = json.loads(DEBUG_RESULT)
print("\n".join([x["value"] for x in result]))
# fzf_process = subprocess.run(["fzf", "--ansi", "--multi", "--preview-window", "up:50%", "--preview", "echo {}"], input="\n".join([x["value"] for x in result]).encode("utf-8"), capture_output=True)
# print(fzf_process.stdout.decode("utf-8"))
# fzf = FzfPrompt()
# selection = fzf.prompt([x.get("value") for x in result]) # , preview_window="up:50%", preview="echo {}")
# for x in result:
# print(x["value"])
# if not selection:
# print(cmdline)
# else:
# print(selection[0])
if __name__ == "__main__":
asyncio.run(main())
| [
"I will give you information from user's terminal - screen content and history of related commands ran. You can use this information to complete the current command line.\n\nYou have to reply with only the full command lines, do not output anything else. Do not prepend the lines with line numbers. Reply with 1-5 completions. The returned lines should contain the user command line input, and you can also change the user input if needed.",
"You are an AI autocompleting for user's terminal session."
] |
2024-01-10 | Mohamed01555/Video-QuERI | YouChat_V8.py | import gpt4_curl, gpt4_tls, gpt3
from time import sleep
from asyncio import run
from langchain.prompts import PromptTemplate
from utils import *
import streamlit as st
from pathlib import Path
from streamlit_option_menu import option_menu
question_prompt_template = """
You are very good at handling very long texts,so I will give you a video transcription (mostly,in english) splitted in small pieces.This is piece number {i}
You will get a request about it, you should translate this request to the language of transcription if it isn't,
then give me the answer in the language of question, or in another one if I asked.
you should enhance your answer with useful proper resources.\n\n
transcription: {input} \n\n
request: {question} \n\n
feel free to neglect the given transcription if you see that the request is not related to it like thank you, hello or ok and similars, provide instead an appropriate answer like you are welcome.
you may be asked to provide your answer in specific language like arabic, and you must provide your answer in the asked language.
Your answer:\n\n
"""
old = '''
You are very good at handling very long texts,so I will give you a video transcription splitted in small pieces,this is piece number {i}.You will get a query about it,\n\n
transcription: {input}\n\n
query: {question} \n\n
feel free to neglect the given transcription if you see that the query is not related to it like thank you or ok and similars, provide instead an appropriate answer like you are welcome.
query may be a question about it or not, do your best to extract the answer if it exists or make up a suitable answer but hint me if you made one(say for example This answer is not mentioned but and this is a made one).
or it can be explaining something in a simpler way,
or it can be writing programming code explaining a concept in it,
or summerizing it in number of words,
or splitting it to chapters of homogenious content like youtube does.Do your best to give me the answer in this format "hr:min:sec title" and make sure that each chapter is at least 3 minutes.
or any query
you may be asked to provide your answer in specific language like arabic, and you must provide your answer in the asked language.
Also you may be provided with the previous query and a summary of your answer to use them like a memory of past interactions.
You can neglect them if you see that the answer of the current query doesn't need them.
Your answer:\n\n
'''
prompt = PromptTemplate(input_variables=["i","input", "question"], template=question_prompt_template)
async def get_answer_from_chatgpt(question):
try:
resp = await gpt3.Completion().create(question)
return resp
except:
st.info('Service may be stopped or you are disconnected with internet. Feel free to open an issue here "https://github.com/Mohamed01555/VideoQuERI"')
st.stop()
# Fetching answers from You.com will only work offline
async def get_answer_from_youbot(question):
try:
resp = await gpt4_curl.Completion().create(question)
return resp
except:
try:
resp = await gpt4_tls.Completion().create(question)
return resp
except:
st.info('Service may be stopped or you are disconnected with internet. Feel free to open an issue here "https://github.com/Mohamed01555/VideoQuERI"')
st.stop()
def img_to_bytes(img_path):
img_bytes = Path(img_path).read_bytes()
encoded = base64.b64encode(img_bytes).decode()
return encoded
def main():
# setup streamlit page
st.set_page_config(
page_title="VideoQuERI",
page_icon="vqueri.jpeg")
option = option_menu(
menu_title=None,
options=["Home", "FAQs", "Contact", "Donate"],
icons=["house-check", "patch-question-fill", "envelope","currency-dollar"],
orientation='horizontal',
styles={
"container": {"padding": "0!important", "background-color": "#333"},
"icon": {"color": "orange", "font-size": "25px"},
"nav-link": {"font-size": "25px", "text-align": "left", "margin":"0px", "--hover-color": "#ff9900"},
"nav-link-selected": {"background-color": "#6c757d"},
}
)
st.markdown(page_bg_img, unsafe_allow_html=True)
st.markdown(html_code, unsafe_allow_html=True)
# initialize responses.
if "responses" not in st.session_state:
st.session_state.responses = []
# initialize caption.
if "caption" not in st.session_state:
st.session_state.caption = None
# initialize test_splitter.
if "text_splitter" not in st.session_state:
text_splitter = None
# Initialize session state variables
if 'captions' not in st.session_state:
st.session_state.captions = {}
# initialize chunks.
if "chunks" not in st.session_state:
st.session_state.chunks = None
if "button_pressed" not in st.session_state:
st.session_state.button_pressed = False
if "chosen_chunks" not in st.session_state:
st.session_state.chosen_chunks = []
if "prev_qa" not in st.session_state:
st.session_state.prev_qa = None
if 'video_url_list' not in st.session_state:
st.session_state.video_url_list = []
if "question" not in st.session_state:
st.session_state.question = None
if "chosen_radio" not in st.session_state:
st.session_state.chosen_radio = None
if "chosen_model" not in st.session_state:
st.session_state.chosen_model = None
# Set the maximum number of stored captions
MAX_CAPTIONS = 10
with st.sidebar:
video_url = st.text_input("**Paste the video url here:**")
help_slider= "Processing the entire video in a single iteration might be beyond the capability of GPT.\
So we split it in chunks. Please choose the desired chunk size. The bigger the chunk size is, the more precise the answer you get."
selected_value = st.slider("Select a value for chunk size", min_value=100, max_value=3000, value=1500, step=1, help=help_slider)
help_button = "Creating captions from scratch for a video lasting one hour typically requires approximately 2 minutes.\n \
In the event of the server experiencing a high volume of requests, the caption generation process could become significantly delayed.\
If this occurs, we recommend revisiting at a different time. Alternatively, if you already possess the caption, please feel free to provide it below."
if st.button("Generate the Caption...", help = help_button):
st.session_state.button_pressed = True
if (video_url.strip().startswith('http') or video_url.strip().startswith('https')):
with st.spinner("Generating the video Caption..."):
if video_url not in st.session_state.captions.keys():
st.session_state.caption, ret = get_transcript(video_url)
if st.session_state.caption:
if ret == 'return_from_whisper':
st.session_state.captions[video_url] = st.session_state.caption
text_splitter = TokenTextSplitter(chunk_size = selected_value, chunk_overlap=11)
st.session_state.chunks = text_splitter.split_documents(st.session_state.caption)
#add the url to the list to ensure whether i will provide a summary of perious qa
st.info("Caption was generated successfully. You can ask now.")
else:
st.info('Most likely it is not a video, Or caption eneration service if full now. Please try again later')
st.stop()
else:
st.session_state.caption = st.session_state.captions[video_url]
text_splitter = TokenTextSplitter(chunk_size = selected_value, chunk_overlap=11)
st.session_state.chunks = text_splitter.split_documents(st.session_state.caption)
#add the url to the list to ensure whether i will provide a summary of perious qa
st.info("Caption was generated successfully. You can ask now")
# Limit the number of stored captions
if len(st.session_state.captions) > MAX_CAPTIONS:
oldest_url = next(iter(st.session_state.captions))
st.session_state.captions.pop(oldest_url)
else:
st.info('Valid URL must start with `http://` or `https://` ')
st.stop()
if st.session_state.button_pressed:
t=''
for c,doc in enumerate(st.session_state.chunks):
start, end = extract_start_end_time(doc.page_content)
if start is not None and end is not None:
t += f'Chunk {c+1} : from {start} to {end}\n\n'
with st.expander('**Info :information_source:**'):
st.info(
f'Number of Chunks : {len(st.session_state.chunks)}\n\n{t}'
)
with st.expander("**If your query is about specific chunks, please choose them** :slightly_smiling_face:"):
st.session_state.chosen_chunks = []
for i in range(len(st.session_state.chunks)):
chosen_chunk = st.checkbox(label= str(i+1))
if chosen_chunk:
st.session_state.chosen_chunks.append(i + 1)
if st.session_state.chosen_chunks:
st.info(f"Selected Chunks: {st.session_state.chosen_chunks}")
st.session_state.chosen_model = st.radio("Please, choose the backend model", ['YouBot', 'ChatGPT'])
st.session_state.chosen_radio = st.radio("Do you want to add some sort of memory?", ['No', 'Yes'], help="Note that it is not that accurate memory")
if option == 'Home':
for response in st.session_state.responses:
with st.chat_message(response['role']):
st.markdown(response['content'], unsafe_allow_html=True)
st.session_state.question = st.chat_input('Your Query...')
if st.session_state.question:
if not st.session_state.button_pressed:
st.info("You forgot to enter your Video URL and click *Generate the Caption...* button.")
st.stop()
with st.chat_message('user'):
st.markdown(st.session_state.question,unsafe_allow_html=True)
st.session_state.responses.append({'role':"user", 'content': st.session_state.question})
with st.chat_message('assistant'):
st.session_state.message_placeholder = st.empty()
full_response = ''
#if the user entered specefic chunks to query about
if len(st.session_state.chosen_chunks) != 0:
for c in st.session_state.chosen_chunks:
doc = st.session_state.chunks[c-1]
# full_response = answer(chunk_number=c, doc = doc, question = question)
query = prompt.format(i = c, input = doc.page_content, question = st.session_state.question)
try:
if video_url == st.session_state.video_url_list[-1]:
query += st.session_state.prev_qa if st.session_state.prev_qa else ''
except:
query = query
start, end = extract_start_end_time(doc.page_content)
if start is not None and end is not None:
with st.spinner(f"Searching for the answer in the period {start} --> {end}"):
if st.session_state.chosen_model == 'YouBot':
ai_response = run(get_answer_from_youbot(query))
ai_response_decoded = decode_unicode(ai_response)
else:
ai_response = run(get_answer_from_chatgpt(query))
ai_response_decoded = decode_unicode(ai_response)
time_ = f"""<span style="color: #00FF00;">Answer in the period <span style="color: #800080;">{start} --> {end}</span> is \n\n</span>"""
full_response += '\n' + time_ + '\n'+ ai_response_decoded + '\n'
st.session_state.message_placeholder.markdown(full_response + "▌", unsafe_allow_html=True)
else:
if st.session_state.chosen_model == 'YouBot':
ai_response = run(get_answer_from_youbot(query))
ai_response_decoded = decode_unicode(ai_response)
else:
ai_response = run(get_answer_from_chatgpt(query))
ai_response_decoded = decode_unicode(ai_response)
full_response += '\n\n' + ai_response_decoded + '\n\n'
st.session_state.message_placeholder.markdown(full_response + "▌", unsafe_allow_html=True)
#if the user did not entered specefic chunks, use all chunks
else:
for c,doc in enumerate(st.session_state.chunks):
# full_response = answer(chunk_number=c+1, doc = doc, question = question)
query = prompt.format(i = c+1, input = doc.page_content, question = st.session_state.question)
try:
if video_url == st.session_state.video_url_list[-1]:
query += st.session_state.prev_qa if st.session_state.prev_qa else ''
except:
query = query
start, end = extract_start_end_time(doc.page_content)
if start is not None and end is not None:
with st.spinner(f"Searching for the answer in the period {start} --> {end}"):
if st.session_state.chosen_model == 'YouBot':
ai_response = run(get_answer_from_youbot(query))
ai_response_decoded = decode_unicode(ai_response)
else:
ai_response = run(get_answer_from_chatgpt(query))
ai_response_decoded = decode_unicode(ai_response)
time = f"""<span style="color: #00FF00;">Answer in the period <span style="color: #800080;">{start} --> {end}</span> is \n\n</span>"""
full_response += '\n' + time + '\n'+ ai_response_decoded + '\n'
st.session_state.message_placeholder.markdown(full_response + "▌", unsafe_allow_html=True)
else:
if st.session_state.chosen_model == 'YouBot':
ai_response = run(get_answer_from_youbot(query))
ai_response_decoded = decode_unicode(ai_response)
else:
ai_response = run(get_answer_from_chatgpt(query))
ai_response_decoded = decode_unicode(ai_response)
full_response += '\n' + ai_response_decoded
st.session_state.message_placeholder.markdown(full_response + "▌", unsafe_allow_html=True)
st.session_state.message_placeholder.markdown(full_response, unsafe_allow_html=True)
if st.session_state.chosen_radio == 'Yes':
# get a summary of the answer and append before the next question
summary_prompt = f"""
Please summarize this in 100 to 200 words as a mximum.
Retain any programming code present, even if doing so exceeds the 200-word limit.
Capture the entites if exist\n{full_response}
"""
summary = run(get_answer_from_youbot(summary_prompt) if st.session_state.chosen_model == 'YouBot' else get_answer_from_youbot(summary_prompt) )
st.session_state.prev_qa = f"This is the previous question: {st.session_state.question}\nand this is the summary of your answer: {summary}"
st.session_state.video_url_list.append(video_url)
st.session_state.responses.append({'role' : 'assistant', 'content' : full_response})
elif option == 'FAQs':
FAQs()
elif option == 'Contact':
contact()
else:
donate()
if __name__ == '__main__':
main()
| [
"question",
"input",
"\n Please summarize this in 100 to 200 words as a mximum.\n Retain any programming code present, even if doing so exceeds the 200-word limit.\n Capture the entites if exist\nPLACEHOLDER\n ",
"\n You are very good at handling very long texts,so I will give you a video transcription (mostly,in english) splitted in small pieces.This is piece number {i}\n You will get a request about it, you should translate this request to the language of transcription if it isn't,\n then give me the answer in the language of question, or in another one if I asked.\n you should enhance your answer with useful proper resources.\n\n\n \n transcription: {input} \n\n\n \n request: {question} \n\n\n \n feel free to neglect the given transcription if you see that the request is not related to it like thank you, hello or ok and similars, provide instead an appropriate answer like you are welcome.\n \n you may be asked to provide your answer in specific language like arabic, and you must provide your answer in the asked language.\n \n Your answer:\n\n\n "
] |
2024-01-10 | nicolas-raoul/langchain | libs~langchain~langchain~schema~runnable.py | from __future__ import annotations
import asyncio
from abc import ABC, abstractmethod
from concurrent.futures import ThreadPoolExecutor
from typing import (
Any,
AsyncIterator,
Callable,
Coroutine,
Dict,
Generic,
Iterator,
List,
Mapping,
Optional,
TypedDict,
TypeVar,
Union,
cast,
)
from pydantic import Field
from langchain.callbacks.base import BaseCallbackManager, Callbacks
from langchain.load.dump import dumpd
from langchain.load.serializable import Serializable
async def _gated_coro(semaphore: asyncio.Semaphore, coro: Coroutine) -> Any:
async with semaphore:
return await coro
async def _gather_with_concurrency(n: Union[int, None], *coros: Coroutine) -> list:
if n is None:
return await asyncio.gather(*coros)
semaphore = asyncio.Semaphore(n)
return await asyncio.gather(*(_gated_coro(semaphore, c) for c in coros))
class RunnableConfig(TypedDict, total=False):
tags: List[str]
"""
Tags for this call and any sub-calls (eg. a Chain calling an LLM).
You can use these to filter calls.
"""
metadata: Dict[str, Any]
"""
Metadata for this call and any sub-calls (eg. a Chain calling an LLM).
Keys should be strings, values should be JSON-serializable.
"""
callbacks: Callbacks
"""
Callbacks for this call and any sub-calls (eg. a Chain calling an LLM).
Tags are passed to all callbacks, metadata is passed to handle*Start callbacks.
"""
Input = TypeVar("Input")
# Output type should implement __concat__, as eg str, list, dict do
Output = TypeVar("Output")
Other = TypeVar("Other")
class Runnable(Generic[Input, Output], ABC):
def __or__(
self,
other: Union[
Runnable[Any, Other],
Callable[[Any], Other],
Mapping[str, Union[Runnable[Any, Other], Callable[[Any], Other]]],
],
) -> RunnableSequence[Input, Other]:
return RunnableSequence(first=self, last=_coerce_to_runnable(other))
def __ror__(
self,
other: Union[
Runnable[Other, Any],
Callable[[Any], Other],
Mapping[str, Union[Runnable[Other, Any], Callable[[Other], Any]]],
],
) -> RunnableSequence[Other, Output]:
return RunnableSequence(first=_coerce_to_runnable(other), last=self)
@abstractmethod
def invoke(self, input: Input, config: Optional[RunnableConfig] = None) -> Output:
...
async def ainvoke(
self, input: Input, config: Optional[RunnableConfig] = None
) -> Output:
return await asyncio.get_running_loop().run_in_executor(
None, self.invoke, input, config
)
def batch(
self,
inputs: List[Input],
config: Optional[Union[RunnableConfig, List[RunnableConfig]]] = None,
*,
max_concurrency: Optional[int] = None,
) -> List[Output]:
configs = self._get_config_list(config, len(inputs))
with ThreadPoolExecutor(max_workers=max_concurrency) as executor:
return list(executor.map(self.invoke, inputs, configs))
async def abatch(
self,
inputs: List[Input],
config: Optional[Union[RunnableConfig, List[RunnableConfig]]] = None,
*,
max_concurrency: Optional[int] = None,
) -> List[Output]:
configs = self._get_config_list(config, len(inputs))
coros = map(self.ainvoke, inputs, configs)
return await _gather_with_concurrency(max_concurrency, *coros)
def stream(
self, input: Input, config: Optional[RunnableConfig] = None
) -> Iterator[Output]:
yield self.invoke(input, config)
async def astream(
self, input: Input, config: Optional[RunnableConfig] = None
) -> AsyncIterator[Output]:
yield await self.ainvoke(input, config)
def bind(self, **kwargs: Any) -> Runnable[Input, Output]:
"""
Bind arguments to a Runnable, returning a new Runnable.
"""
return RunnableBinding(bound=self, kwargs=kwargs)
def _get_config_list(
self, config: Optional[Union[RunnableConfig, List[RunnableConfig]]], length: int
) -> List[RunnableConfig]:
if isinstance(config, list) and len(config) != length:
raise ValueError(
f"config must be a list of the same length as inputs, "
f"but got {len(config)} configs for {length} inputs"
)
return (
config
if isinstance(config, list)
else [config.copy() if config is not None else {} for _ in range(length)]
)
def _call_with_config(
self,
func: Callable[[Input], Output],
input: Input,
config: Optional[RunnableConfig],
) -> Output:
from langchain.callbacks.manager import CallbackManager
config = config or {}
callback_manager = CallbackManager.configure(
inheritable_callbacks=config.get("callbacks"),
inheritable_tags=config.get("tags"),
inheritable_metadata=config.get("metadata"),
)
run_manager = callback_manager.on_chain_start(
dumpd(self), input if isinstance(input, dict) else {"input": input}
)
try:
output = func(input)
except Exception as e:
run_manager.on_chain_error(e)
raise
else:
run_manager.on_chain_end(
output if isinstance(output, dict) else {"output": output}
)
return output
class RunnableSequence(Serializable, Runnable[Input, Output]):
first: Runnable[Input, Any]
middle: List[Runnable[Any, Any]] = Field(default_factory=list)
last: Runnable[Any, Output]
@property
def steps(self) -> List[Runnable[Any, Any]]:
return [self.first] + self.middle + [self.last]
@property
def lc_serializable(self) -> bool:
return True
class Config:
arbitrary_types_allowed = True
def __or__(
self,
other: Union[
Runnable[Any, Other],
Callable[[Any], Other],
Mapping[str, Union[Runnable[Any, Other], Callable[[Any], Other]]],
],
) -> RunnableSequence[Input, Other]:
if isinstance(other, RunnableSequence):
return RunnableSequence(
first=self.first,
middle=self.middle + [self.last] + other.middle,
last=other.last,
)
else:
return RunnableSequence(
first=self.first,
middle=self.middle + [self.last],
last=_coerce_to_runnable(other),
)
def __ror__(
self,
other: Union[
Runnable[Other, Any],
Callable[[Any], Other],
Mapping[str, Union[Runnable[Other, Any], Callable[[Other], Any]]],
],
) -> RunnableSequence[Other, Output]:
if isinstance(other, RunnableSequence):
return RunnableSequence(
first=other.first,
middle=other.middle + [other.last] + self.middle,
last=self.last,
)
else:
return RunnableSequence(
first=_coerce_to_runnable(other),
middle=[self.first] + self.middle,
last=self.last,
)
def invoke(self, input: Input, config: Optional[RunnableConfig] = None) -> Output:
from langchain.callbacks.manager import CallbackManager
# setup callbacks
config = config or {}
callback_manager = CallbackManager.configure(
inheritable_callbacks=config.get("callbacks"),
local_callbacks=None,
verbose=False,
inheritable_tags=config.get("tags"),
local_tags=None,
inheritable_metadata=config.get("metadata"),
local_metadata=None,
)
# start the root run
run_manager = callback_manager.on_chain_start(
dumpd(self), input if isinstance(input, dict) else {"input": input}
)
# invoke all steps in sequence
try:
for step in self.steps:
input = step.invoke(
input,
# mark each step as a child run
_patch_config(config, run_manager.get_child()),
)
# finish the root run
except (KeyboardInterrupt, Exception) as e:
run_manager.on_chain_error(e)
raise
else:
run_manager.on_chain_end(
input if isinstance(input, dict) else {"output": input}
)
return cast(Output, input)
async def ainvoke(
self, input: Input, config: Optional[RunnableConfig] = None
) -> Output:
from langchain.callbacks.manager import AsyncCallbackManager
# setup callbacks
config = config or {}
callback_manager = AsyncCallbackManager.configure(
inheritable_callbacks=config.get("callbacks"),
local_callbacks=None,
verbose=False,
inheritable_tags=config.get("tags"),
local_tags=None,
inheritable_metadata=config.get("metadata"),
local_metadata=None,
)
# start the root run
run_manager = await callback_manager.on_chain_start(
dumpd(self), input if isinstance(input, dict) else {"input": input}
)
# invoke all steps in sequence
try:
for step in self.steps:
input = await step.ainvoke(
input,
# mark each step as a child run
_patch_config(config, run_manager.get_child()),
)
# finish the root run
except (KeyboardInterrupt, Exception) as e:
await run_manager.on_chain_error(e)
raise
else:
await run_manager.on_chain_end(
input if isinstance(input, dict) else {"output": input}
)
return cast(Output, input)
def batch(
self,
inputs: List[Input],
config: Optional[Union[RunnableConfig, List[RunnableConfig]]] = None,
*,
max_concurrency: Optional[int] = None,
) -> List[Output]:
from langchain.callbacks.manager import CallbackManager
# setup callbacks
configs = self._get_config_list(config, len(inputs))
callback_managers = [
CallbackManager.configure(
inheritable_callbacks=config.get("callbacks"),
local_callbacks=None,
verbose=False,
inheritable_tags=config.get("tags"),
local_tags=None,
inheritable_metadata=config.get("metadata"),
local_metadata=None,
)
for config in configs
]
# start the root runs, one per input
run_managers = [
cm.on_chain_start(
dumpd(self), input if isinstance(input, dict) else {"input": input}
)
for cm, input in zip(callback_managers, inputs)
]
# invoke
try:
for step in self.steps:
inputs = step.batch(
inputs,
[
# each step a child run of the corresponding root run
_patch_config(config, rm.get_child())
for rm, config in zip(run_managers, configs)
],
max_concurrency=max_concurrency,
)
# finish the root runs
except (KeyboardInterrupt, Exception) as e:
for rm in run_managers:
rm.on_chain_error(e)
raise
else:
for rm, input in zip(run_managers, inputs):
rm.on_chain_end(input if isinstance(input, dict) else {"output": input})
return cast(List[Output], inputs)
async def abatch(
self,
inputs: List[Input],
config: Optional[Union[RunnableConfig, List[RunnableConfig]]] = None,
*,
max_concurrency: Optional[int] = None,
) -> List[Output]:
from langchain.callbacks.manager import (
AsyncCallbackManager,
AsyncCallbackManagerForChainRun,
)
# setup callbacks
configs = self._get_config_list(config, len(inputs))
callback_managers = [
AsyncCallbackManager.configure(
inheritable_callbacks=config.get("callbacks"),
local_callbacks=None,
verbose=False,
inheritable_tags=config.get("tags"),
local_tags=None,
inheritable_metadata=config.get("metadata"),
local_metadata=None,
)
for config in configs
]
# start the root runs, one per input
run_managers: List[AsyncCallbackManagerForChainRun] = await asyncio.gather(
*(
cm.on_chain_start(
dumpd(self), input if isinstance(input, dict) else {"input": input}
)
for cm, input in zip(callback_managers, inputs)
)
)
# invoke .batch() on each step
# this uses batching optimizations in Runnable subclasses, like LLM
try:
for step in self.steps:
inputs = await step.abatch(
inputs,
[
# each step a child run of the corresponding root run
_patch_config(config, rm.get_child())
for rm, config in zip(run_managers, configs)
],
max_concurrency=max_concurrency,
)
# finish the root runs
except (KeyboardInterrupt, Exception) as e:
await asyncio.gather(*(rm.on_chain_error(e) for rm in run_managers))
raise
else:
await asyncio.gather(
*(
rm.on_chain_end(
input if isinstance(input, dict) else {"output": input}
)
for rm, input in zip(run_managers, inputs)
)
)
return cast(List[Output], inputs)
def stream(
self, input: Input, config: Optional[RunnableConfig] = None
) -> Iterator[Output]:
from langchain.callbacks.manager import CallbackManager
# setup callbacks
config = config or {}
callback_manager = CallbackManager.configure(
inheritable_callbacks=config.get("callbacks"),
local_callbacks=None,
verbose=False,
inheritable_tags=config.get("tags"),
local_tags=None,
inheritable_metadata=config.get("metadata"),
local_metadata=None,
)
# start the root run
run_manager = callback_manager.on_chain_start(
dumpd(self), input if isinstance(input, dict) else {"input": input}
)
# invoke the first steps
try:
for step in [self.first] + self.middle:
input = step.invoke(
input,
# mark each step as a child run
_patch_config(config, run_manager.get_child()),
)
except (KeyboardInterrupt, Exception) as e:
run_manager.on_chain_error(e)
raise
# stream the last step
final: Union[Output, None] = None
final_supported = True
try:
for output in self.last.stream(
input,
# mark the last step as a child run
_patch_config(config, run_manager.get_child()),
):
yield output
# Accumulate output if possible, otherwise disable accumulation
if final_supported:
if final is None:
final = output
else:
try:
final += output # type: ignore[operator]
except TypeError:
final = None
final_supported = False
pass
# finish the root run
except (KeyboardInterrupt, Exception) as e:
run_manager.on_chain_error(e)
raise
else:
run_manager.on_chain_end(
final if isinstance(final, dict) else {"output": final}
)
async def astream(
self, input: Input, config: Optional[RunnableConfig] = None
) -> AsyncIterator[Output]:
from langchain.callbacks.manager import AsyncCallbackManager
# setup callbacks
config = config or {}
callback_manager = AsyncCallbackManager.configure(
inheritable_callbacks=config.get("callbacks"),
local_callbacks=None,
verbose=False,
inheritable_tags=config.get("tags"),
local_tags=None,
inheritable_metadata=config.get("metadata"),
local_metadata=None,
)
# start the root run
run_manager = await callback_manager.on_chain_start(
dumpd(self), input if isinstance(input, dict) else {"input": input}
)
# invoke the first steps
try:
for step in [self.first] + self.middle:
input = await step.ainvoke(
input,
# mark each step as a child run
_patch_config(config, run_manager.get_child()),
)
except (KeyboardInterrupt, Exception) as e:
await run_manager.on_chain_error(e)
raise
# stream the last step
final: Union[Output, None] = None
final_supported = True
try:
async for output in self.last.astream(
input,
# mark the last step as a child run
_patch_config(config, run_manager.get_child()),
):
yield output
# Accumulate output if possible, otherwise disable accumulation
if final_supported:
if final is None:
final = output
else:
try:
final += output # type: ignore[operator]
except TypeError:
final = None
final_supported = False
pass
# finish the root run
except (KeyboardInterrupt, Exception) as e:
await run_manager.on_chain_error(e)
raise
else:
await run_manager.on_chain_end(
final if isinstance(final, dict) else {"output": final}
)
class RunnableMap(Serializable, Runnable[Input, Dict[str, Any]]):
steps: Mapping[str, Runnable[Input, Any]]
def __init__(
self,
steps: Mapping[
str,
Union[
Runnable[Input, Any],
Callable[[Input], Any],
Mapping[str, Union[Runnable[Input, Any], Callable[[Input], Any]]],
],
],
) -> None:
super().__init__(
steps={key: _coerce_to_runnable(r) for key, r in steps.items()}
)
@property
def lc_serializable(self) -> bool:
return True
class Config:
arbitrary_types_allowed = True
def invoke(
self, input: Input, config: Optional[RunnableConfig] = None
) -> Dict[str, Any]:
from langchain.callbacks.manager import CallbackManager
# setup callbacks
config = config or {}
callback_manager = CallbackManager.configure(
inheritable_callbacks=config.get("callbacks"),
local_callbacks=None,
verbose=False,
inheritable_tags=config.get("tags"),
local_tags=None,
inheritable_metadata=config.get("metadata"),
local_metadata=None,
)
# start the root run
run_manager = callback_manager.on_chain_start(dumpd(self), {"input": input})
# gather results from all steps
try:
# copy to avoid issues from the caller mutating the steps during invoke()
steps = dict(self.steps)
with ThreadPoolExecutor() as executor:
futures = [
executor.submit(
step.invoke,
input,
# mark each step as a child run
_patch_config(config, run_manager.get_child()),
)
for step in steps.values()
]
output = {key: future.result() for key, future in zip(steps, futures)}
# finish the root run
except (KeyboardInterrupt, Exception) as e:
run_manager.on_chain_error(e)
raise
else:
run_manager.on_chain_end(output)
return output
async def ainvoke(
self, input: Input, config: Optional[RunnableConfig] = None
) -> Dict[str, Any]:
from langchain.callbacks.manager import AsyncCallbackManager
# setup callbacks
config = config or {}
callback_manager = AsyncCallbackManager.configure(
inheritable_callbacks=config.get("callbacks"),
local_callbacks=None,
verbose=False,
inheritable_tags=config.get("tags"),
local_tags=None,
inheritable_metadata=config.get("metadata"),
local_metadata=None,
)
# start the root run
run_manager = await callback_manager.on_chain_start(
dumpd(self), {"input": input}
)
# gather results from all steps
try:
# copy to avoid issues from the caller mutating the steps during invoke()
steps = dict(self.steps)
results = await asyncio.gather(
*(
step.ainvoke(
input,
# mark each step as a child run
_patch_config(config, run_manager.get_child()),
)
for step in steps.values()
)
)
output = {key: value for key, value in zip(steps, results)}
# finish the root run
except (KeyboardInterrupt, Exception) as e:
await run_manager.on_chain_error(e)
raise
else:
await run_manager.on_chain_end(output)
return output
class RunnableLambda(Runnable[Input, Output]):
def __init__(self, func: Callable[[Input], Output]) -> None:
if callable(func):
self.func = func
else:
raise TypeError(
"Expected a callable type for `func`."
f"Instead got an unsupported type: {type(func)}"
)
def __eq__(self, other: Any) -> bool:
if isinstance(other, RunnableLambda):
return self.func == other.func
else:
return False
def invoke(self, input: Input, config: Optional[RunnableConfig] = None) -> Output:
return self._call_with_config(self.func, input, config)
class RunnablePassthrough(Serializable, Runnable[Input, Input]):
@property
def lc_serializable(self) -> bool:
return True
def invoke(self, input: Input, config: Optional[RunnableConfig] = None) -> Input:
return self._call_with_config(lambda x: x, input, config)
class RunnableBinding(Serializable, Runnable[Input, Output]):
bound: Runnable[Input, Output]
kwargs: Mapping[str, Any]
class Config:
arbitrary_types_allowed = True
@property
def lc_serializable(self) -> bool:
return True
def bind(self, **kwargs: Any) -> Runnable[Input, Output]:
return self.__class__(bound=self.bound, kwargs={**self.kwargs, **kwargs})
def invoke(self, input: Input, config: Optional[RunnableConfig] = None) -> Output:
return self.bound.invoke(input, config, **self.kwargs)
async def ainvoke(
self, input: Input, config: Optional[RunnableConfig] = None
) -> Output:
return await self.bound.ainvoke(input, config, **self.kwargs)
def batch(
self,
inputs: List[Input],
config: Optional[Union[RunnableConfig, List[RunnableConfig]]] = None,
*,
max_concurrency: Optional[int] = None,
) -> List[Output]:
return self.bound.batch(
inputs, config, max_concurrency=max_concurrency, **self.kwargs
)
async def abatch(
self,
inputs: List[Input],
config: Optional[Union[RunnableConfig, List[RunnableConfig]]] = None,
*,
max_concurrency: Optional[int] = None,
) -> List[Output]:
return await self.bound.abatch(
inputs, config, max_concurrency=max_concurrency, **self.kwargs
)
def stream(
self, input: Input, config: Optional[RunnableConfig] = None
) -> Iterator[Output]:
yield from self.bound.stream(input, config, **self.kwargs)
async def astream(
self, input: Input, config: Optional[RunnableConfig] = None
) -> AsyncIterator[Output]:
async for item in self.bound.astream(input, config, **self.kwargs):
yield item
def _patch_config(
config: RunnableConfig, callback_manager: BaseCallbackManager
) -> RunnableConfig:
config = config.copy()
config["callbacks"] = callback_manager
return config
def _coerce_to_runnable(
thing: Union[
Runnable[Input, Output],
Callable[[Input], Output],
Mapping[str, Union[Runnable[Input, Output], Callable[[Input], Output]]],
]
) -> Runnable[Input, Output]:
if isinstance(thing, Runnable):
return thing
elif callable(thing):
return RunnableLambda(thing)
elif isinstance(thing, dict):
runnables = {key: _coerce_to_runnable(r) for key, r in thing.items()}
return cast(Runnable[Input, Output], RunnableMap(steps=runnables))
else:
raise TypeError(
f"Expected a Runnable, callable or dict."
f"Instead got an unsupported type: {type(thing)}"
)
| [] |
2024-01-10 | julianez/AI-Testing | scoty_openai~main_api.py | import os
from flask import Flask, jsonify, request
from langchain.vectorstores import Chroma
from chromadb.config import Settings
from langchain.prompts.chat import (
PromptTemplate
)
from langchain.embeddings import AzureOpenAIEmbeddings
from langchain.llms import AzureOpenAI
from langchain.chains import RetrievalQA
ROOT_DIRECTORY = os.path.dirname(os.path.realpath(__file__))
PERSIST_DIRECTORY = f"{ROOT_DIRECTORY}/DB"
openaiLLM = AzureOpenAI(
azure_endpoint="https://openai-jez.openai.azure.com/",
azure_deployment="GPT-35-turbo",
model="GPT-35-turbo",
api_version="2023-05-15"
)
embeddings = AzureOpenAIEmbeddings()
# load the vectorstore
db = Chroma(
persist_directory=PERSIST_DIRECTORY,
embedding_function=embeddings,
)
RETRIEVER = db.as_retriever()
QA = RetrievalQA.from_chain_type(
llm=openaiLLM,
chain_type="stuff",
retriever=RETRIEVER,
return_source_documents=True
)
app = Flask(__name__)
@app.route("/api/prompt_route", methods=["GET", "POST"])
def prompt_route():
global QA
user_prompt = request.form.get("user_prompt")
print(f'User Prompt: {user_prompt}')
if user_prompt:
# print(f'User Prompt: {user_prompt}')
# Get the answer from the chain
help_request = "Eres un asesor. Ayuda al usuario. Si no sabes la respuesta di que no tienes la información." +\
f"\nUser:{user_prompt}"
res = QA(help_request)
answer, docs = res["result"], res["source_documents"]
prompt_response_dict = {
"Prompt": help_request,
"Answer": answer,
}
prompt_response_dict["Sources"] = []
for document in docs:
prompt_response_dict["Sources"].append(
(os.path.basename(str(document.metadata["source"])), str(document.page_content))
)
return jsonify(prompt_response_dict), 200
else:
return "No user prompt received", 400
if __name__ == "__main__":
app.run(debug=True, port=5110) | [
"user_prompt",
"{'Prompt': 'Eres un asesor. Ayuda al usuario. Si no sabes la respuesta di que no tienes la información.\\nUser:PLACEHOLDER', 'Answer': PLACEHOLDER}"
] |
2024-01-10 | julianez/AI-Testing | scoty_openai~main_mem.py | import os
import logging
from langchain.prompts.chat import (
PromptTemplate
)
from langchain.embeddings import AzureOpenAIEmbeddings
from langchain.llms import AzureOpenAI
from langchain.chains import RetrievalQA
from langchain.vectorstores import Qdrant
from langchain.output_parsers import PydanticOutputParser
from qdrant_client.http import models as rest
from pydantic import BaseModel, Field
from langchain.document_loaders.csv_loader import CSVLoader
from langchain.document_loaders import WebBaseLoader
from typing import Dict, List, Optional
from langchain.document_loaders.base import BaseLoader
from langchain.docstore.document import Document
with open('URLs-Scotiabank-CL.txt', 'r') as f:
lines = f.readlines()
urls = [line.strip() for line in lines]
loader = WebBaseLoader(urls)
webDocs = loader.load()
embeddings = AzureOpenAIEmbeddings()
quadrant_docsearch = Qdrant.from_documents(
webDocs,
embeddings,
location=":memory:",
collection_name="book"
)
openaiLLM = AzureOpenAI(
azure_endpoint="https://openai-jez.openai.azure.com/",
azure_deployment="GPT-35-turbo",
model="GPT-35-turbo",
api_version="2023-05-15"
)
qa = RetrievalQA.from_chain_type(
llm=openaiLLM, chain_type="stuff", retriever=quadrant_docsearch.as_retriever(), return_source_documents=True)
while True:
user_input = input("Hola, soy Scoty en que puedo ayudarte?\n")
help_request = "Eres un asesor. Ayuda al usuario. Si no sabes la respuesta di que no tienes la información." +\
f"\nUser:{user_input}"
result = qa({"query": help_request})
#print(len(result['source_documents']))
print(result["result"])
| [] |
2024-01-10 | julianez/AI-Testing | scoty_openai~main_chroma.py | import os
from langchain.vectorstores import Chroma
from chromadb.config import Settings
from langchain.prompts.chat import (
PromptTemplate
)
from langchain.embeddings import AzureOpenAIEmbeddings
from langchain.llms import AzureOpenAI
from langchain.chains import RetrievalQA
ROOT_DIRECTORY = os.path.dirname(os.path.realpath(__file__))
PERSIST_DIRECTORY = f"{ROOT_DIRECTORY}/DB"
openaiLLM = AzureOpenAI(
azure_endpoint="https://openai-jez.openai.azure.com/",
azure_deployment="GPT-35-turbo",
model="GPT-35-turbo",
api_version="2023-05-15"
)
embeddings = AzureOpenAIEmbeddings()
# load the vectorstore
db = Chroma(
persist_directory=PERSIST_DIRECTORY,
embedding_function=embeddings,
)
retriever = db.as_retriever()
qa = RetrievalQA.from_chain_type(
llm=openaiLLM,
chain_type="stuff",
retriever=retriever,
return_source_documents=True
)
while True:
user_input = input("Hola, soy Scoty en que puedo ayudarte?\n")
help_request = "Eres un asesor. Ayuda al usuario. Si no sabes la respuesta di que no tienes la información." +\
f"\nUser:{user_input}"
result = qa({"query": help_request})
#print(len(result['source_documents']))
print(result["result"])
| [] |
2024-01-10 | julianez/AI-Testing | langChainPDF~run_localGPT.py | import logging
import os
import click
import torch
from auto_gptq import AutoGPTQForCausalLM
from huggingface_hub import hf_hub_download
from langchain.chains import RetrievalQA
from langchain.embeddings import HuggingFaceInstructEmbeddings
from langchain.llms import HuggingFacePipeline, LlamaCpp
from langchain.memory import ConversationBufferMemory
from langchain.prompts import PromptTemplate
# from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler
from langchain.vectorstores import Chroma
# Context Window and Max New Tokens
CONTEXT_WINDOW_SIZE = 4096
MAX_NEW_TOKENS = CONTEXT_WINDOW_SIZE # int(CONTEXT_WINDOW_SIZE/4)
N_GPU_LAYERS = 100 # Llama-2-70B has 83 layers
N_BATCH = 512
MODELS_PATH = "./models"
MODEL_ID = "TheBloke/Llama-2-7B-Chat-GGML"
MODEL_BASENAME = "llama-2-7b-chat.ggmlv3.q4_0.bin"
# load_dotenv()
ROOT_DIRECTORY = os.path.dirname(os.path.realpath(__file__))
PERSIST_DIRECTORY = f"{ROOT_DIRECTORY}/DB"
# Default Instructor Model
# https://huggingface.co/hkunlp/instructor-large
EMBEDDING_MODEL_NAME = "hkunlp/instructor-large" # Uses 1.5 GB of VRAM (High Accuracy with lower VRAM usage)
def load_model(device_type, model_id, model_basename=None):
"""
Load a GGUF/GGML quantized model using LlamaCpp.
This function attempts to load a GGUF/GGML quantized model using the LlamaCpp library.
If the model is of type GGML, and newer version of LLAMA-CPP is used which does not support GGML,
it logs a message indicating that LLAMA-CPP has dropped support for GGML.
Parameters:
- model_id (str): The identifier for the model on HuggingFace Hub.
- model_basename (str): The base name of the model file.
- device_type (str): The type of device where the model will run, e.g., 'mps', 'cuda', etc.
- logging (logging.Logger): Logger instance for logging messages.
Returns:
- LlamaCpp: An instance of the LlamaCpp model if successful, otherwise None.
Notes:
- The function uses the `hf_hub_download` function to download the model from the HuggingFace Hub.
- The number of GPU layers is set based on the device type.
"""
try:
logging.info("Using Llamacpp for GGUF/GGML quantized models")
model_path = hf_hub_download(
repo_id=model_id,
filename=model_basename,
resume_download=True,
cache_dir="./models",
)
kwargs = {
"model_path": model_path,
"n_ctx": CONTEXT_WINDOW_SIZE,
"max_tokens": MAX_NEW_TOKENS,
}
if device_type.lower() == "mps":
kwargs["n_gpu_layers"] = 1
if device_type.lower() == "cuda":
kwargs["n_gpu_layers"] = 100 # set this based on your GPU
kwargs["n_batch"] = N_BATCH # set this based on your GPU & CPU RAM
return LlamaCpp(**kwargs)
except:
if 'ggml' in model_basename:
logging.INFO("If you were using GGML model, LLAMA-CPP Dropped Support, Use GGUF Instead")
return None
# chose device typ to run on as well as to show source documents.
@click.command()
@click.option(
"--device_type",
default="cuda" if torch.cuda.is_available() else "cpu",
type=click.Choice(
[
"cpu",
"cuda",
"ipu",
"xpu",
"mkldnn",
"opengl",
"opencl",
"ideep",
"hip",
"ve",
"fpga",
"ort",
"xla",
"lazy",
"vulkan",
"mps",
"meta",
"hpu",
"mtia",
],
),
help="Device to run on. (Default is cuda)",
)
@click.option(
"--show_sources",
"-s",
is_flag=True,
help="Show sources along with answers (Default is False)",
)
def main(device_type, show_sources):
"""
This function implements the information retrieval task.
1. Loads an embedding model, can be HuggingFaceInstructEmbeddings or HuggingFaceEmbeddings
2. Loads the existing vectorestore that was created by inget.py
3. Loads the local LLM using load_model function - You can now set different LLMs.
4. Setup the Question Answer retreival chain.
5. Question answers.
"""
logging.info(f"Running on: {device_type}")
logging.info(f"Display Source Documents set to: {show_sources}")
embeddings = HuggingFaceInstructEmbeddings(model_name=EMBEDDING_MODEL_NAME, model_kwargs={"device": device_type})
# uncomment the following line if you used HuggingFaceEmbeddings in the ingest.py
# embeddings = HuggingFaceEmbeddings(model_name=EMBEDDING_MODEL_NAME)
# load the vectorstore
db = Chroma(
persist_directory=PERSIST_DIRECTORY,
embedding_function=embeddings,
)
retriever = db.as_retriever()
template = """Use the following pieces of context to answer the question at the end. If you don't know the answer,\
just say that you don't know, don't try to make up an answer.
{context}
{history}
Question: {question}
Helpful Answer:"""
prompt = PromptTemplate(input_variables=["history", "context", "question"], template=template)
memory = ConversationBufferMemory(input_key="question", memory_key="history")
llm = load_model(device_type, model_id=MODEL_ID, model_basename=MODEL_BASENAME)
qa = RetrievalQA.from_chain_type(
llm=llm,
chain_type="stuff",
retriever=retriever,
return_source_documents=True,
chain_type_kwargs={"prompt": prompt, "memory": memory},
)
# Interactive questions and answers
while True:
query = input("\nEnter a query: ")
if query == "exit":
break
# Get the answer from the chain
res = qa(query)
answer, docs = res["result"], res["source_documents"]
# Print the result
print("\n\n> Question:")
print(query)
print("\n> Answer:")
print(answer)
if show_sources: # this is a flag that you can set to disable showing answers.
# # Print the relevant sources used for the answer
print("----------------------------------SOURCE DOCUMENTS---------------------------")
for document in docs:
print("\n> " + document.metadata["source"] + ":")
print(document.page_content)
print("----------------------------------SOURCE DOCUMENTS---------------------------")
if __name__ == "__main__":
logging.basicConfig(
format="%(asctime)s - %(levelname)s - %(filename)s:%(lineno)s - %(message)s", level=logging.INFO
)
main()
| [
"t know the answer, just say that you don",
"question",
"Use the following pieces of context to answer the question at the end. If you don't know the answer, just say that you don't know, don't try to make up an answer.\n\n {context}\n\n {history}\n Question: {question}\n Helpful Answer:",
"context"
] |
2024-01-10 | PRBonn/bonnet | train_py~arch~msg.py | # This file is NOT a part of Bonnet. It was included from OpenAI's code on
# this GitHub repo: https://github.com/openai/gradient-checkpointing
# Give them a star, they deserve it.
from toposort import toposort
import contextlib
import numpy as np
import tensorflow as tf
import tensorflow.contrib.graph_editor as ge
import time
import sys
sys.setrecursionlimit(10000)
# refers back to current module if we decide to split helpers out
util = sys.modules[__name__]
# getting rid of "WARNING:tensorflow:VARIABLES collection name is deprecated"
setattr(tf.GraphKeys, "VARIABLES", "variables")
# save original gradients since tf.gradient could be monkey-patched to point
# to our version
from tensorflow.python.ops import gradients as tf_gradients_lib
tf_gradients = tf_gradients_lib.gradients
MIN_CHECKPOINT_NODE_SIZE = 1024 # use lower value during testing
# specific versions we can use to do process-wide replacement of tf.gradients
def gradients_speed(ys, xs, grad_ys=None, **kwargs):
print("Using OpenAI's checkpoint'd grads. Speed optimization.")
return gradients(ys, xs, grad_ys, checkpoints='speed', **kwargs)
def gradients_memory(ys, xs, grad_ys=None, **kwargs):
print("Using OpenAI's checkpoint'd grads. Memory optimization.")
return gradients(ys, xs, grad_ys, checkpoints='memory', **kwargs)
def gradients_collection(ys, xs, grad_ys=None, **kwargs):
print("Using OpenAI's checkpoint'd grads. Specific collection.")
return gradients(ys, xs, grad_ys, checkpoints='collection', **kwargs)
def gradients(ys, xs, grad_ys=None, checkpoints='collection', **kwargs):
'''
Authors: Tim Salimans & Yaroslav Bulatov
memory efficient gradient implementation inspired by "Training Deep Nets with Sublinear Memory Cost"
by Chen et al. 2016 (https://arxiv.org/abs/1604.06174)
ys,xs,grad_ys,kwargs are the arguments to standard tensorflow tf.gradients
(https://www.tensorflow.org/versions/r0.12/api_docs/python/train.html#gradients)
'checkpoints' can either be
- a list consisting of tensors from the forward pass of the neural net
that we should re-use when calculating the gradients in the backward pass
all other tensors that do not appear in this list will be re-computed
- a string specifying how this list should be determined. currently we support
- 'speed': checkpoint all outputs of convolutions and matmuls. these ops are usually the most expensive,
so checkpointing them maximizes the running speed
(this is a good option if nonlinearities, concats, batchnorms, etc are taking up a lot of memory)
- 'memory': try to minimize the memory usage
(currently using a very simple strategy that identifies a number of bottleneck tensors in the graph to checkpoint)
- 'collection': look for a tensorflow collection named 'checkpoints', which holds the tensors to checkpoint
'''
# print("Calling memsaving gradients with", checkpoints)
if not isinstance(ys, list):
ys = [ys]
if not isinstance(xs, list):
xs = [xs]
bwd_ops = ge.get_backward_walk_ops([y.op for y in ys],
inclusive=True)
debug_print("bwd_ops: %s", bwd_ops)
# forward ops are all ops that are candidates for recomputation
fwd_ops = ge.get_forward_walk_ops([x.op for x in xs],
inclusive=True,
within_ops=bwd_ops)
debug_print("fwd_ops: %s", fwd_ops)
# exclude ops with no inputs
fwd_ops = [op for op in fwd_ops if op._inputs]
# don't recompute xs, remove variables
xs_ops = _to_ops(xs)
fwd_ops = [op for op in fwd_ops if not op in xs_ops]
fwd_ops = [op for op in fwd_ops if not '/assign' in op.name]
fwd_ops = [op for op in fwd_ops if not '/Assign' in op.name]
fwd_ops = [op for op in fwd_ops if not '/read' in op.name]
ts_all = ge.filter_ts(fwd_ops, True) # get the tensors
ts_all = [t for t in ts_all if '/read' not in t.name]
ts_all = set(ts_all) - set(xs) - set(ys)
# construct list of tensors to checkpoint during forward pass, if not
# given as input
if type(checkpoints) is not list:
if checkpoints == 'collection':
checkpoints = tf.get_collection('checkpoints')
elif checkpoints == 'speed':
# checkpoint all expensive ops to maximize running speed
checkpoints = ge.filter_ts_from_regex(
fwd_ops, 'conv2d|Conv|MatMul')
elif checkpoints == 'memory':
# remove very small tensors and some weird ops
def fixdims(t): # tf.Dimension values are not compatible with int, convert manually
try:
return [int(e if e.value is not None else 64) for e in t]
except:
return [0] # unknown shape
ts_all = [t for t in ts_all if np.prod(
fixdims(t.shape)) > MIN_CHECKPOINT_NODE_SIZE]
ts_all = [t for t in ts_all if 'L2Loss' not in t.name]
ts_all = [t for t in ts_all if 'entropy' not in t.name]
ts_all = [t for t in ts_all if 'FusedBatchNorm' not in t.name]
ts_all = [t for t in ts_all if 'Switch' not in t.name]
ts_all = [t for t in ts_all if 'dropout' not in t.name]
# filter out all tensors that are inputs of the backward graph
with util.capture_ops() as bwd_ops:
tf_gradients(ys, xs, grad_ys, **kwargs)
bwd_inputs = [t for op in bwd_ops for t in op.inputs]
# list of tensors in forward graph that is in input to bwd graph
ts_filtered = list(set(bwd_inputs).intersection(ts_all))
debug_print("Using tensors %s", ts_filtered)
# try two slightly different ways of getting bottlenecks tensors
# to checkpoint
for ts in [ts_filtered, ts_all]:
# get all bottlenecks in the graph
bottleneck_ts = []
for t in ts:
b = set(ge.get_backward_walk_ops(
t.op, inclusive=True, within_ops=fwd_ops))
f = set(ge.get_forward_walk_ops(
t.op, inclusive=False, within_ops=fwd_ops))
# check that there are not shortcuts
b_inp = set(
[inp for op in b for inp in op.inputs]).intersection(ts_all)
f_inp = set(
[inp for op in f for inp in op.inputs]).intersection(ts_all)
if not set(b_inp).intersection(f_inp) and len(b_inp) + len(f_inp) >= len(ts_all):
bottleneck_ts.append(t) # we have a bottleneck!
else:
debug_print("Rejected bottleneck candidate and ops %s", [
t] + list(set(ts_all) - set(b_inp) - set(f_inp)))
# success? or try again without filtering?
if len(bottleneck_ts) >= np.sqrt(len(ts_filtered)): # yes, enough bottlenecks found!
break
if not bottleneck_ts:
raise Exception(
'unable to find bottleneck tensors! please provide checkpoint nodes manually, or use checkpoints="speed".')
# sort the bottlenecks
bottlenecks_sorted_lists = tf_toposort(
bottleneck_ts, within_ops=fwd_ops)
sorted_bottlenecks = [
t for ts in bottlenecks_sorted_lists for t in ts]
# save an approximately optimal number ~ sqrt(N)
N = len(ts_filtered)
if len(bottleneck_ts) <= np.ceil(np.sqrt(N)):
checkpoints = sorted_bottlenecks
else:
step = int(np.ceil(len(bottleneck_ts) / np.sqrt(N)))
checkpoints = sorted_bottlenecks[step::step]
else:
raise Exception(
'%s is unsupported input for "checkpoints"' % (checkpoints,))
checkpoints = list(set(checkpoints).intersection(ts_all))
# at this point automatic selection happened and checkpoints is list of nodes
assert isinstance(checkpoints, list)
debug_print("Checkpoint nodes used: %s", checkpoints)
# better error handling of special cases
# xs are already handled as checkpoint nodes, so no need to include them
xs_intersect_checkpoints = set(xs).intersection(set(checkpoints))
if xs_intersect_checkpoints:
debug_print("Warning, some input nodes are also checkpoint nodes: %s",
xs_intersect_checkpoints)
ys_intersect_checkpoints = set(ys).intersection(set(checkpoints))
debug_print("ys: %s, checkpoints: %s, intersect: %s", ys, checkpoints,
ys_intersect_checkpoints)
# saving an output node (ys) gives no benefit in memory while creating
# new edge cases, exclude them
if ys_intersect_checkpoints:
debug_print("Warning, some output nodes are also checkpoints nodes: %s",
format_ops(ys_intersect_checkpoints))
# remove initial and terminal nodes from checkpoints list if present
checkpoints = list(set(checkpoints) - set(ys) - set(xs))
# check that we have some nodes to checkpoint
if not checkpoints:
raise Exception('no checkpoints nodes found or given as input! ')
# disconnect dependencies between checkpointed tensors
checkpoints_disconnected = {}
for x in checkpoints:
if x.op and x.op.name is not None:
grad_node = tf.stop_gradient(x, name=x.op.name + "_sg")
else:
grad_node = tf.stop_gradient(x)
checkpoints_disconnected[x] = grad_node
# partial derivatives to the checkpointed tensors and xs
ops_to_copy = fast_backward_ops(seed_ops=[y.op for y in ys],
stop_at_ts=checkpoints, within_ops=fwd_ops)
debug_print("Found %s ops to copy within fwd_ops %s, seed %s, stop_at %s",
len(ops_to_copy), fwd_ops, [r.op for r in ys], checkpoints)
debug_print("ops_to_copy = %s", ops_to_copy)
debug_print("Processing list %s", ys)
copied_sgv, info = ge.copy_with_input_replacements(ge.sgv(ops_to_copy), {})
copied_ops = info._transformed_ops.values()
debug_print("Copied %s to %s", ops_to_copy, copied_ops)
ge.reroute_ts(checkpoints_disconnected.values(),
checkpoints_disconnected.keys(), can_modify=copied_ops)
debug_print("Rewired %s in place of %s restricted to %s",
checkpoints_disconnected.values(), checkpoints_disconnected.keys(), copied_ops)
# get gradients with respect to current boundary + original x's
copied_ys = [info._transformed_ops[y.op]._outputs[0] for y in ys]
boundary = list(checkpoints_disconnected.values())
dv = tf_gradients(ys=copied_ys, xs=boundary +
xs, grad_ys=grad_ys, **kwargs)
debug_print("Got gradients %s", dv)
debug_print("for %s", copied_ys)
debug_print("with respect to %s", boundary + xs)
inputs_to_do_before = [y.op for y in ys]
if grad_ys is not None:
inputs_to_do_before += grad_ys
wait_to_do_ops = list(copied_ops) + [g.op for g in dv if g is not None]
my_add_control_inputs(wait_to_do_ops, inputs_to_do_before)
# partial derivatives to the checkpointed nodes
# dictionary of "node: backprop" for nodes in the boundary
d_checkpoints = {r: dr for r, dr in zip(checkpoints_disconnected.keys(),
dv[:len(checkpoints_disconnected)])}
# partial derivatives to xs (usually the params of the neural net)
d_xs = dv[len(checkpoints_disconnected):]
# incorporate derivatives flowing through the checkpointed nodes
checkpoints_sorted_lists = tf_toposort(checkpoints, within_ops=fwd_ops)
for ts in checkpoints_sorted_lists[::-1]:
debug_print("Processing list %s", ts)
checkpoints_other = [r for r in checkpoints if r not in ts]
checkpoints_disconnected_other = [
checkpoints_disconnected[r] for r in checkpoints_other]
# copy part of the graph below current checkpoint node, stopping at
# other checkpoints nodes
ops_to_copy = fast_backward_ops(within_ops=fwd_ops, seed_ops=[
r.op for r in ts], stop_at_ts=checkpoints_other)
debug_print("Found %s ops to copy within %s, seed %s, stop_at %s",
len(ops_to_copy), fwd_ops, [r.op for r in ts],
checkpoints_other)
debug_print("ops_to_copy = %s", ops_to_copy)
if not ops_to_copy: # we're done!
break
copied_sgv, info = ge.copy_with_input_replacements(
ge.sgv(ops_to_copy), {})
copied_ops = info._transformed_ops.values()
debug_print("Copied %s to %s", ops_to_copy, copied_ops)
ge.reroute_ts(checkpoints_disconnected_other,
checkpoints_other, can_modify=copied_ops)
debug_print("Rewired %s in place of %s restricted to %s",
checkpoints_disconnected_other, checkpoints_other, copied_ops)
# gradient flowing through the checkpointed node
boundary = [info._transformed_ops[r.op]._outputs[0] for r in ts]
substitute_backprops = [d_checkpoints[r] for r in ts]
dv = tf_gradients(boundary,
checkpoints_disconnected_other + xs,
grad_ys=substitute_backprops, **kwargs)
debug_print("Got gradients %s", dv)
debug_print("for %s", boundary)
debug_print("with respect to %s", checkpoints_disconnected_other + xs)
debug_print("with boundary backprop substitutions %s",
substitute_backprops)
inputs_to_do_before = [d_checkpoints[r].op for r in ts]
wait_to_do_ops = list(copied_ops) + [g.op for g in dv if g is not None]
my_add_control_inputs(wait_to_do_ops, inputs_to_do_before)
# partial derivatives to the checkpointed nodes
for r, dr in zip(checkpoints_other, dv[:len(checkpoints_other)]):
if dr is not None:
if d_checkpoints[r] is None:
d_checkpoints[r] = dr
else:
d_checkpoints[r] += dr
# partial derivatives to xs (usually the params of the neural net)
d_xs_new = dv[len(checkpoints_other):]
for j in range(len(xs)):
if d_xs_new[j] is not None:
if d_xs[j] is None:
d_xs[j] = d_xs_new[j]
else:
d_xs[j] += d_xs_new[j]
return d_xs
def tf_toposort(ts, within_ops=None):
all_ops = ge.get_forward_walk_ops(
[x.op for x in ts], within_ops=within_ops)
deps = {}
for op in all_ops:
for o in op.outputs:
deps[o] = set(op.inputs)
sorted_ts = toposort(deps)
# only keep the tensors from our original list
ts_sorted_lists = []
for l in sorted_ts:
keep = list(set(l).intersection(ts))
if keep:
ts_sorted_lists.append(keep)
return ts_sorted_lists
def fast_backward_ops(within_ops, seed_ops, stop_at_ts):
bwd_ops = set(ge.get_backward_walk_ops(seed_ops, stop_at_ts=stop_at_ts))
ops = bwd_ops.intersection(within_ops).difference(
[t.op for t in stop_at_ts])
return list(ops)
@contextlib.contextmanager
def capture_ops():
"""Decorator to capture ops created in the block.
with capture_ops() as ops:
# create some ops
print(ops) # => prints ops created.
"""
micros = int(time.time() * 10**6)
scope_name = str(micros)
op_list = []
with tf.name_scope(scope_name):
yield op_list
g = tf.get_default_graph()
op_list.extend(ge.select_ops(scope_name + "/.*", graph=g))
def _to_op(tensor_or_op):
if hasattr(tensor_or_op, "op"):
return tensor_or_op.op
return tensor_or_op
def _to_ops(iterable):
if not _is_iterable(iterable):
return iterable
return [_to_op(i) for i in iterable]
def _is_iterable(o):
try:
_ = iter(o)
except Exception:
return False
return True
DEBUG_LOGGING = False
def debug_print(s, *args):
"""Like logger.log, but also replaces all TensorFlow ops/tensors with their
names. Sensitive to value of DEBUG_LOGGING, see enable_debug/disable_debug
Usage:
debug_print("see tensors %s for %s", tensorlist, [1,2,3])
"""
if DEBUG_LOGGING:
formatted_args = [format_ops(arg) for arg in args]
print("DEBUG " + s % tuple(formatted_args))
def format_ops(ops, sort_outputs=True):
"""Helper method for printing ops. Converts Tensor/Operation op to op.name,
rest to str(op)."""
if hasattr(ops, '__iter__') and not isinstance(ops, str):
l = [(op.name if hasattr(op, "name") else str(op)) for op in ops]
if sort_outputs:
return sorted(l)
return l
else:
return ops.name if hasattr(ops, "name") else str(ops)
def my_add_control_inputs(wait_to_do_ops, inputs_to_do_before):
for op in wait_to_do_ops:
ci = [i for i in inputs_to_do_before if op.control_inputs is None or i not in op.control_inputs]
ge.add_control_inputs(op, ci)
| [] |
2024-01-10 | princeton-nlp/SWE-bench | inference~run_live.py | """
This module contains functions for running a live inference session on a GitHub issue.
It clones the repository associated with the issue, builds a BM25 retrieval index, and
generates a prompt for the user to interact with the model. The output is saved to a
specified directory.
"""
import json
import shutil
import subprocess
from pathlib import Path
from ghapi.all import GhApi
import os
import re
import time
from datetime import datetime
from tqdm.auto import tqdm
from tempfile import TemporaryDirectory
from make_datasets.utils import ContextManager, string_to_bool, extract_diff, extract_minimal_patch
from make_datasets.bm25_retrieval import (
make_index,
clone_repo,
search,
DOCUMENT_ENCODING_FUNCTIONS,
)
from make_datasets.create_instance import (
PROMPT_FUNCTIONS,
TOKENIZER_FUNCS,
make_code_text,
ingest_files,
)
from run_model import call_chat, call_anthropic
import logging
from argparse import ArgumentParser
logging.basicConfig(
level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s"
)
logger = logging.getLogger(__name__)
def get_problem_statement(owner, repo, issue_num, ghapi, include_comments=False):
issue = ghapi.issues.get(owner, repo, issue_num)
issue_text = "\n".join([issue.title, issue.body])
# Solved issues may include comments that give answers away too much
if include_comments:
all_comments = list(ghapi.issues.list_comments(owner, repo, issue_num))
comments = [comment.body for comment in all_comments]
comment_text = "Comment: " if comments else "" + "\nComment:".join(comments)
issue_text += "\n" + comment_text
return issue_text
def get_readme_files(repo_path):
files = list(Path(repo_path).iterdir())
files = list(filter(lambda x: x.is_file(), files))
files = list(filter(lambda x: x.name.lower().startswith("readme"), files))
if files:
files = sorted(files, key=lambda x: len(x.name))
files = [files[0]]
return [Path(file).relative_to(repo_path).as_posix() for file in files]
def make_instance(
owner,
repo,
query,
commit,
root_dir,
token,
document_encoding_func,
python,
instance_id,
tokenizer,
tokenizer_func,
prompt_style,
max_context_len,
include_readmes,
):
"""
Creates an instance for a given query and repository.
Args:
owner (str): The owner of the repository.
repo (str): The name of the repository.
query (str): The query to search for.
commit (str): The commit hash to use.
root_dir (str): The root directory to clone the repository to.
token (str): The GitHub token to use for authentication.
document_encoding_func (function): The function to use for encoding documents.
python (str): The path to the Python executable.
instance_id (int): The ID of the instance.
tokenizer (str): The name of the tokenizer to use.
tokenizer_func (function): The function to use for tokenization.
prompt_style (str): The style of prompt to use.
max_context_len (int): The maximum length of the context.
include_readmes (bool): Whether to include README files in the instance.
Returns:
dict: The instance.
"""
thread_id = 0
instance = {"instance_id": instance_id, "problem_statement": query}
logger.info(f"Cloning repo {owner}/{repo}")
repo_dir = clone_repo(f"{owner}/{repo}", root_dir, token, False, thread_id)
if commit is None:
commit = subprocess.check_output(
["git", "rev-parse", "HEAD"], cwd=repo_dir
).decode("utf-8").strip()
logger.info(f"Buidling BM25 retrieval index for {owner}/{repo}@{commit}")
index_dir = make_index(
repo_dir,
root_dir,
commit,
document_encoding_func,
python,
thread_id,
instance_id,
)
results = search(instance, index_dir)
hits = results["hits"]
logger.info(f"Retrieved {len(hits)} documents")
with ContextManager(repo_dir, commit) as cm:
if include_readmes:
readmes = get_readme_files(cm.repo_path)
else:
readmes = list()
instance["readmes"] = ingest_files(readmes)
for hit in hits:
hit["file_contents"] = open(hit["docid"]).read()
instance["file_contents"] = dict()
base_text_inputs = PROMPT_FUNCTIONS[prompt_style](instance)
base_text_input_length = len(tokenizer_func(base_text_inputs, tokenizer))
instance["file_contents"] = {x["docid"]: x["file_contents"] for x in hits}
cur_input_len = base_text_input_length
include_files = list()
for filename in [x["docid"] for x in hits]:
content = make_code_text({filename: instance["file_contents"][filename]})
tokens = tokenizer_func(content, tokenizer)
if cur_input_len + len(tokens) < max_context_len:
include_files.append(filename)
cur_input_len += len(tokens)
logger.info(
f"Including {len(include_files)} files in context with {cur_input_len} tokens:\n"
+ "\n\t".join(sorted(include_files))
)
instance["file_contents"] = {
filename: instance["file_contents"][filename] for filename in include_files
}
instance["text_inputs"] = PROMPT_FUNCTIONS[prompt_style](instance)
return instance
def parse_issue_url(issue_url):
issue_pat = re.compile(r"github\.com\/(.+?)\/(.+?)\/issues\/(\d+)")
match = issue_pat.search(issue_url)
if not match:
raise ValueError(
(
f"issue_url ({issue_url}) does not seem to be a valid issue url."
+ "\nPlease use url like https://github.com/owner/repo/issues/12345"
)
)
owner, repo, issue_num = match.groups()
return owner, repo, issue_num
def main(
model_name,
prompt_style,
issue_url,
base_commit,
max_context_length,
document_encoding_func,
output_dir,
root_dir,
include_readmes,
):
if base_commit is not None and len(issue_url) != len(base_commit):
raise ValueError(
f"Must provide either no base commits or one base commit per issue url"
)
if base_commit is None:
base_commit = [None] * len(issue_url)
gh_token = os.environ.get("GITHUB_TOKEN", None)
if gh_token is not None:
logger.warning(f'Using GitHub token: {"*" * 8}{gh_token[-4:]}')
gh = GhApi(token=gh_token)
tokenizer, tokenizer_func = TOKENIZER_FUNCS["cl100k"]
document_encoding_func = DOCUMENT_ENCODING_FUNCTIONS[document_encoding_func]
python = subprocess.check_output(["which", "python"]).decode("utf-8").strip()
outputs = list()
for issue, commit in tqdm(zip(issue_url, base_commit), total=len(issue_url)):
owner, repo, issue_num = parse_issue_url(issue)
problem_statement = get_problem_statement(owner, repo, int(issue_num), gh)
instance_id = f"{owner}__{repo}-{issue_num}"
logger.info(f"Creating instance {instance_id}")
instance = make_instance(
owner,
repo,
problem_statement,
commit,
root_dir,
gh_token,
document_encoding_func,
python,
instance_id,
tokenizer,
tokenizer_func,
prompt_style,
max_context_length,
include_readmes,
)
logger.info(f"Calling model {model_name}")
start = time.time()
if model_name.startswith("gpt"):
import openai
openai.api_key = os.environ.get("OPENAI_API_KEY", None)
inputs = instance["text_inputs"]
response, _ = call_chat(
model_name, inputs, use_azure=False, temperature=0, top_p=1
)
completion = response.choices[0]["message"]["content"]
logger.info(f'Generated {response.usage.completion_tokens} tokens in {(time.time() - start):.2f} seconds')
else:
from anthropic import Anthropic
api_key = os.environ.get("ANTHROPIC_API_KEY", None)
anthropic = Anthropic(api_key=api_key)
response = call_anthropic(
inputs, anthropic, model_name, temperature=0, top_p=1
)
completion = response.completion
model_patch = extract_diff(completion)
minimal_patch = extract_minimal_patch(model_patch)
outputs.append(
{
"instance_id": instance_id,
"response": completion,
"problem_statement": problem_statement,
"text_inputs": inputs,
"model_patch": model_patch,
"minimal_patch": minimal_patch,
}
)
os.makedirs(output_dir, exist_ok=True)
output_file = Path(
output_dir,
f'{model_name}__{prompt_style}__{datetime.now().strftime("%Y-%m-%d_%H-%M-%S")}.jsonl',
)
with open(output_file, "+a") as f:
for output in outputs:
print(json.dumps(output), file=f, flush=True)
logger.info(f"Wrote output to {output_file}")
if __name__ == "__main__":
parser = ArgumentParser()
parser.add_argument("--model_name", type=str)
parser.add_argument(
"--prompt_style", type=str, choices=PROMPT_FUNCTIONS.keys(), default="style-3"
)
parser.add_argument("--issue_url", type=str, nargs="+")
parser.add_argument("--base_commit", type=str, nargs="+")
parser.add_argument("--max_context_length", type=int, default=16_000)
parser.add_argument(
"--document_encoding_func",
type=str,
choices=DOCUMENT_ENCODING_FUNCTIONS.keys(),
default="file_name_and_contents",
)
parser.add_argument("--output_dir", type=str, default="./live_outputs")
parser.add_argument("--root_dir", type=str, default="./run_live_data")
parser.add_argument("--include_readmes", type=string_to_bool, default=False)
args = parser.parse_args()
main(**vars(args))
| [] |
2024-01-10 | princeton-nlp/SWE-bench | inference~run_api.py | import json
import os
import time
import dotenv
import traceback
from pathlib import Path
from tqdm.auto import tqdm
import numpy as np
import openai
import tiktoken
from anthropic import HUMAN_PROMPT, AI_PROMPT, Anthropic
from tenacity import (
retry,
stop_after_attempt,
wait_random_exponential,
)
from datasets import load_dataset, load_from_disk
from make_datasets.utils import extract_diff
from argparse import ArgumentParser
import logging
logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
logger = logging.getLogger(__name__)
dotenv.load_dotenv()
MODEL_LIMITS = {
"claude-instant-1": 100_000,
"claude-2": 100_000,
"gpt-3.5-turbo-16k-0613": 16_385,
"gpt-3.5-turbo-0613": 4_097,
"gpt-3.5-turbo-1106": 16_385,
"gpt-4-32k-0613": 32_768,
"gpt-4-0613": 8_192,
"gpt-4-1106-preview": 128_000,
}
# The cost per token for each model input.
MODEL_COST_PER_INPUT = {
"claude-instant-1": 0.00000163,
"claude-2": 0.00001102,
"gpt-3.5-turbo-16k-0613": 0.0000015,
"gpt-3.5-turbo-0613": 0.0000015,
"gpt-3.5-turbo-1106": 0.000001,
"gpt-35-turbo-0613": 0.0000015,
"gpt-35-turbo": 0.0000015, # probably still 0613
"gpt-4-0613": 0.00003,
"gpt-4-32k-0613": 0.00006,
"gpt-4-1106-preview": 0.00001,
}
# The cost per token for each model output.
MODEL_COST_PER_OUTPUT = {
"claude-instant-1": 0.00000551,
"claude-2": 0.00003268,
"gpt-3.5-turbo-16k-0613": 0.000002,
"gpt-3.5-turbo-16k": 0.000002,
"gpt-3.5-turbo-1106": 0.000002,
"gpt-35-turbo-0613": 0.000002,
"gpt-35-turbo": 0.000002,
"gpt-4-0613": 0.00006,
"gpt-4-32k-0613": 0.00012,
"gpt-4-32k": 0.00012,
"gpt-4-1106-preview": 0.00003,
}
# used for azure
ENGINES = {
"gpt-3.5-turbo-16k-0613": "gpt-35-turbo-16k",
"gpt-4-0613": "gpt-4",
"gpt-4-32k-0613": "gpt-4-32k",
}
def calc_cost(model_name, input_tokens, output_tokens):
"""
Calculates the cost of a response from the openai API.
Args:
response (openai.ChatCompletion): The response from the API.
Returns:
float: The cost of the response.
"""
cost = (
MODEL_COST_PER_INPUT[model_name] * input_tokens
+ MODEL_COST_PER_OUTPUT[model_name] * output_tokens
)
logger.info(
f"input_tokens={input_tokens}, output_tokens={output_tokens}, cost={cost:.2f}"
)
return cost
@retry(wait=wait_random_exponential(min=30, max=600), stop=stop_after_attempt(3))
def call_chat(model_name_or_path, inputs, use_azure, temperature, top_p, **model_args):
"""
Calls the openai API to generate completions for the given inputs.
Args:
model_name_or_path (str): The name or path of the model to use.
inputs (str): The inputs to generate completions for.
use_azure (bool): Whether to use the azure API.
temperature (float): The temperature to use.
top_p (float): The top_p to use.
**model_args (dict): A dictionary of model arguments.
"""
system_messages = inputs.split("\n", 1)[0]
user_message = inputs.split("\n", 1)[1]
try:
if use_azure:
response = openai.ChatCompletion.create(
engine=ENGINES[model_name_or_path] if use_azure else None,
messages=[
{"role": "system", "content": system_messages},
{"role": "user", "content": user_message},
],
temperature=temperature,
top_p=top_p,
**model_args,
)
else:
response = openai.ChatCompletion.create(
model=model_name_or_path,
messages=[
{"role": "system", "content": system_messages},
{"role": "user", "content": user_message},
],
temperature=temperature,
top_p=top_p,
**model_args,
)
input_tokens = response.usage.prompt_tokens
output_tokens = response.usage.completion_tokens
cost = calc_cost(response.model, input_tokens, output_tokens)
return response, cost
except openai.error.InvalidRequestError as e:
if e.code == "context_length_exceeded":
print("Context length exceeded")
return None
raise e
def gpt_tokenize(string: str, encoding) -> int:
"""Returns the number of tokens in a text string."""
num_tokens = len(encoding.encode(string))
return num_tokens
def claude_tokenize(string: str, api) -> int:
"""Returns the number of tokens in a text string."""
num_tokens = api.count_tokens(string)
return num_tokens
def openai_inference(
test_dataset,
model_name_or_path,
output_file,
model_args,
existing_ids,
max_cost,
):
"""
Runs inference on a dataset using the openai API.
Args:
test_dataset (datasets.Dataset): The dataset to run inference on.
model_name_or_path (str): The name or path of the model to use.
output_file (str): The path to the output file.
model_args (dict): A dictionary of model arguments.
existing_ids (set): A set of ids that have already been processed.
max_cost (float): The maximum cost to spend on inference.
"""
encoding = tiktoken.encoding_for_model(model_name_or_path)
test_dataset = test_dataset.filter(
lambda x: gpt_tokenize(x["text"], encoding) <= MODEL_LIMITS[model_name_or_path],
desc="Filtering",
load_from_cache_file=False,
)
openai_key = os.environ.get("OPENAI_API_KEY", None)
if openai_key is None:
raise ValueError(
"Must provide an api key. Expected in OPENAI_API_KEY environment variable."
)
openai.api_key = openai_key
print(f"Using OpenAI key {'*' * max(0, len(openai_key)-5) + openai_key[-5:]}")
use_azure = model_args.pop("use_azure", False)
if use_azure:
openai.api_type = "azure"
openai.api_base = "https://pnlpopenai3.openai.azure.com/"
openai.api_version = "2023-05-15"
temperature = model_args.pop("temperature", 0.2)
top_p = model_args.pop("top_p", 0.95 if temperature > 0 else 1)
print(f"Using temperature={temperature}, top_p={top_p}")
basic_args = {
"model_name_or_path": model_name_or_path,
}
total_cost = 0
print(f"Filtered to {len(test_dataset)} instances")
with open(output_file, "a+") as f:
for datum in tqdm(test_dataset, desc=f"Inference for {model_name_or_path}"):
instance_id = datum["instance_id"]
if instance_id in existing_ids:
continue
output_dict = {"instance_id": instance_id}
output_dict.update(basic_args)
output_dict["text"] = f"{datum['text']}\n\n"
response, cost = call_chat(
output_dict["model_name_or_path"],
output_dict["text"],
use_azure,
temperature,
top_p,
)
completion = response.choices[0]["message"]["content"]
total_cost += cost
print(f"Total Cost: {total_cost:.2f}")
output_dict["full_output"] = completion
output_dict["model_patch"] = extract_diff(completion)
print(json.dumps(output_dict), file=f, flush=True)
if max_cost is not None and total_cost >= max_cost:
print(f"Reached max cost {max_cost}, exiting")
break
@retry(wait=wait_random_exponential(min=60, max=600), stop=stop_after_attempt(6))
def call_anthropic(
inputs, anthropic, model_name_or_path, temperature, top_p, **model_args
):
"""
Calls the anthropic API to generate completions for the given inputs.
Args:
inputs (str): The inputs to generate completions for.
anthropic (Anthropic): The anthropic API object.
model_name_or_path (str): The name or path of the model to use.
temperature (float): The temperature to use.
top_p (float): The top_p to use.
model_args (dict): A dictionary of model arguments.
"""
try:
completion = anthropic.completions.create(
model=model_name_or_path,
max_tokens_to_sample=6000,
prompt=inputs,
temperature=temperature,
top_p=top_p,
**model_args,
)
response = completion.completion
input_tokens = anthropic.count_tokens(inputs)
output_tokens = anthropic.count_tokens(response)
cost = calc_cost(model_name_or_path, input_tokens, output_tokens)
return completion, cost
except Exception as e:
logger.error(e)
logger.error(f"Inputs: {inputs}")
traceback.print_exc()
time.sleep(20)
return None
def anthropic_inference(
test_dataset,
model_name_or_path,
output_file,
model_args,
existing_ids,
max_cost,
):
"""
Runs inference on a dataset using the anthropic API.
Args:
test_dataset (datasets.Dataset): The dataset to run inference on.
model_name_or_path (str): The name or path of the model to use.
output_file (str): The path to the output file.
model_args (dict): A dictionary of model arguments.
existing_ids (set): A set of ids that have already been processed.
max_cost (float): The maximum cost to spend on inference.
"""
api_key = os.environ.get("ANTHROPIC_API_KEY", None)
if api_key is None:
raise ValueError(
"Must provide an api key. Expected in ANTHROPIC_API_KEY environment variable."
)
print(f"Using Anthropic key {'*' * max(0, len(api_key)-5) + api_key[-5:]}")
anthropic = Anthropic(api_key=api_key)
test_dataset = test_dataset.filter(
lambda x: claude_tokenize(x["text"], anthropic)
<= MODEL_LIMITS[model_name_or_path],
desc="Filtering",
load_from_cache_file=False,
)
temperature = model_args.pop("temperature", 0.2)
top_p = model_args.pop("top_p", 0.95 if temperature > 0 else 1)
print(f"Using temperature={temperature}, top_p={top_p}")
basic_args = {
"model_name_or_path": model_name_or_path,
}
total_cost = 0
print(f"Filtered to {len(test_dataset)} instances")
with open(output_file, "a+") as f:
for datum in tqdm(test_dataset, desc=f"Inference for {model_name_or_path}"):
instance_id = datum["instance_id"]
if instance_id in existing_ids:
continue
output_dict = {"instance_id": instance_id}
output_dict.update(basic_args)
output_dict[
"text_inputs"
] = f"{HUMAN_PROMPT} {datum['text']}\n\n{AI_PROMPT}"
completion, cost = call_anthropic(
output_dict["text_inputs"],
anthropic,
model_name_or_path,
temperature,
top_p,
**model_args,
)
total_cost += cost
print(f"Total Cost: {total_cost:.2f}")
output_dict["full_output"] = completion.completion
output_dict["model_patch"] = extract_diff(completion.completion)
print(json.dumps(output_dict), file=f, flush=True)
if max_cost is not None and total_cost >= max_cost:
print(f"Reached max cost {max_cost}, exiting")
break
def parse_model_args(model_args):
"""
Parses a string of model arguments and returns a dictionary of keyword arguments.
Args:
model_args (str): A string of comma-separated key-value pairs representing model arguments.
Returns:
dict: A dictionary of keyword arguments parsed from the input string.
"""
kwargs = dict()
if model_args is not None:
for arg in model_args.split(","):
key, value = arg.split("=")
# infer value type
if value in {"True", "False"}:
kwargs[key] = value == "True"
elif value.isnumeric():
kwargs[key] = int(value)
elif value.replace(".", "", 1).isnumeric():
kwargs[key] = float(value)
elif value in {"None"}:
kwargs[key] = None
elif value in {"[]"}:
kwargs[key] = []
elif value in {"{}"}:
kwargs[key] = {}
elif value.startswith("'") and value.endswith("'"):
kwargs[key] = value[1:-1]
elif value.startswith('"') and value.endswith('"'):
kwargs[key] = value[1:-1]
else:
kwargs[key] = value
return kwargs
def main(
dataset_name_or_path,
split,
model_name_or_path,
shard_id,
num_shards,
output_dir,
model_args,
max_cost,
):
if shard_id is None and num_shards is not None:
logger.warning(
f"Received num_shards={num_shards} but shard_id is None, ignoring"
)
if shard_id is not None and num_shards is None:
logger.warning(f"Received shard_id={shard_id} but num_shards is None, ignoring")
model_args = parse_model_args(model_args)
model_nickname = model_name_or_path
if "checkpoint" in Path(model_name_or_path).name:
model_nickname = Path(model_name_or_path).parent.name
else:
model_nickname = Path(model_name_or_path).name
output_file = f"{model_nickname}__{dataset_name_or_path.split('/')[-1]}__{split}"
if shard_id is not None and num_shards is not None:
output_file += f"__shard-{shard_id}__num_shards-{num_shards}"
output_file = Path(output_dir, output_file + ".jsonl")
logger.info(f"Will write to {output_file}")
existing_ids = set()
if os.path.exists(output_file):
with open(output_file, "r") as f:
for line in f:
data = json.loads(line)
instance_id = data["instance_id"]
existing_ids.add(instance_id)
logger.info(f"Read {len(existing_ids)} already completed ids from {output_file}")
if Path(dataset_name_or_path).exists():
dataset = load_from_disk(dataset_name_or_path)
else:
dataset = load_dataset(dataset_name_or_path)
if not split in dataset:
raise ValueError(f"Invalid split {split} for dataset {dataset_name_or_path}")
dataset = dataset[split]
lens = np.array(list(map(len, dataset["text"])))
dataset = dataset.select(np.argsort(lens))
if len(existing_ids) > 0:
dataset = dataset.filter(
lambda x: x["instance_id"] not in existing_ids,
desc="Filtering out existing ids",
load_from_cache_file=False,
)
if shard_id is not None and num_shards is not None:
dataset = dataset.shard(num_shards, shard_id, contiguous=True)
inference_args = {
"test_dataset": dataset,
"model_name_or_path": model_name_or_path,
"output_file": output_file,
"model_args": model_args,
"existing_ids": existing_ids,
"max_cost": max_cost,
}
if model_name_or_path.startswith("claude"):
anthropic_inference(**inference_args)
elif model_name_or_path.startswith("gpt"):
openai_inference(**inference_args)
else:
raise ValueError(f"Invalid model name or path {model_name_or_path}")
logger.info(f"Done!")
if __name__ == "__main__":
parser = ArgumentParser()
parser.add_argument(
"--dataset_name_or_path",
type=str,
required=True,
help="HuggingFace dataset name or local path",
)
parser.add_argument(
"--split",
type=str,
default="test",
help="Dataset split to use",
)
parser.add_argument(
"--model_name_or_path",
type=str,
help="Name of API model. Update MODEL* constants in this file to add new models.",
choices=sorted(list(MODEL_LIMITS.keys())),
)
parser.add_argument(
"--shard_id",
type=int,
default=None,
help="Shard id to process. If None, process all shards.",
)
parser.add_argument(
"--num_shards",
type=int,
default=None,
help="Number of shards. If None, process all shards.",
)
parser.add_argument(
"--output_dir",
type=str,
default=None,
required=True,
help="Path to the output file.",
)
parser.add_argument(
"--model_args",
type=str,
default=None,
help="List of model arguments separated by commas. (e.g. 'top_p=0.95,temperature=0.70')",
)
parser.add_argument(
"--max_cost",
type=float,
default=None,
help="Maximum cost to spend on inference.",
)
args = parser.parse_args()
main(**vars(args))
| [] |
2024-01-10 | animeshbhatt651/ChatGPT_v1 | animesh.py | import os
import openai
import gradio as gr
openai.api_key = "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"
start_sequence = "\nAI:"
restart_sequence = "\nHuman: "
prompt = "The following is a conversation with an AI assistant. The assistant is helpful, creative, clever, and very friendly.\n\nHuman: Hello, who are you?\nAI: I am an AI created by OpenAI. How can I help you today?\nHuman: "
def openai_create(prompt):
response = openai.Completion.create(
model="text-davinci-003",
prompt=prompt,
temperature=0.9,
max_tokens=150,
top_p=1,
frequency_penalty=0,
presence_penalty=0.6,
stop=[" Human:", " AI:"]
)
return response.choices[0].text
def chatgpt_clone(input, history):
history = history or []
s = list(sum(history, ()))
s.append(input)
inp = ' '.join(s)
output = openai_create(inp)
history.append((input, output))
return history, history
block = gr.Blocks()
with block:
gr.Markdown("""<h1><center>Ask Animesh (chatGPT clone1)</center></h1>
""")
chatbot = gr.Chatbot()
message = gr.Textbox(placeholder=prompt)
state = gr.State()
submit = gr.Button("SEND")
submit.click(chatgpt_clone, inputs=[message, state], outputs=[chatbot, state])
block.launch(debug = True)
| [
"The following is a conversation with an AI assistant. The assistant is helpful, creative, clever, and very friendly.\n\nHuman: Hello, who are you?\nAI: I am an AI created by OpenAI. How can I help you today?\nHuman: "
] |
2024-01-10 | Sheudz/OpenAI-BOT | src~openai_bot~cogs~ai_bot.py | import disnake
from disnake.ext import commands
from datetime import timedelta
from os import getenv
from time import time
from re import sub
import openai
role_ban: int = 1054109349628358817
role_admin: int = 1054002956493664268
role_newbie: int = 973871427788873748
role_constant: int = 974602932265811988
role_old: int = 973718824174092288
role_eternalold: int = 1044959103316918354
role_pseudoowner: int = 1044959814096269312
channel_gpt: int = 1054106565663264809
class AiBot(commands.Cog):
def __init__(self, bot: commands.InteractionBot):
self.bot = bot
openai.api_key = getenv("OPENAI_API_KEY")
@commands.user_command(name="Block")
async def member_block_user(
self, inter: disnake.UserCommandInteraction, member: disnake.Member
) -> None:
if isinstance(inter.author, disnake.Member):
roles: list[int] = [role.id for role in inter.author.roles]
if role_admin in roles:
target_roles: list[int] = [role.id for role in member.roles]
if role_admin not in target_roles:
try:
if isinstance(inter.guild, disnake.Guild):
await member.add_roles(inter.guild.get_role(role_ban))
await inter.response.send_message(
f"{member.mention}/{member.name} заблокований",
ephemeral=True,
)
except Exception:
await inter.response.send_message(
f"{member.mention}/{member.name} не був заблокований",
ephemeral=True,
)
else:
raise commands.CommandError(
"Адміністратори не можуть блокувати інших адміністраторів"
)
else:
raise commands.MissingRole(role_admin)
@commands.user_command(name="Unblock")
async def member_unblock_user(
self, inter: disnake.UserCommandInteraction, member: disnake.Member
) -> None:
if isinstance(inter.author, disnake.Member):
roles: list[int] = [role.id for role in inter.author.roles]
if role_admin in roles:
target_roles: list[int] = [role.id for role in member.roles]
if role_admin not in target_roles:
try:
if isinstance(inter.guild, disnake.Guild):
await member.remove_roles(inter.guild.get_role(role_ban))
await inter.response.send_message(
f"{member.mention}/{member.name} разблокований",
ephemeral=True,
)
except Exception:
await inter.response.send_message(
f"{member.mention}/{member.name} не був заблокований",
ephemeral=True,
)
else:
raise commands.CommandError(
"Адміністратори не можуть розблоковувати інших адміністраторів"
)
else:
raise commands.MissingRole(role_admin)
@commands.Cog.listener()
async def on_message(self, message: disnake.Message) -> None:
if message.channel.id == channel_gpt:
if message.author.id != self.bot.user.id:
if f"<@{self.bot.user.id}>" == message.content[:21]:
await message.channel.trigger_typing()
response = await openai.ChatCompletion.acreate(
model="gpt-3.5-turbo",
messages=[
{
"role": "system",
"content": "You are a discord bot powered by ChatGPT",
},
{"role": "user", "content": message.content[21:]},
],
max_tokens=3000,
)
msg: str = sub(
r"\[.*]\((.*)\)", r"\1", response.choices[0].message.content
)
if len(msg) > 2000:
msg_chunks: list[str] = [
msg[i : i + 2000] for i in range(0, len(msg), 2000)
]
for chunk in msg_chunks:
await message.reply(chunk)
else:
await message.reply(msg)
@commands.slash_command(
name="ask", description="ask different OpenAI models a question"
)
async def ask_group(self, inter: disnake.ApplicationCommandInteraction) -> None:
pass
@ask_group.sub_command(name="babbage", description="ask babbage model a question")
@commands.cooldown(1, 30, commands.BucketType.user)
async def ask_babbage(
self, inter: disnake.ApplicationCommandInteraction, prompt: str
) -> None:
if isinstance(inter.author, disnake.Member):
if role_ban in [role.id for role in inter.author.roles]:
await inter.response.send_message(
f"Тобі не доступний {self.bot.user.name}", ephemeral=True
)
elif inter.channel.id != channel_gpt:
await inter.response.send_message(
"Я можу відповідати на ваші запитання лише у каналі #gpt-chat",
ephemeral=True,
)
else:
await inter.response.defer(ephemeral=True)
try:
computation_start: float = time()
response = await openai.Completion.acreate(
engine="text-babbage-001",
prompt=prompt,
temperature=0.4,
max_tokens=1024,
top_p=0.1,
frequency_penalty=0.1,
presence_penalty=0.1,
)
elapsedtime = int(round(time() - computation_start))
embed = disnake.Embed(
title="Відповідь:",
description=response["choices"][0]["text"],
color=0x5258BD,
)
embed.add_field(name="Запитання:", value=prompt, inline=False)
embed.set_footer(
text=f"обробка зайняла {str(timedelta(seconds=elapsedtime))}"
)
await inter.followup.send(embed=embed)
except Exception as errmsg:
await inter.followup.send(f"{errmsg}")
@ask_group.sub_command(name="curie", description="ask curie model a question")
@commands.cooldown(1, 30, commands.BucketType.user)
async def ask_curie(
self, inter: disnake.ApplicationCommandInteraction, prompt: str
) -> None:
if isinstance(inter.author, disnake.Member):
roles: list[int] = [role.id for role in inter.author.roles]
if role_ban in roles:
await inter.response.send_message(
f"Тобі не доступний {self.bot.user.name}", ephemeral=True
)
elif (
role_newbie not in roles
and role_constant not in roles
and role_old not in roles
and role_eternalold not in roles
and role_pseudoowner not in roles
):
raise commands.MissingRole(role_newbie)
elif inter.channel.id != channel_gpt:
await inter.response.send_message(
"Я можу відповідати на ваші запитання лише у каналі #gpt-chat",
ephemeral=True,
)
else:
await inter.response.defer(ephemeral=True)
try:
computation_start: float = time()
response = await openai.Completion.acreate(
engine="text-curie-001",
prompt=prompt,
temperature=0.4,
max_tokens=1024,
top_p=0.1,
frequency_penalty=0.1,
presence_penalty=0.1,
)
elapsedtime = int(round(time() - computation_start))
embed = disnake.Embed(
title="Відповідь:",
description=response["choices"][0]["text"],
color=0x5258BD,
)
embed.add_field(name="Запитання:", value=prompt, inline=False)
embed.set_footer(
text=f"обробка зайняла {str(timedelta(seconds=elapsedtime))}"
)
await inter.followup.send(embed=embed)
except Exception as errmsg:
await inter.followup.send(f"{errmsg}")
@ask_group.sub_command(name="davinci", description="ask davinci model a question")
@commands.cooldown(1, 30, commands.BucketType.user)
async def ask_davinci(
self, inter: disnake.ApplicationCommandInteraction, prompt: str
) -> None:
if isinstance(inter.author, disnake.Member):
roles: list[int] = [role.id for role in inter.author.roles]
if role_ban in roles:
await inter.response.send_message(
f"Тобі не доступний {self.bot.user.name}", ephemeral=True
)
elif (
role_constant not in roles
and role_old not in roles
and role_eternalold not in roles
and role_pseudoowner not in roles
):
raise commands.MissingRole(role_constant)
elif inter.channel.id != channel_gpt:
await inter.response.send_message(
"Я можу відповідати на ваші запитання лише у каналі #gpt-chat",
ephemeral=True,
)
else:
await inter.response.defer(ephemeral=True)
try:
computation_start: float = time()
response = await openai.Completion.acreate(
engine="text-davinci-003",
prompt=prompt,
temperature=0.4,
max_tokens=1024,
top_p=0.1,
frequency_penalty=0.1,
presence_penalty=0.1,
)
elapsedtime = int(round(time() - computation_start))
embed = disnake.Embed(
title="Відповідь:",
description=response["choices"][0]["text"],
color=0x5258BD,
)
embed.add_field(name="Запитання:", value=prompt, inline=False)
embed.set_footer(
text=f"обробка зайняла {str(timedelta(seconds=elapsedtime))}"
)
await inter.followup.send(embed=embed)
except Exception as errmsg:
await inter.followup.send(f"{errmsg}")
@commands.slash_command(name="image", description="image generation commands")
async def image_group(self, inter: disnake.ApplicationCommandInteraction) -> None:
pass
@image_group.sub_command(name="generate", description="generate image")
@commands.cooldown(1, 70, commands.BucketType.user)
async def image_generate(
self, inter: disnake.ApplicationCommandInteraction, prompt: str
) -> None:
if isinstance(inter.author, disnake.Member):
roles: list[int] = [role.id for role in inter.author.roles]
if role_ban in roles:
await inter.response.send_message(
f"Тобі не доступний {self.bot.user.name}", ephemeral=True
)
elif (
role_newbie not in roles
and role_constant not in roles
and role_old not in roles
and role_eternalold not in roles
and role_pseudoowner not in roles
):
raise commands.MissingRole(role_newbie)
elif inter.channel.id != channel_gpt:
await inter.response.send_message(
"Я можу відповідати на ваші запитання лише у каналі #gpt-chat",
ephemeral=True,
)
else:
await inter.response.defer(ephemeral=True)
try:
computation_start: float = time()
response = await openai.Image.acreate(prompt=prompt, n=1, size="1024x1024")
image_url = response["data"][0]["url"]
elapsedtime = int(round(time() - computation_start))
embed = disnake.Embed(
title="Згенероване зображення: " + prompt, color=0x5258BD
)
embed.set_image(url=image_url)
embed.set_footer(
text=f"обробка зайняла {str(timedelta(seconds=elapsedtime))}"
)
await inter.followup.send(embed=embed)
except Exception as errmsg:
await inter.followup.send(f"{errmsg}")
def setup(bot: commands.InteractionBot) -> None:
bot.add_cog(AiBot(bot))
| [
"You are a discord bot powered by ChatGPT"
] |
2024-01-10 | kairess/Maybejourney | Imagine.py | import streamlit as st
from streamlit_pills import pills
from streamlit_extras.badges import badge
import openai
import pymysql.cursors
import time
import uuid
import re
from Sender import Sender
from Receiver import Receiver
from footer import footer
from helpers import *
from prompt_template import *
# Config
st.set_page_config(page_title="Maybejourney - YouTube 빵형의 개발도상국", page_icon="🎨")
@st.cache_data
def load_config():
config = {
"authorization": st.secrets["authorization"],
"application_id": st.secrets["application_id"],
"guild_id": st.secrets["guild_id"],
"channel_id": st.secrets["channel_id"],
"session_id": st.secrets["session_id"],
"version": st.secrets["version"],
"id": st.secrets["id"],
"openai_api_key": st.secrets["openai_api_key"],
}
return config
config = load_config()
openai.api_key = config["openai_api_key"]
if "user_id" not in st.session_state:
st.session_state["user_id"] = str(uuid.uuid4())
print("[*] user_id", st.session_state["user_id"])
if "latest_id" not in st.session_state:
st.session_state["latest_id"] = None
if "history" not in st.session_state:
st.session_state["history"] = ""
if "page" not in st.session_state:
st.session_state["page"] = 0
if "done" not in st.session_state:
st.session_state["done"] = False
st.session_state["page"] = 0
st.session_state["done"] = False
@st.cache_resource
def load_resources(user_id):
con = pymysql.connect(
host=st.secrets["db_host"],
user=st.secrets["db_username"],
password=st.secrets["db_password"],
database='maybejourney',
cursorclass=pymysql.cursors.DictCursor)
return con, Sender(config=config), Receiver(config, "images", user_id, con)
con, sender, receiver = load_resources(st.session_state["user_id"])
# UI
st.header("Maybejourney v1.3")
with st.expander("📝Update"):
c1, c2, c3 = st.columns(3)
with c1:
badge(type="github", name="kairess/Maybejourney")
with c2:
badge(type="buymeacoffee", name="bbanghyong")
with c3:
st.markdown("❤️[서버 비용 후원하기](https://lnk.bio/kairess)")
st.markdown("""
- v1.3 :: May 20, 2023
- Add `Describe` function
- v1.2 :: May 17, 2023
- Add `upsample` and `variation` of generated images
- v1.1 :: May 15, 2023
- Replace sqlite3 to MariaDB on AWS (Support me a beer)
- Show 1 image per a shot
- With `DALL-E`
- v1.0 :: May 14, 2023
- Launch🚀
""")
def like():
st.session_state["input"] = ""
latest_id = st.session_state["latest_id"]
if not latest_id:
return False
con.ping()
with con:
with con.cursor() as cur:
cur.execute("update prompts set is_liked = %s where id = %s and is_downloaded = 1", (1, latest_id))
con.commit()
# Sidebar
with st.sidebar:
with st.form("parameters-form"):
st.subheader("Parameters")
model = pills("🤖 Model", ["Midjourney", "Niji"])
mid_style = pills("⭐️ Style (Only for Midjourney)", [None, "Raw"])
niji_style = pills("💊 Style (Only for Niji)", [None, "Cute", "Expressive", "Scenic"])
ar = pills("🖼 Aspect Ratio", ["3:4", "4:5", "9:16", "1:1", "16:9", "5:4", "4:3"])
stylize = st.slider("🧂 Stylize", 0, 1000, 100, 50)
quality = st.slider("🎨 Quality", .25, 2., 1., .25)
seed = st.number_input("⚙️ Seed", -1, 4294967295, -1)
tile = st.checkbox("Tile", False)
creative = pills("Creative (Only for Midjourney)", [None, "test", "testp"])
submit = st.form_submit_button("Apply")
with st.container():
st.subheader("History")
history = st.empty().markdown("- Empty")
# Prompt
with st.form("prompt-form"):
st.info("프롬프트 맨 앞에 / 를 붙여 ChatGPT에게 프롬프트를 생성하게 할 수 있습니다!", icon="🤖")
prompt = st.text_area("Prompt", placeholder="Draw your imagination or use / to ask ChatGPT to generate prompts.", key="input")
dalle = st.checkbox("with DALL-E")
submit_prompt = st.form_submit_button("Submit")
prompt_helper = st.empty()
progress_bar = st.empty()
result_image = st.empty()
full_prompt_caption = st.empty()
dalle_result_image = st.empty()
dalle_prompt_caption = st.empty()
footer(*footer_content)
# Function
if submit_prompt and prompt.strip():
prompt = prompt.strip()
if prompt.startswith("/"):
new_gpt_prompt = gpt_prompt.copy()
new_gpt_prompt.append({
"role": "user",
"content": prompt[1:]
})
response = openai.ChatCompletion.create(
model="gpt-3.5-turbo",
messages=new_gpt_prompt,
stream=True)
collected_messages = []
for chunk in response:
chunk_message = chunk['choices'][0]['delta']
if "content" in chunk_message:
collected_messages.append(chunk_message["content"])
gpt_response = ''.join(collected_messages)
prompt_helper.markdown(f"🤖 {gpt_response}")
prompt = "".join([c for c in collected_messages])
matches = re.findall(r'\*([^*]+)', prompt)
if not matches or len(matches) == 0:
st.warning("Cannot find prompt from ChatGPT response. Try again.", icon="⚠")
st.stop()
prompt = ""
for match in matches:
prompt += match.split("\n")[0] + " "
if seed == -1:
seed = None
flags = ""
if model == "Niji":
flags += " --niji"
if niji_style:
flags += f" --style {niji_style.lower()}"
else:
if mid_style:
flags += f" --style {mid_style.lower()}"
if ar:
flags += f" --ar {ar}"
if tile:
flags += " --tile"
if creative:
flags += f" --creative --{creative}"
else:
if quality:
flags += f" --q {quality}"
if stylize:
flags += f" --stylize {stylize}"
full_prompt = sender.send(prompt=prompt, seed=seed, flags=flags)
st.session_state["history"] += f"- {full_prompt}\n"
history.markdown(st.session_state["history"])
# Result
progress_bar.progress(0, "Waiting to start")
while True:
id, components = receiver.collecting_results(full_prompt)
if not id:
time.sleep(2.5)
continue
receiver.outputer()
receiver.downloading_results()
con.ping()
with con:
with con.cursor() as cur:
cur.execute("select * from prompts where id = %s limit 1", (id,))
row = cur.fetchone()
if not row:
continue
prompt_helper.empty()
try:
progress_bar.progress(int(row["status"]), text=f"{row['status']}%")
except:
pass
try:
full_prompt_caption.caption(f"{row['full_prompt']} ({row['status']}%)")
except:
pass
if row["url"]:
try:
result_image.image(row["url"])
except:
pass
if row["status"] == 100:
progress_bar.empty()
st.session_state["latest_id"] = row["id"]
def show_component(id, components, full_prompt):
columns = st.columns(9)
columns[0].button("❤️", on_click=like)
if components:
column_index = 1
for comp in components:
for i, c in enumerate(comp["components"]):
if "upsample" in c["custom_id"]:
columns[column_index].button(f"U{i+1}", on_click=run_component, args=(id, "upsample", c["custom_id"], full_prompt, i))
column_index += 1
elif "variation" in c["custom_id"]:
columns[column_index].button(f"V{i+1}", on_click=run_component, args=(id, "variation", c["custom_id"], full_prompt, i))
column_index += 1
def run_component(id, task, custom_id, full_prompt, image_index):
sender.send_component(id, custom_id)
with st.spinner(f"{task.capitalize()} Image #{image_index + 1}..."):
while True:
id, components = receiver.collecting_results(full_prompt)
if not id:
time.sleep(2.5)
continue
receiver.outputer()
receiver.downloading_results()
if id and components:
con.ping()
with con:
with con.cursor() as cur:
cur.execute("select * from prompts where id = %s order by created_at desc limit 1", (id,))
row = cur.fetchone()
if row["url"]:
try:
st.session_state["latest_id"] = row["id"]
st.image(row["url"])
st.caption(full_prompt)
show_component(id, components, full_prompt)
except:
pass
break
time.sleep(2.5)
show_component(id, components, full_prompt)
break
time.sleep(2.5)
if dalle:
with st.spinner('Waiting for DALL-E...'):
dalle_prompt = full_prompt.split("--")[0]
dalle_prompt = re.sub(r"[^a-zA-Z,\s]+", "", dalle_prompt).strip()
dalle_res = openai.Image.create(
prompt=full_prompt,
n=1,
size="1024x1024")
dalle_result_image.image(dalle_res['data'][0]['url'])
dalle_prompt_caption.caption(dalle_prompt)
| [
"[^a-zA-Z,\\s]+",
"\n",
"input",
" ",
"Draw your imagination or use / to ask ChatGPT to generate prompts."
] |
2024-01-10 | kairess/Maybejourney | pages~1_Describe.py | import streamlit as st
import time
import openai
import requests
from Sender import Sender
from Receiver import Receiver
from footer import footer
from helpers import *
# Config
st.set_page_config(page_title="Maybejourney - YouTube 빵형의 개발도상국", page_icon="🎨")
@st.cache_data
def load_config():
config = {
"authorization": st.secrets["authorization"],
"application_id": st.secrets["application_id"],
"guild_id": st.secrets["guild_id"],
"channel_id": st.secrets["channel_id"],
"session_id": st.secrets["session_id"],
"version": "1092492867185950853",
"id": "1092492867185950852",
"openai_api_key": st.secrets["openai_api_key"],
}
return config
config = load_config()
openai.api_key = config["openai_api_key"]
if "page" not in st.session_state:
st.session_state["page"] = 0
if "done" not in st.session_state:
st.session_state["done"] = False
st.session_state["page"] = 0
st.session_state["done"] = False
@st.cache_resource
def load_resources():
return Sender(config=config), Receiver(config, "images", None, None)
sender, receiver = load_resources()
# https://stackoverflow.com/questions/76092002/uploading-files-to-discord-api-thought-put-using-python-requests
def upload_file(file):
filename = file.name
file_size = file.size
api_response = requests.post(
f"https://discord.com/api/v9/channels/{config['channel_id']}/attachments",
headers={"authorization": config["authorization"]},
json={"files": [{"filename": filename, "file_size": file_size, "id": 1}]},
)
api_response.raise_for_status()
attachment_info = api_response.json()["attachments"][0]
put_url = attachment_info["upload_url"]
put_response = requests.put(
put_url,
headers={
"Content-Length": str(file_size),
"Content-Type": "image/png",
"authorization": config["authorization"],
},
data=file,
)
put_response.raise_for_status()
return attachment_info
# UI
st.header("Describe")
# Prompt
with st.form("prompt-form"):
file = st.file_uploader("Image", type=["png", "jpg", "jpeg", "webp", "heic"])
submit_button = st.form_submit_button("Submit")
footer(*footer_content)
# Function
if submit_button and file:
with st.spinner("Describing..."):
attachment = upload_file(file)
filename = file.name
uploaded_filename = attachment["upload_filename"]
sender.send_describe(filename, uploaded_filename)
while True:
time.sleep(2.5)
description, image = receiver.collecting_describes(filename)
if description and image:
st.markdown(description)
st.image(image)
break
| [] |
2024-01-10 | wgryc/phasellm | demos-and-products~newsbot~newsbot_create.py | ### IMPORTS
from phasellm.llms import OpenAIGPTWrapper, ClaudeWrapper, ChatPrompt
from phasellm.agents import NewsSummaryAgent
import json
### ENVIRONMENT VARIABLES
import os
from dotenv import load_dotenv
load_dotenv()
openai_api_key = os.getenv("OPENAI_API_KEY")
anthropic_api_key = os.getenv("ANTHROPIC_API_KEY")
news_api_api_key = os.getenv("NEWS_API_API_KEY")
### SETUP THE EXPERIMENTAL DATA
queries = ['spacex', 'federal reserve', 'shopify', 'openai', 'biden', 'trump', 'met gala', 'king charles', 'poland', 'euro']
JSON_FILE = "news_articles.json"
llm_1 = OpenAIGPTWrapper(openai_api_key, model="gpt-4")
llm_2 = OpenAIGPTWrapper(openai_api_key, model="gpt-4") # ClaudeWrapper(anthropic_api_key)
chat_prompt_raw_1 = [
{"role":"system",
"content": "You are a helpful news summarizer. We will provide you with a list of news articles and will ask that you summarize them and retain links to source by adding footnotes. For example, if you have a news article describing XYZ and URL to the article, you would discuss XYZ[1] and add '[1] URL' to the bottom of the message. Note that the footnotes should be counted as of the summary; you do not need to keep the numbers from the earlier order, just from your summary. In other words, footnotes should start at 1, 2, 3, etc..."},
{"role":"user",
"content": "The articles below are about '{query}'. Please summarize them into a short paragraph with link retained as per the earlier instructions.\n\n{news_articles}"},
]
chat_prompt_raw_2 = [
{"role":"system",
"content": "You are a helpful news summarizer. We will provide you with a list of news articles and will ask that you summarize them and retain links to source by adding footnotes. For example, if you have a news article describing XYZ and URL to the article, you would discuss XYZ[1] and add '[1] URL' to the bottom of the message. The footnote numbers should start at [1] and increase consecutively. In other words, footnotes should start at 1, 2, 3, etc. For the actual paragraph, you can reorder reference articles and choose the ones to include as to make the paragraph as informative, pithy, and concise as possible. You can also have multiple footnotes per sentence if this helps tell the story. While you should avoid adding your own commentary in most cases, feel free to do so if it will help the reader understand the context of the paragraph you are writing."},
{"role":"user",
"content": "The articles below are about '{query}'. Please take on the role of an entertaining, successful, AI-driven investigative journalists and summarize them into a short paragraph. Make sure to follow the 'system' instructions.\n\n{news_articles}"},
]
chat_prompt_1 = ChatPrompt(chat_prompt_raw_1)
chat_prompt_2 = ChatPrompt(chat_prompt_raw_2)
### DATA HELPERS
def create_data_set(queries, json_file):
article_dict = {}
news_agent = NewsSummaryAgent(news_api_api_key, name="tester agent")
for query in queries:
news_articles = news_agent.getQuery(query, days_back=1, include_descriptions=True, max_articles=30)
article_dict[query] = {"articles":news_articles}
update_data_set(article_dict, json_file)
def update_data_set(dict_obj, json_file):
with open(json_file, 'w') as writer:
writer.write(json.dumps(dict_obj))
def load_data_set(json_file):
articles = None
with open(json_file, 'r') as reader:
articles = json.loads(reader.read())
return articles
### RUNNING DATA SET CREATION
create_data_set(queries, JSON_FILE)
articles = load_data_set(JSON_FILE)
for query, article_dict in articles.items():
print(f"Generating news summary for '{query}'")
print("... llm_1")
llm_1_completion = llm_1.complete_chat(chat_prompt_1.fill(query=query, news_articles=article_dict['articles']))
print("... llm_2")
llm_2_completion = llm_2.complete_chat(chat_prompt_2.fill(query=query, news_articles=article_dict['articles']))
# Saving results...
article_dict["llm_1"] = llm_1_completion
article_dict["llm_2"] = llm_2_completion
articles[query] = article_dict
update_data_set(articles, JSON_FILE) | [
"The articles below are about '{query}'. Please take on the role of an entertaining, successful, AI-driven investigative journalists and summarize them into a short paragraph. Make sure to follow the 'system' instructions.\n\n{news_articles}",
"You are a helpful news summarizer. We will provide you with a list of news articles and will ask that you summarize them and retain links to source by adding footnotes. For example, if you have a news article describing XYZ and URL to the article, you would discuss XYZ[1] and add '[1] URL' to the bottom of the message. Note that the footnotes should be counted as of the summary; you do not need to keep the numbers from the earlier order, just from your summary. In other words, footnotes should start at 1, 2, 3, etc...",
"The articles below are about '{query}'. Please summarize them into a short paragraph with link retained as per the earlier instructions.\n\n{news_articles}",
"You are a helpful news summarizer. We will provide you with a list of news articles and will ask that you summarize them and retain links to source by adding footnotes. For example, if you have a news article describing XYZ and URL to the article, you would discuss XYZ[1] and add '[1] URL' to the bottom of the message. The footnote numbers should start at [1] and increase consecutively. In other words, footnotes should start at 1, 2, 3, etc. For the actual paragraph, you can reorder reference articles and choose the ones to include as to make the paragraph as informative, pithy, and concise as possible. You can also have multiple footnotes per sentence if this helps tell the story. While you should avoid adding your own commentary in most cases, feel free to do so if it will help the reader understand the context of the paragraph you are writing."
] |
2024-01-10 | wgryc/phasellm | demos-and-products~eval_platform~llmevaluator~management~commands~runjobs.py | from django.core.management.base import BaseCommand
from llmevaluator.models import *
from django.conf import settings
from phasellm.llms import OpenAIGPTWrapper, ChatBot
# Returns the new ChatBotMessageArray ID
def run_llm_task_and_save(
message_array,
user_message,
job_id,
original_title="Untitled",
model="gpt-4",
temperature=0.7,
print_response=True,
new_system_prompt=None,
resend_last_user_message=False,
):
o = OpenAIGPTWrapper(settings.OPENAI_API_KEY, model=model, temperature=temperature)
cb = ChatBot(o, "")
# If we want to resend the last user message *and* provide a new user message, then we'll have to ignore one of those options
assert not (resend_last_user_message == True and len(user_message) > 0)
ma_copy = message_array.copy()
if new_system_prompt is not None:
if len(new_system_prompt.strip()) > 0:
# If the first message is not a system prompt, then error out.
assert ma_copy[0]["role"] == "system"
ma_copy[0]["content"] = new_system_prompt
cb.messages = ma_copy
if resend_last_user_message:
response = cb.resend()
else:
response = cb.chat(user_message)
new_cbma = ChatBotMessageArray(
message_array=cb.messages,
source_batch_job_id=job_id,
title=f"{original_title} w/ T={temperature}, model={model}",
)
new_cbma.llm_temperature = temperature
new_cbma.llm_model = model
new_cbma.save()
if print_response:
print(response)
return new_cbma
def run_job(job):
print(f"Starting job: {job.title}")
mc = MessageCollection.objects.get(id=job.message_collection_id)
chat_ids_string = mc.chat_ids
chat_ids = chat_ids_string.strip().split(",")
results_ids = []
results_to_append = []
for _cid in chat_ids:
print(f"Analyzing chat ID: {_cid}")
cid = int(_cid)
cbma = ChatBotMessageArray.objects.get(id=cid)
# SETTING: run_n_times
run_n_times = job.run_n_times
for i in range(0, run_n_times):
# SETTING: include_gpt_4
if job.include_gpt_4:
if job.temperature_range:
for t in [0.25, 0.75, 1.25]:
nc = run_llm_task_and_save(
cbma.message_array.copy(),
job.user_message,
job.id,
cbma.title,
model="gpt-4",
temperature=t,
new_system_prompt=job.new_system_prompt,
resend_last_user_message=job.resend_last_user_message,
)
results_ids.append(str(nc.id))
results_to_append.append(nc)
else:
nc = run_llm_task_and_save(
cbma.message_array.copy(),
job.user_message,
job.id,
cbma.title,
"gpt-4",
new_system_prompt=job.new_system_prompt,
resend_last_user_message=job.resend_last_user_message,
)
results_ids.append(str(nc.id))
results_to_append.append(nc)
# SETTING: include_gpt_35
if job.include_gpt_35:
if job.temperature_range:
for t in [0.25, 0.75, 1.25]:
nc = run_llm_task_and_save(
cbma.message_array.copy(),
job.user_message,
job.id,
cbma.title,
model="gpt-3.5-turbo",
temperature=t,
new_system_prompt=job.new_system_prompt,
resend_last_user_message=job.resend_last_user_message,
)
results_ids.append(str(nc.id))
results_to_append.append(nc)
else:
nc = run_llm_task_and_save(
cbma.message_array.copy(),
job.user_message,
job.id,
cbma.title,
"gpt-3.5-turbo",
new_system_prompt=job.new_system_prompt,
resend_last_user_message=job.resend_last_user_message,
)
results_ids.append(str(nc.id))
results_to_append.append(nc)
new_chats_str = ",".join(results_ids)
results_mc = MessageCollection(
title=f"Results from '{job.title}' job",
chat_ids=new_chats_str,
source_collection_id=mc.id,
source_batch_job_id=job.id,
)
results_mc.save()
for r in results_to_append:
results_mc.chats.add(r)
results_mc.save()
job.status = "complete"
job.results_array = results_mc
job.save()
print("Done!")
class Command(BaseCommand):
help = "Runs all scheduled batch jobs."
def handle(self, *args, **options):
jobs = BatchLLMJob.objects.filter(status="scheduled")
for job in jobs:
run_job(job)
| [] |
2024-01-10 | wgryc/phasellm | phasellm~types.py | from phasellm.configurations import OpenAIConfiguration, AzureAPIConfiguration, AzureActiveDirectoryConfiguration
from typing import Union, Literal
CLAUDE_MODEL = Union[
str,
Literal["claude-v1"],
Literal["claude-instant-1"],
Literal["claude-instant-1.1"],
Literal["claude-2"],
Literal["claude-2.0"],
]
OPENAI_API_CONFIG = Union[
OpenAIConfiguration,
AzureAPIConfiguration,
AzureActiveDirectoryConfiguration
]
| [] |
2024-01-10 | wgryc/phasellm | tests-non-deterministic~llms~test_llms.py | import os
from unittest import TestCase
from dotenv import load_dotenv
from phasellm.llms import OpenAIGPTWrapper, ChatBot
load_dotenv()
openai_api_key = os.getenv("OPENAI_API_KEY")
class TestChatBot(TestCase):
def test_openai_gpt_chat_temperature(self):
prompt = 'What is the capital of Jupiter?'
verbose = True
# Test low temperature
llm = OpenAIGPTWrapper(openai_api_key, "gpt-3.5-turbo", temperature=0)
fixture = ChatBot(llm)
low_temp_res = fixture.chat(prompt)
# Test high temperature
llm = OpenAIGPTWrapper(openai_api_key, "gpt-3.5-turbo", temperature=2)
fixture = ChatBot(llm)
high_temp_res = fixture.chat(prompt)
if verbose:
print(f'Low temp response:\n{low_temp_res}')
print(f'Low temperature len: {len(low_temp_res)}')
print(f'High temp response:\n{high_temp_res}')
print(f'High temperature len: {len(high_temp_res)}')
# Responses should differ.
self.assertNotEqual(low_temp_res, high_temp_res)
# High temperature should generally produce longer responses.
self.assertTrue(len(low_temp_res) < len(high_temp_res))
| [
"What is the capital of Jupiter?"
] |
2024-01-10 | wgryc/phasellm | tests~release_checklist_code.py | """
This code is used to test various aspects of PhaseLLM. We recommend running this on a P3 EC2 instance with Ubuntu 22.04 installed. To get this up and running, run the following code:
sudo apt-get update
sudo apt-get upgrade
sudo apt-get install xorg
sudo apt-get install nvidia-driver-460
sudo reboot
Run `nvidia-smi` to ensure you have GPU devices with CUDA installed.
"""
##########################################################################################
# GPU SETUP
#
import torch
# Confirm GPUs are installed and usable.
print(torch.cuda.is_available())
print(torch.cuda.current_device())
##########################################################################################
# ENVIRONMENT VARIABLES
#
# Load all environment variables and API keys
import os
from dotenv import load_dotenv
load_dotenv()
openai_api_key = os.getenv("OPENAI_API_KEY")
anthropic_api_key = os.getenv("ANTHROPIC_API_KEY")
cohere_api_key = os.getenv("COHERE_API_KEY")
hugging_face_api_key = os.getenv("HUGGING_FACE_API_KEY")
##########################################################################################
# GPT-3.5 EVALUATOR WITH COHERE AND CLAUDE COMPARISONS
#
# Run GPT-3.5 evaluator
from phasellm.eval import GPTEvaluator
# We'll use GPT-3.5 as the evaluator; this is the default setting in the class below
e = GPTEvaluator(openai_api_key)
# Our objective.
objective = "We're building a chatbot to discuss a user's travel preferences and provide advice."
# Chats that have been launched by users.
travel_chat_starts = [
"I'm planning to visit Poland in spring.",
"I'm looking for the cheapest flight to Europe next week.",
"I am trying to decide between Prague and Paris for a 5-day trip",
"I want to visit Europe but can't decide if spring, summer, or fall would be better.",
"I'm unsure I should visit Spain by flying via the UK or via France."
]
from phasellm.llms import CohereWrapper, ClaudeWrapper
cohere_model = CohereWrapper(cohere_api_key)
claude_model = ClaudeWrapper(anthropic_api_key)
print("Running test. 1 = Cohere, and 2 = Claude.")
for tcs in travel_chat_starts:
messages = [{"role":"system", "content":objective},
{"role":"user", "content":tcs}]
response_cohere = cohere_model.complete_chat(messages, "assistant")
response_claude = claude_model.complete_chat(messages, "assistant")
pref = e.choose(objective, tcs, response_cohere, response_claude)
print(f"{pref}")
##########################################################################################
# DOLLY TESTS
#
from phasellm.llms import DollyWrapper
dw = DollyWrapper()
# Testing chat capability.
messages = [{"role":"user", "content":"What should I eat for lunch today?"}]
dw.complete_chat(messages, 'assistant')
# Run a text completion.
dw.text_completion("The capital of Poland is")
##########################################################################################
# GPT EVALUATOR WITH COHERE AND DOLLY COMPARISONS
#
import os
from dotenv import load_dotenv
load_dotenv()
openai_api_key = os.getenv("OPENAI_API_KEY")
anthropic_api_key = os.getenv("ANTHROPIC_API_KEY")
cohere_api_key = os.getenv("COHERE_API_KEY")
from phasellm.eval import GPTEvaluator
# We'll use GPT-3.5 as the evaluator.
e = GPTEvaluator(openai_api_key)
# Our objective.
objective = "We're building a chatbot to discuss a user's travel preferences and provide advice."
# Chats that have been launched by users.
travel_chat_starts = [
"I'm planning to visit Poland in spring.",
"I'm looking for the cheapest flight to Europe next week.",
"I am trying to decide between Prague and Paris for a 5-day trip",
"I want to visit Europe but can't decide if spring, summer, or fall would be better.",
"I'm unsure I should visit Spain by flying via the UK or via France."
]
from phasellm.llms import CohereWrapper
from phasellm.llms import DollyWrapper # NEW: importing the DollyWrapper...
dw = DollyWrapper() # NEW: ... and instantiating it.
cohere_model = CohereWrapper(cohere_api_key)
print("Running test. 1 = Cohere, and 2 = Dolly.")
for tcs in travel_chat_starts:
messages = [{"role":"system", "content":objective},
{"role":"user", "content":tcs}]
response_cohere = cohere_model.complete_chat(messages, "assistant")
response_dw = dw.complete_chat(messages, "assistant") # NEW: minor change to variable name
pref = e.choose(objective, tcs, response_cohere, response_dw)
print(f"{pref}")
##########################################################################################
# HUGGINGFACE INFERENCE API TESTS
#
from phasellm.llms import HuggingFaceInferenceWrapper
hf = HuggingFaceInferenceWrapper(hugging_face_api_key, model_url='https://api-inference.huggingface.co/models/google/flan-t5-xxl')
# Testing chat capability.
messages = [{"role":"user", "content":"What should I eat for lunch today?"}]
hf.complete_chat(messages, 'assistant')
# Run a text completion.
hf.text_completion("The capital of Poland is")
##########################################################################################
# CHATBOT resend() TEST
#
from phasellm.llms import OpenAIGPTWrapper, ChatBot
oaiw = OpenAIGPTWrapper(openai_api_key, 'gpt-4')
cb = ChatBot(oaiw)
m = [{'role': 'system', 'content': "You are a robot that adds 'YO!' to the end of every sentence."}, {'role': 'user', 'content': 'Tell me about Poland.'}]
cb.messages = m
cb.resend()
##########################################################################################
# EVAL simulations TO EXCEL
#
from phasellm.llms import ChatBot, OpenAIGPTWrapper
from phasellm.eval import *
o = OpenAIGPTWrapper(openai_api_key)
c = ChatBot(o)
c.messages = [ {"role":"system", "content":"You're a mathbot."}, {"role":"user", "content":"What is 3*4*5*zebra?"} ]
x = simulate_n_chat_simulations(c, 4, 'responses.xlsx') | [
"Tell me about Poland.",
"You are a robot that adds 'YO!' to the end of every sentence.",
"What should I eat for lunch today?",
"You're a mathbot.",
"What is 3*4*5*zebra?"
] |
2024-01-10 | wgryc/phasellm | demos-and-products~cot-analytics~cot.py | """
Chain of Thought (CoT) analysis for a data set. Please see the README.md for more information.
"""
import os
from dotenv import load_dotenv
from phasellm.llms import OpenAIGPTWrapper, ChatBot
# Where we write the output of this analysis.
OUT_FILE = "output.md"
def save_output(output, header):
"""
Appends model outputs to a markdown file. Includes a header ("# header") and then the output itself.
"""
with open(OUT_FILE, 'a') as writer:
writer.write(f"# {header}\n\n{output}\n\n")
# This prompt is basically a copy/paste of what is generated by ResearchLLM for the 'incomes.csv' data set via the generateOverview() function.
messages = [{"role":"system", "content": """You are a data science research assistant. We will ask you about a big data set and would like you to break down the analysis you suggest into specific tasks that we can then write code for."""},
{"role":"user", "content":"""I am researching the relationship between income and sociodemographic census info. I have imported Pandas as `pd`, Numpy as `np`, `scipy`, and `sklearn`, and have a dataframe called `df` loaded into Python. `df` contains the following variables and variable types:
Column Name: age
Column Type: int64
Column Name: workclass
Column Type: object
Sample Values: ['?' 'Federal-gov' 'Local-gov' 'Never-worked' 'Private' 'Self-emp-inc'
'Self-emp-not-inc' 'State-gov' 'Without-pay']
Column Name: fnlwgt
Column Type: int64
Column Name: education
Column Type: object
Sample Values: ['10th' '11th' '12th' '1st-4th' '5th-6th' '7th-8th' '9th' 'Assoc-acdm'
'Assoc-voc' 'Bachelors' 'Doctorate' 'HS-grad' 'Masters' 'Preschool'
'Prof-school' 'Some-college']
Column Name: education.num
Column Type: int64
Column Name: marital.status
Column Type: object
Sample Values: ['Divorced' 'Married-AF-spouse' 'Married-civ-spouse'
'Married-spouse-absent' 'Never-married' 'Separated' 'Widowed']
Column Name: occupation
Column Type: object
Sample Values: ['?' 'Adm-clerical' 'Armed-Forces' 'Craft-repair' 'Exec-managerial'
'Farming-fishing' 'Handlers-cleaners' 'Machine-op-inspct' 'Other-service'
'Priv-house-serv' 'Prof-specialty' 'Protective-serv' 'Sales'
'Tech-support' 'Transport-moving']
Column Name: relationship
Column Type: object
Sample Values: ['Husband' 'Not-in-family' 'Other-relative' 'Own-child' 'Unmarried' 'Wife']
Column Name: race
Column Type: object
Sample Values: ['Amer-Indian-Eskimo' 'Asian-Pac-Islander' 'Black' 'Other' 'White']
Column Name: sex
Column Type: object
Sample Values: ['Female' 'Male']
Column Name: capital.gain
Column Type: int64
Column Name: capital.loss
Column Type: int64
Column Name: hours.per.week
Column Type: int64
Column Name: native.country
Column Type: object
Sample Values: ['?' 'Cambodia' 'Canada' 'China' 'Columbia' 'Cuba' 'Dominican-Republic'
'Ecuador' 'El-Salvador' 'England' 'France' 'Germany' 'Greece' 'Guatemala'
'Haiti' 'Holand-Netherlands' 'Honduras' 'Hong' 'Hungary' 'India' 'Iran'
'Ireland' 'Italy' 'Jamaica' 'Japan' 'Laos' 'Mexico' 'Nicaragua'
'Outlying-US(Guam-USVI-etc)' 'Peru' 'Philippines' 'Poland' 'Portugal'
'Puerto-Rico' 'Scotland' 'South' 'Taiwan' 'Thailand' 'Trinadad&Tobago'
'United-States' 'Vietnam' 'Yugoslavia']
Column Name: income
Column Type: object
Sample Values: ['<=50K' '>50K']
````````
With all of the above in mind, could you please provide me with a set of analysis steps you would recommend I run on the data to better understand what drives income inequality? Please provide a numbered list where each number is a specific analytical step. For each step, include the hypothesis you would test, what variables you'd look at, and what you'd be hoping to find.
Do not worry about visualizing the data, as I'd like to ensure the outputs are all things that you are able to interpret afterwards. """}
]
def split_cot(cot):
"""
Takes a numbered list generated by an LLM and splits it into an array.
"""
lines = cot.split("\n")
cot_steps = []
step_text = ""
for i in range(0, len(lines)):
line = lines[i]
if len(line.strip()) > 0:
step_text += line + "\n"
else:
cot_steps.append(step_text.strip())
step_text = ""
return cot_steps
load_dotenv()
print("Setting up chat...")
openai_api_key = os.getenv("OPENAI_API_KEY")
o = OpenAIGPTWrapper(openai_api_key, 'gpt-4')
c = ChatBot(o, messages[0]['content'])
print("Getting CoT...")
# Step 1, let's get a chain of thought (COT) approach to understanding the data set.
response = c.chat(messages[1]['content'])
save_output(response, "Chain of Thought Plan for Data Analysis")
cot_steps = split_cot(response)
# Step 2, go through each COT step and ask GPT-4 to generate code.
step_num = 1
for step in cot_steps:
print(f"Generating code for step {step_num}.")
prompt = f"""You wrote the following instructions for a step:
{step}
Please write the Python code for the step above. Assume the following:
1. Start your response with ```python
2. End your response with ```
3. Do not add any text outside the code. For anything that requires comment, simply add Python comments.
4. Assume the data was imported into a dataframe called `df`
5. I have imported Pandas as `pd`, Numpy as `np`, `scipy`, and `sklearn`. You can use those libraries and no others.
"""
response = c.chat(prompt)
save_output(step + "\n\n" + response, f"Code for Step #{step_num}")
step_num += 1
print("Done!") | [
"You wrote the following instructions for a step:\nPLACEHOLDER\n\nPlease write the Python code for the step above. Assume the following:\n1. Start your response with ```python\n2. End your response with ```\n3. Do not add any text outside the code. For anything that requires comment, simply add Python comments.\n4. Assume the data was imported into a dataframe called `df`\n5. I have imported Pandas as `pd`, Numpy as `np`, `scipy`, and `sklearn`. You can use those libraries and no others.\n",
" ",
"d look at, and what you",
"content",
"You are a data science research assistant. We will ask you about a big data set and would like you to break down the analysis you suggest into specific tasks that we can then write code for."
] |
2024-01-10 | wgryc/phasellm | phasellm~llms.py | """
Abstract classes and wrappers for LLMs, chatbots, and prompts.
"""
import re
import time
import json
import warnings
import httpx
import requests
# Typing imports
from typing_extensions import TypedDict
from phasellm.types import CLAUDE_MODEL, OPENAI_API_CONFIG
from typing import Optional, List, Union, Generator, Any
# Configuration imports
from phasellm.configurations import OpenAIConfiguration
# Abstract class imports
from abc import ABC, abstractmethod
from warnings import warn
from datetime import datetime
from sseclient import SSEClient
# Imports for external APIs
import cohere
# Support for Replicate
import replicate
# Precompiled regex for variables.
variable_pattern = r'\{\s*[a-zA-Z0-9_]+\s*\}'
variable_regex = re.compile(variable_pattern)
STOP_TOKEN = "<|END|>"
class Message(TypedDict):
"""
Message type for chat messages.
"""
role: str
content: str
class EnhancedMessage(Message):
"""
Message type for chat messages with additional metadata.
"""
timestamp_utc: datetime
log_time_seconds: float
def _fill_variables(source: str, **kwargs: Any) -> str:
"""
Fills variables in a string with the values provided in kwargs.
Args:
source: The string to fill.
**kwargs: The values to fill the string with.
Returns:
The filled string.
"""
# Collect the variables present in the source that need to be filled.
variables = re.findall(variable_regex, source)
# Create a copy of the source to be filled.
filled = source
for m in variables:
keyword = m.replace("{", "").replace("}", "").strip()
if keyword in kwargs:
filled = filled.replace(m, kwargs[keyword])
return filled
def _clean_messages_to_prompt(messages: List[Message]) -> str:
"""
Converts an array of messages in the form {"role": <str>, "content":<str>} into a String.
This is influenced by the OpenAI chat completion API.
Args:
messages: The messages to convert.
Returns:
The messages as a String.
"""
return "\n".join([f"{str(m['role'])}: {str(m['content'])}" for m in messages])
def _truncate_completion(completion: str) -> str:
"""
Truncates a completion to the first newline character.
Args:
completion: The completion to truncate.
Returns:
The truncated completion.
"""
newline_location = completion.find("\n")
if newline_location > 0:
completion = completion[:newline_location]
return completion
def _remove_prompt_from_completion(prompt: str, completion: str) -> str:
"""
Remove the prompt from the completion.
Args:
prompt: The prompt to remove.
completion: The completion to remove the prompt from.
Returns:
The completion without the prompt.
"""
if not completion.startswith(prompt):
return completion
return completion[len(prompt):]
def _get_stop_sequences_from_messages(messages: List[Message]) -> List[str]:
"""
Generates a list of strings of stop sequences from an array of messages in the form
{"role": <str>, "content":<str>}.
Args:
messages: The messages to generate stop sequences from.
Returns:
A list of stop sequences.
"""
roles = set()
for m in messages:
roles.add(m["role"])
return [f"\n{r}:" for r in roles]
def _format_sse(content: str) -> str:
"""
Formats the content for Server Sent Events (SSE). Additionally, handles newline characters gracefully.
Args:
content: The content to format.
Returns:
The formatted content.
"""
# TODO consider adding id and event fields to the SSE.
content = content.replace("\n", "\ndata:")
return f"data: {content}\n\n"
def _conditional_format_sse_response(content: str, format_sse: bool) -> str:
"""
Conditionally formats the response as an SSE.
Args:
content: The content to format.
format_sse: Whether to format the response as an SSE.
Returns:
The formatted content.
"""
if format_sse:
return _format_sse(content)
return content
def swap_roles(messages: List[Message], new_prompt: str) -> List[Message]:
"""
Creates a new messages stack with the new_prompt as the system prompt and the 'user' and 'assistant' roles swapped.
All other messages are ignored.
Args:
messages: the current messages.
new_prompt: the new system prompt.
Returns:
A new list of messages with the new_prompt as the system prompt and user/assistant prompts swapped out.
"""
new_messages = [{"role": "system", "content": new_prompt}]
for m in messages:
if m["role"] in ["user", "assistant"]:
new_message = m.copy()
if m["role"] == "user":
new_role = "assistant"
elif m["role"] == "assistant":
new_role = "user"
new_message["role"] = new_role
new_messages.append(new_message)
return new_messages
class LanguageModelWrapper(ABC):
# default chat completion preamble
chat_completion_preamble: str = (
"You are a friendly chat assistant. "
"You are speaking to the 'user' below and will respond at the end, where it says 'assistant'.\n"
)
_last_response_header: Optional[dict] = None
def __init__(self, temperature: Optional[float] = None, **kwargs: Any):
"""
Abstract Class for interacting with large language models.
Args:
temperature: The temperature to use for the language model.
**kwargs: Keyword arguments to pass to the underlying language model API.
"""
self.temperature: Optional[float] = temperature
self.kwargs: Any = kwargs
def __repr__(self):
pass
@property
def last_response_header(self) -> Optional[dict]:
"""
Returns the last response header from the LLM API.
Returns:
A dictionary containing the last response header.
"""
return self._last_response_header
@last_response_header.setter
def last_response_header(self, header: dict) -> None:
"""
Sets the last_response_header property.
Returns:
"""
self._last_response_header = header
@abstractmethod
def complete_chat(
self,
messages: List[Message],
append_role: Optional[str] = None,
prepend_role: Optional[str] = None
) -> Union[str, Generator]:
"""
Takes an array of messages in the form {"role": <str>, "content":<str>} and generate a response.
This is influenced by the OpenAI chat completion API.
Args:
messages: The messages to generate a response from.
append_role: The role to append to the end of the prompt.
prepend_role: The role to prepend to the beginning of the prompt.
Returns:
The chat completion string or generator, depending on if the class is implemented as a streaming language
model wrapper.
"""
pass
@abstractmethod
def text_completion(self, prompt: str) -> Union[str, Generator]:
"""
Standardizes text completion for large language models.
Args:
prompt: The prompt to generate a response from.
Returns:
The text completion string or generator, depending on if the class is implemented as a streaming language
model wrapper.
"""
pass
def prep_prompt_from_messages(
self,
messages: List[Message] = None,
prepend_role: Optional[str] = None,
append_role: Optional[str] = None,
include_preamble: Optional[bool] = False
) -> str:
"""
Prepares the prompt for an LLM API call.
Args:
messages: The messages to prepare the prompt from.
prepend_role: The role to prepend to the beginning of the prompt.
append_role: The role to append to the end of the prompt.
include_preamble: Whether to include the chat completion preamble.
Returns:
The prepared prompt.
"""
# Convert the messages to a prompt.
prompt_text = _clean_messages_to_prompt(messages)
# Prepend the role, if provided.
if prepend_role:
prompt_text = f"\n\n{prepend_role}: {prompt_text}"
# Add the preamble, if requested.
if include_preamble:
prompt_text = self.chat_completion_preamble + prompt_text
# Append the role, if provided.
if append_role:
prompt_text = f"{prompt_text}\n\n{append_role}:"
# Remove whitespace from before and after prompt.
return prompt_text.strip()
@staticmethod
def prep_prompt(prompt: str, prepend_role: Optional[str] = None, append_role: Optional[str] = None) -> str:
"""
Prepares the prompt for an LLM API call.
Args:
prompt: The prompt to prepare.
prepend_role: The role to prepend to the beginning of the prompt.
append_role: The role to append to the end of the prompt.
Returns:
The prepared prompt.
"""
# Prepend the role, if provided.
if prepend_role:
prompt = f"{prepend_role}: {prompt}"
# Append the role, if provided.
if append_role:
prompt = f"{prompt}\n\n{append_role}:"
# Remove whitespace from before and after prompt.
return prompt.strip()
def _prep_common_kwargs(self, api_config: Optional[OPENAI_API_CONFIG] = None):
"""
This method prepares the common kwargs for the OpenAI APIs.
Returns:
The kwargs to pass to the API.
"""
# Get the base kwargs for the given config.
if api_config is not None:
kwargs = api_config.get_base_api_kwargs()
else:
kwargs = {}
# Add the wrapper's kwargs.
kwargs = {**self.kwargs, **kwargs}
# Add the temperature if it exists.
if self.temperature is not None:
kwargs["temperature"] = self.temperature
return kwargs
class StreamingLanguageModelWrapper(LanguageModelWrapper):
@abstractmethod
def __init__(
self,
temperature: float,
format_sse: bool,
append_stop_token: bool = True,
stop_token: str = STOP_TOKEN,
**kwargs: Any
):
"""
Abstract class for streaming language models. Extends the regular LanguageModelWrapper.
Args:
temperature: The temperature to use for the language model.
format_sse: Whether to format the response as an SSE.
append_stop_token: Whether to append a stop token to the end of the prompt.
stop_token: The stop token to append to the end of the prompt.
**kwargs: Keyword arguments to pass to the underlying language model APIs.
"""
super().__init__(temperature=temperature, **kwargs)
self.format_sse = format_sse
self.append_stop_token = append_stop_token
self.stop_token = stop_token
class ChatPrompt:
def __init__(self, messages: List[Message] = None):
"""
This is used to generate messages for a ChatBot. Like the Prompt class, it enables you to to have variables that
get replaced. This can be done for roles and messages.
Args:
messages: The messages to generate a chat prompt from.
"""
# Set the messages
if messages is None:
self.messages = []
else:
self.messages = messages
def __repr__(self):
return "ChatPrompt()"
def chat_repr(self) -> str:
"""
Returns a string representation of the chat prompt.
Returns:
The string representation of the chat prompt.
"""
return _clean_messages_to_prompt(self.messages)
def fill(self, **kwargs) -> List[Message]:
"""
Fills the variables in the chat prompt.
Args:
**kwargs: The variables to fill.
Returns:
The filled chat prompt.
"""
filled_messages = []
for i in range(0, len(self.messages)):
new_role = _fill_variables(self.messages[i]["role"], **kwargs)
new_content = _fill_variables(self.messages[i]["content"], **kwargs)
new_message = self.messages[i].copy()
new_message["role"] = new_role
new_message["content"] = new_content
filled_messages.append(new_message)
return filled_messages
class Prompt:
def __init__(self, prompt: str):
"""
Prompts are used to generate text completions. Prompts can be simple Strings. They can also include variables
surrounded by curly braces.
Example:
>>> Prompt("Hello {name}!")
In this case, 'name' can be filled using the fill() function. This makes it easier to loop through prompts
that follow a specific pattern or structure.
Args:
prompt: The prompt to generate a text completion from.
"""
self.prompt = prompt
def __repr__(self):
return self.prompt
def get_prompt(self) -> str:
"""
Return the raw prompt command (i.e., does not fill in variables.)
Returns:
The raw prompt command.
"""
return self.prompt
def fill(self, **kwargs: Any) -> str:
"""
Return a prompt with variables filled in.
Args:
**kwargs: The variables to fill.
Returns:
The filled prompt.
"""
return _fill_variables(source=self.prompt, **kwargs)
class HuggingFaceInferenceWrapper(LanguageModelWrapper):
def __init__(
self,
apikey: str,
model_url: str = "https://api-inference.huggingface.co/models/bigscience/bloom",
temperature: float = None,
**kwargs: Any
):
"""
Wrapper for Hugging Face's Inference API. Requires access to Hugging Face's inference API.
Args:
apikey: The API key to access the Hugging Face Inference API.
model_url: The model URL to use for the Hugging Face Inference API.
temperature: The temperature to use for the language model.
**kwargs: Keyword arguments to pass to the Hugging Face Inference API.
"""
super().__init__(temperature=temperature, **kwargs)
self.apikey = apikey
self.model_url = model_url
def __repr__(self):
return f"HuggingFaceInferenceWrapper()"
def _call_model(self, prompt: str) -> str:
"""
This method is used to call the Hugging Face Inference API. It is used by the complete_chat() and
text_completion() methods.
Args:
prompt: The prompt to call the model with.
Returns:
The response from the Hugging Face Inference API.
"""
# https://huggingface.co/docs/api-inference/detailed_parameters#text-generation-task
headers = {"Authorization": f"Bearer {self.apikey}"}
payload = {
"inputs": prompt,
**self.kwargs
}
if self.temperature is not None:
payload["temperature"] = self.temperature
response = requests.post(self.model_url, headers=headers, json=payload)
self.last_response_header = response.headers
response_json = response.json()
return _remove_prompt_from_completion(
prompt=prompt,
completion=response_json[0]['generated_text']
)
def complete_chat(self, messages: List[Message], append_role: str = None, prepend_role: str = None) -> str:
"""
Mimics a chat scenario via a list of {"role": <str>, "content":<str>} objects.
Args:
messages: The messages to generate a chat completion from.
append_role: The role to append to the end of the prompt.
prepend_role: The role to prepend to the beginning of the prompt.
Returns:
The chat completion.
"""
prompt = self.prep_prompt_from_messages(
messages=messages,
prepend_role=prepend_role,
append_role=append_role,
include_preamble=True
)
res = self._call_model(prompt=prompt)
# TODO consider making this more robust by truncating at first "role" using _get_stop_sequences_from_messages
# Truncate the completion to the first new line since this model tends to pretend to be the user.
return _truncate_completion(res)
def text_completion(self, prompt: str) -> str:
"""
Generates a text completion from a prompt.
Args:
prompt: The prompt to generate a text completion from.
Returns:
The text completion.
"""
return self._call_model(prompt=prompt)
# TODO consider deleting the BloomWrapper class since this functionality is in HuggingFaceInferenceWrapper
class BloomWrapper(LanguageModelWrapper):
API_URL = "https://api-inference.huggingface.co/models/bigscience/bloom"
def __init__(self, apikey: str, temperature: float = None, **kwargs: Any):
"""
Wrapper for Hugging Face's BLOOM model. Requires access to Hugging Face's inference API.
Args:
apikey: The API key to access the Hugging Face Inference API.
temperature: The temperature to use for the language model.
**kwargs: Keyword arguments to pass to the underlying language model API.
"""
super().__init__(temperature=temperature, **kwargs)
self.apikey = apikey
def __repr__(self):
return f"BloomWrapper()"
def _call_model(self, prompt: str) -> str:
"""
This method is used to call the Hugging Face Inference API. It is used by the complete_chat() and
text_completion() methods.
Args:
prompt: The prompt to call the model with.
Returns:
The response from the Hugging Face Inference API.
"""
# https://huggingface.co/docs/api-inference/detailed_parameters#text-generation-task
headers = {"Authorization": f"Bearer {self.apikey}"}
payload = {
"inputs": prompt,
**self.kwargs
}
if self.temperature is not None:
payload["temperature"] = self.temperature
response = requests.post(self.API_URL, headers=headers, json=payload)
self.last_response_header = response.headers
response_json = response.json()
return _remove_prompt_from_completion(
prompt=prompt,
completion=response_json[0]['generated_text']
)
def complete_chat(self, messages: List[Message], append_role: str = None, prepend_role: str = None) -> str:
"""
Mimics a chat scenario with BLOOM, via a list of {"role": <str>, "content":<str>} objects.
Args:
messages: The messages to generate a chat completion from.
append_role: The role to append to the end of the prompt.
prepend_role: The role to prepend to the beginning of the prompt.
Returns:
The chat completion.
"""
prompt = self.prep_prompt_from_messages(
messages=messages,
prepend_role=prepend_role,
append_role=append_role,
include_preamble=True
)
res = self._call_model(prompt=prompt)
# TODO consider making this more robust by truncating at first "role" using _get_stop_sequences_from_messages
# Truncate the completion to the first new line since this model tends to pretend to be the user.
return _truncate_completion(res)
def text_completion(self, prompt: str) -> str:
"""
Completes text via BLOOM (Hugging Face).
Args:
prompt: The prompt to generate a text completion from.
Returns:
The text completion.
"""
return self._call_model(prompt=prompt)
class StreamingOpenAIGPTWrapper(StreamingLanguageModelWrapper):
def __init__(
self,
apikey: Optional[str] = None,
model: str = "gpt-3.5-turbo",
format_sse: bool = False,
append_stop_token: bool = True,
stop_token: str = STOP_TOKEN,
temperature: float = None,
api_config: Optional[OPENAI_API_CONFIG] = None,
**kwargs: Any
):
"""
Streaming compliant wrapper for the OpenAI API. Supports all major text and chat completion models by OpenAI.
This wrapper can be configured to use OpenAI's API or Microsoft Azure's API. To use Azure, pass in the
appropriate api_config. To use OpenAI's API, pass in an apikey and model. If both api_config and apikey are
passed in, api_config takes precedence.
Examples:
>>> from phasellm.llms import StreamingOpenAIGPTWrapper
Use OpenAI's API:
>>> llm = StreamingOpenAIGPTWrapper(apikey="my-api-key", model="gpt-3.5-turbo")
>>> llm.text_completion(prompt="Hello, my name is")
"Hello, my name is ChatGPT."
Use OpenAI's API with api_config:
>>> from phasellm.configurations import OpenAIConfiguration
>>> llm = StreamingOpenAIGPTWrapper(api_config=OpenAIConfiguration(
... api_key="my-api-key",
... organization="my-org",
... model="gpt-3.5-turbo"
... ))
Use Azure's API:
>>> from phasellm.configurations import AzureAPIConfiguration
>>> llm = StreamingOpenAIGPTWrapper(api_config=AzureAPIConfiguration(
... api_key="azure_api_key",
... api_base='https://{your-resource-name}.openai.azure.com/openai/deployments/{your-deployment-id}',
... api_version='2023-05-15',
... deployment_id='your-deployment-id'
... ))
>>> llm.text_completion(prompt="Hello, my name is")
"Hello, my name is ChatGPT."
Use Azure's API with Active Directory authentication:
>>> from phasellm.configurations import AzureActiveDirectoryConfiguration
>>> llm = StreamingOpenAIGPTWrapper(api_config=AzureActiveDirectoryConfiguration(
... api_base='https://{your-resource-name}.openai.azure.com/openai/deployments/{your-deployment-id}',
... api_version='2023-05-15',
... deployment_id='your-deployment-id'
... ))
>>> llm.text_completion(prompt="Hello, my name is")
"Hello, my name is ChatGPT."
Args:
apikey: The API key to access the OpenAI API.
model: The model to use. Defaults to "gpt-3.5-turbo".
format_sse: Whether to format the SSE response from OpenAI. Defaults to False.
append_stop_token: Whether to append the stop token to the end of the prompt. Defaults to True.
stop_token: The stop token to use. Defaults to <|END|>.
temperature: The temperature to use for the language model.
api_config: The API configuration to use. Defaults to None. Takes precedence over apikey and model.
**kwargs: Keyword arguments to pass to the OpenAI API.
"""
super().__init__(
format_sse=format_sse,
append_stop_token=append_stop_token,
stop_token=stop_token,
temperature=temperature,
**kwargs
)
if api_config and apikey:
warn("api_config takes precedence over apikey and model arguments.")
if apikey:
self.api_config = OpenAIConfiguration(
api_key=apikey,
model=model
)
if api_config:
self.api_config = api_config
if not hasattr(self, 'api_config'):
raise Exception('Must pass apikey or api_config. If using kwargs, check capitalization.')
self.api_config.response_callback = self._set_last_response_header
# Activate the configuration
self.api_config()
def __repr__(self):
return f"StreamingOpenAIGPTWrapper(model={self.api_config.model})"
def _yield_response(self, response) -> Generator:
"""
Yields the response content. Can handle multiple API versions.
Args:
response: The response to yield text from.
Returns:
Text generator
"""
for chunk in response:
text = None
if not chunk.choices:
text = ''
elif hasattr(chunk.choices[0], 'text'):
text = chunk.choices[0].text
elif hasattr(chunk.choices[0], 'delta') and hasattr(chunk.choices[0].delta, 'text'):
text = chunk.choices[0].delta.text
elif hasattr(chunk.choices[0], 'delta') and hasattr(chunk.choices[0].delta, 'content'):
text = chunk.choices[0].delta.content
if text:
yield _conditional_format_sse_response(content=text, format_sse=self.format_sse)
if self.format_sse and self.append_stop_token:
yield _format_sse(content=self.stop_token)
def complete_chat(self, messages: List[Message], append_role: str = None, prepend_role: str = None) -> Generator:
"""
Completes chat with OpenAI. If using GPT 3.5 or 4, will simply send the list of {"role": <str>, "content":<str>}
objects to the API.
If using an older model, it will structure the messages list into a prompt first.
Yields the text as it is generated, rather than waiting for the entire completion.
Args:
messages: The messages to generate a chat completion from.
append_role: The role to append to the end of the prompt.
prepend_role: The role to prepend to the beginning of the prompt.
Returns:
The chat completion generator.
"""
kwargs = self._prep_common_kwargs(self.api_config)
kwargs['stream'] = True
if ('gpt-4' in self.api_config.model) or ('gpt-3.5' in self.api_config.model):
kwargs["messages"] = messages
response = self.api_config.client.chat.completions.create(**kwargs)
yield from self._yield_response(response)
else:
prompt_text = self.prep_prompt_from_messages(
messages=messages,
prepend_role=prepend_role,
append_role=append_role,
include_preamble=False
)
kwargs["prompt"] = prompt_text
kwargs["stop"] = _get_stop_sequences_from_messages(messages)
response = self.api_config.client.completions.create(**kwargs)
yield from self._yield_response(response)
# TODO Consider error handling for chat models.
def text_completion(self, prompt: str, stop_sequences: List[str] = None) -> Generator:
"""
Completes text via OpenAI. Note that this doesn't support GPT 3.5 or later, as they are chat models.
Yields the text as it is generated, rather than waiting for the entire completion.
Args:
prompt: The prompt to generate a text completion from.
stop_sequences: The stop sequences to use. Defaults to None.
Returns:
The text completion generator.
"""
kwargs = self._prep_common_kwargs(self.api_config)
kwargs = {
"prompt": prompt,
"stream": True,
**kwargs
}
if stop_sequences:
kwargs["stop"] = stop_sequences
response = self.api_config.client.completions.create(**kwargs)
yield from self._yield_response(response)
def _set_last_response_header(self, response: httpx.Response) -> None:
"""
Sets the last response header.
Args:
response: The response to set the last response header from.
Returns:
None
"""
self.last_response_header = response.headers
class OpenAIGPTWrapper(LanguageModelWrapper):
"""
Wrapper for the OpenAI API. Supports all major text and chat completion models by OpenAI.
"""
def __init__(
self,
apikey: Optional[str] = None,
model: str = "gpt-3.5-turbo",
temperature: float = None,
api_config: Optional[OPENAI_API_CONFIG] = None,
**kwargs: Any
):
"""
Wrapper for the OpenAI API. Supports all major text and chat completion models by OpenAI.
This wrapper can be configured to use OpenAI's API or Microsoft Azure's API. To use Azure, pass in the
appropriate api_config. To use OpenAI's API, pass in an apikey and model. If both api_config and apikey are
passed in, api_config takes precedence.
Examples:
>>> from phasellm.llms import OpenAIGPTWrapper
Use OpenAI's API:
>>> llm = OpenAIGPTWrapper(apikey="my-api-key", model="gpt-3.5-turbo")
>>> llm.text_completion(prompt="Hello, my name is")
"Hello, my name is ChatGPT."
Use OpenAI's API with api_config:
>>> from phasellm.configurations import OpenAIConfiguration
>>> llm = OpenAIGPTWrapper(api_config=OpenAIConfiguration(
... api_key="my-api-key",
... organization="my-org",
... model="gpt-3.5-turbo"
... ))
Use Azure's API:
>>> from phasellm.configurations import AzureAPIConfiguration
>>> llm = OpenAIGPTWrapper(api_config=AzureAPIConfiguration(
... api_key="azure_api_key",
... api_base='https://{your-resource-name}.openai.azure.com/openai/deployments/{your-deployment-id}',
... api_version='2023-08-01-preview',
... deployment_id='your-deployment-id'
... ))
>>> llm.text_completion(prompt="Hello, my name is")
"Hello, my name is ChatGPT."
Use Azure's API with Active Directory authentication:
>>> from phasellm.configurations import AzureActiveDirectoryConfiguration
>>> llm = OpenAIGPTWrapper(api_config=AzureActiveDirectoryConfiguration(
... api_base='https://{your-resource-name}.openai.azure.com/openai/deployments/{your-deployment-id}',
... api_version='2023-08-01-preview',
... deployment_id='your-deployment-id'
... ))
>>> llm.text_completion(prompt="Hello, my name is")
"Hello, my name is ChatGPT."
Args:
apikey: The API key to access the OpenAI API.
model: The model to use. Defaults to "gpt-3.5-turbo".
temperature: The temperature to use for the language model.
api_config: The API configuration to use. Defaults to None. Takes precedence over apikey and model.
**kwargs: Keyword arguments to pass to the OpenAI API.
"""
super().__init__(temperature=temperature, **kwargs)
if api_config and apikey:
warn("api_config takes precedence over apikey and model arguments.")
if apikey:
self.api_config = OpenAIConfiguration(
api_key=apikey,
model=model
)
if api_config:
self.api_config = api_config
if not hasattr(self, 'api_config'):
raise Exception('Must pass apikey or api_config. If using kwargs, check capitalization.')
self.api_config.response_callback = self._set_last_response_header
# Activate the configuration
self.api_config()
def __repr__(self):
return f"OpenAIGPTWrapper(model={self.api_config.model})"
def complete_chat(self, messages: List[Message], append_role: str = None, prepend_role: str = None) -> str:
"""
Completes chat with OpenAI. If using GPT 3.5 or 4, will simply send the list of {"role": <str>, "content":<str>}
objects to the API.
If using an older model, it will structure the messages list into a prompt first.
Args:
messages: The messages to generate a chat completion from.
append_role: The role to append to the end of the prompt.
prepend_role: The role to prepend to the beginning of the prompt.
Returns:
The chat completion.
"""
kwargs = self._prep_common_kwargs(self.api_config)
if ('gpt-4' in self.api_config.model) or ('gpt-3.5' in self.api_config.model):
kwargs["messages"] = messages
response = self.api_config.client.chat.completions.create(**kwargs)
return response.choices[0].message.content
else:
prompt_text = self.prep_prompt_from_messages(
messages=messages,
prepend_role=prepend_role,
append_role=append_role,
include_preamble=False
)
kwargs["prompt"] = prompt_text
response = self.api_config.client.completions.create(**kwargs)
return response.choices[0].text
# TODO Consider error handling for chat models.
def text_completion(self, prompt: str, stop_sequences: List[str] = None) -> str:
"""
Completes text via OpenAI. Note that this doesn't support GPT 3.5 or later, as they are chat models.
Args:
prompt: The prompt to generate a text completion from.
stop_sequences: The stop sequences to use. Defaults to None.
Returns:
The text completion.
"""
kwargs = self._prep_common_kwargs(self.api_config)
kwargs['prompt'] = self.prep_prompt(prompt=prompt)
if stop_sequences:
kwargs["stop"] = stop_sequences
response = self.api_config.client.completions.create(**kwargs)
return response.choices[0].text
def _set_last_response_header(self, response: httpx.Response) -> None:
"""
Sets the last response header.
Args:
response: The response to set the last response header from.
Returns:
None
"""
self.last_response_header = response.headers
class StreamingClaudeWrapper(StreamingLanguageModelWrapper):
API_URL = "https://api.anthropic.com/v1/complete"
def __init__(
self,
apikey: str,
model: CLAUDE_MODEL = "claude-2",
format_sse: bool = False,
append_stop_token: bool = True,
stop_token: str = STOP_TOKEN,
temperature: float = None,
anthropic_version: str = "2023-06-01",
**kwargs: Any
):
"""
Streaming wrapper for Anthropic's Claude large language model.
We've opted to call Anthropic's API directly rather than using their Python offering.
Yields the text as it is generated, rather than waiting for the entire completion.
Args:
apikey: The API key to access the Anthropic API.
model: The model to use. Defaults to "claude-2".
format_sse: Whether to format the SSE response. Defaults to False.
append_stop_token: Whether to append the stop token to the end of the prompt. Defaults to True.
stop_token: The stop token to use. Defaults to <|END|>.
temperature: The temperature to use for the language model.
anthropic_version: The version of the Anthropic API to use. See https://docs.anthropic.com/claude/reference/versioning
**kwargs: Keyword arguments to pass to the Anthropic API.
"""
super().__init__(
format_sse=format_sse,
append_stop_token=append_stop_token,
stop_token=stop_token,
temperature=temperature,
**kwargs
)
self.apikey = apikey
self.model = model
self.anthropic_version = anthropic_version
def __repr__(self):
return f"StreamingClaudeWrapper(model={self.model})"
def _call_model(self, prompt: str, stop_sequences: List[str]) -> Generator:
"""
Calls the model with the given prompt.
Args:
prompt: The prompt to generate a text completion from.
stop_sequences: The stop sequences to use. Defaults to None.
Returns:
The text completion generator.
"""
# https://docs.anthropic.com/claude/reference/complete_post
headers = {
"X-API-Key": self.apikey,
"Accept": "text/event-stream",
"anthropic-version": self.anthropic_version
}
kwargs = self._prep_common_kwargs()
kwargs = {
"prompt": prompt,
"model": self.model,
"max_tokens_to_sample": 500,
"stop_sequences": stop_sequences,
"stream": True,
**kwargs
}
resp = requests.post(self.API_URL, headers=headers, json=kwargs, stream=True)
self.last_response_header = resp.headers
client = SSEClient(resp)
strip_index = 0
for event in client.events():
if event.data and event.data != "[DONE]":
# Load the data as JSON
data = json.loads(event.data)
# Extract the completion if it is present.
completion = ''
if "completion" in data:
completion = data["completion"]
# Anthropic's old API returns completions inclusive of previous chunks, so we need to strip them out.
if self.anthropic_version == "2023-01-01":
completion = completion[strip_index:]
strip_index += len(completion)
# If format_sse is True, we need to yield with SSE formatting.
yield _conditional_format_sse_response(content=completion, format_sse=self.format_sse)
if self.format_sse and self.append_stop_token:
yield _format_sse(content=self.stop_token)
def complete_chat(
self,
messages: List[Message],
append_role: str = "Assistant",
prepend_role: str = "Human"
) -> Generator:
"""
Completes chat with Claude. Since Claude doesn't support a chat interface via API, we mimic the chat via a
prompt.
Args:
messages: The messages to generate a chat completion from.
append_role: The role to append to the end of the prompt. Defaults to "Assistant:".
prepend_role: The role to prepend to the beginning of the prompt. Defaults to "Human:".
Returns:
The chat completion generator.
"""
if prepend_role != "Human":
warn("ClaudeWrapper only supports Human as the prepend_role. Ignoring.")
prepend_role = "Human"
if append_role != "Assistant":
warn("ClaudeWrapper only supports Assistant as the append_role. Ignoring.")
append_role = "Assistant"
prompt_text = self.prep_prompt_from_messages(
messages=messages,
prepend_role=prepend_role,
append_role=append_role,
include_preamble=False
)
return self._call_model(
prompt=prompt_text,
stop_sequences=_get_stop_sequences_from_messages(messages)
)
def text_completion(self, prompt: str, stop_sequences: List[str] = None) -> Generator:
"""
Completes text based on provided prompt.
Yields the text as it is generated, rather than waiting for the entire completion.
Args:
prompt: The prompt to generate a text completion from.
stop_sequences: The stop sequences to use. Defaults to None.
Returns:
The text completion generator.
"""
if stop_sequences is None:
stop_sequences = []
prompt = self.prep_prompt(prompt=prompt, prepend_role="Human", append_role="Assistant")
return self._call_model(
prompt=prompt,
stop_sequences=stop_sequences
)
class ClaudeWrapper(LanguageModelWrapper):
API_URL = "https://api.anthropic.com/v1/complete"
def __init__(
self,
apikey: str,
model: CLAUDE_MODEL = "claude-2",
temperature: float = None,
anthropic_version: str = "2023-06-01",
**kwargs: Any
):
"""
Wrapper for Anthropic's Claude large language model.
We've opted to call Anthropic's API directly rather than using their Python offering.
See here for model options: https://docs.anthropic.com/claude/reference/selecting-a-model
Args:
apikey: The API key to access the Anthropic API.
model: The model to use. Defaults to "claude-v1".
temperature: The temperature to use for the language model.
anthropic_version: The version of the Anthropic API to use. See https://docs.anthropic.com/claude/reference/versioning
**kwargs: Keyword arguments to pass to the Anthropic API.
"""
super().__init__(temperature=temperature, **kwargs)
self.apikey = apikey
self.model = model
self.anthropic_version = anthropic_version
def __repr__(self):
return f"ClaudeWrapper(model={self.model})"
def _call_model(self, prompt: str, messages: List[Message]) -> str:
"""
Calls the model with the given prompt.
Args:
prompt: The prompt to call the model with.
messages: The messages to generate stop sequences from.
Returns:
The completion.
"""
# https://docs.anthropic.com/claude/reference/complete_post
headers = {
"X-API-Key": self.apikey,
"Accept": "application/json",
"anthropic-version": self.anthropic_version
}
kwargs = self._prep_common_kwargs()
kwargs = {
"prompt": prompt,
"model": self.model,
"max_tokens_to_sample": 500,
"stop_sequences": _get_stop_sequences_from_messages(messages),
**kwargs
}
resp = requests.post("https://api.anthropic.com/v1/complete", headers=headers, json=kwargs)
self.last_response_header = resp.headers
return json.loads(resp.text)["completion"].strip()
def complete_chat(
self,
messages: List[Message],
append_role: str = "Assistant",
prepend_role: str = "Human"
) -> str:
"""
Completes chat with Claude. Since Claude doesn't support a chat interface via API, we mimic the chat via a
prompt.
Args:
messages: The messages to generate a chat completion from.
append_role: The role to append to the end of the prompt. Defaults to "Assistant:".
prepend_role: The role to prepend to the beginning of the prompt. Defaults to "Human:".
Returns:
The chat completion.
"""
if prepend_role != "Human":
warn("ClaudeWrapper only supports Human as the prepend_role. Ignoring.")
prepend_role = "Human"
if append_role != "Assistant":
warn("ClaudeWrapper only supports Assistant as the append_role. Ignoring.")
append_role = "Assistant"
prompt_text = self.prep_prompt_from_messages(
messages=messages,
prepend_role=prepend_role,
append_role=append_role,
include_preamble=False
)
return self._call_model(prompt_text, messages)
def text_completion(self, prompt: str, stop_sequences: List[str] = None) -> str:
"""
Completes text based on provided prompt.
Args:
prompt: The prompt to generate a text completion from.
stop_sequences: The stop sequences to use. Defaults to None.
Returns:
The text completion.
"""
if stop_sequences is None:
stop_sequences = []
prompt = self.prep_prompt(prompt=prompt, prepend_role="Human", append_role="Assistant")
return self._call_model(prompt, stop_sequences)
# TODO Might want to add stop sequences (new lines, roles) to make this better.
class GPT2Wrapper(LanguageModelWrapper):
def __init__(self, temperature: float = None, **kwargs: Any):
"""
Wrapper for GPT-2 implementation (via Hugging Face).
Note that you must have the phasellm[complete] extra installed to use this wrapper.
Args:
temperature: The temperature to use for the language model.
**kwargs: Keyword arguments to pass to the GPT-2 model.
"""
super().__init__(temperature=temperature, **kwargs)
# Dynamically import torch and transformers to avoid import errors for users who don't have phasellm[complete].
from transformers import pipeline
self.model_name = "GPT-2"
self.pipeline = pipeline('text-generation', model='gpt2')
def __repr__(self):
return f"GPT2Wrapper({self.model_name})"
def _call_model(self, prompt: str, max_length: int = 300) -> str:
"""
Calls the model with the given prompt.
Args:
prompt: The prompt to call the model with.
max_length: The maximum length of the completion. Defaults to 300.
Returns:
The completion.
"""
kwargs = self._prep_common_kwargs()
# https://huggingface.co/docs/transformers/v4.30.0/en/main_classes/text_generation#transformers.GenerationConfig
kwargs = {
"text_inputs": prompt,
"max_length": max_length,
"num_return_sequences": 1,
**kwargs
}
res = self.pipeline(**kwargs)
return _remove_prompt_from_completion(prompt, res[0]['generated_text'])
def complete_chat(
self,
messages: List[Message],
append_role: str = None,
max_length: int = 300,
prepend_role: str = None
) -> str:
"""
Mimics a chat scenario via a list of {"role": <str>, "content":<str>} objects.
Args:
messages: The messages to generate a chat completion from.
append_role: The role to append to the end of the prompt. Defaults to None.
max_length: The maximum length of the completion. Defaults to 300.
prepend_role: The role to prepend to the beginning of the prompt. Defaults to None.
Returns:
The chat completion.
"""
prompt = self.prep_prompt_from_messages(
messages=messages,
prepend_role=prepend_role,
append_role=append_role,
include_preamble=True
)
return self._call_model(prompt=prompt, max_length=max_length)
def text_completion(self, prompt: str, max_length: int = 200) -> str:
"""
Completes text via GPT-2.
Args:
prompt: The prompt to generate a text completion from.
max_length: The maximum length of the completion. Defaults to 200.
Returns:
The text completion.
"""
prompt = self.prep_prompt(prompt=prompt)
return self._call_model(prompt=prompt, max_length=max_length)
class DollyWrapper(LanguageModelWrapper):
def __init__(self, temperature: float = None, **kwargs: Any):
"""
Wrapper for Dolly 2.0 (via Hugging Face).
Note that you must have the phasellm[complete] extra installed to use this wrapper.
Args:
temperature: The temperature to use for the language model.
**kwargs: Keyword arguments to pass to the Dolly model.
"""
super().__init__(temperature=temperature, **kwargs)
# Dynamically import torch and transformers to avoid import errors for users who don't have phasellm[complete].
from transformers import pipeline
import torch
self.model_name = 'dolly-v2-12b'
self.pipeline = pipeline(
"text-generation",
model="databricks/dolly-v2-12b",
torch_dtype=torch.bfloat16,
trust_remote_code=True,
device_map="auto"
)
def __repr__(self):
return f"DollyWrapper(model={self.model_name})"
def _call_model(self, prompt: str) -> str:
"""
Calls the model with the given prompt.
Args:
prompt: The prompt to call the model with.
Returns:
The completion.
"""
kwargs = self._prep_common_kwargs()
kwargs = {
"inputs": prompt,
"num_return_sequences": 1,
**kwargs
}
res = self.pipeline(**kwargs)
return _remove_prompt_from_completion(prompt, res[0]['generated_text'])
def complete_chat(self, messages: List[Message], append_role: str = None, prepend_role: str = None) -> str:
"""
Mimics a chat scenario via a list of {"role": <str>, "content":<str>} objects.
Args:
messages: The messages to generate a chat completion from.
append_role: The role to append to the end of the prompt. Defaults to None.
prepend_role: The role to prepend to the beginning of the prompt. Defaults to None.
Returns:
The chat completion.
"""
prompt = self.prep_prompt_from_messages(
messages=messages,
prepend_role=prepend_role,
append_role=append_role,
include_preamble=True
)
return self._call_model(prompt=prompt)
def text_completion(self, prompt: str) -> str:
"""
Completes text via Dolly.
Args:
prompt: The prompt to generate a text completion from.
Returns:
The text completion.
"""
prompt = self.prep_prompt(prompt=prompt)
return self._call_model(prompt=prompt)
class ReplicateLlama2Wrapper(LanguageModelWrapper):
base_system_chat_prompt = "You are a friendly chatbot."
"""str: Used in defining the system prompt for Llama 2 calls. Only used if a system prompt doesn't exist in the message stack provided."""
first_user_message = "Hi."
"""str: Used as the first 'user' message in chat completions when the chat's first non-system message is from 'assistant'."""
def __init__(self, apikey: str, model: str = "meta/llama-2-70b-chat:02e509c789964a7ea8736978a43525956ef40397be9033abf9fd2badfe68c9e3", temperature: float = None, **kwargs: Any):
"""
Wrapper for Llama 2, provided via Replicate. See https://replicate.com/ for more information.
Args:
apikey: The Replicate API key to use.
model: The Llama 2 model to use.
temperature: The temperature to use for the language model.
**kwargs: Keyword arguments to pass to the API.
"""
super().__init__(temperature=temperature, **kwargs)
self.model = model
self.apikey = apikey
self.temperature = temperature if temperature is not None else 0.5
def __repr__(self):
return f"ReplicateLlama2Wrapper(model={self.model})"
def build_chat_completion_prompt(self, messages: List[Message]):
"""
Converts a list of messages into a properly structured Llama 2 prompt for chats, as outlined here: https://huggingface.co/blog/llama2#how-to-prompt-llama-2
Note that we make a few changes to the process above: (1) if a system prompt does not exist, we use a very basic default prompt. Otherwise, we convert the system prompt to the relevant instructions in the Llama 2 chat prompt.
Next, we iterate through the the rest of the message stack. We assume that the message stack contains alternating messages from a 'user' and 'assistant'. If your first messages outside of a system prompt is from the 'assistant', then we include a 'Hi.' messages from the user.
Please note that this is a work in progress. If you have feedback on the process about, email w --at-- phaseai --dot-- com
Args:
messages: The messages to generate a chat completion from.
append_role: The role to append to the end of the prompt. Defaults to None.
prepend_role: The role to prepend to the beginning of the prompt. Defaults to None.
Returns:
The chat completion.
"""
msgs = messages.copy()
if len(msgs) >= 1:
if not msgs[0]['role'] == 'system':
msgs.insert(0, {"role":"system", "content":self.base_system_chat_prompt})
if msgs[1]['role'].lower() == 'assistant':
msgs.insert(1, {"role":"user", "content":self.first_user_message})
completion_prompt = f"""<s>[INST] <<SYS>>{msgs[0]['content']}<</SYS>>"""
# This means we only have a system prompt and user message, so we need to provide a completion example.
if len(msgs) == 2:
completion_prompt += """User: Hello! [/INST]
Assistant: Greetings! How are you doing today?</s>"""
else:
completion_prompt += f"""User: {msgs[1]['content']} [/INST]
Assistant: {msgs[2]['content']}</s>"""
# Doesn't actually run if len(msgs) == 2
for i in range(3, len(msgs) - 1, 2):
completion_prompt += f"""<s>[INST]User: {msgs[i]['content']} [/INST]
Assistant: {msgs[i+1]['content']}?</s>"""
completion_prompt += f"""<s>[INST]User: {messages[-1]['content']}[/INST]"""
return completion_prompt
def _clean_response(self, assistant_message:str) -> str:
"""
Cleans up the chat response, mainly by stripping whitespace and removing "Assistant:" prepends.
Args:
assistant_message: The message received from the API.
Returns:
The chat completion, cleaned up.
"""
am = assistant_message.strip()
if am.find("Assistant:") == 0:
am = am[10:].strip()
return am
def complete_chat(self, messages: List[Message], append_role: str = None, prepend_role: str = None) -> str:
"""
Mimics a chat scenario via a list of {"role": <str>, "content":<str>} objects.
Args:
messages: The messages to generate a chat completion from.
Returns:
The chat completion.
"""
if append_role is not None or prepend_role is not None:
warnings.warn("Warning: PhaseLLM's implementation of Llama 2 does not support changing roles. We will stick to 'user' and 'assistant' roles.")
chat_prompt = self.build_chat_completion_prompt(messages)
client = replicate.Client(api_token = self.apikey)
output = client.run(
"meta/llama-2-70b-chat:02e509c789964a7ea8736978a43525956ef40397be9033abf9fd2badfe68c9e3",
input={
"debug": False,
"top_k": 50,
"top_p": 1,
"prompt": chat_prompt,
"temperature": 0.5,
"system_prompt": "",
"max_new_tokens": 1000,
"min_new_tokens": -1,
"stop_sequences": "</s>"
}
)
new_text = ""
for x in output:
new_text += x
new_text = self._clean_response(new_text)
return new_text
def text_completion(self, prompt: str, stop_sequences: List[str] = None) -> str:
"""
Completes text via Replicate's Llama 2 service.
Args:
prompt: The prompt to generate a text completion from.
stop_sequences: The stop sequences to use. Defaults to None.
Returns:
The text completion.
"""
input_call = {
"debug": False,
"top_k": 50,
"top_p": 1,
"prompt": prompt,
"temperature": self.temperature,
"system_prompt": "",
"max_new_tokens": 1000,
"min_new_tokens": -1,
}
if stop_sequences is not None:
input_call["stop_sequences"] = ",".join(stop_sequences)
client = replicate.Client(api_token = self.apikey)
output = client.run(
"meta/llama-2-70b-chat:02e509c789964a7ea8736978a43525956ef40397be9033abf9fd2badfe68c9e3",
input=input_call
)
new_text = ""
for x in output:
new_text += x
return new_text
class CohereWrapper(LanguageModelWrapper):
def __init__(self, apikey: str, model: str = "xlarge", temperature: float = None, **kwargs: Any):
"""
Wrapper for Cohere's API.
Args:
apikey: The API key to use.
model: The model to use. Defaults to "xlarge".
temperature: The temperature to use for the language model.
**kwargs: Keyword arguments to pass to the Cohere API.
"""
super().__init__(temperature=temperature, **kwargs)
self.model = model
self.co = cohere.Client(apikey)
def __repr__(self):
return f"CohereWrapper(model={self.model})"
def _call_model(self, prompt, stop_sequences: List[str]):
"""
Calls the model with the given prompt.
Args:
prompt: The prompt to call the model with.
stop_sequences: The stop sequences to use.
Returns:
The completion.
"""
kwargs = self._prep_common_kwargs()
# https://docs.cohere.com/reference/generate
kwargs = {
"prompt": prompt,
"max_tokens": 300,
"stop_sequences": stop_sequences,
**kwargs
}
response = self.co.generate(**kwargs)
return response.generations[0].text
def complete_chat(self, messages: List[Message], append_role: str = None, prepend_role: str = None) -> str:
"""
Mimics a chat scenario via a list of {"role": <str>, "content":<str>} objects.
Args:
messages: The messages to generate a chat completion from.
append_role: The role to append to the end of the prompt. Defaults to None.
prepend_role: The role to prepend to the beginning of the prompt. Defaults to None.
Returns:
The chat completion.
"""
prompt_text = self.prep_prompt_from_messages(
messages=messages,
prepend_role=prepend_role,
append_role=append_role,
include_preamble=False
)
stop_sequences = _get_stop_sequences_from_messages(messages)
res = self._call_model(prompt=prompt_text, stop_sequences=stop_sequences)
for s in stop_sequences:
res = res.replace(s, "").strip()
return res
def text_completion(self, prompt: str, stop_sequences: List[str] = None) -> str:
"""
Completes text via Cohere.
Args:
prompt: The prompt to generate a text completion from.
stop_sequences: The stop sequences to use. Defaults to None.
Returns:
The text completion.
"""
if stop_sequences is None:
stop_sequences = []
prompt = self.prep_prompt(prompt=prompt)
return self._call_model(prompt=prompt, stop_sequences=stop_sequences)
class ChatBot:
def __init__(self, llm: LanguageModelWrapper, initial_system_prompt: str = "You are a friendly chatbot assistant."):
"""
Allows you to have a chat conversation with an LLM wrapper.
In short, it manages the list of {"role": <str>, "content":<str>} objects for you, so you don't have to figure
this out. It also interacts directly with the model.
Warning: not all LLMs are trained to use instructions provided in a system prompt.
Args:
llm: The LLM wrapper to use for the ChatBot.
initial_system_prompt: The initial system prompt to use. Defaults to "You are a friendly chatbot
assistant.". Use this to change the behavior of the chatbot.
"""
self.llm: LanguageModelWrapper = llm
self.messages: List[EnhancedMessage] = []
self.append_message('system', initial_system_prompt)
def _response(self, response: str, start_time: float) -> str:
"""
Handles a response from the LLM by appending it to the message stack.
Args:
response: The response from the LLM.
start_time: The start time of the request.
Returns:
The response.
"""
self.append_message('assistant', response, log_time_seconds=time.time() - start_time)
return response
def _streaming_response(self, response: Generator, start_time: float) -> Generator:
"""
Handles a streaming response from the LLM by appending it to the message stack.
Since the response is a generator, we'll need intercept it so that we can append it to the message stack.
(Generators only yield their results once).
Args:
response: The response from the LLM.
start_time: The start time of the request.
Returns:
The response.
"""
full_response = ''
for chunk in response:
full_response += chunk
yield chunk
self.append_message('assistant', full_response, log_time_seconds=time.time() - start_time)
def append_message(self, role: str, message: str, log_time_seconds: float = None) -> None:
"""
Saves a message to the ChatBot message stack.
Args:
role: The role of the message.
message: The message.
log_time_seconds: The time it took to generate the message. Defaults to None.
"""
# Create the message object.
append_me: EnhancedMessage = {
"role": role,
"content": message,
"timestamp_utc": datetime.now()
}
# Save how long it took to generate the message, if provided.
if log_time_seconds is not None:
append_me["log_time_seconds"] = log_time_seconds
self.messages.append(append_me)
def resend(self) -> Optional[Union[str, Generator]]:
"""
If the last message in the messages stack (i.e. array of role and content pairs) is from the user, it will
resend the message and return the response. It's similar to erasing the last message in the stack and resending
the last user message to the chat model.
This is useful if a model raises an error or if you are building a broader messages stack outside of the
actual chatbot.
Returns:
The response from the chatbot if the last message in the stack was from the user. Otherwise, None.
"""
# TODO consider if this is necessary, given the TODO suggestion in self.chat().
last_message = self.messages.pop()
if last_message['role'] == 'user':
return self.chat(last_message['content'])
else:
self.messages.append(last_message)
def chat(self, message: str) -> Union[str, Generator]:
"""
Chats with the chatbot.
Args:
message: The message to send to the chatbot.
Returns:
The response from the chatbot. Either a string or a generator, depending on if a streaming LLM wrapper is
used.
"""
# TODO consider appending user message only after a successful call to self.llm.complete_chat().
self.append_message('user', message)
start_time = time.time()
clean_messages = [] # We remove fields that the ChatBot class specifically tracks.
for m in self.messages:
m_copy = {"role": m["role"], "content": m["content"]}
clean_messages.append(m_copy)
response = self.llm.complete_chat(clean_messages, append_role='Assistant')
if isinstance(response, Generator):
return self._streaming_response(response=response, start_time=start_time)
else:
return self._response(response=response, start_time=start_time)
| [
"PLACEHOLDER\n\nPLACEHOLDER:",
"\n\nPLACEHOLDER: PLACEHOLDER",
"You are a friendly chatbot.",
"Assistant",
"PLACEHOLDER: PLACEHOLDER",
"Human",
"content",
"User: Hello! [/INST]\nAssistant: Greetings! How are you doing today?</s>"
] |
2024-01-10 | wgryc/phasellm | demos-and-products~newsbot~newsbot.py | """
Sample code for getting a list of news articles, having OpenAI summarize them, and then deploying an email with the summaries.
"""
from phasellm.agents import EmailSenderAgent, NewsSummaryAgent
from phasellm.llms import OpenAIGPTWrapper, ClaudeWrapper
queries = ["inflation", "openai", "llm"] # We will generate a summary for each element in the list
##########################################################################
#
# ENVIRONMENT VARIABLES (Gmail, News API, etc.) (START)
# Update this to customize your newsbot experience.
#
import os
from dotenv import load_dotenv
load_dotenv()
# Load OpenAI and newsapi.org API keys
openai_api_key = os.getenv("OPENAI_API_KEY")
news_api_api_key = os.getenv("NEWS_API_API_KEY")
# Load Anthropic API key
anthropic_api_key = os.getenv("ANTHROPIC_API_KEY")
# Gmail credentials.
gmail_email = os.getenv("GMAIL_EMAIL")
gmail_password = os.getenv("GMAIL_PASSWORD")
RECIPIENT_EMAIL="<who will get the email summary>"
SENDER_NAME="<who is sending the email>"
#
# ENVIRONMENT VARIABLES (END)
#
##########################################################################
def getArticlesAndSummarize(news_agent, llm, query, days_back=1, include_description=True, max_articles=30):
"""
See NewsSummaryAgent docs for what the above variables mean.
"""
# First, we obtain the news articles for the query We limit this to 30 articles going back 1 day.
news_articles = news_agent.getQuery(query, days_back=1, include_descriptions=True, max_articles=max_articles)
# Set up messages for summarization.
system = "You are a helpful news summarizer. We will provide you with a list of news articles and will ask that you summarize them and retain links to source by adding footnotes. For example, if you have a news article describing XYZ and URL to the article, you would discuss XYZ[1] and add '[1] URL' to the bottom of the message. The footnote numbers should start at [1] and increase consecutively. In other words, footnotes should start at 1, 2, 3, etc. For the actual paragraph, you can reorder reference articles and choose the ones to include as to make the paragraph as informative, pithy, and concise as possible. You can also have multiple footnotes per sentence if this helps tell the story. While you should avoid adding your own commentary in most cases, feel free to do so if it will help the reader understand the context of the paragraph you are writing."
user_prompt = f"The articles below are about '{query}'. Please summarize them into a short paragraph with link retained as per the earlier instructions.\n\n{news_articles}"
messages = [{"role":"system", "content":system}, {"role":"user", "content":user_prompt}]
news_message = llm.complete_chat(messages)
return news_message
# News agent
news_agent = NewsSummaryAgent(news_api_api_key, name="tester agent")
# OpenAI model, GPT-4. You can use other models, of course.
#llm = OpenAIGPTWrapper(openai_api_key, model="gpt-4")
#MAX_ARTICLES = 30
# Claude (Anthropic) with 100K tokens.
llm = ClaudeWrapper(anthropic_api_key, model="claude-v1-100k")
MAX_ARTICLES = 100
news_content = ""
for query in queries:
content = getArticlesAndSummarize(news_agent, llm, query, max_articles=MAX_ARTICLES)
news_content += f"# News for {query}\n\n{content}\n\n"
# Generate subject line.
news_subject = f"News about: {', '.join(queries)}"
# Send email.
e = EmailSenderAgent(SENDER_NAME, 'smtp.gmail.com', gmail_email, gmail_password, 587)
e.sendPlainEmail(RECIPIENT_EMAIL, news_subject, news_content)
| [
"The articles below are about 'PLACEHOLDER'. Please summarize them into a short paragraph with link retained as per the earlier instructions.\n\nPLACEHOLDER"
] |
2024-01-10 | wgryc/phasellm | phasellm~configurations.py | import httpx
from warnings import warn
from openai import OpenAI
from abc import ABC, abstractmethod
from phasellm.utils import coerce_azure_base_url
from azure.identity import DefaultAzureCredential
class APIConfiguration(ABC):
def __init__(self, model: str = 'gpt-3.5-turbo'):
self.model = model
@abstractmethod
def __call__(self):
"""
Abstract method to initialize the API configuration.
Returns:
"""
pass
@abstractmethod
def get_base_api_kwargs(self):
"""
Abstract method for the base API kwargs for the API configuration.
Returns:
"""
pass
class OpenAIConfiguration(APIConfiguration):
name = 'openai'
def __init__(
self,
api_key: str,
organization: str = None,
model: str = 'gpt-3.5-turbo'
):
"""
Initializes the OpenAI API configuration.
Args:
api_key: The OpenAI API key.
organization: The OpenAI organization.
model: The model to use.
"""
super().__init__(model=model)
self.api_key = api_key
self.organization = organization
self.response_callback = lambda response: None
def __call__(self):
"""
Calls the OpenAI API configuration to initialize the OpenAI API.
Returns:
"""
self.client = OpenAI(
http_client=httpx.Client(event_hooks={'response': [self.response_callback]}),
api_key=self.api_key,
organization=self.organization
)
def get_base_api_kwargs(self):
"""
Returns the base API kwargs for the OpenAI API configuration.
Returns:
A Dict of the base API kwargs for the OpenAI API configuration.
"""
return {
'model': self.model
}
class AzureAPIConfiguration(APIConfiguration):
name = 'azure'
def __init__(
self,
api_key: str,
base_url: str = None,
api_version: str = '2023-05-15',
deployment_id: str = 'gpt-3.5-turbo',
api_base: str = None
):
"""
Initializes the Azure API configuration.
Args:
api_key: The Azure API key.
base_url: The Azure API base URL.
api_version: The Azure API version.
deployment_id: The model deployment ID.
api_base: (DEPRECATED) The Azure API base.
"""
super().__init__(model=deployment_id)
if api_base:
warn('The api_base argument is deprecated. Use base_url instead.', DeprecationWarning)
self.api_key = api_key
self.api_version = api_version
self.base_url = base_url
if api_base:
self.base_url = api_base
self.base_url = coerce_azure_base_url(self.base_url)
self.deployment_id = deployment_id
self.response_callback = lambda response: None
def __call__(self):
"""
Calls the Azure API configuration to initialize the Azure API.
Returns:
"""
# Reset the OpenAI API configuration.
self.client = OpenAI(
api_key=self.api_key,
base_url=self.base_url,
default_query={
'api-version': self.api_version
},
default_headers={
'api-key': self.api_key
},
http_client=httpx.Client(event_hooks={'response': [self.response_callback]}),
)
def get_base_api_kwargs(self):
"""
Returns the base API kwargs for the Azure API configuration.
Returns:
A Dict of the base API kwargs for the Azure API configuration.
"""
return {
'model': self.deployment_id
}
class AzureActiveDirectoryConfiguration:
name = 'azure_ad'
def __init__(
self,
base_url: str,
api_version: str = '2023-05-15',
deployment_id: str = 'gpt-3.5-turbo',
api_base: str = None
):
"""
Initializes the Azure Active Directory API configuration.
Learn more:
https://learn.microsoft.com/en-us/azure/ai-services/openai/how-to/switching-endpoints#azure-active-directory-authentication
Args:
base_url: The Azure Active Directory API base.
api_version: The API version. https://learn.microsoft.com/en-us/azure/ai-services/openai/reference
deployment_id: The model deployment ID
api_base: (DEPRECATED) The Azure Active Directory API base.
"""
super().__init__(model=deployment_id)
if api_base:
warn('The api_base argument is deprecated. Use base_url instead.', DeprecationWarning)
self.base_url = base_url
if api_base:
self.base_url = api_base
self.base_url = coerce_azure_base_url(self.base_url)
self.api_version = api_version
self.deployment_id = deployment_id
self.response_callback = lambda response: None
def __call__(self):
"""
Calls the Azure Active Directory API configuration to initialize the Azure Active Directory API.
Returns:
"""
# Set the OpenAI API configuration.
credential = DefaultAzureCredential()
token = credential.get_token('https://cognitiveservices.azure.com/.default')
# Reset the OpenAI API configuration.
self.client = OpenAI(
api_key=token.token,
base_url=self.base_url,
http_client=httpx.Client(event_hooks={'response': [self.response_callback]}),
default_query={
'api-version': self.api_version
}
)
def get_base_api_kwargs(self):
"""
Returns the base API kwargs for the Azure Active Directory API configuration.
Returns:
A Dict containing the base API kwargs for the Azure Active Directory API configuration.
"""
return {
'deployment_id': self.deployment_id
}
| [] |
2024-01-10 | KillSwitch140/Gforce | zap.py | # import streamlit as st
# from langchain.llms import OpenAI
# from langchain.agents import initialize_agent
# from langchain.agents.agent_toolkits import ZapierToolkit
# from langchain.utilities.zapier import ZapierNLAWrapper
# import os
# from os import environ
# import time
# zapier_nla_api_key = st.secrets["ZAP_API_KEY"]
# environ["ZAPIER_NLA_API_KEY"] = zapier_nla_api_key
# openai_api_key = st.secrets["OPENAI_API_KEY"]
# llm = OpenAI(temperature=0)
# zapier = ZapierNLAWrapper()
# toolkit = ZapierToolkit.from_zapier_nla_wrapper(zapier)
# agent = initialize_agent(toolkit.get_tools(), llm, agent="zero-shot-react-description", verbose=True)
# def schedule_interview(person_name, person_email, date, time):
# # Create the combined string
# meeting_title = f"Hiring Plug Interview with {person_email}"
# date_time = f"{date} at {time}"
# schedule_meet = f"Schedule a 30 min virtual Google Meet titled {meeting_title} on {date_time}. Add the created meeting's details as a new event in my calendar"
# send_email = (
# f"Draft email to {person_email}"
# )
# # Execute the agent.run function for scheduling the meeting
# agent.run(schedule_meet)
# agent.run(send_email)
# return True # Return True if the interview is scheduled and the email is sent successfully
| [] |
2024-01-10 | KillSwitch140/Gforce | Gforce.py | import streamlit as st
import datetime
import os
from os import environ
import PyPDF2
from langchain.llms import OpenAI
from langchain.memory import ConversationBufferMemory
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import Chroma
from langchain.chains import RetrievalQA
from langchain.prompts import PromptTemplate
from langchain.chat_models import ChatOpenAI
from langchain.chat_models import ChatCohere
from langchain.chains import LLMChain
from langchain.prompts import ChatPromptTemplate, SystemMessagePromptTemplate, MessagesPlaceholder, HumanMessagePromptTemplate
from langchain.chains.question_answering import load_qa_chain
from langchain.text_splitter import CharacterTextSplitter
from langchain.docstore.document import Document
from langchain.prompts import PromptTemplate
from langchain.indexes.vectorstore import VectorstoreIndexCreator
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.embeddings import CohereEmbeddings
from langchain.chains import ConversationalRetrievalChain
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.vectorstores import Chroma
from langchain.chains import RetrievalQA
cohere_api_key = st.secrets["COHERE_API_KEY"]
openai_api_key = st.secrets["OPENAI_API_KEY"]
def read_pdf_text(uploaded_file):
pdf_reader = PyPDF2.PdfReader(uploaded_file)
text = ""
for page in pdf_reader.pages:
text += page.extract_text()
return text
def generate_response(doc_texts, cohere_api_key, query_text):
# Define the character's name and description
text_splitter = RecursiveCharacterTextSplitter(separators=["\n"],chunk_size=1000, chunk_overlap=100)
texts = text_splitter.split_text(doc_texts)
#print(texts)
chat_model = ChatCohere(cohere_api_key=cohere_api_key, model='command',temperature=0.1)
embeddings = CohereEmbeddings(cohere_api_key=cohere_api_key)
# Create a vectorstore from documents
vectorstore = Chroma.from_texts(texts, embeddings)
# Create retriever interface
# Initialize the chat model for the character
chat_model = ChatCohere(cohere_api_key=cohere_api_key, model='command',temperature=0.0)
user_input2 = "Why was Ollivander curious?"
# Create the memory object
memory=ConversationBufferMemory(
memory_key='chat_history', return_messages=True)
search = vectorstore.similarity_search(user_input2)
print(search[0])
# Create the QA chain with memory
conversation_chain = ConversationalRetrievalChain.from_llm(
llm=chat_model,
retriever= vectorstore.as_retriever(),
memory=memory
)
response = conversation_chain({'question': user_input2})
# Ask a question and get the answer
print(response['chat_history'][1].content)
# Store LLM generated responses
if "messages" not in st.session_state.keys():
st.session_state.messages = [{"role": "assistant", "content": "You are a AI assistant created to help hiring managers review resumes and shortlist candidates. You have been provided with resumes and job descriptions to review. When asked questions, use the provided documents to provide helpful and relevant information to assist the hiring manager. Be concise, polite and professional. Do not provide any additional commentary or opinions beyond answering the questions directly based on the provided documents."}]
# Page title
st.set_page_config(page_title='Gforce Resume Assistant', layout='wide')
st.title('Gforce Resume Assistant')
# File upload
uploaded_files = st.file_uploader('Please upload you resume(s)', type=['txt'], accept_multiple_files=True)
# Query text
query_text = st.text_input('Enter your question:', placeholder='Select candidates based on experience and skills')
# Initialize chat placeholder as an empty list
if "chat_placeholder" not in st.session_state.keys():
st.session_state.chat_placeholder = []
# Form input and query
if st.button('Submit', key='submit_button'):
if openai_api_key.startswith('sk-'):
if uploaded_files and query_text:
documents = [uploaded_file.read().decode()]
with st.spinner('Chatbot is typing...'):
response = generate_response(documents, cohere_api_key, query_text)
st.session_state.chat_placeholder.append({"role": "user", "content": query_text})
st.session_state.chat_placeholder.append({"role": "assistant", "content": response})
# Update chat display
for message in st.session_state.chat_placeholder:
with st.chat_message(message["role"]):
st.write(message["content"])
else:
st.warning("Please upload one or more PDF files and enter a question to start the conversation.")
def clear_chat_history():
st.session_state.messages = [{"role": "assistant", "content": "How may I assist you today?"}]
st.session_state.chat_placeholder = []
uploaded_files.clear()
query_text = ""
st.empty() # Clear the chat display
st.button('Clear Chat History', on_click=clear_chat_history)
| [
"You are a AI assistant created to help hiring managers review resumes and shortlist candidates. You have been provided with resumes and job descriptions to review. When asked questions, use the provided documents to provide helpful and relevant information to assist the hiring manager. Be concise, polite and professional. Do not provide any additional commentary or opinions beyond answering the questions directly based on the provided documents.",
"How may I assist you today?"
] |
2024-01-10 | Woronokin/telegram-bot-chatgpt | telechat.py | import openai
from aiogram import Bot, types
from aiogram.dispatcher import Dispatcher
from aiogram.utils import executor
token = 'TELEGRAM_BOT_TOKEN'
openai.api_key = 'OPENAI_KEY'
bot = Bot(token)
dp = Dispatcher(bot)
# print(openai.Model.list())
users = {tg_id1,tg_id2}
accepted_users = lambda message: message.from_user.id not in users
@dp.message_handler(accepted_users, content_types=['any'])
async def handle_unwanted_users(message: types.Message):
await message.answer("Извините, бот работает только для одобренных пользователей. Если вы хотите написать такой же бот - перейдите по ссылке: https://nikonorow.ru/pishem-telegram-bota-chatgpt-na-python/")
return
max_symbols = lambda message: int(len(message.text)) > 2000
@dp.message_handler(max_symbols, content_types=['any'])
async def handle_unwanted_users(message: types.Message):
await message.answer("Ошибка! Введенное количество символов превышает максимальное значение в 2000 \n\nКоличество введенных символов: " + str(len(message.text)) + "\n\nСократите Ваш запрос \n\nЧитайте подробнее о токенах OpenAI API: https://nikonorow.ru/kolichestvo-tokenov-postupleniya-openai-api-python/")
return
@dp.message_handler()
async def send(message: types.Message):
response = openai.Completion.create(
model="text-davinci-003",
prompt=message.text,
temperature=0.9,
max_tokens=4000,
top_p=1.0,
frequency_penalty=0.0,
presence_penalty=0.6,
stop=[" Human:", " AI:"]
)
await message.answer(response['choices'][0]['text'])
executor.start_polling(dp, skip_updates=True)
| [] |
2024-01-10 | omeh2003/telegram_chat | summarizers~gpt_summarizer.py | import openai
def summarize_text(text):
model = "gpt-4"
messages = [{"role": "user", "content": text}]
completion = openai.ChatCompletion.create(model=model, messages=messages)
response = completion.choices[0].message.content
return response
| [] |
2024-01-10 | abhijithasokan/integrating_topics_and_syntax | metrics.py | import os
from pprint import pprint
import gensim.corpora as corpora
from gensim.models.coherencemodel import CoherenceModel
import numpy as np
import matplotlib.pyplot as plt
PHI_Z_FILE = "phi_z.txt"
PHI_C_FILE = "phi_c.txt"
dir_name = "output/0.3_0.3_0.1_0.2_10_5_5000_news_5100"
def plot(x,y,type):
# Show graph
plt.figure(figsize=(8,6))
plt.plot(x, y,label=type)
plt.title(f"Coherence score per iteration ({type})")
plt.xlabel("n_iter")
plt.ylabel("Coherence score")
plt.legend()
plt.xticks(rotation=45)
plt.savefig(os.path.join(dir_name,f"{type}_n_iter_news.png"))
def get_data(type):
if type=='test':
dir_name = os.path.join(".","news_3000_test")
else:
dir_name = os.path.join(".","news_5100")
with open(os.path.join(dir_name, "documents.txt"), "r") as documents_file:
data = documents_file.read().splitlines()
documents = [[int(w) for w in d.split(' ')] for d in data if d != '']
with open(os.path.join(dir_name, "vocab.txt"), "r") as vocab_file:
vocab = vocab_file.read().split(' ')
return vocab,documents
def metrics(type,PHI_Z_FILE=PHI_Z_FILE, dir_name=dir_name):
vocab,docs = get_data('train')
vocab_test,docs_test = get_data('test')
list_of_docs = []
for doc in docs_test:
doc_str_list = []
for word_id in doc:
word = vocab_test[word_id]
doc_str_list.append(word)
list_of_docs.append(doc_str_list)
id2word = corpora.Dictionary(list_of_docs)
corpus = [id2word.doc2bow(text) for text in list_of_docs]
def get_top_k_words_from_topic(topic_id: int, k: int):
top_k_words = np.argsort(topic_word_counts[topic_id])[:-k - 1:-1]
return [vocab[word_id] for word_id in top_k_words]
iter_list =[]
coh_list = []
topics=[]
for subdir, _, files in os.walk(dir_name):
for file in files:
if 'iter' in subdir and PHI_Z_FILE==file:
iter_name = subdir.split('\\')[1]
topic_word_counts = np.loadtxt(os.path.join(subdir, PHI_Z_FILE))
topics = [get_top_k_words_from_topic(t, 5) for t in range(10)]
iter_list.append(iter_name)
cm = CoherenceModel(topics=topics,texts = list_of_docs,corpus=corpus, dictionary=id2word, coherence=type)
coh_list.append(cm.get_coherence())
pprint(topics)
plot(iter_list,coh_list,type)
def class_words():
subdir = os.path.join(dir_name,f"iter_3600")
vocab,docs = get_data('train')
class_word_counts = np.loadtxt(os.path.join(subdir, PHI_C_FILE))
def get_top_k_words_from_class( class_id: int, k: int):
top_k_words = np.argsort(class_word_counts[class_id])[:-k - 1:-1]
return [vocab[word_id] for word_id in top_k_words]
return [get_top_k_words_from_class(t, 10) for t in range(5)]
if __name__ == "__main__":
# metrics(type='c_v')
pprint(class_words()) | [] |
2024-01-10 | abhijithasokan/integrating_topics_and_syntax | pure_lda.py | import os
from pprint import pprint
import gensim
import gensim.corpora as corpora
from gensim.models import CoherenceModel
import matplotlib.pyplot as plt
def get_data():
dir_name = os.path.join(".","data2000")
with open(os.path.join(dir_name, "documents.txt"), "r") as documents_file:
data = documents_file.read().splitlines()
documents = [[int(w) for w in d.split(' ')] for d in data if d != '']
with open(os.path.join(dir_name, "vocab.txt"), "r") as vocab_file:
vocab = vocab_file.read().split(' ')
return vocab,documents
def pure_lda():
vocab,docs = get_data()
list_of_docs = []
for doc in docs:
doc_str_list = []
for word_id in doc:
word = vocab[word_id]
doc_str_list.append(word)
list_of_docs.append(doc_str_list)
# Create Dictionary
id2word = corpora.Dictionary(list_of_docs)
# Create Corpus
texts = list_of_docs
# Term Document Frequency
corpus = [id2word.doc2bow(text) for text in texts]
# lda_model = gensim.models.ldamodel.LdaModel(corpus=corpus,
# id2word=id2word,
# num_topics=20,
# random_state=100,
# update_every=1,
# chunksize=100,
# passes=10,
# alpha='auto',
# per_word_topics=True)
# for i, topic in lda_model.show_topics(num_topics=10, formatted=False):
# print('Topic {}: {}'.format(i, ', '.join([word[0] for word in topic])))
# # Compute Perplexity
# print('\nPerplexity: ', lda_model.log_perplexity(corpus))
# a measure of how good the model is. lower the better.
# Compute Coherence Score
# coherence_model_lda = CoherenceModel(model=lda_model,topn=1, texts=list_of_docs, dictionary=id2word, coherence='c_v')
# coherence_lda = coherence_model_lda.get_coherence_per_topic()
# print('\nCoherence Score: ', coherence_lda)
coherence_values = []
num_topics_list = []
for num_topics in range(1, 22, 5):
model=gensim.models.ldamodel.LdaModel(corpus=corpus,
id2word=id2word,
num_topics=num_topics,
random_state=100,
update_every=1,
chunksize=100,
passes=10,
alpha='auto',
per_word_topics=True)
num_topics_list.append(f"{num_topics}")
coherencemodel = CoherenceModel(model=model,topn=10, texts=list_of_docs, dictionary=id2word, coherence='c_v')
coherence_values.append(coherencemodel.get_coherence())
return num_topics_list, coherence_values
def plot(x,y,type):
# Show graph
plt.figure(figsize=(8,6))
plt.plot(x, y,label=type)
plt.title(f"Coherence score/ num topics ({type})")
plt.xlabel("n_topics")
plt.ylabel("Coherence score")
plt.legend()
plt.xticks(rotation=45)
plt.savefig(f"{type}_n_topics_news_pure.png")
if __name__ == "__main__":
x,y = pure_lda()
pprint(x)
pprint(y)
plot(x,y,'c_v') | [] |
2024-01-10 | shmublu/LLM-logic_puzzle-solver-grader | LLM-solver-grader.py | import re
import subprocess
import tempfile
import os
from openai import OpenAI
import datetime
import csv
class NaiveSolver:
def __init__(self, LLMapi, examples=None):
self.examples = examples
self.LLMapi = LLMapi
self.conversation = [example for example in self.examples] if self.examples else []
def solve_puzzle(self, prompt):
self.conversation.append(prompt)
response = self.LLMapi.get_response(self.conversation)
self.conversation.append(response)
return response
def clear(self):
self.conversation = [example for example in self.examples] if self.examples else []
class PuzzleSolver:
def __init__(self, LLMapi, examples=None):
self.examples = examples
self.LLMapi = LLMapi
self.conversation = [example for example in self.examples] if self.examples else []
def solve_puzzle(self, prompt):
self.conversation.append(prompt)
response = self.LLMapi.get_response(self.conversation)
self.conversation.append(response)
query = self.extract_substring(response, "(set-logic", "(get-model)").replace('`', '')
return response, query
def clear(self):
self.conversation = self.conversation = [example for example in self.examples] if self.examples else []
def getConversation(self):
"""
Formats the conversation history into a string, labeling user and LLM entries.
Returns:
str: A formatted string of the conversation.
"""
conversation_str = ""
examples_length = len(self.examples) if self.examples else 0
for i, entry in enumerate(self.conversation):
if i < examples_length:
continue
label = "User: " if i % 2 == 0 else "LLM: "
conversation_str += label + entry + "\n"
return conversation_str
@staticmethod
def extract_substring(s, b, e):
# Find the last occurrence of the substring 'b'
start = s.rfind(b)
if start == -1:
return "" # 'b' not found in 's'
# Find the starting position of the substring 'e' after 'b'
end = s.find(e, start)
if end == -1:
return "" # 'e' not found after 'b' in 's'
# Return the substring from 'b' to 'e' inclusive
# Add len(e) to include 'e' in the result
return s[start:end + len(e)]
def solve_with_z3(self,smt_lib_code):
try:
# Step 1: Create a temporary file
with tempfile.NamedTemporaryFile(mode='w+', delete=False) as temp_file:
temp_file_name = temp_file.name
temp_file.write(smt_lib_code)
# Step 2: Execute Z3 with the temporary file
z3_command = ["z3", temp_file_name]
result = subprocess.run(z3_command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
# Step 3: Capture the output
output = result.stdout if result.stdout else result.stderr
except Exception as e:
output = f"An error occurred: {e}"
finally:
# Clean up the temporary file
if os.path.exists(temp_file_name):
os.remove(temp_file_name)
pass
# Step 4: Return the output
return output
class SolverGrader:
def __init__(self, LLMapi, example=None):
self.example = example
self.LLMapi = LLMapi
self.conversation = [] if not self.example else [self.example, ""]
self.conv_length = 0 if not example else len(example)
def get_grade(self, answer_key, llm_answer, smt_output):
to_be_graded = [("Answer to be graded: " + llm_answer + "\nSMT-LIB Solver Output: " + smt_output + "\nAnswer Key: " +answer_key)]
response = self.LLMapi.get_response(to_be_graded)
return response, self.extract_answer(response)
def extract_answer(self, s):
pattern = r'\b(\d{1,3})/(\d{1,3})\b'
matches = re.findall(pattern, s)
valid_fractions = [(x, y) for x, y in matches if int(x) <= int(y)]
if valid_fractions:
return '/'.join(valid_fractions[-1])
else:
return None
class LLMApi:
def __init__(self, role, model="gpt-4"):
self.client = OpenAI(organization='org-bY4lHDd6A0w5itFiXf15EdJ0',)
self.model = model
self.role = role
def get_response(self, conversation_history):
# If there is existing conversation history, include it
messages = self.process_conversation_history(conversation_history) if conversation_history else []
# Adding the system instruction for the task
messages = [{"role": "system", "content": self.role}] + messages
# Generate the response
response = self.client.chat.completions.create(
model=self.model,
temperature=0.05,
messages=messages
)
# Extract and return the SMT-LIB code
return response.choices[0].message.content
@staticmethod
def process_conversation_history(plaintext_history):
"""
Processes a plaintext conversation history into a structured format.
Args:
plaintext_history (list): A list of strings representing the conversation history,
alternating between user and assistant messages.
Returns:
list: A list of dictionaries representing the structured conversation.
"""
structured_history = []
role = "user" # Start with the assumption that the first message is from the user
for message in plaintext_history:
structured_history.append({"role": role, "content": message})
# Alternate between 'user' and 'assistant' for each message
role = "assistant" if role == "user" else "user"
return structured_history
class PuzzleData:
def __init__(self, answers, entities, clues):
self.answers = answers
self.entities = entities
self.clues = clues
def read_file_contents(file_path):
with open(file_path, 'r') as file:
return file.read()
def process_puzzles(directory_path):
import os
puzzles = []
for folder in os.listdir(directory_path):
folder_path = os.path.join(directory_path, folder)
if not os.path.isdir(folder_path):
continue
# Check for required files
answers_path = os.path.join(folder_path, 'answers.txt')
entities_path = os.path.join(folder_path, 'entities.txt')
clues_path = os.path.join(folder_path, 'clues.txt')
if os.path.exists(answers_path) and os.path.exists(entities_path) and os.path.exists(clues_path):
answers = read_file_contents(answers_path)
entities = read_file_contents(entities_path)
clues = read_file_contents(clues_path)
puzzles.append(PuzzleData(answers, entities, clues))
return puzzles
timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
csv_file_name = f'LLM-SMT_log_{timestamp}.csv'
csv_file = open(csv_file_name, 'w', newline='')
csv_writer = csv.writer(csv_file)
csv_writer.writerow(['Puzzle', 'SMT-LIB Code', 'Attempted Solution', 'Full LLM Convo' , 'Grading Process', 'Grade', 'Solution'])
example = [("""User: Ages, names, lengths
5, 10, 15, 20
Barnabas, Bubba, Draco, Merlin
9.4 feet, 10.2 feet, 12.0 feet, 14.0 feet
Merlin is somewhat older than Bubba.
Merlin is 10.2 feet long.
Bubba is 10 years older than the gator that is 14.0 feet long.
Barnabas is 12.0 feet long."""
), ("""Let's start by declaring all the constants required:
- integer constants for every person's age.
- integer constants for every person's length.
(set-logic QF_LIA)
; Age of each person
(declare-const Merlin_Age Int)
(declare-const Bubba_Age Int)
(declare-const Draco_Age Int)
(declare-const Barnabas_Age Int)
; Length of each person
(declare-const Merlin_Length Real)
(declare-const Bubba_Length Real)
(declare-const Draco_Length Real)
(declare-const Barnabas_Length Real)
We'll explicit the conditions in the logic puzzle. The ages are in the set {5, 10, 15, 20} and lengths are in the set {9.4, 10.2, 12.0, 14.0}. Let's add these constraints first:
(assert (and
(or (= Merlin_Age 5) (= Merlin_Age 10) (= Merlin_Age 15) (= Merlin_Age 20))
(or (= Bubba_Age 5) (= Bubba_Age 10) (= Bubba_Age 15) (= Bubba_Age 20))
(or (= Draco_Age 5) (= Draco_Age 10) (= Draco_Age 15) (= Draco_Age 20))
(or (= Barnabas_Age 5) (= Barnabas_Age 10) (= Barnabas_Age 15) (= Barnabas_Age 20))
))
(assert (and
(or (= Merlin_Length 9.4) (= Merlin_Length 10.2) (= Merlin_Length 12.0) (= Merlin_Length 14.0))
(or (= Bubba_Length 9.4) (= Bubba_Length 10.2) (= Bubba_Length 12.0) (= Bubba_Length 14.0))
(or (= Draco_Length 9.4) (= Draco_Length 10.2) (= Draco_Length 12.0) (= Draco_Length 14.0))
(or (= Barnabas_Length 9.4) (= Barnabas_Length 10.2) (= Barnabas_Length 12.0) (= Barnabas_Length 14.0))
))
Now let's add the constraints given in the puzzle:
; Merlin is somewhat older than Bubba.
(assert (> Merlin_Age Bubba_Age))
; Merlin is 10.2 feet long.
(assert (= Merlin_Length 10.2))
; Bubba is 10 years older than the gator that is 14.0 feet long.
(assert (or (and (= Draco_Length 14.0) (= Bubba_Age (+ Draco_Age 10)))
(and (= Barnabas_Length 14.0) (= Bubba_Age (+ Barnabas_Age 10)))))
; Barnabas is 12.0 feet long.
(assert (= Barnabas_Length 12.0))
Now let's ensure that they all have distinct ages and lengths:
; Distinct ages
(assert (distinct Merlin_Age Bubba_Age Draco_Age Barnabas_Age))
; Distinct lengths
(assert (distinct Merlin_Length Bubba_Length Draco_Length Barnabas_Length))
We close with the check-sat and get-model commands:
(check-sat)
(get-model)
"""), ("""(error ""line 10 column 34: logic does not support reals"")
(error ""line 11 column 32: logic does not support reals"")
(error ""line 12 column 32: logic does not support reals"")
(error ""line 13 column 35: logic does not support reals"")
(error ""line 15 column 2: unexpected character"")
(error ""line 15 column 75: unexpected character"")
(error ""line 15 column 89: unexpected character"")
(error ""line 15 column 118: unexpected character"")
(error ""line 15 column 140: unexpected character"")
(error ""line 15 column 146: unexpected character"")
(error ""line 25 column 7: unknown constant Merlin_Length"")
(error ""line 31 column 7: unexpected character"")
(error ""line 37 column 12: unknown constant Merlin_Length"")
(error ""line 40 column 21: unknown constant Draco_Length"")
(error ""line 44 column 12: unknown constant Barnabas_Length"")
(error ""line 46 column 7: unexpected character"")
(error ""line 52 column 19: unknown constant Merlin_Length"")
sat
(
(define-fun Merlin_Age () Int
15)
(define-fun Draco_Age () Int
10)
(define-fun Barnabas_Age () Int
20)
(define-fun Bubba_Age () Int
5)
)"""), ("""Apologies for the incorrect logic - we're trying to model real numbers which are not supported in QF_LIA. We can resolve this issue by using the logic QF_LIRA (Quantifier-Free Linear Integer and Real Arithmetic) instead, which supports both integers and real numbers.
Here's the corrected SMT-LIB code:
```
(set-logic QF_LIRA)
; Age of each person
(declare-const Merlin_Age Int)
(declare-const Bubba_Age Int)
(declare-const Draco_Age Int)
(declare-const Barnabas_Age Int)
; Length of each person
(declare-const Merlin_Length Real)
(declare-const Bubba_Length Real)
(declare-const Draco_Length Real)
(declare-const Barnabas_Length Real)
; The ages are in the set {5, 10, 15, 20}
(assert (and
(or (= Merlin_Age 5) (= Merlin_Age 10) (= Merlin_Age 15) (= Merlin_Age 20))
(or (= Bubba_Age 5) (= Bubba_Age 10) (= Bubba_Age 15) (= Bubba_Age 20))
(or (= Draco_Age 5) (= Draco_Age 10) (= Draco_Age 15) (= Draco_Age 20))
(or (= Barnabas_Age 5) (= Barnabas_Age 10) (= Barnabas_Age 15) (= Barnabas_Age 20))))
; Lengths are in the set {9.4, 10.2, 12.0, 14.0}
(assert (and
(or (= Merlin_Length 9.4) (= Merlin_Length 10.2) (= Merlin_Length 12.0) (= Merlin_Length 14.0))
(or (= Bubba_Length 9.4) (= Bubba_Length 10.2) (= Bubba_Length 12.0) (= Bubba_Length 14.0))
(or (= Draco_Length 9.4) (= Draco_Length 10.2) (= Draco_Length 12.0) (= Draco_Length 14.0))
(or (= Barnabas_Length 9.4) (= Barnabas_Length 10.2) (= Barnabas_Length 12.0) (= Barnabas_Length 14.0))))
; Merlin is somewhat older than Bubba.
(assert (> Merlin_Age Bubba_Age))
; Merlin is 10.2 feet long.
(assert (= Merlin_Length 10.2))
; Bubba is 10 years older than the gator that is 14.0 feet long.
(assert (or (and (= Draco_Length 14.0) (= Bubba_Age (+ Draco_Age 10)))
(and (= Barnabas_Length 14.0) (= Bubba_Age (+ Barnabas_Age 10)))))
; Barnabas is 12.0 feet long.
(assert (= Barnabas_Length 12.0))
; Distinct ages
(assert (distinct Merlin_Age Bubba_Age Draco_Age Barnabas_Age))
; Distinct lengths
(assert (distinct Merlin_Length Bubba_Length Draco_Length Barnabas_Length))
(check-sat)
(get-model)
"""), ("""sat
(
(define-fun Merlin_Age () Int
20)
(define-fun Bubba_Length () Real
(/ 47.0 5.0))
(define-fun Barnabas_Age () Int
10)
(define-fun Bubba_Age () Int
15)
(define-fun Merlin_Length () Real
(/ 51.0 5.0))
(define-fun Draco_Age () Int
5)
(define-fun Barnabas_Length () Real
12.0)
(define-fun Draco_Length () Real
14.0)
)"""), "I am done."]
puzzles = process_puzzles("./data/puzzles")
for puzzle in puzzles:
puzzle_description = puzzle.entities + "\n" + puzzle.clues
solution = puzzle.answers
print(puzzle_description)
solver_role_text = (
"Role: Encode the logic puzzle given to you into SMT-LIB code, taking into account all explicit and implicit facts; explain your logic and what implicit facts you are encoding. Make sure to set-logic in your code."
"After encoding, I will submit the last SMT-LIB code you have sent me to an SMT solver for analysis and return to you the output. If there is an error, "
"carefully correct any syntactical mistakes or misinterpretations of the puzzle constraints in your code. "
"Continuously refine your code and resubmit to me until I send you back a correct solution that precisely aligns with the puzzle's parameters. "
"Once you have sent the correct, error-free, final SMT-LIB code, only respond 'I am done.' from then on."
)
grader_role_text = (
"Role: Grade SMT-LIB solver outputs numerically. Use the answer key, the LLM conversation, the latest solver output "
"to determine the score in the format X/Y. 'X' represents the number of correct assignments in the "
"given answer, including partial credit; attempt to interpret the solution and find X even if the SMT model contains errors. 'Y' is the total number of assignments as per "
"the answer key. Provide a detailed explanation of your thought process in calculating both X and Y."
)
solver_llm = LLMApi(role=solver_role_text)
grader_llm = LLMApi(role=grader_role_text)
solver = PuzzleSolver(solver_llm,example)
grader = SolverGrader(grader_llm)
# Use LLMApi to generate SMT-LIB code from the puzzle description
max_retries = 5
flag = False
max_conversation_length = 4
latest_smt_code = ""
while max_retries > 0 and not flag:
solver.clear()
next_input = puzzle_description
for i in range(max_conversation_length):
full_response, smt_lib_code = solver.solve_puzzle(next_input)
if smt_lib_code and "(set-logic" in smt_lib_code:
latest_smt_code = smt_lib_code
next_input = solver.solve_with_z3(latest_smt_code)
if not ("error" in next_input):
flag = True
max_retries -= 1
# Solve the puzzle using Z3
attempted_solution = solver.solve_with_z3(latest_smt_code)
#print(full_response, latest_smt_code, attempted_solution)
full_convo = solver.getConversation()
grading_full_response, grade = grader.get_grade(solution, full_convo, attempted_solution)
csv_writer.writerow([puzzle_description, latest_smt_code, attempted_solution, full_convo,grading_full_response, grade, solution])
print("SMT-LIB Code:\n", latest_smt_code)
print("Solution:\n", attempted_solution)
print("Grading Process: ", grading_full_response)
print("Grade: ", grade)
"""
baseline LLM
vs us
benchmark the grader
""" | [] |
2024-01-10 | vivym/OmniDiffusion | omni_diffusion~trainers~sd_distiller.py | import copy
import os
import random
import shutil
import torch
from accelerate.logging import get_logger
from diffusers import (
AutoencoderKL,
DDIMScheduler,
UNet2DConditionModel,
)
from torch.nn import functional as F
from torch.utils.data import DataLoader
from transformers import AutoTokenizer, PreTrainedModel, PreTrainedTokenizerFast
from tqdm import tqdm
from omni_diffusion.data.streaming_dataset import MMStreamingDataset
from .base_trainer import (
BaseTrainer, compute_snr, compute_vae_encodings, encode_prompts_sd, compute_diffusion_loss
)
logger = get_logger(__name__, log_level="INFO")
class StableDiffusionStepDistiller(BaseTrainer):
def setup_dataloader(self):
ds = MMStreamingDataset(
dataset_path=self.dataset_name_or_path,
model_name_or_path=self.model_name_or_path,
model_revision=self.model_revision,
num_tokenizers=self.num_text_encoders,
resolution=self.resolution,
proportion_empty_prompts=self.proportion_empty_prompts,
center_crop=self.center_crop,
random_flip=self.random_flip,
)
return DataLoader(
ds,
batch_size=self.train_batch_size,
num_workers=self.num_dataset_workers,
pin_memory=True,
)
def setup_noise_scheduler(self) -> tuple[DDIMScheduler, DDIMScheduler]:
# Load scheduler and models.
noise_scheduler: DDIMScheduler = DDIMScheduler.from_pretrained(
self.model_name_or_path,
revision=self.model_revision,
subfolder="scheduler",
)
if self.prediction_type is not None:
# set prediction_type of scheduler if defined
noise_scheduler.register_to_config(prediction_type=self.prediction_type)
teacher_noise_scheduler: DDIMScheduler = DDIMScheduler.from_config(noise_scheduler.config)
teacher_noise_scheduler.set_timesteps(self.num_ddim_steps)
noise_scheduler.set_timesteps(self.num_ddim_steps // 2)
# Check for terminal SNR in combination with SNR Gamma
if (
self.snr_gamma is not None
and not self.force_snr_gamma
and (
hasattr(noise_scheduler.config, "rescale_betas_zero_snr") and noise_scheduler.config.rescale_betas_zero_snr
)
):
raise ValueError(
f"The selected noise scheduler for the model `{self.model_name_or_path}` uses rescaled betas for zero SNR.\n"
"When this configuration is present, the parameter `snr_gamma` may not be used without parameter `force_snr_gamma`.\n"
"This is due to a mathematical incompatibility between our current SNR gamma implementation, and a sigma value of zero."
)
return noise_scheduler, teacher_noise_scheduler
def fit(self):
if self.allow_tf32:
torch.backends.cuda.matmul.allow_tf32 = True
accelerator = self.setup_accelerator()
train_dataloader = self.setup_dataloader()
noise_scheduler, teacher_noise_scheduler = self.setup_noise_scheduler()
alphas_cumprod = noise_scheduler.alphas_cumprod.to(accelerator.device)
sqrt_alphas_cumprod = alphas_cumprod ** 0.5
sqrt_one_minus_alphas_cumprod = (1 - alphas_cumprod) ** 0.5
noise_scheduler.timesteps = noise_scheduler.timesteps.to(accelerator.device)
teacher_noise_scheduler.timesteps = teacher_noise_scheduler.timesteps.to(accelerator.device)
text_encoders, vae, unet, ema_unet, params_to_optimize = self.setup_models(
accelerator=accelerator,
num_text_encoders=self.num_text_encoders,
)
tokenizer = AutoTokenizer.from_pretrained(
self.model_name_or_path,
revision=self.model_revision,
subfolder="tokenizer",
use_fast=True,
)
teacher_unet = copy.deepcopy(unet)
teacher_unet.to(accelerator.device)
teacher_unet.requires_grad_(False)
teacher_unet.eval()
optimizer, lr_scheduler = self.setup_optimizer(params_to_optimize, accelerator=accelerator)
unet, optimizer, lr_scheduler = accelerator.prepare(
unet, optimizer, lr_scheduler
)
if isinstance(train_dataloader, DataLoader):
train_dataloader = accelerator.prepare(train_dataloader)
if self.train_text_encoder:
text_encoders = [
accelerator.prepare(text_encoder)
for text_encoder in text_encoders
]
if accelerator.is_main_process:
accelerator.init_trackers(
self.project_name,
config=self.configs,
)
if self.mixed_precision == "fp16":
weight_dtype = torch.float16
elif self.mixed_precision == "bf16":
weight_dtype = torch.bfloat16
else:
weight_dtype = torch.float32
total_batch_size = self.train_batch_size * accelerator.num_processes * self.gradient_accumulation_steps
logger.info("***** Running training *****")
logger.info(f" Instantaneous batch size per device = {self.train_batch_size}")
logger.info(f" Total train batch size (w. parallel, distributed & accumulation) = {total_batch_size}")
logger.info(f" Gradient Accumulation steps = {self.gradient_accumulation_steps}")
logger.info(f" Total optimization steps = {self.max_steps}")
global_step = 0
# Load in the weights and states from a previous checkpoint.
if self.resume_from_checkpoint is not None:
if self.resume_from_checkpoint != "latest":
dir_name = os.path.basename(self.resume_from_checkpoint)
else:
# Get the latest checkpoint in the output dir.
dirs = os.listdir(self.output_dir)
dirs = [d for d in dirs if d.startswith("checkpoint")]
dirs = sorted(dirs, key=lambda x: int(x.split("-")[1]))
dir_name = dirs[-1] if len(dirs) > 0 else None
if dir_name is None:
logger.warning(
f"Provided `resume_from_checkpoint` ({self.resume_from_checkpoint}) does not exist. "
"Training from scratch."
)
self.resume_from_checkpoint = None
else:
logger.info(f"Loading model from {dir_name}")
accelerator.load_state(os.path.join(self.output_dir, dir_name))
global_step = int(dir_name.split("-")[1])
resume_step = global_step * self.gradient_accumulation_steps
progress_bar = tqdm(
range(global_step, self.max_steps),
desc="Steps",
disable=not accelerator.is_local_main_process,
)
for epoch in range(10000000):
unet.train()
if self.train_text_encoder:
for text_encoder in text_encoders:
text_encoder.train()
train_loss = 0.0
train_loss_diffusion = 0.0
train_loss_distillation = 0.0
# TODO: keep aspec ratio within a batch
# TODO: quick skip or random block order
for step, batch in enumerate(train_dataloader):
with accelerator.accumulate(unet):
loss_diffusion, loss_distillation = self.training_step(
batch,
unet=unet,
teacher_unet=teacher_unet,
vae=vae,
text_encoders=text_encoders,
noise_scheduler=noise_scheduler,
teacher_noise_scheduler=teacher_noise_scheduler,
tokenizer=tokenizer,
sqrt_alphas_cumprod=sqrt_alphas_cumprod,
sqrt_one_minus_alphas_cumprod=sqrt_one_minus_alphas_cumprod,
)
loss = loss_diffusion + loss_distillation
# Gather the losses across all processes for logging (if we use distributed training).
losses = accelerator.gather(loss.detach().repeat(self.train_batch_size))
losses_diffusion = accelerator.gather(loss_diffusion.detach().repeat(self.train_batch_size))
losses_distillation = accelerator.gather(loss_distillation.detach().repeat(self.train_batch_size))
train_loss += losses.mean().item()
train_loss_diffusion += losses_diffusion.mean().item()
train_loss_distillation += losses_distillation.mean().item()
# Backpropagate
accelerator.backward(loss)
if accelerator.sync_gradients:
accelerator.clip_grad_norm_(params_to_optimize, self.gradient_clipping)
optimizer.step()
lr_scheduler.step()
optimizer.zero_grad()
logs = {"step_loss": loss.detach().item(), "lr": lr_scheduler.get_last_lr()[0]}
progress_bar.set_postfix(**logs)
# Checks if the accelerator has performed an optimization step behind the scenes
if accelerator.sync_gradients:
if self.use_ema:
ema_unet.step(unet.parameters())
progress_bar.update(1)
global_step += 1
train_loss = train_loss / self.gradient_accumulation_steps
train_loss_diffusion = train_loss_diffusion / self.gradient_accumulation_steps
train_loss_distillation = train_loss_distillation / self.gradient_accumulation_steps
accelerator.log(
{
"train_loss": train_loss,
"train_loss_diffusion": train_loss_diffusion,
"train_loss_distillation": train_loss_distillation,
},
step=global_step,
)
train_loss = 0.0
train_loss_diffusion = 0.0
train_loss_distillation = 0.0
if global_step % self.checkpointing_every_n_steps == 0:
if accelerator.is_main_process:
if self.max_checkpoints is not None:
checkpoints = os.listdir(self.output_dir)
checkpoints = [d for d in checkpoints if d.startswith("checkpoint")]
checkpoints = sorted(checkpoints, key=lambda x: int(x.split("-")[1]))
# before we save the new checkpoint, we need to have at _most_ `max_checkpoints - 1` checkpoints
if len(checkpoints) >= self.max_checkpoints:
num_to_remove = len(checkpoints) - self.max_checkpoints + 1
removing_checkpoints = checkpoints[0:num_to_remove]
logger.info(
f"{len(checkpoints)} checkpoints already exist, "
f"removing {len(removing_checkpoints)} checkpoints"
)
logger.info(f"removing checkpoints: {', '.join(removing_checkpoints)}")
for removing_checkpoint in removing_checkpoints:
removing_checkpoint = os.path.join(self.output_dir, removing_checkpoint)
shutil.rmtree(removing_checkpoint)
accelerator.wait_for_everyone()
save_path = os.path.join(self.output_dir, f"checkpoint-{global_step}")
accelerator.save_state(save_path)
logger.info(f"Saved state to {save_path}")
if accelerator.is_main_process:
if global_step % self.validation_every_n_steps == 0:
self.validation_step(
global_step,
accelerator=accelerator,
model_name_or_path=self.model_name_or_path,
model_revision=self.model_revision,
text_encoders=text_encoders,
vae=vae,
unet=unet,
ema_unet=ema_unet,
weight_dtype=weight_dtype,
)
if global_step >= self.max_steps:
break
accelerator.end_training()
def training_step(
self,
batch,
unet: UNet2DConditionModel,
teacher_unet: UNet2DConditionModel,
vae: AutoencoderKL,
text_encoders: list[PreTrainedModel],
noise_scheduler: DDIMScheduler,
teacher_noise_scheduler: DDIMScheduler,
tokenizer: PreTrainedTokenizerFast,
sqrt_alphas_cumprod: torch.Tensor,
sqrt_one_minus_alphas_cumprod: torch.Tensor,
) -> tuple[torch.Tensor, torch.Tensor]:
input_ids = batch["input_ids"]
bsz = input_ids.shape[0]
do_cfg_aware_distillation = random.random() < self.cfg_aware_distillation_prob
if do_cfg_aware_distillation:
cfg_scale = torch.rand(bsz, dtype=torch.float32, device=input_ids.device)
cfg_scale = cfg_scale * (14 - 2) + 2
uncond_ids = torch.full_like(
input_ids,
fill_value=tokenizer.eos_token_id,
dtype=input_ids.dtype,
device=input_ids.device,
)
uncond_ids[:, 0] = tokenizer.bos_token_id
input_ids = torch.cat([input_ids, uncond_ids], dim=0)
prompt_embeds = encode_prompts_sd(
input_ids,
text_encoders=text_encoders,
train_text_encoder=self.train_text_encoder,
)
model_input = compute_vae_encodings(batch["image"], vae)
if do_cfg_aware_distillation:
model_input = model_input.repeat(2, 1, 1, 1)
noise = torch.randn_like(model_input)
if self.noise_offset:
# https://www.crosslabs.org//blog/diffusion-with-offset-noise
noise += self.noise_offset * torch.randn(
(model_input.shape[0], model_input.shape[1], 1, 1),
device=model_input.device,
)
# Sample a random timestep for each image
timestep_indices = torch.randint(
0, noise_scheduler.num_inference_steps, (model_input.shape[0],),
dtype=torch.int64,
device=model_input.device,
)
# teacher_timestep_indices = (timestep_indices + 1) * 2 - 1
teacher_timestep_indices = timestep_indices * 2
timesteps = noise_scheduler.timesteps[teacher_timestep_indices]
teacher_timesteps = teacher_noise_scheduler.timesteps[teacher_timestep_indices]
teacher_timesteps_prev = teacher_noise_scheduler.timesteps[teacher_timestep_indices + 1]
# Add noise to the model input according to the noise magnitude at each timestep
# (this is the forward diffusion process)
noisy_model_input = noise_scheduler.add_noise(model_input, noise, timesteps)
model_pred = unet(noisy_model_input, timesteps, prompt_embeds).sample
loss_diffusion = compute_diffusion_loss(
model_input=model_input[:bsz] if do_cfg_aware_distillation else model_input,
noise=noise[:bsz] if do_cfg_aware_distillation else noise,
timesteps=timesteps[:bsz] if do_cfg_aware_distillation else timesteps,
model_pred=model_pred[:bsz] if do_cfg_aware_distillation else model_pred,
noise_scheduler=noise_scheduler,
snr_gamma=self.snr_gamma,
)
if do_cfg_aware_distillation:
model_pred_text, model_pred_uncond = model_pred.chunk(2, dim=0)
model_pred = model_pred_uncond + cfg_scale * (model_pred_text - model_pred_uncond)
model_pred = rescale_noise_cfg(model_pred, model_pred_text, guidance_rescale=self.guidance_rescale)
student_sqrt_alphas_cumprod_t = extract(sqrt_alphas_cumprod, timesteps, model_input.shape)
student_sqrt_one_minus_alphas_cumprod_t = extract(sqrt_one_minus_alphas_cumprod, timesteps, model_input.shape)
with torch.no_grad():
sample = noisy_model_input
# 2 DDIM Diffusion steps
for i, t, t_prev in enumerate([
(teacher_timesteps, teacher_timesteps_prev),
(teacher_timesteps_prev, None)
]):
teacher_model_pred = teacher_unet(sample, t, prompt_embeds).sample
if do_cfg_aware_distillation:
teacher_model_pred_text, teacher_model_pred_uncond = teacher_model_pred.chunk(2, dim=0)
teacher_model_pred = teacher_model_pred_uncond + cfg_scale * (
teacher_model_pred_text - teacher_model_pred_uncond
)
teacher_model_pred = rescale_noise_cfg(
teacher_model_pred, teacher_model_pred_text, guidance_rescale=self.guidance_rescale
)
teacher_model_pred = teacher_model_pred.repeat(2, 1, 1, 1)
# 2. compute alphas, betas
sqrt_alphas_cumprod_t = extract(sqrt_alphas_cumprod, t, sample.shape)
sqrt_one_minus_alphas_cumprod_t = extract(sqrt_one_minus_alphas_cumprod, t, sample.shape)
if t_prev is not None:
sqrt_alphas_cumprod_t_prev = extract(sqrt_alphas_cumprod, t_prev, sample.shape)
sqrt_one_minus_alphas_cumprod_t_prev = extract(sqrt_one_minus_alphas_cumprod, t_prev, sample.shape)
pred_original_sample = sqrt_alphas_cumprod_t * sample - sqrt_one_minus_alphas_cumprod_t * teacher_model_pred
# 4. Clip or threshold "predicted x_0"
if teacher_noise_scheduler.config.thresholding:
pred_original_sample = teacher_noise_scheduler._threshold_sample(pred_original_sample)
elif teacher_noise_scheduler.config.clip_sample:
clip_sample_range = teacher_noise_scheduler.config.clip_sample_range
pred_original_sample = pred_original_sample.clamp(-clip_sample_range, clip_sample_range)
if i == 1:
pred_epsilon = (
noisy_model_input - student_sqrt_alphas_cumprod_t * pred_original_sample
) / student_sqrt_one_minus_alphas_cumprod_t
distill_target = student_sqrt_alphas_cumprod_t * pred_epsilon - \
student_sqrt_one_minus_alphas_cumprod_t * pred_original_sample
else:
pred_epsilon = sqrt_alphas_cumprod_t * teacher_model_pred + sqrt_one_minus_alphas_cumprod_t * sample
# 6. compute "direction pointing to x_t" of formula (12) from https://arxiv.org/pdf/2010.02502.pdf
pred_sample_direction = sqrt_one_minus_alphas_cumprod_t_prev * pred_epsilon
# 7. compute x_t without "random noise" of formula (12) from https://arxiv.org/pdf/2010.02502.pdf
prev_sample = sqrt_alphas_cumprod_t_prev * pred_original_sample + pred_sample_direction
sample = prev_sample
assert noise_scheduler.config.prediction_type == "v_prediction"
if self.snr_gamma is None:
loss_distillation = F.mse_loss(model_pred.float(), distill_target.float(), reduction="mean")
else:
# Compute loss-weights as per Section 3.4 of https://arxiv.org/abs/2303.09556.
# Since we predict the noise instead of x_0, the original formulation is slightly changed.
# This is discussed in Section 4.2 of the same paper.
snr = compute_snr(timesteps, noise_scheduler.alphas_cumprod)
if noise_scheduler.config.prediction_type == "v_prediction":
# Velocity objective requires that we add one to SNR values before we divide by them.
snr = snr + 1
mse_loss_weights = (
torch.stack([snr, self.snr_gamma * torch.ones_like(timesteps)], dim=1).min(dim=1)[0] / snr
)
# We first calculate the original loss. Then we mean over the non-batch dimensions and
# rebalance the sample-wise losses with their respective loss weights.
# Finally, we take the mean of the rebalanced loss.
loss_distillation = F.mse_loss(model_pred.float(), distill_target.float(), reduction="none")
loss_distillation = loss_distillation.mean(dim=list(range(1, len(loss_distillation.shape)))) * mse_loss_weights
loss_distillation = loss_distillation.mean()
return loss_diffusion, loss_distillation
def extract(a, t, x_shape):
b, *_ = t.shape
out = a.gather(-1, t)
return out.reshape(b, *((1,) * (len(x_shape) - 1)))
def rescale_noise_cfg(noise_cfg, noise_pred_text, guidance_rescale=0.0):
"""
Rescale `noise_cfg` according to `guidance_rescale`. Based on findings of [Common Diffusion Noise Schedules and
Sample Steps are Flawed](https://arxiv.org/pdf/2305.08891.pdf). See Section 3.4
"""
std_text = noise_pred_text.std(dim=list(range(1, noise_pred_text.ndim)), keepdim=True)
std_cfg = noise_cfg.std(dim=list(range(1, noise_cfg.ndim)), keepdim=True)
# rescale the results from guidance (fixes overexposure)
noise_pred_rescaled = noise_cfg * (std_text / std_cfg)
# mix with the original results from guidance by factor guidance_rescale to avoid "plain looking" images
noise_cfg = guidance_rescale * noise_pred_rescaled + (1 - guidance_rescale) * noise_cfg
return noise_cfg
| [] |
2024-01-10 | ComradeMisha/TrustButVerify | alpacka~networks~tensorflow.py | """Network interface implementation using the TF v1 framework."""
import warnings
import gin
import numpy as np
import tensorflow as tf
from alpacka.networks import core
class TFMetaGraphNetwork(core.Network):
"""Fixed network loaded from the TF v1 MetaGraph checkpoint."""
def __init__(self, network_signature,
model_path=gin.REQUIRED,
x_name='ppo2_model/Ob:0',
y_name='ppo2_model/pi_1/add:0'):
"""Initialize TF session from MetaGraph.
Args:
network_signature (NetworkSignature): Network signature.
model_path (string): Path to a saved model. It's a common part of
the three files with extensions: .meta, .index, .data.
x_name (string): Name of the input placeholder.
Default for PPO2 from OpenAI Baselines.
y_name (string): Name of the output tensor.
Default for PPO2 from OpenAI Baselines.
"""
super().__init__(network_signature)
# Recall to legacy execution engine and create a tf.Session.
tf.compat.v1.disable_eager_execution()
self._sess = tf.compat.v1.Session()
tf.compat.v1.keras.backend.set_session(self._sess)
# Import meta graph and restore checkpoint.
self._saver = tf.compat.v1.train.import_meta_graph(model_path + '.meta')
self._saver.restore(self._sess, model_path)
# Get input and output ops.
graph = tf.compat.v1.get_default_graph()
self._x = graph.get_tensor_by_name(x_name)
self._y = graph.get_tensor_by_name(y_name)
self._batch_size = self._x.shape[0]
# Test the restored model compliance with the network signature.
assert self._x.shape[1:] == network_signature.input.shape
assert self._x.dtype == network_signature.input.dtype
assert self._y.shape[1:] == network_signature.output.shape
assert self._y.dtype == network_signature.output.dtype
if self._batch_size is not None:
warnings.warn(
'The input batch dimension has fixed size ({}), you should save'
' your graph with the batch dimension set to None.'.format(
self._batch_size))
def predict(self, inputs):
batch_size = inputs.shape[0]
if self._batch_size is not None and batch_size < self._batch_size:
# Handle an input batch size lower than the model fixed batch size.
inputs = np.resize(inputs, (self._batch_size, ) + inputs.shape[1:])
return self._sess.run(self._y, feed_dict={self._x: inputs})[:batch_size]
@property
def params(self):
return self._sess.run(tf.compat.v1.trainable_variables())
@params.setter
def params(self, new_params):
for t, v in zip(tf.compat.v1.trainable_variables(), new_params):
tf.compat.v1.keras.backend.set_value(t, v)
def save(self, checkpoint_path):
self._saver.save(sess=self._sess,
save_path=checkpoint_path,
global_step=tf.compat.v1.train.get_global_step())
def restore(self, checkpoint_path):
self._saver.restore(self._sess, checkpoint_path)
| [] |
2024-01-10 | ricklentz/salina | salina~agents~gyma.py | #
# Copyright (c) Facebook, Inc. and its affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
#
import numpy as np
import torch
from salina import TAgent
def _format_frame(frame):
if isinstance(frame, dict):
r = {}
for k in frame:
r[k] = _format_frame(frame[k])
return r
elif isinstance(frame, list):
t = torch.tensor(frame).unsqueeze(0)
if t.dtype == torch.float64 or t.dtype == torch.float32:
t = t.float()
else:
t = t.long()
return t
elif isinstance(frame, np.ndarray):
t = torch.from_numpy(frame).unsqueeze(0)
if t.dtype == torch.float64 or t.dtype == torch.float32:
t = t.float()
else:
t = t.long()
return t
elif isinstance(frame, torch.Tensor):
return frame.unsqueeze(0) # .float()
elif isinstance(frame, bool):
return torch.tensor([frame]).bool()
elif isinstance(frame, int):
return torch.tensor([frame]).long()
elif isinstance(frame, float):
return torch.tensor([frame]).float()
else:
try:
# Check if its a LazyFrame from OpenAI Baselines
o = torch.from_numpy(frame.__array__()).unsqueeze(0).float()
return o
except:
assert False
def _torch_type(d):
nd = {}
for k in d:
if d[k].dtype == torch.float64:
nd[k] = d[k].float()
else:
nd[k] = d[k]
return nd
def _torch_cat_dict(d):
r = {}
for k in d[0]:
r[k] = torch.cat([dd[k] for dd in d], dim=0)
return r
class GymAgent(TAgent):
""" Create an Agent from a gyn environment
"""
def __init__(
self,
make_env_fn=None,
make_env_args={},
n_envs=None,
input="action",
output="env/",
use_seed=True
):
""" Create an agent from a Gym environment
Args:
make_env_fn ([function that returns a gym.Env]): The function to create a single gym environments
make_env_args (dict): The arguments of the function that creates a gym.Env
n_envs ([int]): The number of environments to create.
input (str, optional): [the name of the action variable in the workspace]. Defaults to "action".
output (str, optional): [the output prefix of the environment]. Defaults to "env/".
use_seed (bool, optional): [If True, then the seed is chained to the environments, and each environment will have its own seed]. Defaults to True.
"""
super().__init__()
self.use_seed=use_seed
assert n_envs > 0
self.envs = None
self.env_args = make_env_args
self._seed = 0
self.n_envs = n_envs
self.output = output
self.input = input
self.make_env_fn = make_env_fn
self.ghost_params = torch.nn.Parameter(torch.randn(()))
def _initialize_envs(self, n):
assert self._seed is not None, "[GymAgent] seeds must be specified"
self.envs = [self.make_env_fn(**self.env_args) for k in range(n)]
if self.use_seed:
for k in range(n):
self.envs[k].seed(self._seed + k)
self.timestep = 0
self.finished = torch.tensor([True for e in self.envs])
self.timestep = torch.tensor([0 for e in self.envs])
self.last_frame = {}
self.cumulated_reward = {}
def _reset(self, k, save_render):
env = self.envs[k]
self.cumulated_reward[k] = 0.0
o = env.reset()
self.cumulated_reward[k] = 0.0
observation = _format_frame(o)
if isinstance(observation, torch.Tensor):
observation = {"env_obs": observation}
else:
assert isinstance(observation, dict)
if save_render:
image = env.render(mode="image").unsqueeze(0)
observation["rendering"] = image
self.last_frame[k] = observation
done = torch.tensor([False])
initial_state = torch.tensor([True])
self.finished[k] = False
finished = torch.tensor([False])
reward = torch.tensor([0.0]).float()
self.timestep[k] = 0
timestep = torch.tensor([self.timestep[k]])
ret = {
**observation,
"done": done,
"initial_state": initial_state,
"reward": reward,
"timestep": timestep,
"cumulated_reward": torch.tensor([self.cumulated_reward[k]]).float(),
}
return _torch_type(ret)
def _step(self, k, action, save_render):
if self.finished[k]:
assert k in self.last_frame
return {
**self.last_frame[k],
"done": torch.tensor([True]),
"initial_state": torch.tensor([False]),
"reward": torch.tensor([0.0]).float(),
"cumulated_reward": torch.tensor([self.cumulated_reward[k]]).float(),
"timestep": torch.tensor([self.timestep[k]]),
}
self.timestep[k] += 1
env = self.envs[k]
if len(action.size()) == 0:
action = action.item()
assert isinstance(action, int)
else:
action = np.array(action.tolist())
o, r, d, _ = env.step(action)
self.cumulated_reward[k] += r
observation = _format_frame(o)
if isinstance(observation, torch.Tensor):
observation = {"env_obs": observation}
else:
assert isinstance(observation, dict)
if save_render:
image = env.render(mode="image").unsqueeze(0)
observation["rendering"] = image
self.last_frame[k] = observation
if d:
self.finished[k] = True
ret = {
**observation,
"done": torch.tensor([d]),
"initial_state": torch.tensor([False]),
"reward": torch.tensor([r]).float(),
"cumulated_reward": torch.tensor([self.cumulated_reward[k]]),
"timestep": torch.tensor([self.timestep[k]]),
"cumulated_reward": torch.tensor([self.cumulated_reward[k]]),
}
return _torch_type(ret)
def forward(self, t=0, save_render=False, **kwargs):
"""Do one step by reading the `action` at t-1
If t==0, environments are reset
If save_render is True, then the output of env.render(mode="image") is written as env/rendering
"""
if self.envs is None:
self._initialize_envs(self.n_envs)
if t == 0:
self.timestep = torch.tensor([0 for e in self.envs])
observations = []
for k, e in enumerate(self.envs):
obs = self._reset(k, save_render)
observations.append(obs)
observations = _torch_cat_dict(observations)
for k in observations:
self.set(
(self.output + k, t), observations[k].to(self.ghost_params.device)
)
else:
assert t > 0
action = self.get((self.input, t - 1))
assert action.size()[0] == self.n_envs, "Incompatible number of envs"
observations = []
for k, e in enumerate(self.envs):
obs = self._step(k, action[k], save_render)
observations.append(obs)
observations = _torch_cat_dict(observations)
for k in observations:
self.set(
(self.output + k, t), observations[k].to(self.ghost_params.device)
)
def seed(self, seed):
self._seed = seed
if self.use_seed:
if not self.envs is None:
for k, e in enumerate(self.envs):
e.seed(self._seed + k)
class AutoResetGymAgent(TAgent):
"""The same than GymAgent, but with an automoatic reset when done is True"""
def __init__(
self,
make_env_fn=None,
make_env_args={},
n_envs=None,
input="action",
output="env/",
use_seed=True,
):
""" Create an agent from a Gym environment with Autoreset
Args:
make_env_fn ([function that returns a gym.Env]): The function to create a single gym environments
make_env_args (dict): The arguments of the function that creates a gym.Env
n_envs ([int]): The number of environments to create.
input (str, optional): [the name of the action variable in the workspace]. Defaults to "action".
output (str, optional): [the output prefix of the environment]. Defaults to "env/".
use_seed (bool, optional): [If True, then the seed is chained to the environments, and each environment will have its own seed]. Defaults to True.
"""
super().__init__()
self.use_seed=use_seed
assert n_envs > 0
self.envs = None
self.env_args = make_env_args
self._seed = None
self.n_envs = n_envs
self.output = output
self.input = input
self.make_env_fn = make_env_fn
self.ghost_params = torch.nn.Parameter(torch.randn(()))
def _initialize_envs(self, n):
assert self._seed is not None, "[GymAgent] seeds must be specified"
self.envs = [self.make_env_fn(**self.env_args) for k in range(n)]
if self.use_seed:
for k in range(n):
self.envs[k].seed(self._seed + k)
self.n_envs = n
self.timestep = 0
self.finished = torch.tensor([True for e in self.envs])
self.timestep = torch.tensor([0 for e in self.envs])
self.is_running = [False for k in range(n)]
self.cumulated_reward = {}
def _reset(self, k, save_render):
env = self.envs[k]
self.cumulated_reward[k] = 0.0
o = env.reset()
self.cumulated_reward[k] = 0
observation = _format_frame(o)
if isinstance(observation, torch.Tensor):
observation = {"env_obs": observation}
else:
assert isinstance(observation, dict)
done = torch.tensor([False])
initial_state = torch.tensor([True])
self.finished[k] = False
finished = torch.tensor([False])
reward = torch.tensor([0.0]).float()
self.timestep[k] = 0
timestep = torch.tensor([self.timestep[k]])
self.is_running[k] = True
if save_render:
image = env.render(mode="image").unsqueeze(0)
observation["rendering"] = image
ret = {
**observation,
"done": done,
"initial_state": initial_state,
"reward": reward,
"timestep": timestep,
"cumulated_reward": torch.tensor([self.cumulated_reward[k]]).float(),
}
return _torch_type(ret)
def _step(self, k, action, save_render):
self.timestep[k] += 1
env = self.envs[k]
if len(action.size()) == 0:
action = action.item()
assert isinstance(action, int)
else:
action = np.array(action.tolist())
o, r, d, _ = env.step(action)
self.cumulated_reward[k] += r
observation = _format_frame(o)
if isinstance(observation, torch.Tensor):
observation = {"env_obs": observation}
else:
assert isinstance(observation, dict)
if d:
self.is_running[k] = False
if save_render:
image = env.render(mode="image").unsqueeze(0)
observation["rendering"] = image
ret = {
**observation,
"done": torch.tensor([d]),
"initial_state": torch.tensor([False]),
"reward": torch.tensor([r]).float(),
"timestep": torch.tensor([self.timestep[k]]),
"cumulated_reward": torch.tensor([self.cumulated_reward[k]]).float(),
}
return _torch_type(ret)
def forward(self, t=0, save_render=False, **kwargs):
if self.envs is None:
self._initialize_envs(self.n_envs)
observations = []
for k, env in enumerate(self.envs):
if not self.is_running[k]:
observations.append(self._reset(k, save_render))
else:
assert t > 0
action = self.get((self.input, t - 1))
assert action.size()[0] == self.n_envs, "Incompatible number of envs"
observations.append(self._step(k, action[k], save_render))
observations = _torch_cat_dict(observations)
for k in observations:
self.set((self.output + k, t), observations[k].to(self.ghost_params.device))
def seed(self, seed):
self._seed = seed
assert (
self.envs is None
), "[GymAgent.seed] Seeding only possible before running the agent"
class NoAutoResetGymAgent(GymAgent):
""" Create an Agent from a gyn environment
"""
def __init__(
self,
make_env_fn=None,
make_env_args={},
n_envs=None,
input="action",
output="env/",
use_seed=True
):
super().__init__(
make_env_fn=make_env_fn,
make_env_args=make_env_args,
n_envs=n_envs,
input=input,
output=output,
use_seed=use_seed
)
| [] |
2024-01-10 | TyperClub/RoboMaster-Simulator | src~openai_ros~openai_ros~src~openai_ros~robot_envs~cube_single_disk_env.py | import numpy
import rospy
from openai_ros import robot_gazebo_env
from std_msgs.msg import Float64
from sensor_msgs.msg import JointState
from nav_msgs.msg import Odometry
from openai_ros.openai_ros_common import ROSLauncher
class CubeSingleDiskEnv(robot_gazebo_env.RobotGazeboEnv):
"""Superclass for all CubeSingleDisk environments.
"""
def __init__(self, ros_ws_abspath):
"""Initializes a new CubeSingleDisk environment.
Args:
"""
# We launch the ROSlaunch that spawns the robot into the world
ROSLauncher(rospackage_name="moving_cube_description",
launch_file_name="put_cube_in_world.launch",
ros_ws_abspath=ros_ws_abspath)
# Variables that we give through the constructor.
# None in this case
# Internal Vars
self.controllers_list = ['joint_state_controller',
'inertia_wheel_roll_joint_velocity_controller'
]
self.robot_name_space = "moving_cube"
# We launch the init function of the Parent Class robot_gazebo_env.RobotGazeboEnv
super(CubeSingleDiskEnv, self).__init__(controllers_list=self.controllers_list,
robot_name_space=self.robot_name_space,
reset_controls=True)
"""
To check any topic we need to have the simulations running, we need to do two things:
1) Unpause the simulation: without that th stream of data doesnt flow. This is for simulations
that are pause for whatever the reason
2) If the simulation was running already for some reason, we need to reset the controlers.
This has to do with the fact that some plugins with tf, dont understand the reset of the simulation
and need to be reseted to work properly.
"""
self.gazebo.unpauseSim()
self.controllers_object.reset_controllers()
self._check_all_sensors_ready()
# We Start all the ROS related Subscribers and publishers
rospy.Subscriber("/moving_cube/joint_states",
JointState, self._joints_callback)
rospy.Subscriber("/moving_cube/odom", Odometry, self._odom_callback)
self._roll_vel_pub = rospy.Publisher('/moving_cube/inertia_wheel_roll_joint_velocity_controller/command',
Float64, queue_size=1)
self._check_publishers_connection()
self.gazebo.pauseSim()
# Methods needed by the RobotGazeboEnv
# ----------------------------
def _check_all_systems_ready(self):
"""
Checks that all the sensors, publishers and other simulation systems are
operational.
"""
self._check_all_sensors_ready()
return True
# CubeSingleDiskEnv virtual methods
# ----------------------------
def _check_all_sensors_ready(self):
self._check_joint_states_ready()
self._check_odom_ready()
rospy.logdebug("ALL SENSORS READY")
def _check_joint_states_ready(self):
self.joints = None
while self.joints is None and not rospy.is_shutdown():
try:
self.joints = rospy.wait_for_message(
"/moving_cube/joint_states", JointState, timeout=1.0)
rospy.logdebug(
"Current moving_cube/joint_states READY=>" + str(self.joints))
except:
rospy.logerr(
"Current moving_cube/joint_states not ready yet, retrying for getting joint_states")
return self.joints
def _check_odom_ready(self):
self.odom = None
while self.odom is None and not rospy.is_shutdown():
try:
self.odom = rospy.wait_for_message(
"/moving_cube/odom", Odometry, timeout=1.0)
rospy.logdebug(
"Current /moving_cube/odom READY=>" + str(self.odom))
except:
rospy.logerr(
"Current /moving_cube/odom not ready yet, retrying for getting odom")
return self.odom
def _joints_callback(self, data):
self.joints = data
def _odom_callback(self, data):
self.odom = data
def _check_publishers_connection(self):
"""
Checks that all the publishers are working
:return:
"""
rate = rospy.Rate(10) # 10hz
while self._roll_vel_pub.get_num_connections() == 0 and not rospy.is_shutdown():
rospy.logdebug(
"No susbribers to _roll_vel_pub yet so we wait and try again")
try:
rate.sleep()
except rospy.ROSInterruptException:
# This is to avoid error when world is rested, time when backwards.
pass
rospy.logdebug("_roll_vel_pub Publisher Connected")
rospy.logdebug("All Publishers READY")
# Methods that the TrainingEnvironment will need to define here as virtual
# because they will be used in RobotGazeboEnv GrandParentClass and defined in the
# TrainingEnvironment.
# ----------------------------
def _set_init_pose(self):
"""Sets the Robot in its init pose
"""
raise NotImplementedError()
def _init_env_variables(self):
"""Inits variables needed to be initialised each time we reset at the start
of an episode.
"""
raise NotImplementedError()
def _compute_reward(self, observations, done):
"""Calculates the reward to give based on the observations given.
"""
raise NotImplementedError()
def _set_action(self, action):
"""Applies the given action to the simulation.
"""
raise NotImplementedError()
def _get_obs(self):
raise NotImplementedError()
def _is_done(self, observations):
"""Checks if episode done based on observations given.
"""
raise NotImplementedError()
# Methods that the TrainingEnvironment will need.
# ----------------------------
def move_joints(self, roll_speed):
joint_speed_value = Float64()
joint_speed_value.data = roll_speed
rospy.logdebug("Single Disk Roll Velocity>>" + str(joint_speed_value))
self._roll_vel_pub.publish(joint_speed_value)
self.wait_until_roll_is_in_vel(joint_speed_value.data)
def wait_until_roll_is_in_vel(self, velocity):
rate = rospy.Rate(10)
start_wait_time = rospy.get_rostime().to_sec()
end_wait_time = 0.0
epsilon = 0.1
v_plus = velocity + epsilon
v_minus = velocity - epsilon
while not rospy.is_shutdown():
joint_data = self._check_joint_states_ready()
roll_vel = joint_data.velocity[0]
rospy.logdebug("VEL=" + str(roll_vel) +
", ?RANGE=[" + str(v_minus) + ","+str(v_plus)+"]")
are_close = (roll_vel <= v_plus) and (roll_vel > v_minus)
if are_close:
rospy.logdebug("Reached Velocity!")
end_wait_time = rospy.get_rostime().to_sec()
break
rospy.logdebug("Not there yet, keep waiting...")
rate.sleep()
delta_time = end_wait_time - start_wait_time
rospy.logdebug("[Wait Time=" + str(delta_time)+"]")
return delta_time
def get_joints(self):
return self.joints
def get_odom(self):
return self.odom
| [] |
2024-01-10 | TyperClub/RoboMaster-Simulator | src~openai_ros~openai_ros~src~openai_ros~robot_envs~sawyer_env.py | import numpy
import rospy
import time
import tf
from openai_ros import robot_gazebo_env
import intera_interface
import intera_external_devices
from intera_interface import CHECK_VERSION
from intera_core_msgs.msg import JointLimits
from sensor_msgs.msg import Image
from openai_ros.openai_ros_common import ROSLauncher
class SawyerEnv(robot_gazebo_env.RobotGazeboEnv):
"""Superclass for all SawyerEnv environments.
"""
def __init__(self, ros_ws_abspath):
"""
Initializes a new SawyerEnv environment.
To check any topic we need to have the simulations running, we need to do two things:
1) Unpause the simulation: without that th stream of data doesnt flow. This is for simulations
that are pause for whatever the reason
2) If the simulation was running already for some reason, we need to reset the controlers.
This has to do with the fact that some plugins with tf, dont understand the reset of the simulation
and need to be reseted to work properly.
The Sensors: The sensors accesible are the ones considered usefull for AI learning.
Sensor Topic List:
* /robot/joint_limits: Odometry of the Base of Wamv
Actuators Topic List:
* As actuator we will use a class to interface with the movements through commands.
Args:
"""
rospy.logdebug("Start SawyerEnv INIT...")
# Variables that we give through the constructor.
# None in this case
# We launch the ROSlaunch that spawns the robot into the world
ROSLauncher(rospackage_name="sawyer_gazebo",
launch_file_name="put_sawyer_in_world.launch",
ros_ws_abspath=ros_ws_abspath)
# Internal Vars
# Doesnt have any accesibles
self.controllers_list = []
# It doesnt use namespace
self.robot_name_space = ""
# We launch the init function of the Parent Class robot_gazebo_env.RobotGazeboEnv
super(SawyerEnv, self).__init__(controllers_list=self.controllers_list,
robot_name_space=self.robot_name_space,
reset_controls=False,
start_init_physics_parameters=False,
reset_world_or_sim="WORLD")
rospy.logdebug("SawyerEnv unpause...")
self.gazebo.unpauseSim()
# self.controllers_object.reset_controllers()
# TODO: Fill it with the sensors
self._check_all_systems_ready()
rospy.Subscriber("/io/internal_camera/head_camera/image_raw",
Image, self._head_camera_image_raw_callback)
rospy.Subscriber("/io/internal_camera/right_hand_camera/image_raw",
Image, self._right_hand_camera_image_raw_callback)
self._setup_tf_listener()
self._setup_movement_system()
self.gazebo.pauseSim()
rospy.logdebug("Finished SawyerEnv INIT...")
# Methods needed by the RobotGazeboEnv
# ----------------------------
def _check_all_systems_ready(self):
"""
Checks that all the sensors, publishers and other simulation systems are
operational.
"""
rospy.logdebug("SawyerEnv check_all_systems_ready...")
self._check_all_sensors_ready()
rospy.logdebug("END SawyerEnv _check_all_systems_ready...")
return True
# CubeSingleDiskEnv virtual methods
# ----------------------------
def _check_all_sensors_ready(self):
rospy.logdebug("START ALL SENSORS READY")
# TODO: Here go the sensors like cameras and joint states
self._check_head_camera_image_raw_ready()
self._check_right_hand_camera_image_raw_ready()
rospy.logdebug("ALL SENSORS READY")
def _check_head_camera_image_raw_ready(self):
self.head_camera_image_raw = None
rospy.logdebug(
"Waiting for /io/internal_camera/head_camera/image_raw to be READY...")
while self.head_camera_image_raw is None and not rospy.is_shutdown():
try:
self.head_camera_image_raw = rospy.wait_for_message(
"/io/internal_camera/head_camera/image_raw", Image, timeout=5.0)
rospy.logdebug(
"Current /io/internal_camera/head_camera/image_raw READY=>")
except:
rospy.logerr(
"Current /io/internal_camera/head_camera/image_raw not ready yet, retrying for getting head_camera_image_raw")
return self.head_camera_image_raw
def _check_right_hand_camera_image_raw_ready(self):
self.right_hand_camera_image_raw = None
rospy.logdebug(
"Waiting for /io/internal_camera/right_hand_camera/image_raw to be READY...")
while self.right_hand_camera_image_raw is None and not rospy.is_shutdown():
try:
self.right_hand_camera_image_raw = rospy.wait_for_message(
"/io/internal_camera/right_hand_camera/image_raw", Image, timeout=5.0)
rospy.logdebug(
"Current /io/internal_camera/right_hand_camera/image_raw READY=>")
except:
rospy.logerr(
"Current /io/internal_camera/right_hand_camera/image_raw not ready yet, retrying for getting right_hand_camera_image_raw")
return self.right_hand_camera_image_raw
def _head_camera_image_raw_callback(self, data):
self.head_camera_image_raw = data
def _right_hand_camera_image_raw_callback(self, data):
self.right_hand_camera_image_raw = data
def _setup_tf_listener(self):
"""
Set ups the TF listener for getting the transforms you ask for.
"""
self.listener = tf.TransformListener()
def _setup_movement_system(self):
"""
Setup of the movement system.
:return:
"""
rp = intera_interface.RobotParams()
valid_limbs = rp.get_limb_names()
if not valid_limbs:
rp.log_message(("Cannot detect any limb parameters on this robot. "
"Exiting."), "ERROR")
return
rospy.loginfo("Valid Sawyer Limbs==>"+str(valid_limbs))
print("Getting robot state... ")
rs = intera_interface.RobotEnable(CHECK_VERSION)
init_state = rs.state().enabled
rospy.loginfo("Enabling robot...")
rs.enable()
self._map_actions_to_movement()
def _map_actions_to_movement(self, side="right", joint_delta=0.1):
self.limb = intera_interface.Limb(side)
try:
self.gripper = intera_interface.Gripper(side + '_gripper')
except:
self.has_gripper = False
rospy.loginfo("The electric gripper is not detected on the robot.")
else:
self.has_gripper = True
self.joints = self.limb.joint_names()
self.bindings = {
self.joints[0]+"_increase": (self.set_j, [self.joints[0], joint_delta], self.joints[0]+" increase"),
self.joints[0]+"_decrease": (self.set_j, [self.joints[0], -joint_delta], self.joints[0]+" decrease"),
self.joints[1]+"_increase": (self.set_j, [self.joints[1], joint_delta], self.joints[1]+" increase"),
self.joints[1]+"_decrease": (self.set_j, [self.joints[1], -joint_delta], self.joints[1]+" decrease"),
self.joints[2]+"_increase": (self.set_j, [self.joints[2], joint_delta], self.joints[2]+" increase"),
self.joints[2]+"_decrease": (self.set_j, [self.joints[2], -joint_delta], self.joints[2]+" decrease"),
self.joints[3]+"_increase": (self.set_j, [self.joints[3], joint_delta], self.joints[3]+" increase"),
self.joints[3]+"_decrease": (self.set_j, [self.joints[3], -joint_delta], self.joints[3]+" decrease"),
self.joints[4]+"_increase": (self.set_j, [self.joints[4], joint_delta], self.joints[4]+" increase"),
self.joints[4]+"_decrease": (self.set_j, [self.joints[4], -joint_delta], self.joints[4]+" decrease"),
self.joints[5]+"_increase": (self.set_j, [self.joints[5], joint_delta], self.joints[5]+" increase"),
self.joints[5]+"_decrease": (self.set_j, [self.joints[5], -joint_delta], self.joints[5]+" decrease"),
self.joints[6]+"_increase": (self.set_j, [self.joints[6], joint_delta], self.joints[6]+" increase"),
self.joints[6]+"_decrease": (self.set_j, [self.joints[6], -joint_delta], self.joints[6]+" decrease")
}
if self.has_gripper:
self.bindings.update({
"close": (self.set_g, "close", side+" gripper close"),
"open": (self.set_g, "open", side+" gripper open"),
"calibrate": (self.set_g, "calibrate", side+" gripper calibrate")
})
rospy.loginfo("Controlling joints...")
# Methods that the TrainingEnvironment will need to define here as virtual
# because they will be used in RobotGazeboEnv GrandParentClass and defined in the
# TrainingEnvironment.
# ----------------------------
def _set_init_pose(self):
"""Sets the Robot in its init pose
"""
raise NotImplementedError()
def _init_env_variables(self):
"""Inits variables needed to be initialised each time we reset at the start
of an episode.
"""
raise NotImplementedError()
def _compute_reward(self, observations, done):
"""Calculates the reward to give based on the observations given.
"""
raise NotImplementedError()
def _set_action(self, action):
"""Applies the given action to the simulation.
"""
raise NotImplementedError()
def _get_obs(self):
raise NotImplementedError()
def _is_done(self, observations):
"""Checks if episode done based on observations given.
"""
raise NotImplementedError()
# Methods that the TrainingEnvironment will need.
# ----------------------------
def execute_movement(self, action_id):
"""
It executed the command given through an id. This will move any joint
of Sawyer, including the gripper if it has it.
:param: action_id: These are the possible action_id values and the action asociated.
self.joints[0]+"_increase",
self.joints[0]+_decrease,
self.joints[1]+"_increase",
self.joints[1]+"_decrease",
self.joints[2]+"_increase",
self.joints[2]+"_decrease",
self.joints[3]+"_increase",
self.joints[3]+"_decrease",
self.joints[4]+"_increase",
self.joints[4]+"_decrease",
self.joints[5]+"_increase",
self.joints[5]+"_decrease",
self.joints[6]+"_increase",
self.joints[6]+"_decrease",
gripper_close,
gripper_open,
gripper_calibrate
"""
if action_id in self.bindings:
cmd = self.bindings[action_id]
if action_id == "gripper_close" or action_id == "gripper_open" or action_id == "gripper_calibrate":
cmd[0](cmd[1])
rospy.loginfo("command: %s" % (cmd[2],))
else:
# expand binding to something like "self.set_j(right, 'j0', joint_delta)"
cmd[0](*cmd[1])
rospy.loginfo("command: %s" % (cmd[2],))
else:
rospy.logerr("NOT VALID key binding, it should be one of these: ")
for key, val in sorted(self.bindings.items(),
key=lambda x: x[1][2]):
rospy.logerr(" %s: %s" % (key, val[2]))
def set_j(self, joint_name, delta):
current_position = self.limb.joint_angle(joint_name)
joint_command = {joint_name: current_position + delta}
self.limb.set_joint_positions(joint_command)
def set_g(self, action):
if self.has_gripper:
if action == "close":
self.gripper.close()
elif action == "open":
self.gripper.open()
elif action == "calibrate":
self.gripper.calibrate()
def move_joints_to_angle_blocking(self, joint_positions_dict, timeout=15.0, threshold=0.008726646):
"""
It moves all the joints to the given position and doesnt exit until it reaches that position
"""
self.limb.move_to_joint_positions(positions=joint_positions_dict,
timeout=15.0,
threshold=0.008726646,
test=None)
def get_limb_joint_names_array(self):
"""
Returns the Joint Names array of the Limb.
"""
return self.joints
def get_all_limb_joint_angles(self):
"""
Return dictionary dict({str:float}) with all the joints angles
"""
return self.limb.joint_angles()
def get_all_limb_joint_efforts(self):
"""
Returns a dictionary dict({str:float}) with all the joints efforts
"""
return self.limb.joint_efforts()
def get_tf_start_to_end_frames(self, start_frame_name, end_frame_name):
"""
Given two frames, it returns the transform from the start_frame_name to the end_frame_name.
It will only return something different to None if the TFs of the Two frames are in TF topic
published and are connected through the TF tree.
:param: start_frame_name: Start Frame of the TF transform
end_frame_name: End Frame of the TF transform
:return: trans,rot of the transform between the start and end frames.
"""
start_frame = "/"+start_frame_name
end_frame = "/"+end_frame_name
trans, rot = None, None
while (trans is None or rot is None) and not rospy.is_shutdown():
try:
(trans, rot) = self.listener.lookupTransform(
start_frame, end_frame, rospy.Time(0))
except (tf.LookupException, tf.ConnectivityException, tf.ExtrapolationException):
rospy.logerr("TF start to end not ready YET...")
duration_obj = rospy.Duration.from_sec(1.0)
rospy.sleep(duration_obj)
return trans, rot
def check_joint_limits_ready(self):
self.joint_limits = None
rospy.logdebug("Waiting for /robot/joint_limits to be READY...")
while self.joint_limits is None and not rospy.is_shutdown():
try:
self.joint_limits = rospy.wait_for_message(
"/robot/joint_limits", JointLimits, timeout=3.0)
rospy.logdebug("Current /robot/joint_limits READY=>")
except:
rospy.logerr(
"Current /robot/joint_limits not ready yet, retrying for getting joint_limits")
return self.joint_limits
def get_joint_limits(self):
return self.joint_limits
def get_head_camera_image_raw(self):
return self.head_camera_image_raw
def get_right_hand_camera_image_raw(self):
return self.right_hand_camera_image_raw
def init_joint_limits(self):
"""
Get the Joint Limits, in the init fase where we need to unpause the simulation to get them
:return: joint_limits: The Joint Limits Dictionary, with names, angles, vel and effort limits.
"""
self.gazebo.unpauseSim()
joint_limits = self.check_joint_limits_ready()
self.gazebo.pauseSim()
return joint_limits
| [] |
2024-01-10 | TyperClub/RoboMaster-Simulator | src~openai_ros~openai_ros~src~openai_ros~task_envs~cartpole_stay_up~stay_up.py | from gym import utils
from openai_ros.robot_envs import cartpole_env
from gym.envs.registration import register
from gym import error, spaces
import rospy
import math
import numpy as np
from openai_ros.task_envs.task_commons import LoadYamlFileParamsTest
from openai_ros.openai_ros_common import ROSLauncher
import os
class CartPoleStayUpEnv(cartpole_env.CartPoleEnv):
def __init__(self):
ros_ws_abspath = rospy.get_param("/cartpole_v0/ros_ws_abspath", None)
assert ros_ws_abspath is not None, "You forgot to set ros_ws_abspath in your yaml file of your main RL script. Set ros_ws_abspath: \'YOUR/SIM_WS/PATH\'"
assert os.path.exists(ros_ws_abspath), "The Simulation ROS Workspace path " + ros_ws_abspath + \
" DOESNT exist, execute: mkdir -p " + ros_ws_abspath + \
"/src;cd " + ros_ws_abspath + ";catkin_make"
ROSLauncher(rospackage_name="cartpole_description",
launch_file_name="start_world.launch",
ros_ws_abspath=ros_ws_abspath)
# Load Params from the desired Yaml file
LoadYamlFileParamsTest(rospackage_name="openai_ros",
rel_path_from_package_to_file="src/openai_ros/task_envs/cartpole_stay_up/config",
yaml_file_name="stay_up.yaml")
self.get_params()
self.action_space = spaces.Discrete(self.n_actions)
high = np.array([
2.5 * 2,
np.finfo(np.float32).max,
0.7 * 2,
np.finfo(np.float32).max])
self.observation_space = spaces.Box(-high, high)
# TODO: Remove when working
"""
cartpole_env.CartPoleEnv.__init__(
self, control_type=self.control_type
)
"""
# Here we will add any init functions prior to starting the MyRobotEnv
super(CartPoleStayUpEnv, self).__init__(control_type=self.control_type,
ros_ws_abspath=ros_ws_abspath)
def get_params(self):
# get configuration parameters
self.n_actions = rospy.get_param('/cartpole_v0/n_actions')
self.min_pole_angle = rospy.get_param('/cartpole_v0/min_pole_angle')
self.max_pole_angle = rospy.get_param('/cartpole_v0/max_pole_angle')
self.max_base_velocity = rospy.get_param(
'/cartpole_v0/max_base_velocity')
self.min_base_pose_x = rospy.get_param('/cartpole_v0/min_base_pose_x')
self.max_base_pose_x = rospy.get_param('/cartpole_v0/max_base_pose_x')
self.pos_step = rospy.get_param('/cartpole_v0/pos_step')
self.running_step = rospy.get_param('/cartpole_v0/running_step')
self.init_pos = rospy.get_param('/cartpole_v0/init_pos')
self.wait_time = rospy.get_param('/cartpole_v0/wait_time')
self.control_type = rospy.get_param('/cartpole_v0/control_type')
def _set_action(self, action):
# Take action
if action == 0: # LEFT
rospy.loginfo("GO LEFT...")
self.pos[0] -= self.pos_step
elif action == 1: # RIGHT
rospy.loginfo("GO RIGHT...")
self.pos[0] += self.pos_step
elif action == 2: # LEFT BIG
rospy.loginfo("GO LEFT BIG...")
self.pos[0] -= self.pos_step * 10
elif action == 3: # RIGHT BIG
rospy.loginfo("GO RIGHT BIG...")
self.pos[0] += self.pos_step * 10
# Apply action to simulation.
rospy.loginfo("MOVING TO POS=="+str(self.pos))
# 1st: unpause simulation
#rospy.logdebug("Unpause SIM...")
# self.gazebo.unpauseSim()
self.move_joints(self.pos)
rospy.logdebug(
"Wait for some time to execute movement, time="+str(self.running_step))
rospy.sleep(self.running_step) # wait for some time
rospy.logdebug(
"DONE Wait for some time to execute movement, time=" + str(self.running_step))
# 3rd: pause simulation
#rospy.logdebug("Pause SIM...")
# self.gazebo.pauseSim()
def _get_obs(self):
data = self.joints
# base_postion base_velocity pole angle pole velocity
#obs = [round(data.position[1],1), round(data.velocity[1],1), round(data.position[0],1), round(data.velocity[0],1)]
obs = [data.position[1], data.velocity[1],
data.position[0], data.velocity[0]]
return np.array(obs)
def _is_done(self, observations):
done = False
data = self.joints
rospy.loginfo("BASEPOSITION=="+str(observations[0]))
rospy.loginfo("POLE ANGLE==" + str(observations[2]))
# check if the base is still within the ranges of (-2, 2)
if (self.min_base_pose_x >= observations[0] or observations[0] >= self.max_base_pose_x):
rospy.logerr("Base Outside Limits==>min="+str(self.min_base_pose_x) +
",pos="+str(observations[0])+",max="+str(self.max_base_pose_x))
done = True
# check if pole has toppled over
if (self.min_pole_angle >= observations[2] or observations[2] >= self.max_pole_angle):
rospy.logerr(
"Pole Angle Outside Limits==>min=" + str(self.min_pole_angle) + ",pos=" + str(observations[2]) + ",max=" + str(
self.max_pole_angle))
done = True
rospy.loginfo("FINISHED get _is_done")
return done
def _compute_reward(self, observations, done):
"""
Gives more points for staying upright, gets data from given observations to avoid
having different data than other previous functions
:return:reward
"""
rospy.logdebug("START _compute_reward")
if not done:
reward = 1.0
elif self.steps_beyond_done is None:
# Pole just fell!
self.steps_beyond_done = 0
reward = 1.0
else:
if self.steps_beyond_done == 0:
logger.warning("You are calling 'step()' even though this environment has already returned done = True. You should always call 'reset()' once you receive 'done = True' -- any further steps are undefined behavior.")
self.steps_beyond_done += 1
reward = 0.0
rospy.logdebug("END _compute_reward")
return reward
def _init_env_variables(self):
"""
Inits variables needed to be initialised each time we reset at the start
of an episode.
:return:
"""
self.steps_beyond_done = None
def _set_init_pose(self):
"""
Sets joints to initial position [0,0,0]
:return:
"""
self.check_publishers_connection()
# Reset Internal pos variable
self.init_internal_vars(self.init_pos)
self.move_joints(self.pos)
| [] |
2024-01-10 | krasserm/grammar-based-agents | gba~math.py | import re
from typing import List, Dict, Any, Optional
from langchain.chains.base import Chain
from langchain_core.callbacks import CallbackManagerForChainRun
from langchain_core.language_models import LLM
from langchain_core.prompts import PromptTemplate
_PROMPT_TEMPLATE = """[INST] Your task is to create python code to solve a mathematical problem and assign the result to a variable named `result`. Do not perform the calculation yourself no matter how trivial it is, as you are not good at math. Instead you should generate Python code to do the calculation for you. The result of the calculation should be assigned to a variable named `result`. Provide a single answer using python code and wrap your code answer using ```. Ensure that the python code is as simple as possible while still being correct.
Mathematical problem: {question}
[/INST]"""
PROMPT = PromptTemplate(
input_variables=["question"],
template=_PROMPT_TEMPLATE,
)
class Llama2Math(Chain):
llm: LLM
prompt: PromptTemplate = PROMPT
@property
def input_keys(self) -> List[str]:
return ["message"]
@property
def output_keys(self) -> List[str]:
return ["result"]
def _call(self, inputs: Dict[str, Any], run_manager: Optional[CallbackManagerForChainRun] = None) -> Dict[str, Any]:
output = (self.prompt | self.llm).invoke({"question": inputs["message"]})
code = self._parse_output(output)
code = code.strip("\n")
print("Executing Llama2Math Python code:")
print(f"```\n{code}\n```")
try:
loc_variables = {}
exec(code, globals(), loc_variables)
result = loc_variables["result"]
return {"result": f"{result:.5f}"}
except Exception as e:
raise ValueError(f"LLM output could not be evaluated (output='{output}', error='{e}')")
@staticmethod
def _parse_output(output: str) -> str:
match = re.search(r"^```(.*)```$", output, re.DOTALL)
if not match:
raise ValueError(f"LLM output could not be parsed (output='{output}')")
return match.group(1)
| [
"[INST] Your task is to create python code to solve a mathematical problem and assign the result to a variable named `result`. Do not perform the calculation yourself no matter how trivial it is, as you are not good at math. Instead you should generate Python code to do the calculation for you. The result of the calculation should be assigned to a variable named `result`. Provide a single answer using python code and wrap your code answer using ```. Ensure that the python code is as simple as possible while still being correct.\nMathematical problem: {question}\n[/INST]",
"question"
] |
2024-01-10 | sidaw/DS-1000 | ds1000.py | import os
import pickle
import shutil
import signal
import json
import configparser
import importlib
import tempfile
import threading
import sys
from pathlib import Path
from subprocess import PIPE, Popen
from dataclasses import dataclass
from typing import List, Union
def check_cpu_count(num_procs: int):
from multiprocessing import cpu_count
import warnings
if 2 * num_procs > cpu_count():
warnings.warn(
f"You have {cpu_count()} cpus but are using {num_procs} processes to run the evaluation!",
Warning,
)
def check_version():
import DateTime
import gensim
import matplotlib
import numpy
import openai
import pandas
import pandas_datareader
import pathlib
import sklearn
import scipy
import seaborn
import statsmodels
import tensorflow
import torch
import torchvision
import tqdm
import transformers
import xgboost
import platform
assert platform.python_version() == "3.7.10"
assert gensim.__version__ == "4.2.0"
assert matplotlib.__version__ == "3.5.2"
assert numpy.__version__ == "1.21.6"
assert pandas.__version__ == "1.3.5"
assert pandas_datareader.__version__ == "0.10.0"
assert sklearn.__version__ == "1.0.2"
assert scipy.__version__ == "1.7.3"
assert seaborn.__version__ == "0.11.2"
assert statsmodels.__version__ == "0.13.2"
assert tensorflow.__version__ == "2.10.0"
assert "1.12.1" in torch.__version__
assert "0.13.1" in torchvision.__version__
assert tqdm.__version__ == "4.64.1"
assert transformers.__version__ == "4.22.1"
assert xgboost.__version__ == "1.6.2"
class Command(object):
"""
This object takes in command and executes it with time out
"""
def __init__(self, cmd):
self.cmd = cmd
self.process = None
def run(self, timeout):
def target():
# Check if in Windows https://stackoverflow.com/questions/1325581/how-do-i-check-if-im-running-on-windows-in-python
if os.name == "nt":
self.process = Popen(self.cmd, shell=True, stdout=PIPE, stderr=PIPE)
else:
self.process = Popen(
self.cmd, shell=True, stdout=PIPE, stderr=PIPE, preexec_fn=os.setsid
)
self.process.communicate()
thread = threading.Thread(target=target)
thread.start()
thread.join(timeout)
if thread.is_alive():
# Check if in Windows https://stackoverflow.com/questions/1325581/how-do-i-check-if-im-running-on-windows-in-python
if os.name == "nt":
Popen("TASKKILL /F /PID {pid} /T".format(pid=self.process.pid))
else:
os.killpg(self.process.pid, signal.SIGTERM)
thread.join()
return self.process.returncode
def import_source_file(fname, modname):
"""
Import a Python source file and return the loaded module.
Args:
fname: The full path to the source file. It may container characters like `.`
or `-`.
modname: The name for the loaded module. It may contain `.` and even characters
that would normally not be allowed (e.g., `-`).
Return:
The imported module
Raises:
ImportError: If the file cannot be imported (e.g, if it's not a `.py` file or if
it does not exist).
Exception: Any exception that is raised while executing the module (e.g.,
:exc:`SyntaxError). These are errors made by the author of the module!
"""
# https://docs.python.org/3/library/importlib.html#importing-a-source-file-directly
spec = importlib.util.spec_from_file_location(modname, fname)
if spec is None:
raise ImportError(f"Could not load spec for module '{modname}' at: {fname}")
module = importlib.util.module_from_spec(spec)
sys.modules[modname] = module
try:
spec.loader.exec_module(module)
except FileNotFoundError as e:
raise ImportError(f"{e.strerror}: {fname}") from e
return module
class DS1000Problem:
"""
A DS1000 Problem.
problem = DS1000Problem("ds1000_data/Pandas/Completion/q1") # loads all relevant objects into RAM
# useful attributes
problem["prompt"] # official prompt
problem["reference_code"] # reference_code
problem.keys() # gives all accessible attributes
"""
def __init__(
self,
problem_path: Union[str, Path],
):
self.problem_path = Path(problem_path)
self.problem_id = int(self.problem_path.name.replace("q", ""))
self.data = dict()
# load meta information in .cfg
problem_config = configparser.RawConfigParser()
problem_config.read(self.problem_path / ".cfg")
for args in [
("library", "lib"),
("test", "test_type"),
("test", "test_case_cnt"),
("perturbation", "perturbation_type"),
("perturbation", "perturbation_origin_id"),
]:
self.data[args[1]] = problem_config.get(*args)
# read problem content files
for file_name in [
"reference_code.txt",
"test_code.py",
"code_context.txt",
"test_generate_pickle.py",
"prompt.txt",
]:
with open(self.problem_path / file_name, "r", encoding="UTF-8") as f:
self.data[file_name.split(".")[0]] = f.read()
# loading precomputed pickles files of inputs and expected outputs
self.data["ans"] = []
# an question may have no input or no answer output
# in such cases, we put a None object
# otherwise, we load the pickle file
test_cnt = max(int(self.data["test_case_cnt"]), 1)
for i in range(1, test_cnt + 1):
if os.path.exists(self.problem_path / f"ans/ans{i}.pkl"):
try:
with open(self.problem_path / "ans/ans{}.pkl".format(i), "rb") as f:
# with HiddenPrints():
self.data["ans"].append(pickle.load(f))
except:
self.data["ans"].append(None)
else:
self.data["ans"].append(None)
self.data["source_url"] = ""
def __getitem__(self, key):
return self.data[key]
def keys(self):
return self.data.keys()
def values(self):
return self.data.values()
def items(self):
return self.data.items()
def postprocess(self, generated_code: str):
if self.data["lib"] == "Matplotlib":
code_lines = generated_code.split("\n")
postprocessed_lines = []
for line in code_lines:
skip_line_flag = False
# Matplotlib removes function calls that will clear the global figure object
# Removing these functions helps running execution-based evaluation
for phrase in ["plt.show()", "plt.clf()", "plt.close()", "savefig"]:
if phrase in line:
skip_line_flag = True
break
if skip_line_flag:
continue
else:
postprocessed_lines.append(line)
generated_code = "\n".join(postprocessed_lines)
return generated_code
def test(self, generated_code: str):
# get current dir because we will enter a temp dir to execute generated code
cwd = os.getcwd()
# we create a tempdir to execute each generated program
with tempfile.TemporaryDirectory() as tempdir_name:
# clean everything in the tempdir (unlikely)
for file_name in os.listdir(tempdir_name):
os.remove(file_name)
tempdir_name = Path(tempdir_name)
# copy all files and data dependencies from
for file_name in os.listdir(self.problem_path):
if os.path.isfile(self.problem_path / file_name):
shutil.copy(self.problem_path / file_name, tempdir_name / file_name)
elif os.path.isdir(self.problem_path / file_name):
shutil.copytree(
self.problem_path / file_name, tempdir_name / file_name
)
else:
raise ValueError("impossible.")
# generated outputs will be put into `result`
os.mkdir(tempdir_name / "result")
# Matplotlib requires postprocessing
generated_code = self.postprocess(generated_code)
program = self.data["code_context"].replace("[insert]", generated_code)
with open(tempdir_name / "program.py", "w", encoding="UTF-8") as f:
f.write(program)
# enter into the tempdir to execute
os.chdir(tempdir_name)
execution_status = []
# a question may not have test case but we can still execute and see if there is error
test_cnt = max(1, int(self["test_case_cnt"]))
for i in range(1, test_cnt + 1):
# notice this command, e.g., you may need to replace `python` with `python3`
cmd_text = f"python program.py --test_case {i}"
time_limit = 60 # should not change the official time_limit
cmd = Command(
cmd_text,
)
exit_code = cmd.run(timeout=time_limit) # 0 if there is no error
execution_status.append(exit_code)
# loading testing code as a module
test_module = import_source_file(tempdir_name / "test_code.py", "test_code")
pass_flag = True
if int(self["test_type"]) == 3:
# stringTest parses the generated code into AST and check AST components
# if there is static error, stringTest may raise an exception
try:
pass_flag = test_module.stringTest(generated_code)
except:
pass_flag = False
for i in range(1, test_cnt + 1):
# if the generated program already failed some test, we don't have to compare new test outputs
if not pass_flag:
break
# when the generated didn't generate an output, we count it as incorrect
if not os.path.exists(f"result/result_{i}.pkl"):
pass_flag = False
else:
try:
# loading the generated output might still raise Exception
# if the generated code is not correct
result = pickle.load(
open("result/result_{}.pkl".format(i), "rb")
)
expected_result = self.data["ans"][i - 1]
try:
pass_flag = test_module.test(result, expected_result) == 1
except:
pass_flag = False
except:
pass_flag = False
os.chdir(cwd)
return pass_flag
class DS1000Dataset:
"""
A DS1000 Dataset.
ds1000 = DS1000Dataset("ds1000_data") # loads all questions into RAM
# DS1000Dataset is splitted by different packages
ds1000["Pandas"] # list of 291 Pandas questions
ds1000["Pandas"][0] # get first Pandas question
"""
def __init__(
self,
source_dir: Union[str, Path] = "ds1000_data",
libs: Union[str, List[str]] = "all",
mode: str = "Insertion",
):
self.source_dir = source_dir
# to specify which mode to use, ``Insertion'' or ``Completion''
self.mode = mode
# libs can be a str "Pandas" or a List[str] ["Pandas", "Numpy"]
if libs == "all":
self.libs = [
"Pandas",
"Numpy",
"Matplotlib",
"Tensorflow",
"Scipy",
"Sklearn",
"Pytorch",
]
elif isinstance(libs, str):
self.libs = [libs]
elif isinstance(libs, list):
self.libs = libs
self.data = {}
for lib in self.libs:
self.data[lib] = []
source_path = Path(source_dir) / lib / mode
problems = sorted(
os.listdir(source_path), key=lambda x: int(str(x).replace("q", ""))
)
for problem in problems:
new_problem = DS1000Problem(source_path / problem)
self.data[lib].append(new_problem)
def __len__(self):
return sum([len(self.data[lib]) for lib in self.libs])
def __getitem__(self, key):
return self.data[key]
@dataclass
class ScoreRecord:
"""
A Record object containing the test results of all samples corresponding
to a single question.
Args:
library: str, name of library a question is from
problem_id: str
perturbation_type: str, options among {Origin, Surface, Semantic, Difficult-Rewrite}
perturbation_origin_id: str, id of the original question from which this question is
perturbed
test_results: List[int], each number represeting the test result of a single program sample
use ``write_to_json'' Function to dump attributes into a json file
"""
library: str
problem_id: int
perturbation_type: str
perturbation_origin_id: int
test_results: List[int]
def write_to_json(self, path: Union[str, Path]):
with open(path, "w", encoding="UTF-8") as f:
result = dict()
result["library"] = self.library
result["perturbation_type"] = self.perturbation_type
result["id"] = self.problem_id
result["original_id"] = self.perturbation_origin_id
result["test_results"] = self.test_results
json.dump(result, f)
| [] |
2024-01-10 | sidaw/DS-1000 | run_inference.py | import argparse
import os
import json
import time
import openai
from tqdm import trange
from pathlib import Path
from ds1000 import DS1000Dataset, check_version
codex_name_mapping = {
"codex-cushman": "code-cushman-001",
"codex002": "code-davinci-002",
"codex001": "code-davinci-001",
}
def normalize(raw_text: str):
# replace the html symbols '<' '>' '&'
if "<" in raw_text:
raw_text = raw_text.replace("<", "<")
if ">" in raw_text:
raw_text = raw_text.replace(">", ">")
if "&" in raw_text:
raw_text = raw_text.replace("&", "&")
return raw_text
CURRENT_KEY_ID = 0
def multikey_call(
codex_name: str, prefix: str, suffix: str = None, batch_size: int = 1
):
"""
multiple keys to accelerate the inference
"""
KEYS = []
global CURRENT_KEY_ID
response = None
while response is None:
try:
key = KEYS[CURRENT_KEY_ID]
CURRENT_KEY_ID = (CURRENT_KEY_ID + 1) % len(KEYS)
"""codes only"""
response = openai.Completion.create(
engine=codex_name,
prompt=prefix,
suffix=suffix,
temperature=args.temperature,
max_tokens=args.max_tokens,
api_key=key,
top_p=args.top_p,
frequency_penalty=0,
presence_penalty=0,
stop=["</code>", "# SOLUTION END"],
logprobs=1,
n=batch_size,
)
for batch_i in range(batch_size):
if len(response["choices"][batch_i]["text"]) > 0:
response["choices"][batch_i]["text"] = normalize(
response["choices"][batch_i]["text"]
)
return response
except (openai.error.RateLimitError, openai.error.APIConnectionError) as e:
print(type(e), e)
time.sleep(10)
def codex_inference(output_dir: Path, prefix: str, suffix: str):
"""
Calls OpenAI API to get Codex responses and save prediction text and logprobs
"""
# if outputs are already cached, we skip this sample
for batch_start in trange(0, args.num_samples, args.batch_size):
all_cached = True
for batch_i in range(min(args.num_samples - batch_start, args.batch_size)):
if not all(
[
not args.overwrite_output_dir,
(output_dir / f"{batch_start + batch_i}.py").is_file(),
(output_dir / f"{batch_start + batch_i}.json").is_file(),
]
):
all_cached = False
if all_cached:
continue
response = multikey_call(
codex_name_mapping[args.model],
prefix,
suffix if args.mode == "Insertion" else None,
batch_size=min(args.num_samples - batch_start, args.batch_size),
)
# storing responses
for batch_i in range(min(args.num_samples - batch_start, args.batch_size)):
with open(
output_dir / f"{batch_start + batch_i}.py", "w", encoding="UTF-8"
) as f:
f.write(response["choices"][batch_i]["text"])
result = dict()
result["trg_prediction"] = response["choices"][batch_i]["text"]
result["logprobs"] = response["choices"][batch_i]["logprobs"][
"token_logprobs"
]
result["tokens"] = response["choices"][batch_i]["logprobs"]["tokens"]
with open(output_dir / f"{batch_start + batch_i}.json", "w") as f:
json.dump(result, f)
def model_inference(output_dir: Path, prefix: str, suffix: str = None):
"""
provide an interface for different models to use this inference framework
"""
os.makedirs(output_dir, exist_ok=True)
if "codex" in args.model:
codex_inference(output_dir, prefix, suffix)
else:
# put your model's interface here
pass
def inference(ds1000: DS1000Dataset, args):
"""
A function for model inference
Input:
`ds1000` is a `DS1000Dataset` object
"""
for lib in ds1000.libs:
for problem_id in trange(len(ds1000[lib])):
prefix = ""
suffix = ""
insert_flag = False
first_line_flag = True
# extract prefix and suffix of the prompt
for line in ds1000[lib][problem_id]["prompt"].split("\n"):
if "[insert]" in line:
insert_flag = True
continue
if first_line_flag:
first_line_flag = False
else:
line = "\n" + line
if not insert_flag:
prefix += line
else:
suffix += line
model_inference(
args.output_dir
/ args.model
/ lib
/ args.mode
/ ("q" + str(problem_id)),
prefix,
suffix,
)
if __name__ == "__main__":
check_version()
parser = argparse.ArgumentParser()
parser.add_argument(
"--model",
type=str,
default="codex002",
choices=["codex-cushman", "codex001", "codex002"],
help="Type of Codex Model to run",
)
parser.add_argument(
"--mode", type=str, default="Insertion", choices=["Insertion", "Completion"]
)
parser.add_argument(
"--output_dir",
type=str,
default="./codex_greedy_outputs",
help="Path to which the Codex responses will be cached at",
)
parser.add_argument(
"--source_dir",
type=str,
default="./ds1000_data",
help="Path to the downloaded DS-1000 data",
)
parser.add_argument(
"--num_samples",
type=int,
default=40,
help="Number of Codex samples to draw for one question.",
)
parser.add_argument(
"--overwrite_output_dir",
action="store_true",
default=True,
help="By default will skip cached samples; Turn on this flag to overwrite the existing caches.",
)
parser.add_argument(
"--temperature",
type=float,
default=0.0,
help="Temperature of the Codex sampling distribtuion.",
)
parser.add_argument(
"--top_p",
type=float,
default=0.95,
help="Top-p cutoff of the Codex sampling distribtuion",
)
parser.add_argument(
"--max_tokens",
type=int,
default=1024,
help="Number of maximum tokens for Codex to generate",
)
parser.add_argument(
"--batch_size",
type=int,
default=20,
help="Number of requests to issue at one time",
)
parser.add_argument(
"--libs",
type=str,
nargs="+",
default="all",
help="Specify the subset of DS-1000 to run on. e.g., specifying `--libs Numpy Pandas` will only inference on the Numpy and Pandas split of DS-1000",
)
args = parser.parse_args()
args.output_dir = Path(args.output_dir)
args.source_dir = Path(args.source_dir)
ds1000 = DS1000Dataset(source_dir=args.source_dir, libs=args.libs, mode=args.mode)
print("loaded dataset")
inference(ds1000, args)
| [] |
2024-01-10 | jjjutla/Auto-BTC | AutoBTCPinecone.py | import os
import openai
import json
import numpy as np
from numpy.linalg import norm
import re
from time import time,sleep
from uuid import uuid4
import datetime
import pinecone
def open_file(filepath):
with open(filepath, 'r', encoding='utf-8') as infile:
return infile.read()
def save_file(filepath, content):
with open(filepath, 'w', encoding='utf-8') as outfile:
outfile.write(content)
def load_json(filepath):
with open(filepath, 'r', encoding='utf-8') as infile:
return json.load(infile)
def save_json(filepath, payload):
with open(filepath, 'w', encoding='utf-8') as outfile:
json.dump(payload, outfile, ensure_ascii=False, sort_keys=True, indent=2)
def timestamp_to_datetime(unix_time):
return datetime.datetime.fromtimestamp(unix_time).strftime("%A, %B %d, %Y at %I:%M%p %Z")
def gpt3_embedding(content, engine='text-embedding-ada-002'):
content = content.encode(encoding='ASCII',errors='ignore').decode() # fix any UNICODE errors
response = openai.Embedding.create(input=content,engine=engine)
vector = response['data'][0]['embedding'] # this is a normal list
return vector
def gpt3_completion(prompt, engine='text-davinci-003', temp=0.0, top_p=1.0, tokens=400, freq_pen=0.0, pres_pen=0.0, stop=['USER:', 'AutoBTC:']):
max_retry = 5
retry = 0
prompt = prompt.encode(encoding='ASCII',errors='ignore').decode()
while True:
try:
response = openai.Completion.create(
engine=engine,
prompt=prompt,
temperature=temp,
max_tokens=tokens,
top_p=top_p,
frequency_penalty=freq_pen,
presence_penalty=pres_pen,
stop=stop)
text = response['choices'][0]['text'].strip()
text = re.sub('[\r\n]+', '\n', text)
text = re.sub('[\t ]+', ' ', text)
filename = '%s_gpt3.txt' % time()
if not os.path.exists('gpt3_logs'):
os.makedirs('gpt3_logs')
save_file('gpt3_logs/%s' % filename, prompt + '\n\n==========\n\n' + text)
return text
except Exception as oops:
retry += 1
if retry >= max_retry:
return "GPT3 error: %s" % oops
print('Error communicating with OpenAI:', oops)
sleep(1)
def load_conversation(results):
result = list()
for m in results['matches']:
info = load_json('nexus/%s.json' % m['id'])
result.append(info)
ordered = sorted(result, key=lambda d: d['time'], reverse=False) # sort them all chronologically
messages = [i['message'] for i in ordered]
return '\n'.join(messages).strip()
# Task Prioritization Agent
def prioritize_tasks(task_queue):
prompt = "Given the following tasks:\n" + "\n".join(task_queue) + "\nPrioritize them:"
response = openai.Completion.create(prompt=prompt, engine="text-davinci-003", max_tokens=150)
prioritized_tasks = response['choices'][0]['text'].strip().split("\n")
return prioritized_tasks
# Execution Agent
def execute_task(task):
prompt = f"Execute the task: {task}"
response = openai.Completion.create(prompt=prompt, engine="text-gpt4.0-turbo", max_tokens=150)
result = response['choices'][0]['text'].strip()
return result
# Task Creation Agent
def create_tasks(objective, prev_result, task_description, current_tasks):
prompt = f"Objective: {objective}\nPrevious Task Result: {prev_result}\nTask Description: {task_description}\nCurrent Tasks: {', '.join(current_tasks)}\nSuggest new tasks."
response = openai.Completion.create(prompt=prompt, engine="text-davinci-003", max_tokens=200)
new_tasks_str = response['choices'][0]['text'].strip().split("\n")
new_tasks = [{'task': task} for task in new_tasks_str]
return new_tasks
if __name__ == '__main__':
convo_length = 15 ## request limit
openai.api_key = open_file('key_openai.txt')
pinecone.init(api_key=open_file('key_pinecone.txt'), environment='gcp-starter')
task_vdb = pinecone.Index("task-priority-queue")
vdb = pinecone.Index("autoBTC-mvp")
task_queue = []
while True:
#### get user input, save it, vectorize it, save to pinecone
payload = list()
a = input('\n\nUSER: ')
timestamp = time()
timestring = timestamp_to_datetime(timestamp)
#message = '%s: %s - %s' % ('USER', timestring, a)
message = a
vector = gpt3_embedding(message)
unique_id = str(uuid4())
metadata = {'speaker': 'USER', 'time': timestamp, 'message': message, 'timestring': timestring, 'uuid': unique_id}
save_json('nexus/%s.json' % unique_id, metadata)
payload.append((unique_id, vector))
#### search for relevant messages, and generate a response
results = vdb.query(vector=vector, top_k=convo_length)
conversation = load_conversation(results) # results should be a DICT with 'matches' which is a LIST of DICTS, with 'id'
prompt = open_file('prompt_response.txt').replace('<<CONVERSATION>>', conversation).replace('<<MESSAGE>>', a)
#### generate response, vectorize, save, etc
output = gpt3_completion(prompt)
timestamp = time()
timestring = timestamp_to_datetime(timestamp)
message = output
vector = gpt3_embedding(message)
unique_id = str(uuid4())
metadata = {'speaker': 'AutoBTC', 'time': timestamp, 'message': message, 'timestring': timestring, 'uuid': unique_id}
save_json('nexus/%s.json' % unique_id, metadata)
payload.append((unique_id, vector))
vdb.upsert(payload)
print('\n\nAutoBTC: %s' % output) | [
"Execute the task: PLACEHOLDER",
"\n",
"<<MESSAGE>>",
"\nPrioritize them:",
"<<CONVERSATION>>",
"ignore",
"Given the following tasks:\n",
", ",
"prompt_response.txt"
] |
2024-01-10 | kesper09/Prompt | example.py | import openai
from apikey import api
openai.api_key = api
messages=[
{
"role": "system",
"content": """This is where you write the prompts"""
}
]
while input != "quit()":
message = input("")
#for i in messages:
# print(f"Role: {i['role']}, Content: {i['content']}")
messages.append({"role":"user","content":message})
response = openai.ChatCompletion.create(
model="gpt-3.5-turbo",
messages = messages,
temperature=1,
max_tokens=1024,
top_p=1,
frequency_penalty=0,
presence_penalty=0
)
reply = response["choices"][0]["message"]["content"]
messages.append({"role":"assistant","content":reply})
print("\n"+reply+"\n") | [
"This is where you write the prompts"
] |
2024-01-10 | withmartian/martian-python | martian~openai~api_resources~abstract~api_resource.py | from urllib.parse import quote_plus
from martian import openai
from martian.openai import api_requestor, error, util
from martian.openai.openai_object import OpenAIObject
from martian.openai.util import ApiType
from typing import Optional
class APIResource(OpenAIObject):
api_prefix = ""
azure_api_prefix = "openai"
azure_deployments_prefix = "deployments"
@classmethod
def retrieve(
cls, id, api_key=None, request_id=None, request_timeout=None, **params
):
instance = cls(id=id, api_key=api_key, **params)
instance.refresh(request_id=request_id, request_timeout=request_timeout)
return instance
@classmethod
def aretrieve(
cls, id, api_key=None, request_id=None, request_timeout=None, **params
):
instance = cls(id=id, api_key=api_key, **params)
return instance.arefresh(request_id=request_id, request_timeout=request_timeout)
def refresh(self, request_id=None, request_timeout=None):
self.refresh_from(
self.request(
"get",
self.instance_url(),
request_id=request_id,
request_timeout=request_timeout,
)
)
return self
async def arefresh(self, request_id=None, request_timeout=None):
self.refresh_from(
await self.arequest(
"get",
self.instance_url(operation="refresh"),
request_id=request_id,
request_timeout=request_timeout,
)
)
return self
@classmethod
def class_url(cls):
if cls == APIResource:
raise NotImplementedError(
"APIResource is an abstract class. You should perform actions on its subclasses."
)
# Namespaces are separated in object names with periods (.) and in URLs
# with forward slashes (/), so replace the former with the latter.
base = cls.OBJECT_NAME.replace(".", "/") # type: ignore
if cls.api_prefix:
return "/%s/%s" % (cls.api_prefix, base)
return "/%s" % (base)
def instance_url(self, operation=None):
id = self.get("id")
if not isinstance(id, str):
raise error.InvalidRequestError(
"Could not determine which URL to request: %s instance "
"has invalid ID: %r, %s. ID should be of type `str` (or"
" `unicode`)" % (type(self).__name__, id, type(id)),
"id",
)
api_version = self.api_version or openai.api_version
extn = quote_plus(id)
if self.typed_api_type in (ApiType.AZURE, ApiType.AZURE_AD):
if not api_version:
raise error.InvalidRequestError(
"An API version is required for the Azure API type."
)
if not operation:
base = self.class_url()
return "/%s%s/%s?api-version=%s" % (
self.azure_api_prefix,
base,
extn,
api_version,
)
return "/%s/%s/%s/%s?api-version=%s" % (
self.azure_api_prefix,
self.azure_deployments_prefix,
extn,
operation,
api_version,
)
elif self.typed_api_type == ApiType.OPEN_AI:
base = self.class_url()
return "%s/%s" % (base, extn)
else:
raise error.InvalidAPIType("Unsupported API type %s" % self.api_type)
# The `method_` and `url_` arguments are suffixed with an underscore to
# avoid conflicting with actual request parameters in `params`.
@classmethod
def _static_request(
cls,
method_,
url_,
api_key=None,
api_base=None,
api_type=None,
request_id=None,
api_version=None,
organization=None,
**params,
):
requestor = api_requestor.APIRequestor(
api_key,
api_version=api_version,
organization=organization,
api_base=api_base,
api_type=api_type,
)
response, _, api_key = requestor.request(
method_, url_, params, request_id=request_id
)
return util.convert_to_openai_object(
response, api_key, api_version, organization
)
@classmethod
async def _astatic_request(
cls,
method_,
url_,
api_key=None,
api_base=None,
api_type=None,
request_id=None,
api_version=None,
organization=None,
**params,
):
requestor = api_requestor.APIRequestor(
api_key,
api_version=api_version,
organization=organization,
api_base=api_base,
api_type=api_type,
)
response, _, api_key = await requestor.arequest(
method_, url_, params, request_id=request_id
)
return response
@classmethod
def _get_api_type_and_version(
cls, api_type: Optional[str] = None, api_version: Optional[str] = None
):
typed_api_type = (
ApiType.from_str(api_type)
if api_type
else ApiType.from_str(openai.api_type)
)
typed_api_version = api_version or openai.api_version
return (typed_api_type, typed_api_version)
| [] |
2024-01-10 | withmartian/martian-python | martian~openai~error.py | from martian import openai
class OpenAIError(Exception):
def __init__(
self,
message=None,
http_body=None,
http_status=None,
json_body=None,
headers=None,
code=None,
):
super(OpenAIError, self).__init__(message)
if http_body and hasattr(http_body, "decode"):
try:
http_body = http_body.decode("utf-8")
except BaseException:
http_body = (
"<Could not decode body as utf-8. "
"Please contact us through our help center at help.openai.com.>"
)
self._message = message
self.http_body = http_body
self.http_status = http_status
self.json_body = json_body
self.headers = headers or {}
self.code = code
self.request_id = self.headers.get("request-id", None)
self.error = self.construct_error_object()
self.organization = self.headers.get("openai-organization", None)
def __str__(self):
msg = self._message or "<empty message>"
if self.request_id is not None:
return "Request {0}: {1}".format(self.request_id, msg)
else:
return msg
# Returns the underlying `Exception` (base class) message, which is usually
# the raw message returned by OpenAI's API. This was previously available
# in python2 via `error.message`. Unlike `str(error)`, it omits "Request
# req_..." from the beginning of the string.
@property
def user_message(self):
return self._message
def __repr__(self):
return "%s(message=%r, http_status=%r, request_id=%r)" % (
self.__class__.__name__,
self._message,
self.http_status,
self.request_id,
)
def construct_error_object(self):
if (
self.json_body is None
or not isinstance(self.json_body, dict)
or "error" not in self.json_body
or not isinstance(self.json_body["error"], dict)
):
return None
return openai.api_resources.error_object.ErrorObject.construct_from(
self.json_body["error"]
)
class APIError(OpenAIError):
pass
class TryAgain(OpenAIError):
pass
class Timeout(OpenAIError):
pass
class APIConnectionError(OpenAIError):
def __init__(
self,
message,
http_body=None,
http_status=None,
json_body=None,
headers=None,
code=None,
should_retry=False,
):
super(APIConnectionError, self).__init__(
message, http_body, http_status, json_body, headers, code
)
self.should_retry = should_retry
class InvalidRequestError(OpenAIError):
def __init__(
self,
message,
param,
code=None,
http_body=None,
http_status=None,
json_body=None,
headers=None,
):
super(InvalidRequestError, self).__init__(
message, http_body, http_status, json_body, headers, code
)
self.param = param
def __repr__(self):
return "%s(message=%r, param=%r, code=%r, http_status=%r, " "request_id=%r)" % (
self.__class__.__name__,
self._message,
self.param,
self.code,
self.http_status,
self.request_id,
)
def __reduce__(self):
return type(self), (
self._message,
self.param,
self.code,
self.http_body,
self.http_status,
self.json_body,
self.headers,
)
class AuthenticationError(OpenAIError):
pass
class PermissionError(OpenAIError):
pass
class RateLimitError(OpenAIError):
pass
class ServiceUnavailableError(OpenAIError):
pass
class InvalidAPIType(OpenAIError):
pass
class SignatureVerificationError(OpenAIError):
def __init__(self, message, sig_header, http_body=None):
super(SignatureVerificationError, self).__init__(message, http_body)
self.sig_header = sig_header
def __reduce__(self):
return type(self), (
self._message,
self.sig_header,
self.http_body,
)
| [] |
2024-01-10 | withmartian/martian-python | martian~openai~api_resources~abstract~engine_api_resource.py | import time
from typing import Optional
from urllib.parse import quote_plus
from martian import openai
from martian.openai import api_requestor, error, util
from martian.openai.api_resources.abstract.api_resource import APIResource
from martian.openai.openai_response import OpenAIResponse
from martian.openai.util import ApiType
MAX_TIMEOUT = 20
class EngineAPIResource(APIResource):
plain_old_data = False
def __init__(self, engine: Optional[str] = None, **kwargs):
super().__init__(engine=engine, **kwargs)
@classmethod
def class_url(
cls,
engine: Optional[str] = None,
api_type: Optional[str] = None,
api_version: Optional[str] = None,
):
# Namespaces are separated in object names with periods (.) and in URLs
# with forward slashes (/), so replace the former with the latter.
base = cls.OBJECT_NAME.replace(".", "/") # type: ignore
typed_api_type, api_version = cls._get_api_type_and_version(
api_type, api_version
)
if typed_api_type in (ApiType.AZURE, ApiType.AZURE_AD):
if not api_version:
raise error.InvalidRequestError(
"An API version is required for the Azure API type."
)
if engine is None:
raise error.InvalidRequestError(
"You must provide the deployment name in the 'engine' parameter to access the Azure OpenAI service"
)
extn = quote_plus(engine)
return "/%s/%s/%s/%s?api-version=%s" % (
cls.azure_api_prefix,
cls.azure_deployments_prefix,
extn,
base,
api_version,
)
elif typed_api_type == ApiType.OPEN_AI:
return "/%s" % (base)
else:
raise error.InvalidAPIType("Unsupported API type %s" % api_type)
@classmethod
def __prepare_create_request(
cls,
api_key=None,
api_base=None,
api_type=None,
api_version=None,
organization=None,
**params,
):
deployment_id = params.pop("deployment_id", None)
engine = params.pop("engine", deployment_id)
model = params.get("model", None)
timeout = params.pop("timeout", None)
stream = params.get("stream", False)
headers = params.pop("headers", None)
request_timeout = params.pop("request_timeout", None)
typed_api_type = cls._get_api_type_and_version(api_type=api_type)[0]
if typed_api_type in (util.ApiType.AZURE, util.ApiType.AZURE_AD):
if deployment_id is None and engine is None:
raise error.InvalidRequestError(
"Must provide an 'engine' or 'deployment_id' parameter to create a %s"
% cls,
"engine",
)
if timeout is None:
# No special timeout handling
pass
elif timeout > 0:
# API only supports timeouts up to MAX_TIMEOUT
params["timeout"] = min(timeout, MAX_TIMEOUT)
timeout = (timeout - params["timeout"]) or None
elif timeout == 0:
params["timeout"] = MAX_TIMEOUT
requestor = api_requestor.APIRequestor(
api_key,
api_base=api_base,
api_type=api_type,
api_version=api_version,
organization=organization,
)
url = cls.class_url(engine, api_type, api_version)
return (
deployment_id,
engine,
timeout,
stream,
headers,
request_timeout,
typed_api_type,
requestor,
url,
params,
)
@classmethod
def create(
cls,
api_key=None,
api_base=None,
api_type=None,
request_id=None,
api_version=None,
organization=None,
**params,
):
(
deployment_id,
engine,
timeout,
stream,
headers,
request_timeout,
typed_api_type,
requestor,
url,
params,
) = cls.__prepare_create_request(
api_key, api_base, api_type, api_version, organization, **params
)
response, _, api_key = requestor.request(
"post",
url,
params=params,
headers=headers,
stream=stream,
request_id=request_id,
request_timeout=request_timeout,
)
if stream:
# must be an iterator
assert not isinstance(response, OpenAIResponse)
return (
util.convert_to_openai_object(
line,
api_key,
api_version,
organization,
engine=engine,
plain_old_data=cls.plain_old_data,
)
for line in response
)
else:
obj = util.convert_to_openai_object(
response,
api_key,
api_version,
organization,
engine=engine,
plain_old_data=cls.plain_old_data,
)
if timeout is not None:
obj.wait(timeout=timeout or None)
return obj
@classmethod
async def acreate(
cls,
api_key=None,
api_base=None,
api_type=None,
request_id=None,
api_version=None,
organization=None,
**params,
):
(
deployment_id,
engine,
timeout,
stream,
headers,
request_timeout,
typed_api_type,
requestor,
url,
params,
) = cls.__prepare_create_request(
api_key, api_base, api_type, api_version, organization, **params
)
response, _, api_key = await requestor.arequest(
"post",
url,
params=params,
headers=headers,
stream=stream,
request_id=request_id,
request_timeout=request_timeout,
)
if stream:
# must be an iterator
assert not isinstance(response, OpenAIResponse)
return (
util.convert_to_openai_object(
line,
api_key,
api_version,
organization,
engine=engine,
plain_old_data=cls.plain_old_data,
)
async for line in response
)
else:
obj = util.convert_to_openai_object(
response,
api_key,
api_version,
organization,
engine=engine,
plain_old_data=cls.plain_old_data,
)
if timeout is not None:
await obj.await_(timeout=timeout or None)
return obj
def instance_url(self):
id = self.get("id")
if not isinstance(id, str):
raise error.InvalidRequestError(
f"Could not determine which URL to request: {type(self).__name__} instance has invalid ID: {id}, {type(id)}. ID should be of type str.",
"id",
)
extn = quote_plus(id)
params_connector = "?"
if self.typed_api_type in (ApiType.AZURE, ApiType.AZURE_AD):
api_version = self.api_version or openai.api_version
if not api_version:
raise error.InvalidRequestError(
"An API version is required for the Azure API type."
)
base = self.OBJECT_NAME.replace(".", "/")
url = "/%s/%s/%s/%s/%s?api-version=%s" % (
self.azure_api_prefix,
self.azure_deployments_prefix,
self.engine,
base,
extn,
api_version,
)
params_connector = "&"
elif self.typed_api_type == ApiType.OPEN_AI:
base = self.class_url(self.engine, self.api_type, self.api_version)
url = "%s/%s" % (base, extn)
else:
raise error.InvalidAPIType("Unsupported API type %s" % self.api_type)
timeout = self.get("timeout")
if timeout is not None:
timeout = quote_plus(str(timeout))
url += params_connector + "timeout={}".format(timeout)
return url
def wait(self, timeout=None):
start = time.time()
while self.status != "complete":
self.timeout = (
min(timeout + start - time.time(), MAX_TIMEOUT)
if timeout is not None
else MAX_TIMEOUT
)
if self.timeout < 0:
del self.timeout
break
self.refresh()
return self
async def await_(self, timeout=None):
"""Async version of `EngineApiResource.wait`"""
start = time.time()
while self.status != "complete":
self.timeout = (
min(timeout + start - time.time(), MAX_TIMEOUT)
if timeout is not None
else MAX_TIMEOUT
)
if self.timeout < 0:
del self.timeout
break
await self.arefresh()
return self
| [] |
2024-01-10 | withmartian/martian-python | martian~openai~api_resources~error_object.py | from typing import Optional
from martian.openai.openai_object import OpenAIObject
from martian.openai.util import merge_dicts
class ErrorObject(OpenAIObject):
def refresh_from(
self,
values,
api_key=None,
api_version=None,
api_type=None,
organization=None,
response_ms: Optional[int] = None,
):
# Unlike most other API resources, the API will omit attributes in
# error objects when they have a null value. We manually set default
# values here to facilitate generic error handling.
values = merge_dicts({"message": None, "type": None}, values)
return super(ErrorObject, self).refresh_from(
values=values,
api_key=api_key,
api_version=api_version,
api_type=api_type,
organization=organization,
response_ms=response_ms,
)
| [] |
2024-01-10 | withmartian/martian-python | martian~openai~api_requestor.py | import asyncio
import json
import time
import platform
import sys
import threading
import time
import warnings
from contextlib import asynccontextmanager
from json import JSONDecodeError
from typing import (
AsyncGenerator,
AsyncIterator,
Callable,
Dict,
Iterator,
Optional,
Tuple,
Union,
overload,
)
from urllib.parse import urlencode, urlsplit, urlunsplit
import aiohttp
import requests
if sys.version_info >= (3, 8):
from typing import Literal
else:
from typing_extensions import Literal
from martian import openai
from martian.openai import error, util, version
from martian.openai.openai_response import OpenAIResponse
from martian.openai.util import ApiType
TIMEOUT_SECS = 600
MAX_SESSION_LIFETIME_SECS = 180
MAX_CONNECTION_RETRIES = 2
# Has one attribute per thread, 'session'.
_thread_context = threading.local()
def _build_api_url(url, query):
scheme, netloc, path, base_query, fragment = urlsplit(url)
if base_query:
query = "%s&%s" % (base_query, query)
return urlunsplit((scheme, netloc, path, query, fragment))
def _requests_proxies_arg(proxy) -> Optional[Dict[str, str]]:
"""Returns a value suitable for the 'proxies' argument to 'requests.request."""
if proxy is None:
return None
elif isinstance(proxy, str):
return {"http": proxy, "https": proxy}
elif isinstance(proxy, dict):
return proxy.copy()
else:
raise ValueError(
"'openai.proxy' must be specified as either a string URL or a dict with string URL under the https and/or http keys."
)
def _aiohttp_proxies_arg(proxy) -> Optional[str]:
"""Returns a value suitable for the 'proxies' argument to 'aiohttp.ClientSession.request."""
if proxy is None:
return None
elif isinstance(proxy, str):
return proxy
elif isinstance(proxy, dict):
return proxy["https"] if "https" in proxy else proxy["http"]
else:
raise ValueError(
"'openai.proxy' must be specified as either a string URL or a dict with string URL under the https and/or http keys."
)
def _make_session() -> requests.Session:
if openai.requestssession:
if isinstance(openai.requestssession, requests.Session):
return openai.requestssession
return openai.requestssession()
if not openai.verify_ssl_certs:
warnings.warn("verify_ssl_certs is ignored; openai always verifies.")
s = requests.Session()
proxies = _requests_proxies_arg(openai.proxy)
if proxies:
s.proxies = proxies
s.mount(
"https://",
requests.adapters.HTTPAdapter(max_retries=MAX_CONNECTION_RETRIES),
)
return s
def parse_stream_helper(line: bytes) -> Optional[str]:
if line:
if line.strip() == b"data: [DONE]":
# return here will cause GeneratorExit exception in urllib3
# and it will close http connection with TCP Reset
return None
if line.startswith(b"data: "):
line = line[len(b"data: ") :]
return line.decode("utf-8")
else:
return None
return None
def parse_stream(rbody: Iterator[bytes]) -> Iterator[str]:
for line in rbody:
_line = parse_stream_helper(line)
if _line is not None:
yield _line
async def parse_stream_async(rbody: aiohttp.StreamReader):
async for line in rbody:
_line = parse_stream_helper(line)
if _line is not None:
yield _line
class APIRequestor:
def __init__(
self,
key=None,
api_base=None,
api_type=None,
api_version=None,
organization=None,
):
self.api_base = api_base or openai.api_base
self.api_key = key or util.default_api_key()
self.api_type = (
ApiType.from_str(api_type)
if api_type
else ApiType.from_str(openai.api_type)
)
self.api_version = api_version or openai.api_version
self.organization = organization or openai.organization
@classmethod
def format_app_info(cls, info):
str = info["name"]
if info["version"]:
str += "/%s" % (info["version"],)
if info["url"]:
str += " (%s)" % (info["url"],)
return str
def _check_polling_response(
self, response: OpenAIResponse, predicate: Callable[[OpenAIResponse], bool]
):
if not predicate(response):
return
error_data = response.data["error"]
message = error_data.get("message", "Operation failed")
code = error_data.get("code")
raise error.OpenAIError(message=message, code=code)
def _poll(
self,
method,
url,
until,
failed,
params=None,
headers=None,
interval=None,
delay=None,
) -> Tuple[Iterator[OpenAIResponse], bool, str]:
if delay:
time.sleep(delay)
response, b, api_key = self.request(method, url, params, headers)
self._check_polling_response(response, failed)
start_time = time.time()
while not until(response):
if time.time() - start_time > TIMEOUT_SECS:
raise error.Timeout("Operation polling timed out.")
time.sleep(interval or response.retry_after or 10)
response, b, api_key = self.request(method, url, params, headers)
self._check_polling_response(response, failed)
response.data = response.data["result"]
return response, b, api_key
async def _apoll(
self,
method,
url,
until,
failed,
params=None,
headers=None,
interval=None,
delay=None,
) -> Tuple[Iterator[OpenAIResponse], bool, str]:
if delay:
await asyncio.sleep(delay)
response, b, api_key = await self.arequest(method, url, params, headers)
self._check_polling_response(response, failed)
start_time = time.time()
while not until(response):
if time.time() - start_time > TIMEOUT_SECS:
raise error.Timeout("Operation polling timed out.")
await asyncio.sleep(interval or response.retry_after or 10)
response, b, api_key = await self.arequest(method, url, params, headers)
self._check_polling_response(response, failed)
response.data = response.data["result"]
return response, b, api_key
@overload
def request(
self,
method,
url,
params,
headers,
files,
stream: Literal[True],
request_id: Optional[str] = ...,
request_timeout: Optional[Union[float, Tuple[float, float]]] = ...,
) -> Tuple[Iterator[OpenAIResponse], bool, str]:
pass
@overload
def request(
self,
method,
url,
params=...,
headers=...,
files=...,
*,
stream: Literal[True],
request_id: Optional[str] = ...,
request_timeout: Optional[Union[float, Tuple[float, float]]] = ...,
) -> Tuple[Iterator[OpenAIResponse], bool, str]:
pass
@overload
def request(
self,
method,
url,
params=...,
headers=...,
files=...,
stream: Literal[False] = ...,
request_id: Optional[str] = ...,
request_timeout: Optional[Union[float, Tuple[float, float]]] = ...,
) -> Tuple[OpenAIResponse, bool, str]:
pass
@overload
def request(
self,
method,
url,
params=...,
headers=...,
files=...,
stream: bool = ...,
request_id: Optional[str] = ...,
request_timeout: Optional[Union[float, Tuple[float, float]]] = ...,
) -> Tuple[Union[OpenAIResponse, Iterator[OpenAIResponse]], bool, str]:
pass
def request(
self,
method,
url,
params=None,
headers=None,
files=None,
stream: bool = False,
request_id: Optional[str] = None,
request_timeout: Optional[Union[float, Tuple[float, float]]] = None,
) -> Tuple[Union[OpenAIResponse, Iterator[OpenAIResponse]], bool, str]:
result = self.request_raw(
method.lower(),
url,
params=params,
supplied_headers=headers,
files=files,
stream=stream,
request_id=request_id,
request_timeout=request_timeout,
)
resp, got_stream = self._interpret_response(result, stream)
return resp, got_stream, self.api_key
@overload
async def arequest(
self,
method,
url,
params,
headers,
files,
stream: Literal[True],
request_id: Optional[str] = ...,
request_timeout: Optional[Union[float, Tuple[float, float]]] = ...,
) -> Tuple[AsyncGenerator[OpenAIResponse, None], bool, str]:
pass
@overload
async def arequest(
self,
method,
url,
params=...,
headers=...,
files=...,
*,
stream: Literal[True],
request_id: Optional[str] = ...,
request_timeout: Optional[Union[float, Tuple[float, float]]] = ...,
) -> Tuple[AsyncGenerator[OpenAIResponse, None], bool, str]:
pass
@overload
async def arequest(
self,
method,
url,
params=...,
headers=...,
files=...,
stream: Literal[False] = ...,
request_id: Optional[str] = ...,
request_timeout: Optional[Union[float, Tuple[float, float]]] = ...,
) -> Tuple[OpenAIResponse, bool, str]:
pass
@overload
async def arequest(
self,
method,
url,
params=...,
headers=...,
files=...,
stream: bool = ...,
request_id: Optional[str] = ...,
request_timeout: Optional[Union[float, Tuple[float, float]]] = ...,
) -> Tuple[Union[OpenAIResponse, AsyncGenerator[OpenAIResponse, None]], bool, str]:
pass
async def arequest(
self,
method,
url,
params=None,
headers=None,
files=None,
stream: bool = False,
request_id: Optional[str] = None,
request_timeout: Optional[Union[float, Tuple[float, float]]] = None,
) -> Tuple[Union[OpenAIResponse, AsyncGenerator[OpenAIResponse, None]], bool, str]:
ctx = aiohttp_session()
session = await ctx.__aenter__()
try:
result = await self.arequest_raw(
method.lower(),
url,
session,
params=params,
supplied_headers=headers,
files=files,
request_id=request_id,
request_timeout=request_timeout,
)
resp, got_stream = await self._interpret_async_response(result, stream)
except Exception:
await ctx.__aexit__(None, None, None)
raise
if got_stream:
async def wrap_resp():
assert isinstance(resp, AsyncGenerator)
try:
async for r in resp:
yield r
finally:
await ctx.__aexit__(None, None, None)
return wrap_resp(), got_stream, self.api_key
else:
await ctx.__aexit__(None, None, None)
return resp, got_stream, self.api_key
def handle_error_response(self, rbody, rcode, resp, rheaders, stream_error=False):
try:
error_data = resp["error"]
except (KeyError, TypeError):
raise error.APIError(
"Invalid response object from API: %r (HTTP response code "
"was %d)" % (rbody, rcode),
rbody,
rcode,
resp,
)
if "internal_message" in error_data:
error_data["message"] += "\n\n" + error_data["internal_message"]
util.log_info(
"OpenAI API error received",
error_code=error_data.get("code"),
error_type=error_data.get("type"),
error_message=error_data.get("message"),
error_param=error_data.get("param"),
stream_error=stream_error,
)
# Rate limits were previously coded as 400's with code 'rate_limit'
if rcode == 429:
return error.RateLimitError(
error_data.get("message"), rbody, rcode, resp, rheaders
)
elif rcode in [400, 404, 415]:
return error.InvalidRequestError(
error_data.get("message"),
error_data.get("param"),
error_data.get("code"),
rbody,
rcode,
resp,
rheaders,
)
elif rcode == 401:
return error.AuthenticationError(
error_data.get("message"), rbody, rcode, resp, rheaders
)
elif rcode == 403:
return error.PermissionError(
error_data.get("message"), rbody, rcode, resp, rheaders
)
elif rcode == 409:
return error.TryAgain(
error_data.get("message"), rbody, rcode, resp, rheaders
)
elif stream_error:
# TODO: we will soon attach status codes to stream errors
parts = [error_data.get("message"), "(Error occurred while streaming.)"]
message = " ".join([p for p in parts if p is not None])
return error.APIError(message, rbody, rcode, resp, rheaders)
else:
return error.APIError(
f"{error_data.get('message')} {rbody} {rcode} {resp} {rheaders}",
rbody,
rcode,
resp,
rheaders,
)
def request_headers(
self, method: str, extra, request_id: Optional[str]
) -> Dict[str, str]:
user_agent = "OpenAI/v1 PythonBindings/%s" % (version.VERSION,)
if openai.app_info:
user_agent += " " + self.format_app_info(openai.app_info)
uname_without_node = " ".join(
v for k, v in platform.uname()._asdict().items() if k != "node"
)
ua = {
"bindings_version": version.VERSION,
"httplib": "requests",
"lang": "python",
"lang_version": platform.python_version(),
"platform": platform.platform(),
"publisher": "openai",
"uname": uname_without_node,
}
if openai.app_info:
ua["application"] = openai.app_info
headers = util.api_key_to_header(self.api_type, self.api_key)
if self.organization:
headers["OpenAI-Organization"] = self.organization
if self.api_version is not None and self.api_type == ApiType.OPEN_AI:
headers["OpenAI-Version"] = self.api_version
if request_id is not None:
headers["X-Request-Id"] = request_id
if openai.debug:
headers["OpenAI-Debug"] = "true"
headers.update(extra)
return headers
def _validate_headers(
self, supplied_headers: Optional[Dict[str, str]]
) -> Dict[str, str]:
headers: Dict[str, str] = {}
if supplied_headers is None:
return headers
if not isinstance(supplied_headers, dict):
raise TypeError("Headers must be a dictionary")
for k, v in supplied_headers.items():
if not isinstance(k, str):
raise TypeError("Header keys must be strings")
if not isinstance(v, str):
raise TypeError("Header values must be strings")
headers[k] = v
# NOTE: It is possible to do more validation of the headers, but a request could always
# be made to the API manually with invalid headers, so we need to handle them server side.
return headers
def _prepare_request_raw(
self,
url,
supplied_headers,
method,
params,
files,
request_id: Optional[str],
) -> Tuple[str, Dict[str, str], Optional[bytes]]:
abs_url = "%s%s" % (self.api_base, url)
headers = self._validate_headers(supplied_headers)
data = None
if method == "get" or method == "delete":
if params:
encoded_params = urlencode(
[(k, v) for k, v in params.items() if v is not None]
)
abs_url = _build_api_url(abs_url, encoded_params)
elif method in {"post", "put"}:
if params and files:
data = params
if params and not files:
data = json.dumps(params).encode()
headers["Content-Type"] = "application/json"
else:
raise error.APIConnectionError(
"Unrecognized HTTP method %r. This may indicate a bug in the "
"OpenAI bindings. Please contact us through our help center at help.openai.com for "
"assistance." % (method,)
)
headers = self.request_headers(method, headers, request_id)
util.log_debug("Request to OpenAI API", method=method, path=abs_url)
util.log_debug("Post details", data=data, api_version=self.api_version)
return abs_url, headers, data
def request_raw(
self,
method,
url,
*,
params=None,
supplied_headers: Optional[Dict[str, str]] = None,
files=None,
stream: bool = False,
request_id: Optional[str] = None,
request_timeout: Optional[Union[float, Tuple[float, float]]] = None,
) -> requests.Response:
abs_url, headers, data = self._prepare_request_raw(
url, supplied_headers, method, params, files, request_id
)
if not hasattr(_thread_context, "session"):
_thread_context.session = _make_session()
_thread_context.session_create_time = time.time()
elif (
time.time() - getattr(_thread_context, "session_create_time", 0)
>= MAX_SESSION_LIFETIME_SECS
):
_thread_context.session.close()
_thread_context.session = _make_session()
_thread_context.session_create_time = time.time()
try:
result = _thread_context.session.request(
method,
abs_url,
headers=headers,
data=data,
files=files,
stream=stream,
timeout=request_timeout if request_timeout else TIMEOUT_SECS,
proxies=_thread_context.session.proxies,
)
except requests.exceptions.Timeout as e:
raise error.Timeout("Request timed out: {}".format(e)) from e
except requests.exceptions.RequestException as e:
raise error.APIConnectionError(
"Error communicating with OpenAI: {}".format(e)
) from e
util.log_debug(
"OpenAI API response",
path=abs_url,
response_code=result.status_code,
processing_ms=result.headers.get("OpenAI-Processing-Ms"),
request_id=result.headers.get("X-Request-Id"),
)
# Don't read the whole stream for debug logging unless necessary.
if openai.log == "debug":
util.log_debug(
"API response body", body=result.content, headers=result.headers
)
return result
async def arequest_raw(
self,
method,
url,
session,
*,
params=None,
supplied_headers: Optional[Dict[str, str]] = None,
files=None,
request_id: Optional[str] = None,
request_timeout: Optional[Union[float, Tuple[float, float]]] = None,
) -> aiohttp.ClientResponse:
abs_url, headers, data = self._prepare_request_raw(
url, supplied_headers, method, params, files, request_id
)
if isinstance(request_timeout, tuple):
timeout = aiohttp.ClientTimeout(
connect=request_timeout[0],
total=request_timeout[1],
)
else:
timeout = aiohttp.ClientTimeout(
total=request_timeout if request_timeout else TIMEOUT_SECS
)
if files:
# TODO: Use `aiohttp.MultipartWriter` to create the multipart form data here.
# For now we use the private `requests` method that is known to have worked so far.
data, content_type = requests.models.RequestEncodingMixin._encode_files( # type: ignore
files, data
)
headers["Content-Type"] = content_type
request_kwargs = {
"method": method,
"url": abs_url,
"headers": headers,
"data": data,
"proxy": _aiohttp_proxies_arg(openai.proxy),
"timeout": timeout,
}
try:
result = await session.request(**request_kwargs)
util.log_info(
"OpenAI API response",
path=abs_url,
response_code=result.status,
processing_ms=result.headers.get("OpenAI-Processing-Ms"),
request_id=result.headers.get("X-Request-Id"),
)
# Don't read the whole stream for debug logging unless necessary.
if openai.log == "debug":
util.log_debug(
"API response body", body=result.content, headers=result.headers
)
return result
except (aiohttp.ServerTimeoutError, asyncio.TimeoutError) as e:
raise error.Timeout("Request timed out") from e
except aiohttp.ClientError as e:
raise error.APIConnectionError("Error communicating with OpenAI") from e
def _interpret_response(
self, result: requests.Response, stream: bool
) -> Tuple[Union[OpenAIResponse, Iterator[OpenAIResponse]], bool]:
"""Returns the response(s) and a bool indicating whether it is a stream."""
if stream and "text/event-stream" in result.headers.get("Content-Type", ""):
return (
self._interpret_response_line(
line, result.status_code, result.headers, stream=True
)
for line in parse_stream(result.iter_lines())
), True
else:
return (
self._interpret_response_line(
result.content.decode("utf-8"),
result.status_code,
result.headers,
stream=False,
),
False,
)
async def _interpret_async_response(
self, result: aiohttp.ClientResponse, stream: bool
) -> Tuple[Union[OpenAIResponse, AsyncGenerator[OpenAIResponse, None]], bool]:
"""Returns the response(s) and a bool indicating whether it is a stream."""
if stream and "text/event-stream" in result.headers.get("Content-Type", ""):
return (
self._interpret_response_line(
line, result.status, result.headers, stream=True
)
async for line in parse_stream_async(result.content)
), True
else:
try:
await result.read()
except (aiohttp.ServerTimeoutError, asyncio.TimeoutError) as e:
raise error.Timeout("Request timed out") from e
except aiohttp.ClientError as e:
util.log_warn(e, body=result.content)
return (
self._interpret_response_line(
(await result.read()).decode("utf-8"),
result.status,
result.headers,
stream=False,
),
False,
)
def _interpret_response_line(
self, rbody: str, rcode: int, rheaders, stream: bool
) -> OpenAIResponse:
# HTTP 204 response code does not have any content in the body.
if rcode == 204:
return OpenAIResponse(None, rheaders)
if rcode == 503:
raise error.ServiceUnavailableError(
"The server is overloaded or not ready yet.",
rbody,
rcode,
headers=rheaders,
)
try:
if "text/plain" in rheaders.get("Content-Type", ""):
data = rbody
else:
data = json.loads(rbody)
except (JSONDecodeError, UnicodeDecodeError) as e:
raise error.APIError(
f"HTTP code {rcode} from API ({rbody})", rbody, rcode, headers=rheaders
) from e
resp = OpenAIResponse(data, rheaders)
# In the future, we might add a "status" parameter to errors
# to better handle the "error while streaming" case.
stream_error = stream and "error" in resp.data
if stream_error or not 200 <= rcode < 300:
raise self.handle_error_response(
rbody, rcode, resp.data, rheaders, stream_error=stream_error
)
return resp
@asynccontextmanager
async def aiohttp_session() -> AsyncIterator[aiohttp.ClientSession]:
user_set_session = openai.aiosession.get()
if user_set_session:
yield user_set_session
else:
async with aiohttp.ClientSession() as session:
yield session
| [] |
2024-01-10 | ElGarno/NarrAItive | src~ai_model_apis.py | import requests
import base64
import openai
from elevenlabs import clone
from elevenlabs import set_api_key
from aws_scripts import get_voice_id_by_voice_name
CHUNK_SIZE = 1024
def get_completion_from_messages(api_key,
messages,
model="gpt-3.5-turbo-16k",
temperature=0,
max_tokens=3500):
client = openai.OpenAI(api_key=api_key)
response = client.chat.completions.create(
model=model,
messages=messages,
temperature=temperature,
max_tokens=max_tokens,
)
return response.choices[0].message.content
def get_audio_from_text_and_save_to_file(api_key,
text,
speech_file_path,
model="tts-1",
voice="alloy"):
client = openai.OpenAI(api_key=api_key)
response = client.audio.speech.create(
model=model,
voice=voice,
input=text
)
response.stream_to_file(speech_file_path)
def get_image_from_prompt(api_key,
prompt,
model="dall-e-3"):
client = openai.OpenAI(api_key=api_key)
response = client.images.generate(
prompt=prompt,
model=model, # Use the DALL-E model
n=1,
size="1024x1024"
)
image_url = response.data[0].url
return image_url
def encode_image(image_path):
with open(image_path, "rb") as image_file:
return base64.b64encode(image_file.read()).decode('utf-8')
def get_description_from_image(api_key,
image_url,
model="gpt-4-vision-preview"):
# Path to your image
image_path = image_url
# Getting the base64 string
base64_image = encode_image(image_path)
headers = {
"Content-Type": "application/json",
"Authorization": f"Bearer {api_key}"
}
payload = {
"model": model,
"messages": [
{
"role": "user",
"content": [
{
"type": "text",
"text": "Please describe the character in this image in about 2 sentences and don't talk about"
" the image itself. Just describe the character and start with "
"'A toddler, A boy.. / a girl / a man...' Make sure that you describe the colour of "
"hair and the potential age of the character."
},
{
"type": "image_url",
"image_url": {
"url": f"data:image/jpeg;base64,{base64_image}"
}
}
]
}
],
"max_tokens": 300
}
response = None
for i_try in range(10):
response = requests.post("https://api.openai.com/v1/chat/completions", headers=headers, json=payload)
if response.status_code == 200:
break
return response.json()["choices"][0]['message']['content']
def clone_voice(api_key, files, name, description="", labels=None):
"""
Clone a voice from files.
"""
if labels is None:
labels = {}
set_api_key(api_key)
voice = clone(
name=name,
files=files,
description=description,
labels=labels
)
return voice
def get_voice_id_by_name(voices_response, name):
return [voice["voice_id"] for voice in voices_response["voices"] if voice["name"] == name][0]
def generate_audio_voice_id(api_key, voice_id, text, file_path, model_id="eleven_multilingual_v2",
stability=0.5, similarity_boost=0.5):
"""
Generate audio from a voice and a text.
"""
# get voice_id by voice name
# voice_id = get_voice_id_by_voice_name(voice_name)
# voice_id = voice_name
# print(f"voice_id: {voice_id}, file_path: {file_path}, text: {text}")
url = f"https://api.elevenlabs.io/v1/text-to-speech/{voice_id}"
headers = {
"Accept": "audio/mpeg",
"Content-Type": "application/json",
"xi-api-key": api_key
}
data = {
"text": text,
"model_id": model_id,
"voice_settings": {
"stability": stability,
"similarity_boost": similarity_boost
}
}
response = requests.post(url, json=data, headers=headers)
with open(file_path, 'wb') as f:
for chunk in response.iter_content(chunk_size=CHUNK_SIZE):
if chunk:
f.write(chunk)
def get_voices(api_key):
set_api_key(api_key)
url = "https://api.elevenlabs.io/v1/voices"
response = requests.request("GET", url)
return response.json()
| [
"[{'type': 'text', 'text': \"Please describe the character in this image in about 2 sentences and don't talk about the image itself. Just describe the character and start with 'A toddler, A boy.. / a girl / a man...' Make sure that you describe the colour of hair and the potential age of the character.\"}, {'type': 'image_url', 'image_url': {'url': 'data:image/jpeg;base64,PLACEHOLDER'}}]"
] |
2024-01-10 | Juicibox/llama2 | llama2.py | #import libraries
import streamlit as st
import replicate
import os
from langchain.llms import Replicate
from langchain import PromptTemplate, LLMChain
# App title
st.set_page_config(page_title="Llama2🦙🤖 ")
#function
def generate_response(txt):
# Instantiate the Llama2 model
llm = Replicate(model="a16z-infra/llama13b-v2-chat:df7690f1994d94e96ad9d568eac121aecf50684a0b0963b25a41cc40061269e5",
input={"temperature":0.03, "top_p":0.8, "max_length":900})
template = """
Escribe un resumen conciso del texto, devuelve tus respuestas con 5 líneas que cubran los puntos clave del texto..
```{text}```
RESUMEN:
"""
prompt = PromptTemplate(template=template, input_variables=["text"])
llm_chain = LLMChain(prompt=prompt, llm=llm)
summary = llm_chain.run(txt)
return summary
#new
page = st.sidebar.selectbox("Seleccione una función", ("Chat", "Resumen"))
# verify key
with st.sidebar:
if 'REPLICATE_API_TOKEN' in st.secrets:
st.success('API key already provided!', icon='✅')
replicate_api = st.secrets['REPLICATE_API_TOKEN']
else:
replicate_api = st.text_input('Enter Replicate API token:', type='password')
if not (replicate_api.startswith('r8_') and len(replicate_api)==40):
st.warning('Please enter your credentials!', icon='⚠️')
else:
st.success('Proceed to entering your prompt message!', icon='👉')
os.environ['REPLICATE_API_TOKEN'] = replicate_api
if page == "Chat":
#credentials
with st.sidebar:
st.title('Llama2 Chatbot🦙')
st.subheader('Models and parameters')
selected_model = st.sidebar.selectbox('Escoja el modelo Llama2', ['Llama2-7B', 'Llama2-13B'], key='selected_model')
if selected_model == 'Llama2-7B':
llm = 'a16z-infra/llama7b-v2-chat:4f0a4744c7295c024a1de15e1a63c880d3da035fa1f49bfd344fe076074c8eea'
elif selected_model == 'Llama2-13B':
llm = 'a16z-infra/llama13b-v2-chat:df7690f1994d94e96ad9d568eac121aecf50684a0b0963b25a41cc40061269e5'
temperature = st.sidebar.slider('creatividad del modelo', min_value=0.01, max_value=5.0, value=0.1, step=0.01)
top_p = st.sidebar.slider('creatividad de palabras', min_value=0.01, max_value=1.0, value=0.9, step=0.01)
max_length = st.sidebar.slider('longitud de respuestas', min_value=32, max_value=600, value=420, step=8)
# Store LLM generated responses
if "messages" not in st.session_state.keys():
st.session_state.messages = [{"role": "assistant", "content": "¿En qué puedo ayudarte?"}]
# Display or clear chat messages
for message in st.session_state.messages:
with st.chat_message(message["role"]):
st.write(message["content"])
def clear_chat_history():
st.session_state.messages = [{"role": "assistant", "content": "¿En qué puedo ayudarte?"}]
st.sidebar.button('Limpiar Chat', on_click=clear_chat_history)
# Function for generating LLaMA2 response. Refactored from https://github.com/a16z-infra/llama2-chatbot
def generate_llama2_response(prompt_input):
string_dialogue = "You are a helpful assistant. You do not respond as 'User' or pretend to be 'User'. You only respond once as 'Assistant'."
for dict_message in st.session_state.messages:
if dict_message["role"] == "user":
string_dialogue += "User: " + dict_message["content"] + "\n\n"
else:
string_dialogue += "Assistant: " + dict_message["content"] + "\n\n"
output = replicate.run('a16z-infra/llama13b-v2-chat:df7690f1994d94e96ad9d568eac121aecf50684a0b0963b25a41cc40061269e5',
input={"prompt": f"{string_dialogue} {prompt_input} Assistant: ",
"temperature":temperature, "top_p":top_p, "max_length":max_length, "repetition_penalty":1})
return output
# User-provided prompt
if prompt := st.chat_input(disabled=not replicate_api):
st.session_state.messages.append({"role": "user", "content": prompt})
with st.chat_message("user"):
st.write(prompt)
# Generate a new response if last message is not from assistant
if st.session_state.messages[-1]["role"] != "assistant":
with st.chat_message("assistant"):
with st.spinner("Thinking..."):
response = generate_llama2_response(prompt)
placeholder = st.empty()
full_response = ''
for item in response:
full_response += item
placeholder.markdown(full_response)
placeholder.markdown(full_response)
message = {"role": "assistant", "content": full_response}
st.session_state.messages.append(message)
elif page == "Resumen":
with st.sidebar:
st.title('Resumen con Llama2🦙')
# Text input
txt_input = st.text_area('Introduzca el texto', '', height=200)
# Form to accept user's text input for summarization
result = []
submitted = st.button('Resumir')
if submitted:
with st.spinner('Resumiendo...'):
response = generate_response(txt_input)
result.append(response)
if len(result):
st.info(result[0])
| [
"¿En qué puedo ayudarte?",
"\n Escribe un resumen conciso del texto, devuelve tus respuestas con 5 líneas que cubran los puntos clave del texto..\n ```{text}```\n RESUMEN:\n "
] |
2024-01-10 | reedjones/magick_library_crawler | scraper.py | __author__ = "[email protected]"
"""
Todo - convert PDFs to images where text extraction doesn't work then use OCR to convert images to text
"""
import logging
import os
import pickle
import time
from collections import Counter
from io import StringIO, BytesIO
from urllib.request import urlopen, Request
from zipfile import ZipFile
import pandas as pd
import bs4
import langid
import pdf2image
import pytesseract
import requests
from bs4 import BeautifulSoup
from langchain.document_loaders import PyMuPDFLoader as MyPDFLoader
from pdfminer.converter import TextConverter
from pdfminer.layout import LAParams
from pdfminer.pdfdocument import PDFDocument
from pdfminer.pdfinterp import PDFPageInterpreter, PDFResourceManager
from pdfminer.pdfpage import PDFPage
from pdfminer.pdfparser import PDFParser
from requests_ip_rotator import ApiGateway
from datastore import load, dump, finished_url, problem_url, store_data, append_to_aws, load_from_aws
import uuid
already_on_s3 = "processed_items.pickle"
already_scraped = "already_scraped.pickle"
uid = uuid.uuid4()
import boto3
import json
from datetime import date
from ocr import url_to_text
finished = f'finished_{uid}.pickle'
problem = f'problem_{uid}.pickle'
results = f'results_{uid}.pickle'
import logging
logging.basicConfig(filename='scraper.log', encoding='utf-8', level=logging.DEBUG)
# http_client.HTTPConnection.debuglevel = 1
logging.basicConfig()
logging.getLogger().setLevel(logging.WARNING)
requests_log = logging.getLogger("requests.packages.urllib3")
requests_log.setLevel(logging.WARNING)
requests_log.propagate = True
resource_manager = PDFResourceManager()
def check_pdf_is_parseable(url, session):
fake_file_handle = StringIO()
converter = TextConverter(resource_manager, fake_file_handle)
response = get_with_session(url, session=session)
fb = BytesIO(response.content)
page_interpreter = PDFPageInterpreter(resource_manager, converter)
parser = PDFParser(fb)
doc = PDFDocument(parser, password='', caching=True)
# Check if the document allows text extraction.
# If not, warn the user and proceed.
extractable = doc.is_extractable
fb.close()
converter.close()
fake_file_handle.close()
return extractable
def extract_text_from_pdf_url(url):
fake_file_handle = StringIO()
converter = TextConverter(resource_manager, fake_file_handle)
request = Request(url)
response = urlopen(request).read()
logging.debug(f"Got response {response}")
fb = BytesIO(response)
page_interpreter = PDFPageInterpreter(resource_manager, converter)
parser = PDFParser(fb)
doc = PDFDocument(parser, password='', caching=True)
# Check if the document allows text extraction.
# If not, warn the user and proceed.
if not doc.is_extractable:
return None
for page in PDFPage.get_pages(fb, caching=True, check_extractable=True):
page_interpreter.process_page(page)
text = fake_file_handle.getvalue()
# close open handles
fb.close()
converter.close()
fake_file_handle.close()
if text:
# If document has instances of \xa0 replace them with spaces.
# NOTE: \xa0 is non-breaking space in Latin1 (ISO 8859-1) & chr(160)
text = text.replace(u'\xa0', u' ')
return text
def text_from_url(u, second=1):
logging.debug("waiting")
if not u:
return ""
loader = MyPDFLoader(u)
try:
data = loader.load()
logging.debug(f"Got text {data[0]}")
return data[0]
except Exception as e:
logging.debug(e)
if second > 3:
return ""
time.sleep(5 + second * 3)
return text_from_url(u, second=second + 1)
def text_from_url2(u):
loader = MyPDFLoader(u)
try:
data = loader.load()
logging.debug(f"Got text {data[0]}")
return data[0]
except Exception as e:
logging.debug(e)
def images_to_txt(path, language):
images = pdf2image.convert_from_bytes(path)
all_text = []
for i in images:
pil_im = i
text = pytesseract.image_to_string(pil_im, lang=language)
# ocr_dict = pytesseract.image_to_data(pil_im, lang='eng', output_type=Output.DICT)
# ocr_dict now holds all the OCR info including text and location on the image
# text = " ".join(ocr_dict['text'])
# text = re.sub('[ ]{2,}', '\n', text)
all_text.append(text)
return all_text, len(all_text)
def convert_pdf_to_txt_pages(path):
texts = []
rsrcmgr = PDFResourceManager()
retstr = StringIO()
laparams = LAParams()
device = TextConverter(rsrcmgr, retstr, laparams=laparams)
# fp = open(path, 'rb')
interpreter = PDFPageInterpreter(rsrcmgr, device)
size = 0
c = 0
file_pages = PDFPage.get_pages(path)
nbPages = len(list(file_pages))
for page in PDFPage.get_pages(path):
interpreter.process_page(page)
t = retstr.getvalue()
if c == 0:
texts.append(t)
else:
texts.append(t[size:])
c = c + 1
size = len(t)
# text = retstr.getvalue()
# fp.close()
device.close()
retstr.close()
return texts, nbPages
def convert_pdf_to_txt_file(path):
texts = []
rsrcmgr = PDFResourceManager()
retstr = StringIO()
laparams = LAParams()
device = TextConverter(rsrcmgr, retstr, laparams=laparams)
# fp = open(path, 'rb')
interpreter = PDFPageInterpreter(rsrcmgr, device)
file_pages = PDFPage.get_pages(path)
nbPages = len(list(file_pages))
for page in PDFPage.get_pages(path):
interpreter.process_page(page)
t = retstr.getvalue()
# text = retstr.getvalue()
# fp.close()
device.close()
retstr.close()
return t, nbPages
def save_pages(pages):
files = []
for page in range(len(pages)):
filename = "page_" + str(page) + ".txt"
with open("./file_pages/" + filename, 'w', encoding="utf-8") as file:
file.write(pages[page])
files.append(file.name)
# create zipfile object
zipPath = './file_pages/pdf_to_txt.zip'
zipObj = ZipFile(zipPath, 'w')
for f in files:
zipObj.write(f)
zipObj.close()
return zipPath
def extract_books_data(url):
# Send a GET request to the website
response = requests.get(url)
# Create a BeautifulSoup object to parse the HTML content
soup = BeautifulSoup(response.content, 'html.parser')
# Find all the book elements on the page
book_elements = soup.find_all('div', class_='book')
# Initialize a variable to store the total data size
total_data_size = 0
# Iterate over each book element and extract the title and file size
for book_element in book_elements:
# Find the title element within the book element
title_element = book_element.find('div', class_='title')
title = title_element.text.strip() # Extract the text and remove leading/trailing whitespace
# Find the file size element within the book element
file_size_element = book_element.find('div', class_='filesize')
file_size = file_size_element.text.strip() # Extract the text and remove leading/trailing whitespace
# Add the file size to the total data size
total_data_size += int(file_size)
# logging.debug the title and file size
logging.debug('Title:', title)
logging.debug('File Size:', file_size)
logging.debug('---')
# logging.debug the total data size
logging.debug('Total Data Size (bytes):', total_data_size)
# URL of the website
start_url = 'http://english.grimoar.cz/?Loc=key&Lng=2&S=' # 0
end_url = 'http://english.grimoar.cz/?Loc=key&Lng=2&S=' # 2011
def get_page(num):
return f"http://english.grimoar.cz/?Loc=key&Lng=2&S={num}"
def all_pages():
for i in range(198, 2011): # last was 198
yield get_page(i)
# Call the function to extract the books data
# extract_books_data(start_url)
def get_page_html(url):
"""
Function to get the HTML content of a webpage given its URL.
"""
response = requests.get(url)
html_content = response.text
return html_content
def is_download_link(tag):
return tag.name == 'a' and tag.has_attr('href') and 'download' in tag.text
def get_book_links(url):
html_content = get_page_html(url)
soup = BeautifulSoup(html_content, 'html.parser')
# Scrape the books data from the current page
links = []
next_page_link = soup.find('a', class_='next')
if next_page_link:
next_page_url = next_page_link.get('href')
# Recursive call to get books data from the next page
links += get_book_links(next_page_url)
# nnumber, link() with title, authors, maybe size, date
def clean_file_size(v):
return v.replace(" ", "").strip().replace("(", "").replace(")", "").replace('.', '').strip()[:-1]
def has_keyword_str(t):
return t.name == 'h4' and t.text == "Keywords suggestions"
def parse_keywords(soup):
tag = soup.find('h4', string="Keywords suggestions")
keywords = []
if not tag:
return keywords
while True:
if isinstance(tag, bs4.element.Tag):
if tag.name == 'form':
break
elif tag.name == 'a':
keywords.append(tag.text)
tag = tag.nextSibling
return keywords
def get_keywords(u):
if not u:
return []
try:
html_content = get_page_html(u)
soup = BeautifulSoup(html_content, 'html.parser')
return parse_keywords(soup)
except Exception as e:
logging.debug(e)
return []
def test_keywords():
assert os.path.isfile('keyword.html')
with open('keyword.html') as d:
soup = BeautifulSoup(d.read(), 'html.parser')
logging.debug(soup)
keywords = parse_keywords(soup)
logging.debug(keywords)
return keywords
def try_with_default(default, fun, fun_param):
try:
return fun(fun_param)
except Exception as e:
logging.debug(e)
return default
def marked_scraped(data):
store_data(data['title'], results=already_scraped, unique=True)
def mark_ons3(data):
store_data(data['title'], results=already_on_s3, unique=True)
def check_on_s3(data):
items = load(already_on_s3)
return data['title'] in items
def check_scraped(data):
items = load(already_scraped)
return data['title'] in items
def scrape_table(table):
column_names = ('number', 'title', 'author', 'size', 'date')
rows = table.find_all('tr')
table = []
for row in rows:
columns = row.find_all('td')
link = columns[1].find('a', href=True)['href']
columns = [i.text for i in columns]
assert len(columns) == len(column_names)
data = dict(zip(column_names, columns))
if not check_scraped(data):
marked_scraped(data)
data['link'] = link
data['size'] = clean_file_size(data['size'])
try:
data['lang'] = langid.classify(data['title'])[0]
except Exception as e:
data['lang'] = '?'
logging.debug(e)
data['download_url'] = book_url_to_download_url(data['link'])
data['keywords'] = try_with_default([], get_keywords, data['link'])
table.append(data)
else:
logging.debug(f"Skipping {data['title']}")
return table
def get_container(soup):
div = soup.find('div', id='right_inner')
if div:
return div.find('div', class_='margin')
def scrape_page(current_url):
html_content = get_page_html(current_url)
soup = BeautifulSoup(html_content, 'html.parser')
container = get_container(soup)
if container:
table = container.find('table')
if table:
try:
data = scrape_table(table)
finished_url(current_url)
return data
except Exception as e:
logging.debug(e)
problem_url(current_url)
def book_url_to_download_url(url):
if "Loc=book" in url:
return url.replace("Loc=book", "Loc=dl")
return None
def get_download_link(url):
html_content = get_page_html(url)
soup = BeautifulSoup(html_content, 'html.parser')
content = soup.find('div', id='content')
cont = content.find('div', id='cont')
def get_book_data(url):
"""
Recursive function to scrape the books data from the website.
It handles pagination and navigates through all the pages.
"""
html_content = get_page_html(url)
soup = BeautifulSoup(html_content, 'html.parser')
# Scrape the books data from the current page
books = []
book_elements = soup.find_all('div', id='content')
for book_element in book_elements:
title = book_element.find('h2').text
file_size = book_element.find('div', class_='fr').text
books.append({'title': title, 'file_size': file_size})
link = book_element.find('a', is_download_link)
if link:
link = link['href']
# Check if there is a next page
next_page_link = soup.find('a', class_='next')
if next_page_link:
next_page_url = next_page_link.get('href')
# Recursive call to get books data from the next page
# books += get_books_data(next_page_url)
return books
def test_clean_file():
t = "(32.657.206 B)"
t2 = " (887.837 B)"
logging.debug(clean_file_size(t))
logging.debug(clean_file_size(t2))
def calculate_library_size(books):
"""
Function to calculate the total amount of data the library contains in bytes.
"""
total_size = 0
for book in books:
file_size = book['file_size']
if 'KB' in file_size:
size_in_bytes = int(file_size[:-2]) * 1024
elif 'MB' in file_size:
size_in_bytes = int(file_size[:-2]) * 1024 * 1024
elif 'GB' in file_size:
size_in_bytes = int(file_size[:-2]) * 1024 * 1024 * 1024
else:
size_in_bytes = int(file_size[:-1])
total_size += size_in_bytes
return total_size
def get_everything():
for page in all_pages():
logging.debug(f"Scraping {page}")
data = scrape_page(page)
if data:
store_data(data, results=results)
logging.debug("done")
else:
logging.debug("no data")
def step_2(data_name):
data = load(data_name)
data = flatten(data)
for item in data:
if isinstance(item['lang'], tuple):
item['lang'] = item['lang'][0]
# Define the starting URL
starting_url = 'http://english.grimoar.cz/?Loc=key&Lng=2'
def get_langs_from_data():
data = load(results)
logging.debug(f"Data is {len(data)} items \n type: {type(data)} {type(data[0])} {len(data[0])}")
# sizes = [int(i['size'])[:-1] for i in data]
# logging.debug(f"{sum(sizes)}")
logging.debug(data[0])
total = 0
langs = []
for i in data:
for item in i:
item['lang'] = langid.classify(item['title'])
if item['lang'] not in langs:
langs.append(item['lang'])
store_data(data)
logging.debug(f"done\n {langs}")
dump('langs.pickle', langs)
lang_dict = dict.fromkeys(langs, 0)
# for i in data:
# c = Counter(i.keys())
# logging.debug(c)
# for k, v in groupby(i, key=itemgetter('lang')):
# logging.debug(f"\t{k} -\n\t\t{v}\n")
# Scrape the books data
# Calculate the library size
# library_size = calculate_library_size(books_data)
def flatten(container):
for i in container:
if isinstance(i, (list, tuple)):
for j in flatten(i):
yield j
else:
yield i
def clean_lang():
data = load(results)
langs = load('langs.pickle')
data = list(flatten(data))
for i in data:
i['lang'] = i.get('lang', ['?'])[0]
c = Counter([d['lang'] for d in data])
store_data(data) # bad
logging.debug(c)
def fetch_with_proxy(url, user_agent=None):
if not user_agent:
user_agent = 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.61 Safari/537.36'
headers = {'User-Agent': user_agent}
with ApiGateway("http://english.grimoar.cz") as g:
session = requests.Session()
session.headers = headers
session.mount("http://english.grimoar.cz", g)
response = session.get(url)
logging.debug(response.status_code)
return response
def run_with_proxy(func, user_agent=None):
if not user_agent:
user_agent = 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.61 Safari/537.36'
headers = {'User-Agent': user_agent}
with ApiGateway("http://english.grimoar.cz") as g:
session = requests.Session()
session.headers = headers
session.mount("http://english.grimoar.cz", g)
return func(session=session)
def run_with_proxy2(func, user_agent=None):
if not user_agent:
user_agent = 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.61 Safari/537.36'
headers = {'User-Agent': user_agent}
with ApiGateway("http://english.grimoar.cz") as g:
session = requests.Session()
session.headers = headers
session.mount("http://english.grimoar.cz", g)
return func(session)
def get_with_session(url, **kwargs):
session = kwargs.pop('session', None)
if not session:
raise Exception("Use session!")
return session.get(url, **kwargs)
def check_files():
with open("results_3de989d7-d32c-4465-827a-6e46c9ca52fa.pickle", 'rb') as f:
data = pickle.load(f)
# logging.debug(data)
logging.debug(f"""
Data : {len(data)}
type: {type(data)}
item 1 : {type(data[0])}
""")
titles = {
}
for item in flatten(data):
t = item['title']
count = titles.get(t, 0)
count += 1
titles[t] = count
for k,v in titles.items():
logging.debug(f"Title {k} \n #number items {v}")
# data = [i for i in flatten(data)]
# logging.debug(f"""
# Data : {len(data)}
# type: {type(data)}
# item 1 : {type(data[0])}
#
# """)
# if not os.path.isfile(results):
# logging.debug(f'will save to results')
# store_data(data)
def test_load():
data = [{'title':'hello'}, {'title':'world'}]
marked_scraped(data[0])
marked_scraped(data[1])
logging.debug("marked \n loading")
data2 = load(already_scraped)
logging.debug(data2)
logging.debug("-------")
logging.debug(check_scraped({'title':'hello'}))
logging.debug(check_scraped({'title':'goat'}))
marked_scraped({'title':'goat'})
data3 = load(already_scraped)
logging.debug(data3)
from timeit import default_timer as timer
def get_the_data(result_file):
data = load(result_file)
for item in flatten(data):
yield item
def get_document_texts(result_file):
for item in get_the_data(result_file):
if not check_on_s3(item):
target = item['download_url']
doc = url_to_text(target)
item['document_text'] = doc
df = pd.DataFrame([item])
append_to_aws(df)
mark_ons3(item)
else:
logging.debug(f"Skipping {item['title']}")
def test_append_s3():
data = [{'name':'reed'}]
df = pd.DataFrame(data)
append_to_aws(df)
logging.debug("load")
data2 = load_from_aws()
logging.debug(data2)
n = [{'name':'jo'}, {'name':'mama'}]
nd = pd.DataFrame(n)
append_to_aws(nd)
data3 = load_from_aws()
logging.debug(data3)
if __name__ == '__main__':
logging.debug(f"Results will be stored in {results}")
# get_everything()
get_document_texts("results_a9fd713a-906a-43d5-9776-0f137fd2d3e2.pickle")
| [] |
2024-01-10 | wangxing7714436/codeinterpreter-api-replaceAzure | codeinterpreterapi~session.py | import uuid, base64, re
from io import BytesIO
from typing import Optional
from codeboxapi import CodeBox # type: ignore
from codeboxapi.schema import CodeBoxOutput # type: ignore
from langchain.tools import StructuredTool, BaseTool
from langchain.chat_models import AzureChatOpenAI
from langchain.chat_models.base import BaseChatModel
from langchain.prompts.chat import MessagesPlaceholder
from langchain.agents import AgentExecutor, BaseSingleActionAgent
from langchain.memory import ConversationBufferMemory
from codeinterpreterapi.schema import CodeInterpreterResponse, CodeInput, File, UserRequest
from codeinterpreterapi.config import settings
from codeinterpreterapi.chains.functions_agent import OpenAIFunctionsAgent
from codeinterpreterapi.prompts import code_interpreter_system_message
from codeinterpreterapi.callbacks import CodeCallbackHandler
from codeinterpreterapi.chains.modifications_check import get_file_modifications
from codeinterpreterapi.chains.remove_download_link import remove_download_link
class CodeInterpreterSession:
def __init__(
self,
model=None,
openai_api_key=settings.OPENAI_API_KEY,
deployment_name=settings.DEPLOYMENT_NAME,
openai_api_base=settings.OPENAI_API_BASE,
openai_api_version=settings.OPENAI_API_VERSION,
verbose=settings.VERBOSE,
tools: list[BaseTool] = None
) -> None:
self.codebox = CodeBox()
self.verbose = verbose
self.tools: list[BaseTool] = self._tools(tools)
self.llm: BaseChatModel = self._llm(model, openai_api_key,deployment_name,openai_api_base,openai_api_version)
self.agent_executor: AgentExecutor = self._agent_executor()
self.input_files: list[File] = []
self.output_files: list[File] = []
async def astart(self) -> None:
await self.codebox.astart()
def _tools(self, additional_tools: list[BaseTool] = None) -> list[BaseTool]:
additional_tools = additional_tools or []
return additional_tools + [
StructuredTool(
name="python",
description=
# TODO: variables as context to the agent
# TODO: current files as context to the agent
"Input a string of code to a python interpreter (jupyter kernel). "
"Variables are preserved between runs. ",
func=self.run_handler,
coroutine=self.arun_handler,
args_schema=CodeInput,
),
]
def _llm(self, model: Optional[str] = None, openai_api_key: Optional[str] = None,deployment_name: Optional[str] = None,openai_api_base: Optional[str] = None,openai_api_version: Optional[str] = None) -> BaseChatModel:
if model is None:
model = "gpt-4"
if deployment_name is None:
raise ValueError(
"OpenAI API key missing. Set DEPLOYENT_NAME env variable or pass `deployment_name` to session."
)
if openai_api_base is None:
raise ValueError(
"OpenAI API key missing. Set OPENAI_API_BASE env variable or pass `openai_api_base` to session."
)
if openai_api_version is None:
raise ValueError(
"OpenAI API key missing. Set OPENAI_API_VERSION env variable or pass `openai_api_version` to session."
)
if openai_api_key is None:
raise ValueError(
"OpenAI API key missing. Set OPENAI_API_KEY env variable or pass `openai_api_key` to session."
)
return AzureChatOpenAI(
temperature=0.03,
model=model,
openai_api_key=openai_api_key,
max_retries=3,
request_timeout=60 * 3,
deployment_name=deployment_name,
openai_api_type="azure", #delete to use origin openai api
openai_api_base=openai_api_base,
openai_api_version=openai_api_version
# openai_api_key: str = ""
# openai_organization: str = ""
# openai_proxy: str = ""
) # type: ignore
def _agent(self) -> BaseSingleActionAgent:
return OpenAIFunctionsAgent.from_llm_and_tools(
llm=self.llm,
tools=self.tools,
system_message=code_interpreter_system_message,
extra_prompt_messages=[MessagesPlaceholder(variable_name="memory")],
)
def _agent_executor(self) -> AgentExecutor:
return AgentExecutor.from_agent_and_tools(
agent=self._agent(),
callbacks=[CodeCallbackHandler(self)],
max_iterations=9,
tools=self.tools,
verbose=self.verbose,
memory=ConversationBufferMemory(memory_key="memory", return_messages=True),
)
async def show_code(self, code: str) -> None:
"""Callback function to show code to the user."""
if self.verbose:
print(code)
def run_handler(self, code: str):
raise NotImplementedError("Use arun_handler for now.")
async def arun_handler(self, code: str):
"""Run code in container and send the output to the user"""
output: CodeBoxOutput = await self.codebox.arun(code)
if not isinstance(output.content, str):
raise TypeError("Expected output.content to be a string.")
if output.type == "image/png":
filename = f"image-{uuid.uuid4()}.png"
file_buffer = BytesIO(base64.b64decode(output.content))
file_buffer.name = filename
self.output_files.append(File(name=filename, content=file_buffer.read()))
return f"Image {filename} got send to the user."
elif output.type == "error":
if "ModuleNotFoundError" in output.content:
if package := re.search(
r"ModuleNotFoundError: No module named '(.*)'", output.content
):
await self.codebox.ainstall(package.group(1))
return f"{package.group(1)} was missing but got installed now. Please try again."
else: pass
# TODO: preanalyze error to optimize next code generation
if self.verbose:
print("Error:", output.content)
elif modifications := await get_file_modifications(code, self.llm):
for filename in modifications:
if filename in [file.name for file in self.input_files]:
continue
fileb = await self.codebox.adownload(filename)
if not fileb.content:
continue
file_buffer = BytesIO(fileb.content)
file_buffer.name = filename
self.output_files.append(
File(name=filename, content=file_buffer.read())
)
return output.content
async def input_handler(self, request: UserRequest):
if not request.files:
return
if not request.content:
request.content = (
"I uploaded, just text me back and confirm that you got the file(s)."
)
request.content += "\n**The user uploaded the following files: **\n"
for file in request.files:
self.input_files.append(file)
request.content += f"[Attachment: {file.name}]\n"
await self.codebox.aupload(file.name, file.content)
request.content += "**File(s) are now available in the cwd. **\n"
async def output_handler(self, final_response: str) -> CodeInterpreterResponse:
"""Embed images in the response"""
for file in self.output_files:
if str(file.name) in final_response:
# rm  from the response
final_response = re.sub(rf"\n\n!\[.*\]\(.*\)", "", final_response)
if self.output_files and re.search(rf"\n\[.*\]\(.*\)", final_response):
final_response = await remove_download_link(final_response, self.llm)
return CodeInterpreterResponse(content=final_response, files=self.output_files)
async def generate_response(
self,
user_msg: str,
files: list[File] = [],
detailed_error: bool = False,
) -> CodeInterpreterResponse:
"""Generate a Code Interpreter response based on the user's input."""
user_request = UserRequest(content=user_msg, files=files)
try:
await self.input_handler(user_request)
response = await self.agent_executor.arun(input=user_request.content)
return await self.output_handler(response)
except Exception as e:
if self.verbose:
import traceback
traceback.print_exc()
if detailed_error:
return CodeInterpreterResponse(
content=f"Error in CodeInterpreterSession: {e.__class__.__name__} - {e}"
)
else:
return CodeInterpreterResponse(
content="Sorry, something went while generating your response."
"Please try again or restart the session."
)
async def is_running(self) -> bool:
return await self.codebox.astatus() == "running"
async def astop(self) -> None:
await self.codebox.astop()
async def __aenter__(self) -> "CodeInterpreterSession":
await self.astart()
return self
async def __aexit__(self, exc_type, exc_value, traceback) -> None:
await self.astop()
| [] |
2024-01-10 | shadowaxe99/book-writer-ghost | src~interview_system.py | ```python
import openai
from src.models.language_model import GPT3Model
from src.models.sentiment_analysis import SentimentAnalysis
from src.models.named_entity_recognition import NamedEntityRecognition
from src.utils.data_encryption import encrypt_data
from src.database.mongodb_connection import MongoDBConnection
class InterviewSystem:
def __init__(self):
self.gpt3_model = GPT3Model()
self.sentiment_analysis = SentimentAnalysis()
self.named_entity_recognition = NamedEntityRecognition()
self.db_connection = MongoDBConnection()
def generate_interview_questions(self, context):
prompt = f"{context}\nWhat would you like to ask next?"
response = self.gpt3_model.generate_text(prompt)
return response
def analyze_sentiment(self, text):
sentiment = self.sentiment_analysis.analyze(text)
return sentiment
def extract_entities(self, text):
entities = self.named_entity_recognition.extract(text)
return entities
def store_interview_data(self, interview_data):
encrypted_data = encrypt_data(interview_data)
self.db_connection.insert_data("interviews", encrypted_data)
def conduct_interview(self, initial_prompt):
interview_data = {"questions": [], "answers": [], "sentiments": [], "entities": []}
context = initial_prompt
while True:
question = self.generate_interview_questions(context)
print(question)
answer = input()
sentiment = self.analyze_sentiment(answer)
entities = self.extract_entities(answer)
interview_data["questions"].append(question)
interview_data["answers"].append(answer)
interview_data["sentiments"].append(sentiment)
interview_data["entities"].append(entities)
context += f"\n{question}\n{answer}"
if input("Continue interview? (yes/no)") == "no":
break
self.store_interview_data(interview_data)
return interview_data
``` | [
"PLACEHOLDER\nWhat would you like to ask next?"
] |
2024-01-10 | shadowaxe99/book-writer-ghost | src~narrative_generation.py | ```python
import openai
from src.models.language_model import GPT3_5
from src.models.sentiment_analysis import SentimentAnalysis
from src.models.named_entity_recognition import NamedEntityRecognition
from src.models.custom_ml_model import CustomMLModel
from src.information_retention import store_data
from src.prompt_chaining import maintain_context
class NarrativeGeneration:
def __init__(self):
self.gpt = GPT3_5()
self.sentiment_analysis = SentimentAnalysis()
self.ner = NamedEntityRecognition()
self.custom_ml_model = CustomMLModel()
self.interview_data = {}
self.narrative_data = {}
def generate_narrative(self, interview_data):
self.interview_data = interview_data
narrative = self.gpt.generate_text(self.interview_data)
self.narrative_data = narrative
return narrative
def analyze_sentiment(self, narrative):
sentiment = self.sentiment_analysis.analyze(narrative)
return sentiment
def extract_entities(self, narrative):
entities = self.ner.extract(narrative)
return entities
def mimic_style(self, narrative):
styled_narrative = self.custom_ml_model.mimic_style(narrative)
return styled_narrative
def store_narrative_data(self, narrative_data):
store_data(narrative_data)
def maintain_narrative_context(self, narrative_data):
maintain_context(narrative_data)
def generate_autobiography(self):
narrative = self.generate_narrative(self.interview_data)
sentiment = self.analyze_sentiment(narrative)
entities = self.extract_entities(narrative)
styled_narrative = self.mimic_style(narrative)
self.store_narrative_data(styled_narrative)
self.maintain_narrative_context(styled_narrative)
return styled_narrative, sentiment, entities
``` | [] |
2024-01-10 | shadowaxe99/book-writer-ghost | src~models~language_model.py | ```python
from openai import GPT3LM
class LanguageModel:
def __init__(self, model_name="gpt-3.5-turbo"):
self.model = GPT3LM(model_name)
def generate_response(self, prompt, max_tokens=100):
response = self.model.generate(prompt, max_tokens=max_tokens)
return response
def generate_interview_questions(self, context):
prompt = f"{context}\nWhat would be your next question?"
question = self.generate_response(prompt)
return question
def generate_narrative(self, interviewData):
prompt = f"Based on the following interview data: {interviewData}\nGenerate a narrative:"
narrative = self.generate_response(prompt, max_tokens=16385)
return narrative
``` | [
"Based on the following interview data: PLACEHOLDER\nGenerate a narrative:",
"PLACEHOLDER\nWhat would be your next question?"
] |
2024-01-10 | abdulrahimq/jor | journo.py | import os
import openai
openai.api_key = "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"
paragraph = "TEMPLATE TEXT"
prompts_dict = {
"headline": f'''
Write a headline for the following article for the New York Times:
""""""
The Brady-Johnson Program in Grand Strategy is one of Yale University’s most celebrated and prestigious programs. Over the course of a year, it allows a select group of about two dozen students to immerse themselves in classic texts of history and statecraft, while also rubbing shoulders with guest instructors drawn from the worlds of government, politics, military affairs and the media. But now, a program created to train future leaders how to steer through the turbulent waters of history is facing a crisis of its own. Beverly Gage, a historian of 20th-century politics who has led the program since 2017, has resigned, saying the university failed to stand up for academic freedom amid inappropriate efforts by its donors to influence its curriculum and faculty hiring.
Headline: Leader of Prestigious Yale Program Resigns, Citing Donor Pressure
""""""
{paragraph}\n\n
Headline:
''',
"interview_questions": f'''
Create a list of questions for my interview with the CEO of a big corporate:
1. Do you believe there is a right or wrong when it comes to how companies function in the world, or is it all a matter of degree?
2. How would you characterize that disposition of a socially responsible C.E.O.? What are the attributes?
3. There are reasons your company has been a positive force in the world — chiefly economic ones but also ones having to do with personal pleasure. But inarguably some of those beneficial aspects have come at a cost to both human and environmental health. How did you think about those ethical trade-offs?
4. When you meet with business leaders today, is there anything you’re hearing that makes you think, gosh, these people are living in the past?
5. So let’s say you were running a company in Texas, and that company believed in the importance of supporting young families. What would the company’s thinking be around the state’s abortion laws?
6. But surely the issues you just described are connected to the ability to have a family when you want to have a family?
7. More generally, when it comes to corporate responses to political changes, what factors would you be looking at to help you determine the right response for your company?
8. How did your attitude about money change the further along you went in your career, once you became very handsomely compensated?
9. Do you think there is anything gendered to your decision to turn down a raise?
10. Did you feel as if you understood the blowback to the ad and agreed with it? Or was the blowback itself sufficient for you to feel you’d made a mistake?
------------
Create a list of questions for my interview with a cognitive psychologist, psycholinguist, popular science author and public intellectual:
1. Your new book is driven by the idea that it would be good if more people thought more rationally. But people don’t think they’re irrational. So what mechanisms would induce more people to test their own thinking and beliefs for rationality?
2. Are there aspects of your own life in which you’re knowingly irrational?
3. Do you see any irrational beliefs as useful?
4. What about love?
5. I don’t think I’m alone in feeling that rising authoritarianism, the pandemic and the climate crisis, among other things, are signs that we’re going to hell in a handbasket. Is that irrational of me?
6. How can we know if the fights happening in academia over free speech — which you’ve experienced firsthand — are just the labor pains of new norms? And how do we then judge if those norms are ultimately positive or negative?
7. You said we have to look at whether or not new norms are designed to reward more accurate beliefs or marginalize less accurate ones. How does that apply to subjective issues like, for example, ones to do with identity?
8. What links do you see between rationality and morality?
9. If we agree that well-being is better than its opposite, where does economic equality fit in? Is that a core aspect of well-being?
10. Is it possible that the rising-tide-lifts-all-boats economic argument provides the wealthy with an undue moral cover for the self-interested inequality that their wealth grants them?
------
Create a list of questions for my interview with '''
}
def generate_interview_question(max_tokens=100, paragraph=""):
if not paragraph:
paragraph = input(f'''Please enter the main paragraph\n-------------------------\n''')
print("GENERATED:", paragraph)
text = prompts_dict['interview_questions'] + f"{paragraph}:\n1."
print("GENERATED:", text)
response = openai.Completion.create(engine="davinci-instruct-beta", prompt=text, max_tokens=max_tokens,
temperature=0.8, top_p=1)
return response['choices'][0]['text']
def generate_article_outline():
pass
def generate_article_ideas(paragraph="", max_tokens=100) -> str:
pass
def generate_headline(paragraph="", max_tokens=20) -> str:
if not paragraph:
paragraph = input(f'''Please enter the main paragraph\n-------------------------\n''')
text = prompts_dict['headline'] + f"{paragraph}:\n1."
response = openai.Completion.create(engine="davinci-instruct-beta", prompt=paragraph, max_tokens=max_tokens,
temperature=0.8, top_p=1)
return response['choices'][0]['text']
def clean_prompt(prompt):
prompt = prompt.replace("\n", " ")
prompt = prompt.replace("\t", " ")
return prompt
task_dict = {
"interview_questions": generate_interview_question,
"article_outline": generate_article_ideas,
"article_ideas": generate_article_ideas,
"headline": generate_headline
}
def choose_generation(task_type="1"):
num = input(f'''Please choose the number what type of text to generate:
1) Inteview Questions
2) Article Outline
3) Article Ideas
4) Headline
''')
tasks = {
"1": "interview_questions",
"2": "article_outline",
"3": "article_ideas",
"4": "headline"
}
name = tasks[num]
return task_dict.get(name, lambda: 'Invalid')()
def parse_important_info(max_tokens=100):
paragraph = input(f'''Please enter the main paragraph\n-------------------------\n''')
text = f'''
Text: Outside the headquarters of Asaib Ahl al-Haq, one of the main Iranian-backed militias in Iraq, fighters have posted a giant banner showing the U.S. Capitol building swallowed up by red tents, symbols of a defining event in Shiite history. It’s election time in Iraq, and Asaib Ahl al-Haq — blamed for attacks on American forces and listed by the United States as a terrorist organization — is just one of the paramilitary factions whose political wings are likely to win Parliament seats in Sunday’s voting. The banner’s imagery of the 7th century Battle of Karbala and a contemporaneous quote pledging revenge sends a message to all who pass: militant defense of Shiite Islam. Eighteen years after the United States invaded Iraq and toppled a dictator, the run-up to the country’s fifth general election highlights a political system dominated by guns and money, and still largely divided along sectarian and ethnic lines.
Keywords: Iraq, Iran, Asaib Ahl al-Haq, Karbala, Shiite, Islam, United States
---------------------------------------------------------------------------------------------------
Text: Bitcoin’s proponents dream of a financial system largely free of government meddling. But the first time that cryptocurrency became a national currency, it was imposed on an unwilling population by an increasingly authoritarian ruler using a secretive state-run system. The surprising announcement last month that El Salvador had adopted bitcoin, the world’s largest cryptocurrency, as legal tender caught its population by surprise, and made the poor, conservative Central American nation an unlikely bellwether of a global technological transformation. The outcome of the uncharted experiment could help determine whether cryptocurrency delivers the freedom from regulation that its proponents envision — or whether it becomes another tool of control and enrichment for autocrats and corporations.
Keywords: Bitcoin, El Salvador, Central America, Cryptocurrency, Inflation, Technology
---------------------------------------------------------------------------------------------------
Text: {paragraph}
Keywords:'''
response = openai.Completion.create(
engine="davinci-instruct-beta",
prompt=text,
temperature=0.3,
max_tokens=max_tokens,
top_p=1.0,
frequency_penalty=0.8,
presence_penalty=0.0,
stop=["\n"]
)
return response['choices'][0]['text']
def show_example(task_type: str) -> str:
return prompts_dict[task_type]
if __name__ == "__main__":
#print(parse_important_info())
print("HE")
#print(choose_generation())
| [
"\n",
"\t",
" ",
"{'headline': '\\n\\t\\t\\t\\tWrite a headline for the following article for the New York Times:\\n\\t\\t\\t\\t\"\"\"\"\"\"\\n\\t\\t\\t\\tThe Brady-Johnson Program in Grand Strategy is one of Yale University’s most celebrated and prestigious programs. Over the course of a year, it allows a select group of about two dozen students to immerse themselves in classic texts of history and statecraft, while also rubbing shoulders with guest instructors drawn from the worlds of government, politics, military affairs and the media. But now, a program created to train future leaders how to steer through the turbulent waters of history is facing a crisis of its own. Beverly Gage, a historian of 20th-century politics who has led the program since 2017, has resigned, saying the university failed to stand up for academic freedom amid inappropriate efforts by its donors to influence its curriculum and faculty hiring.\\n\\t\\t\\t\\tHeadline: Leader of Prestigious Yale Program Resigns, Citing Donor Pressure\\n\\t\\t\\t\\t\"\"\"\"\"\"\\n\\t\\t\\t\\tPLACEHOLDER\\n\\n\\n\\t\\t\\t\\tHeadline: \\n\\t\\t\\t\\t', 'interview_questions': '\\n\\tCreate a list of questions for my interview with the CEO of a big corporate:\\n\\n1. Do you believe there is a right or wrong when it comes to how companies function in the world, or is it all a matter of degree?\\n2. How would you characterize that disposition of a socially responsible C.E.O.? What are the attributes?\\n3. There are reasons your company has been a positive force in the world — chiefly economic ones but also ones having to do with personal pleasure. But inarguably some of those beneficial aspects have come at a cost to both human and environmental health. How did you think about those ethical trade-offs?\\n4. When you meet with business leaders today, is there anything you’re hearing that makes you think, gosh, these people are living in the past?\\n5. So let’s say you were running a company in Texas, and that company believed in the importance of supporting young families. What would the company’s thinking be around the state’s abortion laws?\\n6. But surely the issues you just described are connected to the ability to have a family when you want to have a family?\\n7. More generally, when it comes to corporate responses to political changes, what factors would you be looking at to help you determine the right response for your company?\\n8. How did your attitude about money change the further along you went in your career, once you became very handsomely compensated?\\n9. Do you think there is anything gendered to your decision to turn down a raise?\\n10. Did you feel as if you understood the blowback to the ad and agreed with it? Or was the blowback itself sufficient for you to feel you’d made a mistake?\\n\\n------------\\n\\nCreate a list of questions for my interview with a cognitive psychologist, psycholinguist, popular science author and public intellectual: \\n\\n1. Your new book is driven by the idea that it would be good if more people thought more rationally. But people don’t think they’re irrational. So what mechanisms would induce more people to test their own thinking and beliefs for rationality?\\n2. Are there aspects of your own life in which you’re knowingly irrational?\\n3. Do you see any irrational beliefs as useful?\\n4. What about love?\\n5. I don’t think I’m alone in feeling that rising authoritarianism, the pandemic and the climate crisis, among other things, are signs that we’re going to hell in a handbasket. Is that irrational of me?\\n6. How can we know if the fights happening in academia over free speech — which you’ve experienced firsthand — are just the labor pains of new norms? And how do we then judge if those norms are ultimately positive or negative?\\n7. You said we have to look at whether or not new norms are designed to reward more accurate beliefs or marginalize less accurate ones. How does that apply to subjective issues like, for example, ones to do with identity?\\n8. What links do you see between rationality and morality?\\n9. If we agree that well-being is better than its opposite, where does economic equality fit in? Is that a core aspect of well-being?\\n10. Is it possible that the rising-tide-lifts-all-boats economic argument provides the wealthy with an undue moral cover for the self-interested inequality that their wealth grants them?\\n\\n------\\nCreate a list of questions for my interview with '}"
] |
2024-01-10 | hereiskunalverma/testedtech | agent_utils.py | from llama_index.llms import OpenAI, ChatMessage, Anthropic, Replicate
from llama_index.llms.base import LLM
from llama_index.llms.utils import resolve_llm
from pydantic import BaseModel, Field
import os
from llama_index.agent import OpenAIAgent, ReActAgent
from llama_index.agent.react.prompts import REACT_CHAT_SYSTEM_HEADER
from llama_index import (
VectorStoreIndex,
SummaryIndex,
ServiceContext,
StorageContext,
Document,
load_index_from_storage,
)
from llama_index.prompts import ChatPromptTemplate
from typing import List, cast, Optional
from llama_index import SimpleDirectoryReader
from llama_index.embeddings.utils import resolve_embed_model
from llama_index.tools import QueryEngineTool, ToolMetadata, FunctionTool
from llama_index.agent.types import BaseAgent
from llama_index.chat_engine.types import BaseChatEngine
from llama_index.agent.react.formatter import ReActChatFormatter
from llama_index.llms.openai_utils import is_function_calling_model
from llama_index.chat_engine import CondensePlusContextChatEngine
from builder_config import BUILDER_LLM
from typing import Dict, Tuple, Any, Callable
import streamlit as st
from pathlib import Path
import json
import uuid
from constants import AGENT_CACHE_DIR
import shutil
def _resolve_llm(llm_str: str) -> LLM:
"""Resolve LLM."""
# TODO: make this less hardcoded with if-else statements
# see if there's a prefix
# - if there isn't, assume it's an OpenAI model
# - if there is, resolve it
tokens = llm_str.split(":")
if len(tokens) == 1:
os.environ["OPENAI_API_KEY"] = st.secrets.openai_key
llm: LLM = OpenAI(model=llm_str)
elif tokens[0] == "local":
llm = resolve_llm(llm_str)
elif tokens[0] == "openai":
os.environ["OPENAI_API_KEY"] = st.secrets.openai_key
llm = OpenAI(model=tokens[1])
elif tokens[0] == "anthropic":
os.environ["ANTHROPIC_API_KEY"] = st.secrets.anthropic_key
llm = Anthropic(model=tokens[1])
elif tokens[0] == "replicate":
os.environ["REPLICATE_API_KEY"] = st.secrets.replicate_key
llm = Replicate(model=tokens[1])
else:
raise ValueError(f"LLM {llm_str} not recognized.")
return llm
####################
#### META TOOLS ####
####################
# System prompt tool
GEN_SYS_PROMPT_STR = """\
Task information is given below.
Given the task, please generate a system prompt for an OpenAI-powered bot \
to solve this task:
{task} \
Make sure the system prompt obeys the following requirements:
- Tells the bot to ALWAYS use tools given to solve the task. \
NEVER give an answer without using a tool.
- Does not reference a specific data source. \
The data source is implicit in any queries to the bot, \
and telling the bot to analyze a specific data source might confuse it given a \
user query.
"""
gen_sys_prompt_messages = [
ChatMessage(
role="system",
content="You are helping to build a system prompt for another bot.",
),
ChatMessage(role="user", content=GEN_SYS_PROMPT_STR),
]
GEN_SYS_PROMPT_TMPL = ChatPromptTemplate(gen_sys_prompt_messages)
class RAGParams(BaseModel):
"""RAG parameters.
Parameters used to configure a RAG pipeline.
"""
include_summarization: bool = Field(
default=False,
description=(
"Whether to include summarization in the RAG pipeline. (only for GPT-4)"
),
)
top_k: int = Field(
default=2, description="Number of documents to retrieve from vector store."
)
chunk_size: int = Field(default=1024, description="Chunk size for vector store.")
embed_model: str = Field(
default="default", description="Embedding model to use (default is OpenAI)"
)
llm: str = Field(
default="gpt-4-1106-preview", description="LLM to use for summarization."
)
def load_data(
file_names: Optional[List[str]] = None, urls: Optional[List[str]] = None
) -> List[Document]:
"""Load data."""
file_names = file_names or []
urls = urls or []
if not file_names and not urls:
raise ValueError("Must specify either file_names or urls.")
elif file_names and urls:
raise ValueError("Must specify only one of file_names or urls.")
elif file_names:
reader = SimpleDirectoryReader(input_files=file_names)
docs = reader.load_data()
elif urls:
from llama_hub.web.simple_web.base import SimpleWebPageReader
# use simple web page reader from llamahub
loader = SimpleWebPageReader()
docs = loader.load_data(urls=urls)
else:
raise ValueError("Must specify either file_names or urls.")
return docs
def load_agent(
tools: List,
llm: LLM,
system_prompt: str,
extra_kwargs: Optional[Dict] = None,
**kwargs: Any,
) -> BaseChatEngine:
"""Load agent."""
extra_kwargs = extra_kwargs or {}
if isinstance(llm, OpenAI) and is_function_calling_model(llm.model):
# get OpenAI Agent
agent: BaseChatEngine = OpenAIAgent.from_tools(
tools=tools, llm=llm, system_prompt=system_prompt, **kwargs
)
else:
if "vector_index" not in extra_kwargs:
raise ValueError(
"Must pass in vector index for CondensePlusContextChatEngine."
)
vector_index = cast(VectorStoreIndex, extra_kwargs["vector_index"])
rag_params = cast(RAGParams, extra_kwargs["rag_params"])
# use condense + context chat engine
agent = CondensePlusContextChatEngine.from_defaults(
vector_index.as_retriever(similarity_top_k=rag_params.top_k),
)
return agent
def load_meta_agent(
tools: List,
llm: LLM,
system_prompt: str,
extra_kwargs: Optional[Dict] = None,
**kwargs: Any,
) -> BaseAgent:
"""Load meta agent.
TODO: consolidate with load_agent.
The meta-agent *has* to perform tool-use.
"""
extra_kwargs = extra_kwargs or {}
if isinstance(llm, OpenAI) and is_function_calling_model(llm.model):
# get OpenAI Agent
agent: BaseAgent = OpenAIAgent.from_tools(
tools=tools, llm=llm, system_prompt=system_prompt, **kwargs
)
else:
agent = ReActAgent.from_tools(
tools=tools,
llm=llm,
react_chat_formatter=ReActChatFormatter(
system_header=system_prompt + "\n" + REACT_CHAT_SYSTEM_HEADER,
),
**kwargs,
)
return agent
def construct_agent(
system_prompt: str,
rag_params: RAGParams,
docs: List[Document],
vector_index: Optional[VectorStoreIndex] = None,
additional_tools: Optional[List] = None,
) -> Tuple[BaseChatEngine, Dict]:
"""Construct agent from docs / parameters / indices."""
extra_info = {}
additional_tools = additional_tools or []
# first resolve llm and embedding model
embed_model = resolve_embed_model(rag_params.embed_model)
# llm = resolve_llm(rag_params.llm)
# TODO: use OpenAI for now
# llm = OpenAI(model=rag_params.llm)
llm = _resolve_llm(rag_params.llm)
# first let's index the data with the right parameters
service_context = ServiceContext.from_defaults(
chunk_size=rag_params.chunk_size,
llm=llm,
embed_model=embed_model,
)
if vector_index is None:
vector_index = VectorStoreIndex.from_documents(
docs, service_context=service_context
)
else:
pass
extra_info["vector_index"] = vector_index
vector_query_engine = vector_index.as_query_engine(
similarity_top_k=rag_params.top_k
)
all_tools = []
vector_tool = QueryEngineTool(
query_engine=vector_query_engine,
metadata=ToolMetadata(
name="vector_tool",
description=("Use this tool to answer any user question over any data."),
),
)
all_tools.append(vector_tool)
if rag_params.include_summarization:
summary_index = SummaryIndex.from_documents(
docs, service_context=service_context
)
summary_query_engine = summary_index.as_query_engine()
summary_tool = QueryEngineTool(
query_engine=summary_query_engine,
metadata=ToolMetadata(
name="summary_tool",
description=(
"Use this tool for any user questions that ask "
"for a summarization of content"
),
),
)
all_tools.append(summary_tool)
# then we add tools
all_tools.extend(additional_tools)
# build agent
if system_prompt is None:
return "System prompt not set yet. Please set system prompt first."
agent = load_agent(
all_tools,
llm=llm,
system_prompt=system_prompt,
verbose=True,
extra_kwargs={"vector_index": vector_index, "rag_params": rag_params},
)
return agent, extra_info
class ParamCache(BaseModel):
"""Cache for RAG agent builder.
Created a wrapper class around a dict in case we wanted to more explicitly
type different items in the cache.
"""
# arbitrary types
class Config:
arbitrary_types_allowed = True
# system prompt
system_prompt: Optional[str] = Field(
default=None, description="System prompt for RAG agent."
)
# data
file_names: List[str] = Field(
default_factory=list, description="File names as data source (if specified)"
)
urls: List[str] = Field(
default_factory=list, description="URLs as data source (if specified)"
)
docs: List = Field(default_factory=list, description="Documents for RAG agent.")
# tools
tools: List = Field(
default_factory=list, description="Additional tools for RAG agent (e.g. web)"
)
# RAG params
rag_params: RAGParams = Field(
default_factory=RAGParams, description="RAG parameters for RAG agent."
)
# agent params
vector_index: Optional[VectorStoreIndex] = Field(
default=None, description="Vector index for RAG agent."
)
agent_id: str = Field(
default_factory=lambda: f"Agent_{str(uuid.uuid4())}",
description="Agent ID for RAG agent.",
)
agent: Optional[BaseChatEngine] = Field(default=None, description="RAG agent.")
def save_to_disk(self, save_dir: str) -> None:
"""Save cache to disk."""
# NOTE: more complex than just calling dict() because we want to
# only store serializable fields and be space-efficient
dict_to_serialize = {
"system_prompt": self.system_prompt,
"file_names": self.file_names,
"urls": self.urls,
# TODO: figure out tools
# "tools": [],
"rag_params": self.rag_params.dict(),
"agent_id": self.agent_id,
}
# store the vector store within the agent
if self.vector_index is None:
raise ValueError("Must specify vector index in order to save.")
self.vector_index.storage_context.persist(Path(save_dir) / "storage")
# if save_path directories don't exist, create it
if not Path(save_dir).exists():
Path(save_dir).mkdir(parents=True)
with open(Path(save_dir) / "cache.json", "w") as f:
json.dump(dict_to_serialize, f)
@classmethod
def load_from_disk(
cls,
save_dir: str,
) -> "ParamCache":
"""Load cache from disk."""
storage_context = StorageContext.from_defaults(
persist_dir=str(Path(save_dir) / "storage")
)
vector_index = cast(VectorStoreIndex, load_index_from_storage(storage_context))
with open(Path(save_dir) / "cache.json", "r") as f:
cache_dict = json.load(f)
# replace rag params with RAGParams object
cache_dict["rag_params"] = RAGParams(**cache_dict["rag_params"])
# add in the missing fields
# load docs
cache_dict["docs"] = load_data(
file_names=cache_dict["file_names"], urls=cache_dict["urls"]
)
# load agent from index
agent, _ = construct_agent(
cache_dict["system_prompt"],
cache_dict["rag_params"],
cache_dict["docs"],
vector_index=vector_index,
# TODO: figure out tools
)
cache_dict["vector_index"] = vector_index
cache_dict["agent"] = agent
return cls(**cache_dict)
def add_agent_id_to_directory(dir: str, agent_id: str) -> None:
"""Save agent id to directory."""
full_path = Path(dir) / "agent_ids.json"
if not full_path.exists():
with open(full_path, "w") as f:
json.dump({"agent_ids": [agent_id]}, f)
else:
with open(full_path, "r") as f:
agent_ids = json.load(f)["agent_ids"]
if agent_id in agent_ids:
raise ValueError(f"Agent id {agent_id} already exists.")
agent_ids_set = set(agent_ids)
agent_ids_set.add(agent_id)
with open(full_path, "w") as f:
json.dump({"agent_ids": list(agent_ids_set)}, f)
def load_agent_ids_from_directory(dir: str) -> List[str]:
"""Load agent ids file."""
full_path = Path(dir) / "agent_ids.json"
if not full_path.exists():
return []
with open(full_path, "r") as f:
agent_ids = json.load(f)["agent_ids"]
return agent_ids
def load_cache_from_directory(
dir: str,
agent_id: str,
) -> ParamCache:
"""Load cache from directory."""
full_path = Path(dir) / f"{agent_id}"
if not full_path.exists():
raise ValueError(f"Cache for agent {agent_id} does not exist.")
cache = ParamCache.load_from_disk(str(full_path))
return cache
def remove_agent_from_directory(
dir: str,
agent_id: str,
) -> None:
"""Remove agent from directory."""
# modify / resave agent_ids
agent_ids = load_agent_ids_from_directory(dir)
new_agent_ids = [id for id in agent_ids if id != agent_id]
full_path = Path(dir) / "agent_ids.json"
with open(full_path, "w") as f:
json.dump({"agent_ids": new_agent_ids}, f)
# remove agent cache
full_path = Path(dir) / f"{agent_id}"
if full_path.exists():
# recursive delete
shutil.rmtree(full_path)
class RAGAgentBuilder:
"""RAG Agent builder.
Contains a set of functions to construct a RAG agent, including:
- setting system prompts
- loading data
- adding web search
- setting parameters (e.g. top-k)
Must pass in a cache. This cache will be modified as the agent is built.
"""
def __init__(
self, cache: Optional[ParamCache] = None, cache_dir: Optional[str] = None
) -> None:
"""Init params."""
self._cache = cache or ParamCache()
self._cache_dir = cache_dir or AGENT_CACHE_DIR
@property
def cache(self) -> ParamCache:
"""Cache."""
return self._cache
def create_system_prompt(self, task: str) -> str:
"""Create system prompt for another agent given an input task."""
llm = BUILDER_LLM
fmt_messages = GEN_SYS_PROMPT_TMPL.format_messages(task=task)
response = llm.chat(fmt_messages)
self._cache.system_prompt = response.message.content
return f"System prompt created: {response.message.content}"
def load_data(
self, file_names: Optional[List[str]] = None, urls: Optional[List[str]] = None
) -> str:
"""Load data for a given task.
Only ONE of file_names or urls should be specified.
Args:
file_names (Optional[List[str]]): List of file names to load.
Defaults to None.
urls (Optional[List[str]]): List of urls to load.
Defaults to None.
"""
file_names = file_names or []
urls = urls or []
docs = load_data(file_names=file_names, urls=urls)
self._cache.docs = docs
self._cache.file_names = file_names
self._cache.urls = urls
return "Data loaded successfully."
# NOTE: unused
def add_web_tool(self) -> str:
"""Add a web tool to enable agent to solve a task."""
# TODO: make this not hardcoded to a web tool
# Set up Metaphor tool
from llama_hub.tools.metaphor.base import MetaphorToolSpec
# TODO: set metaphor API key
metaphor_tool = MetaphorToolSpec(
api_key=os.environ["METAPHOR_API_KEY"],
)
metaphor_tool_list = metaphor_tool.to_tool_list()
self._cache.tools.extend(metaphor_tool_list)
return "Web tool added successfully."
def get_rag_params(self) -> Dict:
"""Get parameters used to configure the RAG pipeline.
Should be called before `set_rag_params` so that the agent is aware of the
schema.
"""
rag_params = self._cache.rag_params
return rag_params.dict()
def set_rag_params(self, **rag_params: Dict) -> str:
"""Set RAG parameters.
These parameters will then be used to actually initialize the agent.
Should call `get_rag_params` first to get the schema of the input dictionary.
Args:
**rag_params (Dict): dictionary of RAG parameters.
"""
new_dict = self._cache.rag_params.dict()
new_dict.update(rag_params)
rag_params_obj = RAGParams(**new_dict)
self._cache.rag_params = rag_params_obj
return "RAG parameters set successfully."
def create_agent(self, agent_id: Optional[str] = None) -> str:
"""Create an agent.
There are no parameters for this function because all the
functions should have already been called to set up the agent.
"""
if self._cache.system_prompt is None:
raise ValueError("Must set system prompt before creating agent.")
agent, extra_info = construct_agent(
cast(str, self._cache.system_prompt),
cast(RAGParams, self._cache.rag_params),
self._cache.docs,
additional_tools=self._cache.tools,
)
# if agent_id not specified, randomly generate one
agent_id = agent_id or self._cache.agent_id or f"Agent_{str(uuid.uuid4())}"
self._cache.vector_index = extra_info["vector_index"]
self._cache.agent_id = agent_id
self._cache.agent = agent
# save the cache to disk
agent_cache_path = f"{self._cache_dir}/{agent_id}"
self._cache.save_to_disk(agent_cache_path)
# save to agent ids
add_agent_id_to_directory(str(self._cache_dir), agent_id)
return "Agent created successfully."
def update_agent(
self,
agent_id: str,
system_prompt: Optional[str] = None,
include_summarization: Optional[bool] = None,
top_k: Optional[int] = None,
chunk_size: Optional[int] = None,
embed_model: Optional[str] = None,
llm: Optional[str] = None,
) -> None:
"""Update agent.
Delete old agent by ID and create a new one.
Optionally update the system prompt and RAG parameters.
NOTE: Currently is manually called, not meant for agent use.
"""
# remove saved agent from directory, since we'll be re-saving
remove_agent_from_directory(str(AGENT_CACHE_DIR), self.cache.agent_id)
# set agent id
self.cache.agent_id = agent_id
# set system prompt
if system_prompt is not None:
self.cache.system_prompt = system_prompt
# get agent_builder
# We call set_rag_params and create_agent, which will
# update the cache
# TODO: decouple functions from tool functions exposed to the agent
rag_params_dict: Dict[str, Any] = {}
if include_summarization is not None:
rag_params_dict["include_summarization"] = include_summarization
if top_k is not None:
rag_params_dict["top_k"] = top_k
if chunk_size is not None:
rag_params_dict["chunk_size"] = chunk_size
if embed_model is not None:
rag_params_dict["embed_model"] = embed_model
if llm is not None:
rag_params_dict["llm"] = llm
self.set_rag_params(**rag_params_dict)
# this will update the agent in the cache
self.create_agent()
####################
#### META Agent ####
####################
RAG_BUILDER_SYS_STR = """\
You are helping to construct an agent given a user-specified task.
You should generally use the tools in this rough order to build the agent.
1) Create system prompt tool: to create the system prompt for the agent.
2) Load in user-specified data (based on file paths they specify).
3) Decide whether or not to add additional tools.
4) Set parameters for the RAG pipeline.
5) Build the agent
This will be a back and forth conversation with the user. You should
continue asking users if there's anything else they want to do until
they say they're done. To help guide them on the process,
you can give suggestions on parameters they can set based on the tools they
have available (e.g. "Do you want to set the number of documents to retrieve?")
"""
### DEFINE Agent ####
# NOTE: here we define a function that is dependent on the LLM,
# please make sure to update the LLM above if you change the function below
# define agent
# @st.cache_resource
def load_meta_agent_and_tools(
cache: Optional[ParamCache] = None,
) -> Tuple[BaseAgent, RAGAgentBuilder]:
# think of this as tools for the agent to use
agent_builder = RAGAgentBuilder(cache)
fns: List[Callable] = [
agent_builder.create_system_prompt,
agent_builder.load_data,
# add_web_tool,
agent_builder.get_rag_params,
agent_builder.set_rag_params,
agent_builder.create_agent,
]
fn_tools = [FunctionTool.from_defaults(fn=fn) for fn in fns]
builder_agent = load_meta_agent(
fn_tools, llm=BUILDER_LLM, system_prompt=RAG_BUILDER_SYS_STR, verbose=True
)
return builder_agent, agent_builder
| [
"System prompt for RAG agent.",
"Task information is given below. \n\nGiven the task, please generate a system prompt for an OpenAI-powered bot to solve this task: \n{task} \nMake sure the system prompt obeys the following requirements:\n- Tells the bot to ALWAYS use tools given to solve the task. NEVER give an answer without using a tool.\n- Does not reference a specific data source. The data source is implicit in any queries to the bot, and telling the bot to analyze a specific data source might confuse it given a user query.\n\n",
"You are helping to build a system prompt for another bot."
] |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.