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 | Hiromuabe/VRModFinder | index_ja.py | from flask import Flask, render_template, request, redirect, url_for, session
import openai
from gpt import gpt_interior, gpt_feature, gpt_number,gpt_translate,gpt_translate_ja
from clip_code import *
from other_code import *
app = Flask(__name__)
@app.route('/',methods=['GET','POST'])
def index():
if request.method == "GET":
return render_template('index_ja.html')
else:
if "start" in request.form:
return redirect(url_for("search"))
else:
global interior, features, number,device
input_number = request.form["number"]
device = request.form["device"]
input_text = request.form["keyword"]
input_text = gpt_translate(input_text)
interior = gpt_interior(input_text,input_number)
features = gpt_feature(input_text,interior)
number = gpt_number(input_text,interior)
ja_interior = gpt_translate_ja(",".join(interior))
ja_features = gpt_translate_ja(",".join(features))
return render_template('index_ja.html',interior=ja_interior,features=ja_features,number=number)
@app.route("/search",methods=['GET',"POST"])
def search():
global interior, features, number,device
if request.method == "GET":
return render_template('search_ja.html',interior=interior,features=features,number=number)
else:
if "object_uid" in request.form:
uid = request.form["object_uid"]
return redirect(url_for("watch", uid=uid))
else:
names, urls, uids = squeeze(interior)
selected_name, selected_uid = get_uid(interior, features, names,urls, uids,device)
install_obj(selected_uid)
names = save_img(selected_uid, "./data.json")
return render_template('search_ja.html',interior=interior,features=features,number=number,selected_name=selected_name,selected_uid=selected_uid)
@app.route("/watch", methods=['GET', 'POST'])
def watch():
if request.method == "GET":
uid = request.args.get("uid", None)
if uid:
return render_template('watch.html', uid=uid)
else:
return "No uid provided", 400
if __name__ == "__main__":
app.run(debug=True) | [] |
2024-01-10 | Hiromuabe/VRModFinder | clip_code.py |
import torch
import clip
import PIL.Image
import objaverse
import cv2
import numpy as np
from IPython.display import Image, display
from matplotlib import pyplot as plt
import requests
import tempfile
from tkinter import *
import re
import openai
import os
import json
import objaverse
import multiprocessing as mp
from tqdm import tqdm
def imread_web(url):
# 画像をリクエストする
res = requests.get(url)
img = None
# Tempfileを作成して即読み込む
with tempfile.NamedTemporaryFile(dir='./') as fp:
fp.write(res.content)
fp.file.seek(0)
img = cv2.imread(fp.name)
return img
def imshow(img):
"""ndarray 配列をインラインで Notebook 上に表示する。
"""
ret, encoded = cv2.imencode(".jpg", img)
display(Image(encoded))
def chenge_img(url):
IMG_PATH = imread_web(url)
img = cv2.cvtColor(IMG_PATH,cv2.COLOR_BGR2RGB)
return img
def score_clip(url:str,feature:str,device="cpu"):
# テキスト
TEXT_LIST = [feature,"not "+feature]
# モデルの読み込み
model, preprocess = clip.load("ViT-B/32", device=device)
result_percent = []
try:
img = chenge_img(url)
image = preprocess(PIL.Image.fromarray(img)).unsqueeze(0).to(device)
except:
result_percent.append(None)
return 0.0
text = clip.tokenize(TEXT_LIST).to(device)
with torch.no_grad():
# 画像、テキストのエンコード
image_features = model.encode_image(image)
text_features = model.encode_text(text)
# 推論
logits_per_image, logits_per_text = model(image, text)
probs = logits_per_image.softmax(dim=-1).cpu().numpy()
return probs[0][0]
def squeeze(interior_names):
print(f"squeeze:{interior_names}")
file = open("data.json")
file = json.load(file)
interior_names = interior_names.split(",")
names = [[] for _ in range(len(interior_names))]
urls = [[] for _ in range(len(interior_names))]
uids = [[] for _ in range(len(interior_names))]
for _ in range(len(interior_names)):
points = []
interior = interior_names[_]
print("インテリア名")
print(interior)
# interior = "writing desk"
# interior_name_parts = ["writing","desk"]
interior_name_parts = interior.split(" ")
if len(interior_name_parts) == 1:
for j,k in zip(file.keys(),file.values()):
if interior_name_parts[0] in k["name"].split(" "):
names[_].append(k["name"])
urls[_].append(k["thumbnail_url"])
uids[_].append(j)
else:
for j,k in zip(file.keys(),file.values()):
if interior in k["name"].lower():
names[_].append(k["name"])
urls[_].append(k["thumbnail_url"])
uids[_].append(j)
all_point = 0
name_parts = k["name"].lower().split(" ")
for i in range(len(interior_name_parts)):
if interior_name_parts[i] in name_parts:
if i == len(interior_name_parts)-1:
all_point += 100
else:
all_point += i+1
points.append(all_point)
max_point = max(points)
print(max_point)
threshold = max_point
sorted_index = [index for index, value in sorted(enumerate(points),key=lambda x:-x[1]) if value == threshold]
uid_list = list(file.keys())
for num in sorted_index:
names[_].append(file[uid_list[num]]["name"])
urls[_].append(file[uid_list[num]]["thumbnail_url"])
uids[_].append(uid_list[num])
names[_] = list(set(names[_]))
urls[_] = list(set(urls[_]))
uids[_] = list(set(uids[_]))
return names, urls, uids
def get_uid(interior_list, features_list,names,urls,uids,device="cpu"):
scores = [[] for _ in range(len(interior_list))]
selected_uid = []
selected_name = []
for i in tqdm(range(len(urls))):
for j in tqdm(range(len(urls[i]))):
scores[i].append(score_clip(urls[i][j],features_list[i],device))
index = scores[i].index(max(scores[i]))
selected_uid.append(uids[i][index])
selected_name.append(names[i][index])
return selected_name, selected_uid
def install_obj(uid):
objaverse.load_objects(
uids=uid
)
print("finish")
return | [] |
2024-01-10 | Hiromuabe/VRModFinder | index_en.py | from flask import Flask, render_template, request, redirect, url_for, session
import openai
from gpt import gpt_interior, gpt_feature, gpt_number
from clip_code import *
from other_code import *
app = Flask(__name__)
@app.route('/',methods=['GET','POST'])
def index():
if request.method == "GET":
return render_template('index.html')
else:
global interior, features, number,device
input_number = request.form["number"]
device = request.form["device"]
input_text = request.form["keyword"]
interior = gpt_interior(input_text,input_number)
features = gpt_feature(input_text,interior)
print(features)
number = gpt_number(input_text,interior)
return redirect(url_for("search", interior=",".join(interior), features=features, number=number,device=device))
@app.route("/search",methods=['GET',"POST"])
def search():
global interior, features, number,device
if request.method == "GET":
interior = request.args.get("interior")
print(f'search:{interior}')
print(interior)
features = request.args.get("features")
number = request.args.get("number")
device = request.args.get("device")
return render_template("search_en.html",interior=interior,features=features,number=number)
else:
if "object_uid" in request.form:
uid = request.form["object_uid"]
return redirect(url_for("watch", uid=uid))
else:
names, urls, uids = squeeze(interior)
selected_name, selected_uid = get_uid(interior, features, names,urls, uids,device)
install_obj(selected_uid)
names = save_img(selected_uid, "./data.json")
return render_template('search_en.html',interior=interior,features=features,number=number,selected_name=selected_name,selected_uid=selected_uid,selected_names=names,selected_zip=zip(selected_uid,names))
@app.route("/watch", methods=['GET', 'POST'])
def watch():
if request.method == "GET":
uid = request.args.get("uid", None)
if uid:
return render_template('watch.html', uid=uid)
else:
return "No uid provided", 400
if __name__ == "__main__":
app.run(debug=True) | [] |
2024-01-10 | yumeminami/chatgpt-telegram-bot-py | chatgpt~images_edit.py | import os
import openai
def images_edit(image, prompt):
openai.api_key = os.getenv("OPENAI_API_KEY")
try:
response = openai.Image.create_edit(image=image, prompt=prompt)
return response["data"][0]["url"]
except Exception as e:
print(e)
return "Error"
| [] |
2024-01-10 | yumeminami/chatgpt-telegram-bot-py | chatgpt~moderation.py | import openai
import os
def moeradtions(input: str):
openai.api_key = os.getenv("OPENAI_API_KEY")
# openai.api_key ="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"
try:
response = openai.Moderation.create(
input=input,
)
print(response)
return response.results[0]["flagged"]
except Exception as e:
print(e)
return False
| [] |
2024-01-10 | yumeminami/chatgpt-telegram-bot-py | chatgpt~edits.py | import os
import openai
def edits(input, instruction):
openai.api_key = os.getenv("OPENAI_API_KEY")
try:
response = openai.Edit.create(
model="text-davinci-edit-001",
input=input,
instruction=instruction,
)
return response["choices"][0]["text"]
except Exception as e:
print(e)
return "Error"
| [] |
2024-01-10 | yumeminami/chatgpt-telegram-bot-py | chatgpt~images.py | import openai
import os
def images(prompt) -> str:
try:
openai.api_key = os.getenv("OPENAI_API_KEY")
response = openai.Image.create(
prompt=prompt,
size="512x512",
)
return response["data"][0]["url"]
except Exception as e:
print(e)
return "Error"
| [] |
2024-01-10 | arpy8/insAIghts | brain.py | from langchain.chat_models import ChatOpenAI
from langchain.prompts.chat import (
ChatPromptTemplate,
SystemMessagePromptTemplate,
HumanMessagePromptTemplate,
)
from pytube import YouTube
from youtube_transcript_api import YouTubeTranscriptApi
import streamlit as st
from pytube import YouTube
OPENAI_API = st.secrets["OPENAI_API"]
template = ("""
I'm preparing notes from a video titled "{title}". I need you to
act as an expert professor and provide me with comprehensive and well-structured
notes from the following text.
Here is the text:
{transcription}
Condition: Please ensure the notes cover the following topics: ALL THE TOPICS.
Also do make sure you are printing everything in MARKDOWN.
Strictly do not print anything else other than the notes.
""")
def video_title(url):
"""
This function retrieves the title of a YouTube video given its URL.
Arguments:
url -- A string representing the URL of a YouTube video.
Returns:
str -- A string representing the title of the YouTube video.
Raises:
Exception -- If the provided URL is not valid or does not point to a YouTube video.
"""
yt = YouTube(url)
return yt.title
def text_extractor(url):
"""
This function extracts the text from a YouTube video transcript given its URL.
Args:
url: A string representing the URL of a YouTube video.
Returns:
A string containing the transcript text of the YouTube video.
Raises:
ConnectionError: If there is an error connecting to the YouTube Transcript API.
"""
try:
if "&list=" in url:
url = url.split("&list=")[0]
elif "?si=" in url:
url = url.split("?si=")[0]
video_id = url.split("?v=")[-1] if "?v=" in url else url.split("/")[-1]
except IndexError:
video_id = url.split("/")[-1]
try:
response = YouTubeTranscriptApi.get_transcript(video_id)
final = "".join([i['text'] for i in response])
if 4078 > len(final) > 5:
return final
else:
return None
except ConnectionError as e:
st.error(e)
@st.cache_data
def notes_generator(url):
"""
This function generates notes based on the provided URL.
Args:
url: A string representing the URL of the content for which notes are to be generated.
Returns:
A string containing the generated notes.
Raises:
Exception: If the URL is not valid or if there's an error in generating notes.
"""
chat = ChatOpenAI(temperature=0, openai_api_key=OPENAI_API)
system_message_prompt = SystemMessagePromptTemplate.from_template(template)
human_template = "{text}"
human_message_prompt = HumanMessagePromptTemplate.from_template(human_template)
gpt_response = ChatPromptTemplate.from_messages(
[system_message_prompt, human_message_prompt]
)
response = chat(
gpt_response.format_prompt(
title=video_title(url), transcription=text_extractor(url) if text_extractor(url) is not None else "Sorry, couldn't extract the transcript for this video.",
text=url
).to_messages()
)
return response.content
def credits(url):
"""
This function generates credits of the content-creator based on the provided URL.
Args:
url: A string representing the URL of the content for which notes are to be generated.
Returns:
A string containing the credits for the YouTube video.
Raises:
Exception: If the URL is not valid or if there's an error in generating notes.
"""
yt = YouTube(url)
return yt.title, yt.author, yt.channel_url, yt.publish_date, yt.thumbnail_url | [
" \n I'm preparing notes from a video titled \"{title}\". I need you to\n act as an expert professor and provide me with comprehensive and well-structured \n notes from the following text. \n\n Here is the text:\n {transcription}\n\n Condition: Please ensure the notes cover the following topics: ALL THE TOPICS.\n Also do make sure you are printing everything in MARKDOWN. \n Strictly do not print anything else other than the notes.\n ",
"[PLACEHOLDER, PLACEHOLDER]",
"{text}"
] |
2024-01-10 | YOBEE-8th/YOBEE-AI | AI~Flask~actions.py | import requests
from flask import Flask, request, jsonify, make_response
from flask_cors import CORS, cross_origin
import openai
from api_key import OPENAI
import logging
app = Flask(__name__)
app.config['JSON_AS_ASCII'] = False
app.logger.setLevel(logging.INFO)
cors = CORS(app, resources={
r"/*": {
"origins": "*"
}
})
# 클라이언트 요청 -> RASA (요청 -> 응답) -> 정보 가공 -> 클라이언트 응답
@app.route('/api/v1/voice', methods=['POST'])
def rasa_request():
# 클라이언트 요청
recipeId = request.json['recipeId']
message = request.json['message'] # 클라이언트로부터 메시지를 받아옴
token = request.headers.get('Authorization')
if token is None:
return jsonify({'error': 'No token provided.'}), 401
# Rasa 서버에 요청을 보내고 응답을 받음
rasa_url = "http://13.125.182.198:5005/webhooks/rest/webhook"
# rasa_url = "http://localhost:5005/webhooks/rest/webhook"
rasa_payload = {"message": message}
rasa_response = requests.post(rasa_url, json=rasa_payload).json()
# print(rasa_response)
# 정보 가공
result_type = ''
result_text = ''
result_message = ''
# type: 페이지 이동 (result_type = 0)
if 'page' in rasa_response[0]['text']:
result_type = '0'
result_message = "페이지 이동 명령"
if rasa_response[0]['text'] == "first_page":
result_text = '0'
result_message += "( << )"
elif rasa_response[0]['text'] == "previous_page":
result_text = '1'
result_message += "( < )"
elif rasa_response[0]['text'] == "next_page":
result_text = '2'
result_message += "( > )"
elif rasa_response[0]['text'] == "last_page":
result_text = '3'
result_message += "( >> )"
else:
result_text = '4' # current_page
result_message += "( ● )"
# type: 재료 질문
elif '재료:' in rasa_response[0]['text']:
ingredient = rasa_response[0]['text'].replace("재료:","")
result_type = '1'
result_message = "재료질문 답변"
# Spring 서버 API 주소
spring_url = "http://13.125.182.198:8090/api/v1/AI/recipe/"+ str(recipeId) +"/ingredient"
# HTTP 요청 헤더 설정
headers = {"Authorization": token}
# 요청 보내기
spring_response = requests.get(spring_url, headers=headers)
# 응답 데이터 가져오기
spring_response = spring_response.json()
# print(spring_response)
ingredients = spring_response['data']
# print("ingredients:", ingredients)
for ingredient_name, ingredient_weight in ingredients.items():
if ingredient == ingredient_name:
ingredient_weight = ingredient_weight.replace('g', '그램')
ingredient_weight = ingredient_weight.replace('t', '작은술')
ingredient_weight = ingredient_weight.replace('T', '큰술')
ingredient_weight = ingredient_weight.replace('L', '리터')
ingredient_weight = ingredient_weight.replace('ml', '밀리리터')
result_text = ingredient_name + ' ' + ingredient_weight +' 넣어주세요'
break
else:
result_text = ingredient + ' 들어가지 않아요.'
else:
result_type = '1'
result_message = "ChatGPT 답변"
spring_url = "http://13.125.182.198:8090/api/v1/recipe/unresolved"
headers = {"Authorization": token, "Content-Type": "application/json"}
data = {"recipeId": recipeId, "content": message}
spring_response = requests.post(spring_url, json=data, headers=headers)
spring_response = spring_response.json()
# print(spring_response)
# 발급받은 API 키 설정 (호스트의 디렉토리를 볼륨하는 방법)
OPENAI_API_KEY = OPENAI.OPENAI_API_KEY
openai.api_key = OPENAI_API_KEY
engine = "text-davinci-003"
model = "text-davinci-003"
prompt = message + " 한국어로 요약해서 말해줘. "
temperature = 0.5
max_tokens = 1000
completions = openai.Completion.create(
engine=engine,
prompt=prompt,
temperature=temperature,
max_tokens=max_tokens,
# model=model
)
result_text = completions.choices[0].text.replace('\n','')
# 클라이언트 응답
response = {
'status': 200,
'message': result_message,
'data':{
'type': result_type,
'text': result_text
}
}
response = make_response(jsonify(response))
response.headers['Content-Type'] = 'application/json; charset=utf-8'
app.logger.info(f'')
app.logger.info(f'user_input: {message}')
app.logger.info(f'result_text: {result_text}')
app.logger.info(f'result_message: {result_message}')
app.logger.info(f'')
return response
if __name__ == '__main__':
app.run(host='0.0.0.0', port=5006)
| [
"PLACEHOLDER 한국어로 요약해서 말해줘. "
] |
2024-01-10 | Reverse-Rain/medbot.ai | receive.py | #------------------------------------------------------------------libs-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------#
from keras.models import load_model
from PIL import Image, ImageOps
import numpy as np
from typing import Final
import telebot
from telegram import Update
from telegram.ext import Application, CommandHandler, MessageHandler, filters, ContextTypes
import time
from caloriefinder import get_nutrient_info
import random
from telebot import types
import pyodbc
import mysql.connector
from telebot.types import Message, Location,InlineKeyboardMarkup, InlineKeyboardButton
from conditions import conditions
import wikipedia
import requests
from bs4 import BeautifulSoup
import openpyxl
import schedule
import time
from sklearn.ensemble import RandomForestClassifier
from sympt import symptoms_to_diseases
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.preprocessing import LabelEncoder
from sklearn.ensemble import RandomForestClassifier
import threading
import datetime
import subprocess
import bot
print("main file started...")
from bot import bot
# Use the bot instance in your code specific to reminder.py
# Rest of the code in reminder.py
import openai
from gpt import ask_gpt
import speech_recognition as sr
import tempfile
import os
import json
import base64
import firebase_admin
from firebase_admin import credentials
from firebase_admin import db
from recomend import get_health_articles
#-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------#
print("main file starting...")
#-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------#
# Disable scientific notation for clarity
np.set_printoptions(suppress=True)
TOKEN = '6072587014:AAF9h6Ji1dRyC9yEL1u7UhAKOevbaKVpyPk'
bot2 = telebot.TeleBot('TOKEN')
BOT_USERNAME: Final = '@werus_co_bot'
print('Starting up bot...')
print('bot is online ')
# API endpoint for the USDA Food Composition Databases
url = 'https://api.nal.usda.gov/fdc/v1/foods/search'
# API key (replace with your own if you have one)
api_key = 'IphEUj1GUJWBEjPhPJRENqRokVbVTtAIoaMcXqdK'
# Load the model
model = load_model("keras_Model1.h5", compile=False)
# Load the labels
class_names = open("labels.txt", "r").readlines()
data = np.ndarray(shape=(1, 224, 224, 3), dtype=np.float32)
#-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------#
#------------------------------------------------recommendation-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------#
def recom(condition,message):
# Load the Excel workbook
workbook = openpyxl.load_workbook('data.xlsx')
# Get the active sheet
sheet = workbook.active
# Define lists for the first and second columns
column1_values = []
column2_values = []
# Loop through each row in the sheet and append the first and second column values to the lists
for row in sheet.iter_rows(min_row=2, values_only=True):
column1_values.append(row[0])
column2_values.append(row[1])
for i in range(len(column1_values)):
if condition in column1_values[i]:
print(column2_values[i])
arturl=column2_values[i]
bot.send_message(message.chat.id, text="check out this article, it may help you ", parse_mode='HTML')
bot.send_message(message.chat.id, text=arturl, parse_mode='HTML')
url = f"https://www.amazon.in/s?k=product for {condition}"
link_text = 'Check out this website!'
message_text = f'<a href="{url}">{link_text}</a>'
bot.send_message(message.chat.id, text=message_text, parse_mode='HTML')
bot.send_photo(message.chat.id, photo=url)
#-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------#
#----------------------------------------------conditions-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------#
user_data = {}
@bot.message_handler(commands=['conditions'])
def ask_conditions(message):
keyboard = InlineKeyboardMarkup()
for condition in conditions:
keyboard.add(InlineKeyboardButton(text=condition, callback_data=condition))
bot.send_message(chat_id=message.chat.id, text='Please select any conditions that apply to you:', reply_markup=keyboard)
# Add user data to dictionary
user_data[message.chat.id] = {'conditions': {}, 'submitted': False}
@bot.callback_query_handler(func=lambda call: True)
def handle_callback(call):
if call.data == 'submit':
# Save the selected conditions to the user_data dictionary
selected_conditions = [condition for condition, selected in user_data[call.message.chat.id]['conditions'].items() if selected]
user_data[call.message.chat.id]['conditions'] = selected_conditions
user_data[call.message.chat.id]['submitted'] = True
bot.answer_callback_query(callback_query_id=call.id, text=f'Selected conditions: {selected_conditions}')
else:
condition = call.data
user_data[call.message.chat.id]['conditions'][condition] = not user_data[call.message.chat.id]['conditions'].get(condition, False)
button_text = f'{condition} ✅' if user_data[call.message.chat.id]['conditions'][condition] else condition
keyboard = InlineKeyboardMarkup()
for condition, selected in user_data[call.message.chat.id]['conditions'].items():
button_text = f'{condition} ✅' if selected else condition
keyboard.add(InlineKeyboardButton(text=button_text, callback_data=condition))
bot.edit_message_reply_markup(chat_id=call.message.chat.id, message_id=call.message.message_id, reply_markup=keyboard)
bot.send_message(chat_id=call.message.chat.id, text='You have submitted your medical condition')
cnx = mysql.connector.connect(user='root', password='mes20ad048', host='127.0.0.1', database='pythondatas')
cursor = cnx.cursor()
sql = "INSERT INTO userconditions (uid,conditions) VALUES (%s, %s)"
val = (call.message.chat.id,condition)
cursor.execute(sql, val)
cnx.commit()
cursor.close()
cnx.close()
print(user_data)
# Schedule the function to be called every minute
#recom(condition,call.message)
#schedule.every(1).minutes.do(recom(condition,call.message))
# Keep running the scheduler
#while True:
# schedule.run_pending()
#time.sleep(1)
#-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------#
#----------------------------------------------/book---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------#
# Define the layout of the form
markup = types.ReplyKeyboardMarkup(one_time_keyboard=True)
item1 = types.KeyboardButton('Send Name')
markup.add(item1)
# Ask the user to enter their details
@bot.message_handler(commands=['book'])
def send_welcome(message):
msg = bot.send_message(message.chat.id, "Please enter your name:")
bot.register_next_step_handler(msg, process_name_step)
def process_name_step(message):
try:
chat_id = message.chat.id
name = message.text
# Ask for the user's age
msg = bot.send_message(chat_id, "Please enter your age:")
bot.register_next_step_handler(msg, lambda age_msg: process_age_step(age_msg, chat_id, name))
except Exception as e:
bot.send_message(chat_id, "Oops, something went wrong. Please try again later.")
def process_age_step(message, chat_id, name):
try:
age = int(message.text)
# Ask for the user's phone number
msg = bot.send_message(chat_id, "Please enter your phone number:")
bot.register_next_step_handler(msg, lambda phone_msg: process_phone_step(phone_msg, chat_id, name, age))
except ValueError:
bot.send_message(chat_id, "Please enter a valid age (a number).")
msg = bot.send_message(chat_id, "Please enter your age:")
bot.register_next_step_handler(msg, lambda age_msg: process_age_step(age_msg, chat_id, name))
def process_phone_step(message, chat_id, name, age):
try:
phone_number = message.text
# Ask for the appointment date
msg = bot.send_message(chat_id, "Please enter the date for your appointment (YYYY-MM-DD):")
bot.register_next_step_handler(msg, lambda date_msg: process_date_step(date_msg, chat_id, name, age, phone_number))
except Exception as e:
bot.send_message(chat_id, "Oops, something went wrong. Please try again later.")
def process_date_step(message, chat_id, name, age, phone_number):
try:
date = message.text
# Ask for the appointment time
msg = bot.send_message(chat_id, "Please enter the time for your appointment (HH:MM):")
bot.register_next_step_handler(msg, lambda time_msg: process_time_step(time_msg, chat_id, name, age, phone_number, date))
except Exception as e:
bot.send_message(chat_id, "Oops, something went wrong. Please try again later.")
def process_time_step(message, chat_id, name, age, phone_number, date):
try:
time = message.text
# Ask for the reason for the appointment
msg = bot.send_message(chat_id, "Please enter the reason for your appointment:")
bot.register_next_step_handler(msg, lambda reason_msg: process_reason_step(reason_msg, chat_id, name, age, phone_number, date, time))
except Exception as e:
bot.send_message(chat_id, "Oops, something went wrong. Please try again later.")
def process_reason_step(message, chat_id, name, age, phone_number, date, time):
try:
reason = message.text
cnx = mysql.connector.connect(user='root', password='mes20ad048', host='127.0.0.1',database='pythondatas')
cursor = cnx.cursor()
insert_query = "INSERT INTO appointments (name, age, phone_number, date, time, reason) VALUES (%s, %s, %s, %s, %s, %s)"
data = (name, age, phone_number, date, time, reason)
cursor.execute(insert_query, data)
cnx.commit()
cursor.close()
cnx.close()
# Send confirmation message to user
confirmation_message = f"Thank you, {name}. Your appointment has been scheduled for {date} at {time}. We will contact you at {phone_number} if we need to reschedule or cancel. Thank you for choosing our service."
bot.send_message(chat_id, confirmation_message)
except Exception as e:
bot.send_message(chat_id, "Oops, something went wrong. Please try again later.")
#-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------#
@bot.message_handler(commands=['reminder'])
def handle_reminder_command(message):
token_bot2 = '6254586187:AAGOdBfyQyk6UMoowW494xuOXM2VYrldkF4'
bot2 = telebot.TeleBot(token_bot2)
# Extract the chat ID from the incoming message
chat_id = message.chat.id
# Create a deep-link to the second bot
bot2_deep_link = f'https://t.me/{bot2.get_me().username}'
# Generate the redirection message
redirection_message = f'Click [here]({bot2_deep_link}) to set reminder.'
# Send the redirection message as a reply
bot.send_message(chat_id, redirection_message, parse_mode='Markdown')
#---------------------------------------------------chat----------------------------------------------------------------------------------------------------------------------------------------------------------------------------#
@bot.message_handler(content_types=['text'])
def handle_response(message):
# Create your own response logic
phrases = ['how are you', 'what is your name', 'what can you do', 'who created you']
processed = message.text.lower()
print(processed)
# Set up your OpenAI API credentials
openai.api_key = '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'
# Function to interact with the GPT-3 model
def query_gpt(question):
response = openai.Completion.create(
engine='davinci',
prompt=question,
max_tokens=100,
n=1,
stop=None,
)
return response.choices[0].text.strip()
if 'i have ' in processed:
try:
inpt=message.text.lower()
ert=inpt.replace("i have","")
user_symptoms = [s.strip() for s in ert.split(',')]
bot.send_message(message.chat.id, "Analysing...")
symptoms = []
diseases = []
for symptom, associated_diseases in symptoms_to_diseases.items():
symptoms.append(symptom)
diseases.append(', '.join(associated_diseases))
# Vectorize the symptoms
vectorizer = CountVectorizer()
X = vectorizer.fit_transform(symptoms)
label_encoder = LabelEncoder()
y = label_encoder.fit_transform(diseases)
classifier = RandomForestClassifier()
classifier.fit(X, y)
X_user = vectorizer.transform(user_symptoms)
predicted_diseases_encoded = classifier.predict(X_user)
predicted_diseases = label_encoder.inverse_transform(predicted_diseases_encoded)
if len(predicted_diseases) > 0:
bot.send_message(message.chat.id, "Predicted diseases based on the given symptoms:")
bot.send_message(message.chat.id,predicted_diseases)
else:
print("No diseases predicted for the given symptoms.")
bot.send_message(message.chat.id, " Please keep in mind that the predicted diseases may vary. My ability to predict diseases relies solely on the data provided to me.")
except ValueError:
bot.send_message(message.chat.id, "Please enter valid symptoms.")
elif 'hi' in processed:
bot.send_message(message.chat.id, 'Hi there! 👋')
elif 'what is your name' in processed:
bot.send_message(message.chat.id, 'my name is medbot.ai !')
#-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------#
elif '/help' in processed:
bot.send_message(message.chat.id, 'Welcome to the Help section for the MedBot!\n\nThis bot is designed to help you with various health-related tasks and provide information on different medical topics. Here\'s what you can do with this bot:\n\n• /cam ---for image recognition \n• /book ---for booking appointments\n• /notify ---for reminders\n\n -- symptoms fever,cough,etc')
elif '/start' in processed:
bot.send_message(message.chat.id, 'Welcome to the Help section for the MedBot!')
#-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------#
elif 'how are you' in processed:
bot.send_message(message.chat.id, 'I\'m good! ')
bot.send_message(message.chat.id, 'thanks for asking 😊 ')
elif 'hello' in processed:
bot.send_message(message.chat.id, 'hi there')
elif 'who are you' in processed:
bot.send_message(message.chat.id, 'i am medbot')
elif 'what can you do' in processed:
bot.send_message(message.chat.id, 'I can provide information, answer questions, and have conversations')
elif 'who created you' in processed:
bot.send_message(message.chat.id, "I was created by a team of developers at MESCE \nFor more details go to ")
elif "find what" in processed:
print(processed)
# Search the query in Wikipedia
#-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------#
try:
bot.send_message(message.chat.id, "Searching...")
summary = wikipedia.summary(processed)
bot.send_message(message.chat.id, summary)
except wikipedia.exceptions.DisambiguationError as e:
# If the query is ambiguous, choose the first option
summary = wikipedia.summary(e.options[0])
bot.send_message(message.chat.id, summary)
except wikipedia.exceptions.PageError:
# If no Wikipedia page was found for the query
bot.send_message(message.chat.id, 'Sorry, I could not find any information on that topic.')
except requests.exceptions.ConnectionError:
# If there was an error connecting to Wikipedia
bot.send_message(message.chat.id, 'Sorry, there was an error connecting to the world . Please try again later.')
else :
try:
# Function to send a loading effect
def send_loading_effect(chat_id, duration=3):
message = bot.send_message(chat_id, 'Loading...')
end_time = time.time() + duration
while time.time() < end_time:
bot.edit_message_text(chat_id=chat_id, message_id=message.message_id, text='.')
time.sleep(1)
bot.edit_message_text(chat_id=chat_id, message_id=message.message_id, text='..')
time.sleep(1)
bot.edit_message_text(chat_id=chat_id, message_id=message.message_id, text='...')
time.sleep(1)
bot.delete_message(chat_id, message.message_id)
chat_id=message.chat.id
qry=processed
response = ask_gpt(qry+" is this query is related to helth or medical field or life,comman queries only say 'yes' or 'no'")
send_loading_effect(chat_id)
# Use GPT-3 for other queries
print('Bot:', response)
rsp=response.lower()
print(rsp)
if "yes" in rsp:
rslt=ask_gpt(qry)
bot.send_message(message.chat.id, rslt)
elif "no"in rsp:
bot.send_message(message.chat.id, 'Sorry, i dont understand your message')
bot.send_message(message.chat.id, " i can only response to helth related queries ")
except:
bot.send_message(message.chat.id, 'Sorry, i dont understand your message')
#-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------#
#------------------------------------------------------------image-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------#
@bot.message_handler(content_types=['photo'])
def handle_photo(message):
try:
print("loading...")
file_id = message.photo[-1].file_id
file_info = bot.get_file(file_id)
downloaded_file = bot.download_file(file_info.file_path)
with open('received_image.jpg', 'wb') as new_file:
new_file.write(downloaded_file)
print("image downloaded..")
# Add some delay to simulate image processing time
time.sleep(2)
image = Image.open("received_image.jpg").convert("RGB")
# resizing the image to be at least 224x224 and then cropping from the center
size = (224, 224)
image = ImageOps.fit(image, size, Image.LANCZOS)
# turn the image into a numpy array
image_array = np.asarray(image)
# Normalize the image
normalized_image_array = (image_array.astype(np.float32) / 127.5) - 1
# Load the normalized image into the data array
# Please ensure that the 'data' array is properly defined before using this code.
data[0] = normalized_image_array
# Predict the model
# Please ensure that the 'model' is correctly defined and loaded before using this code.
prediction = model.predict(data)
# Get the index of the predicted class
index = np.argmax(prediction)
# Please ensure that the 'class_names' list is defined and contains class labels.
class_name = class_names[index]
# Send the class name as a message to the user
bot.send_message(message.chat.id, "Name: " + class_name[2:])
food_name = class_name[2:]
print(food_name)
if "none edible item" in food_name:
nutrient_info ="Could not find"
if "Could not find" in nutrient_info:
bot.send_message(message.chat.id, "Could not find any information about it,i think it is not edible ")
else:
nutrient_info = get_nutrient_info(food_name)
if "Could not find" in nutrient_info:
bot.send_message(message.chat.id, "Could not find any information about it, maybe my team forgot to teach me.")
else:
bot.send_message(message.chat.id, nutrient_info)
except Exception as e:
# If any error occurs during image processing or other steps, send a random error message to the user.
print("Error:", e)
error_msg = random.choice(error_messages)
bot.send_message(message.chat.id, error_msg)
#-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------#
#------------------------------------------------------------------------------runbot-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------#
bot.polling(none_stop=True)
#-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------#
| [] |
2024-01-10 | FairyWorld/FairyWorld | tools~auto-translater.py | # -*- coding: utf-8 -*-
# https://github.com/linyuxuanlin/Auto-i18n
import os
import openai
import sys
# import env
# 设置 OpenAI API Key 和 API Base 参数，通过 env.py 传入
openai.api_key = os.environ.get("CHATGPT_API_KEY")
openai.api_base = os.environ.get("CHATGPT_API_BASE")
# 设置翻译的路径
dir_to_translate = "./"
dir_translated = {
"en": "docs/en",
"ja": "docs/ja",
}
exclude_list = ["index.md", "Contact-and-Subscribe.md", "WeChat.md"] # 不进行翻译的文件列表
processed_list = "processed_list.txt" # 已处理的 Markdown 文件名的列表，会自动生成
# 设置最大输入字段，超出会拆分输入，防止超出输入字数限制
max_length = 4000
# 文章使用英文撰写的提示，避免本身为英文的文章被重复翻译为英文
marker_written_in_en = "\n> This post was originally written in English.\n"
# 即使在已处理的列表中，仍需要重新翻译的标记
marker_force_translate = "\n[translate]\n"
# 定义翻译函数
def translate_text(text, lang):
target_lang = {
"en": "English",
"ja": "Japanese",
}[lang]
# 使用OpenAI API进行翻译
completion = openai.ChatCompletion.create(
model="gpt-3.5-turbo",
messages=[
{
"role": "user",
"content": f"Translate the following text into {target_lang}, maintain the original markdown format.\n\n{text}\n\n{target_lang}:",
}
],
)
# 获取翻译结果
output_text = completion.choices[0].message.content
return output_text
# 定义文章拆分函数
def split_text(text, max_length):
# 根据段落拆分文章
paragraphs = text.split("\n\n")
output_paragraphs = []
current_paragraph = ""
for paragraph in paragraphs:
if len(current_paragraph) + len(paragraph) + 2 <= max_length:
# 如果当前段落加上新段落的长度不超过最大长度，就将它们合并
if current_paragraph:
current_paragraph += "\n\n"
current_paragraph += paragraph
else:
# 否则将当前段落添加到输出列表中，并重新开始一个新段落
output_paragraphs.append(current_paragraph)
current_paragraph = paragraph
# 将最后一个段落添加到输出列表中
if current_paragraph:
output_paragraphs.append(current_paragraph)
# 将输出段落合并为字符串
output_text = "\n\n".join(output_paragraphs)
return output_text
# 定义翻译文件函数
def translate_file(input_file, filename, lang):
print(f"Translating into {lang}: {filename}")
sys.stdout.flush()
# 定义输出文件
if lang in dir_translated:
output_dir = dir_translated[lang]
if not os.path.exists(output_dir):
os.makedirs(output_dir)
output_file = os.path.join(output_dir, filename)
# 读取输入文件内容
with open(input_file, "r", encoding="utf-8") as f:
input_text = f.read()
# 创建一个字典来存储占位词和对应的替换文本
placeholder_dict = {}
# print(input_text) # debug 用，看看输入的是什么
# 拆分文章
paragraphs = input_text.split("\n\n")
input_text = ""
output_paragraphs = []
current_paragraph = ""
for paragraph in paragraphs:
if len(current_paragraph) + len(paragraph) + 2 <= max_length:
# 如果当前段落加上新段落的长度不超过最大长度，就将它们合并
if current_paragraph:
current_paragraph += "\n\n"
current_paragraph += paragraph
else:
# 否则翻译当前段落，并将翻译结果添加到输出列表中
output_paragraphs.append(translate_text(current_paragraph, lang))
current_paragraph = paragraph
# 处理最后一个段落
if current_paragraph:
if len(current_paragraph) + len(input_text) <= max_length:
# 如果当前段落加上之前的文本长度不超过最大长度，就将它们合并
input_text += "\n\n" + current_paragraph
else:
# 否则翻译当前段落，并将翻译结果添加到输出列表中
output_paragraphs.append(translate_text(current_paragraph, lang))
# 如果还有未翻译的文本，就将它们添加到输出列表中
if input_text:
output_paragraphs.append(translate_text(input_text, lang))
# 将输出段落合并为字符串
output_text = "\n\n".join(output_paragraphs)
# 最后，将占位词替换为对应的替换文本
for placeholder, replacement in placeholder_dict.items():
output_text = output_text.replace(placeholder, replacement)
# 写入输出文件
with open(output_file, "w", encoding="utf-8") as f:
f.write(output_text)
# 按文件名称顺序排序
file_list = os.listdir(dir_to_translate)
sorted_file_list = sorted(file_list)
# print(sorted_file_list)
try:
# 创建一个外部列表文件，存放已处理的 Markdown 文件名列表
if not os.path.exists(processed_list):
with open(processed_list, "w", encoding="utf-8") as f:
print("processed_list created")
sys.stdout.flush()
# 遍历目录下的所有.md文件，并进行翻译
for filename in sorted_file_list:
if filename.endswith(".md"):
input_file = os.path.join(dir_to_translate, filename)
# 读取 Markdown 文件的内容
with open(input_file, "r", encoding="utf-8") as f:
md_content = f.read()
# 读取processed_list内容
with open(processed_list, "r", encoding="utf-8") as f:
processed_list_content = f.read()
if marker_force_translate in md_content: # 如果有强制翻译的标识，则执行这部分的代码
# 删除这个提示字段
md_content = md_content.replace(marker_force_translate, "")
# 将删除marker_force_translate后的内容写回原文件
# with open(filename, "w", encoding="utf-8") as f:
# f.write(md_content)
if marker_written_in_en in md_content: # 翻译为除英文之外的语言
print("Pass the en-en translation: ", filename)
sys.stdout.flush()
md_content = md_content.replace(marker_written_in_en, "") # 删除这个字段
translate_file(input_file, filename, "ja")
else: # 翻译为所有语言
translate_file(input_file, filename, "en")
translate_file(input_file, filename, "ja")
elif filename in exclude_list: # 不进行翻译
print(f"Pass the post in exclude_list: {filename}")
sys.stdout.flush()
elif filename in processed_list_content: # 不进行翻译
print(f"Pass the post in processed_list: {filename}")
sys.stdout.flush()
elif marker_written_in_en in md_content: # 翻译为除英文之外的语言
print(f"Pass the en-en translation: {filename}")
sys.stdout.flush()
md_content = md_content.replace(marker_written_in_en, "") # 删除这个字段
for lang in ["ja"]:
translate_file(input_file, filename, lang)
else: # 翻译为所有语言
for lang in ["en", "ja"]:
translate_file(input_file, filename, lang)
# 将处理完成的文件名加到列表，下次跳过不处理
if filename not in processed_list_content:
print(f"Added into processed_list: {filename}")
with open(processed_list, "a", encoding="utf-8") as f:
f.write("\n")
f.write(filename)
# 强制将缓冲区中的数据刷新到终端中，使用 GitHub Action 时方便实时查看过程
sys.stdout.flush()
except Exception as e:
# 捕获异常并输出错误信息
print(f"An error has occurred: {e}")
sys.stdout.flush()
raise SystemExit(1) # 1 表示非正常退出，可以根据需要更改退出码
# os.remove(input_file) # 删除源文件 | [
"Translate the following text into PLACEHOLDER, maintain the original markdown format.\n\nPLACEHOLDER\n\nPLACEHOLDER:"
] |
2024-01-10 | anudeep22003/poc-pdf-chatbot | app1.py | from langchain.llms import OpenAI
from agents import Agent, classification_agent
from indexer import BuildRagIndex, index_to_product_mapping, product_descriptions
from fastapi import FastAPI
from pydantic import BaseModel, Field
import json
from flask import Flask, make_response, jsonify
from flask import request
import json
from flask_cors import CORS
from utils import documents_to_index
import logging
logger = logging.getLogger(__name__)
logger.setLevel(logging.INFO)
fh = logging.FileHandler("query.log", mode="a")
fh.setLevel(logging.INFO)
logger.addHandler(fh)
###### Pydantic base classes for FastAPI ######
class Message(BaseModel):
content: str
class Response(BaseModel):
content: str
product: str | None
sources: str | None
####################################################
app = Flask(__name__)
CORS(app)
@app.route("/")
def hello_world():
return "Hello, World!"
def _build_cors_preflight_response():
response = make_response()
response.headers.add("Access-Control-Allow-Origin", "*")
response.headers.add("Access-Control-Allow-Headers", "*")
response.headers.add("Access-Control-Allow-Methods", "*")
return response
# query = "What are the most important maintenance steps I need to do within one year?"
# query = "Something is wrong with the scanner. What should I do?"
def memory_refresher():
f = open("memory.txt", "w")
f.close()
def memory_getter() -> Message | None:
f = open("memory.txt", "r")
memory = f.read()
f.close()
if memory == "":
# return means this is a new request
return None
else:
memory = json.loads(memory)
return Message(**memory)
def memory_writer(memory: Message):
with open("memory.txt", "w") as f:
f.write(json.dumps(memory.dict()))
def get_classification(message: Message) -> Response:
product_that_query_is_about = classification_agent(message.content)
product_that_query_is_about = product_that_query_is_about.strip()
logger.debug(f"product_that_query_is_about: {product_that_query_is_about}")
# appropriate rag index
try:
index_id = index_to_product_mapping[product_that_query_is_about]
msg1 = f"You seem to be asking about {product_that_query_is_about}. Press enter if I got it right. \n\nIf not type `no`, and I will try asking the question again.\n\nI am fairly capable, so help me with a few contextual clues and I'll figure it out."
return {"content":msg1, "product":product_that_query_is_about, "sources":None}
except KeyError:
msg1 = f"Sorry, I cannot seem to find the product you are asking about in my database.\n\n"
msg2 = f"As reference, I only have the following products in my database:\n{list(index_to_product_mapping.keys())}"
msg3 = f"\n\nPlease try again. It may help to give any identifying infromation about the product for my benefit."
return {"content":f"{msg1}{msg2}{msg3}", "product":None, "sources":None}
def perform_rag_call(message: Message) -> Response:
# response query initialize
response_query = []
# find the appropriate index for the product
product_that_query_is_about = classification_agent(message.content)
product_that_query_is_about = product_that_query_is_about.strip()
print(f"product_that_query_is_about: {product_that_query_is_about}")
# appropriate rag index
try:
index_id = index_to_product_mapping[product_that_query_is_about]
msg1 = f"Product: {product_that_query_is_about}.\n\n"
except KeyError:
msg1 = f"Sorry, I cannot seem to find the product you are asking about in my database."
msg2 = f"I only have the following products in my database: {list(index_to_product_mapping.keys())}"
msg3 = f"Please try again. It may help to give any identifying infromation about the product for my lookup benefit."
response_query.extend([msg1, msg2, msg3])
response_obj = {
"content": "\n\n".join(response_query),
"product": None,
"sources": None,
}
logger.info(response_obj)
logger.info(f"\n {'-'*30}\n")
return response_obj
b = BuildRagIndex(index_id)
response_text, page_numbers = b.query(message.content)
# sort page numbers for presentation
page_numbers = sorted(page_numbers)
response_query.append(msg1)
response_query.append(response_text)
response_obj = {
"content": "\n\n".join(response_query),
"product": product_that_query_is_about,
"sources": ", ".join([str(page_num) for page_num in page_numbers]),
}
logger.info(response_obj)
logger.info(f"\n {'-'*30}\n")
return response_obj
class Dict2Class(object):
def __init__(self, my_dict):
for key in my_dict:
setattr(self, key, my_dict[key])
@app.route("/chat", methods=["POST", "OPTIONS"])
def get_response() -> dict | Response | None:
if request.method == "OPTIONS": # CORS preflight
return _build_cors_preflight_response()
else:
print("Hello")
# postData = json.loads(request.data)
bytes_data = request.data
json_obj = request.get_json()
passed_to_message = jsonify(request.get_json())
message = Message(content=json_obj["content"])
print(message)
# print(postData)
# message = Dict2Class(postData)
memory = memory_getter()
if memory is None:
print("memory is None, hence doing classification")
# means this is a fresh request
# send a classification response
memory_writer(message)
response_msg = get_classification(message)
if "sorry" in response_msg["content"].lower():
memory_refresher()
return response_msg
return response_msg
elif message.content.strip().lower() in ["n", "no"]:
memory_refresher()
return {
"content":"Sorry for getting it wrong, request you to try asking your question again.\n\n",
"product":None,
"source":None,
}
elif message.content.strip().lower() in ["", "y", "yes"]:
# switch the message so as to reset the memory for the next call
memory_refresher()
# perform the rag call
return perform_rag_call(memory)
else:
memory_refresher()
return {
"content":"\nApologoes for the hiccup. Needed to reset my memory there. I am ready now. Please ask me again.",
"product":None,
"sources":None
}
class ConversationHandler:
def __init__(self, message: Message):
self.memory: Message | None = None
if __name__ == "__main__":
app.run(host="0.0.0.0", port=8000)
| [
"\n\n",
"\nApologoes for the hiccup. Needed to reset my memory there. I am ready now. Please ask me again.",
"Sorry for getting it wrong, request you to try asking your question again.\n\n",
"PLACEHOLDERPLACEHOLDERPLACEHOLDER",
"content"
] |
2024-01-10 | MarcosSalib/Cocktail_MOOC | Informatics~Reinforcement%20Learning~Practical%20RL%20-%20HSE~week3_model_free~qlearning.py | #!/usr/bin/env python
# coding: utf-8
# ## Q-learning
#
# This notebook will guide you through implementation of vanilla Q-learning algorithm.
#
# You need to implement QLearningAgent (follow instructions for each method) and use it on a number of tests below.
# In[1]:
import sys, os
if 'google.colab' in sys.modules and not os.path.exists('.setup_complete'):
get_ipython().system('wget -q https://raw.githubusercontent.com/yandexdataschool/Practical_RL/spring20/setup_colab.sh -O- | bash')
get_ipython().system('wget -q https://raw.githubusercontent.com/yandexdataschool/Practical_RL/coursera/grading.py -O ../grading.py')
get_ipython().system('wget -q https://raw.githubusercontent.com/yandexdataschool/Practical_RL/coursera/week3_model_free/submit.py')
get_ipython().system('touch .setup_complete')
# This code creates a virtual display to draw game images on.
# It will have no effect if your machine has a monitor.
if type(os.environ.get("DISPLAY")) is not str or len(os.environ.get("DISPLAY")) == 0:
get_ipython().system('bash ../xvfb start')
os.environ['DISPLAY'] = ':1'
# In[2]:
import numpy as np
import matplotlib.pyplot as plt
get_ipython().run_line_magic('matplotlib', 'inline')
# In[16]:
from collections import defaultdict
import random
import math
import numpy as np
class QLearningAgent:
def __init__(self, alpha, epsilon, discount, get_legal_actions):
"""
Q-Learning Agent
based on https://inst.eecs.berkeley.edu/~cs188/sp19/projects.html
Instance variables you have access to
- self.epsilon (exploration prob)
- self.alpha (learning rate)
- self.discount (discount rate aka gamma)
Functions you should use
- self.get_legal_actions(state) {state, hashable -> list of actions, each is hashable}
which returns legal actions for a state
- self.get_qvalue(state,action)
which returns Q(state,action)
- self.set_qvalue(state,action,value)
which sets Q(state,action) := value
!!!Important!!!
Note: please avoid using self._qValues directly.
There's a special self.get_qvalue/set_qvalue for that.
"""
self.get_legal_actions = get_legal_actions
self._qvalues = defaultdict(lambda: defaultdict(lambda: 0))
self.alpha = alpha
self.epsilon = epsilon
self.discount = discount
def get_qvalue(self, state, action):
""" Returns Q(state,action) """
return self._qvalues[state][action]
def set_qvalue(self, state, action, value):
""" Sets the Qvalue for [state,action] to the given value """
self._qvalues[state][action] = value
#---------------------START OF YOUR CODE---------------------#
def get_value(self, state):
"""
Compute your agent's estimate of V(s) using current q-values
V(s) = max_over_action Q(state,action) over possible actions.
Note: please take into account that q-values can be negative.
"""
possible_actions = self.get_legal_actions(state)
# If there are no legal actions, return 0.0
if len(possible_actions) == 0:
return 0.0
value = max([self.get_qvalue(state, action) for action in possible_actions])
return value
def update(self, state, action, reward, next_state):
"""
You should do your Q-Value update here:
Q(s,a) := (1 - alpha) * Q(s,a) + alpha * (r + gamma * V(s'))
"""
# agent parameters
gamma = self.discount
learning_rate = self.alpha
q_value = (1-learning_rate)*self.get_qvalue(state,action) + learning_rate * (reward + gamma * self.get_value(next_state))
self.set_qvalue(state, action, q_value)
def get_best_action(self, state):
"""
Compute the best action to take in a state (using current q-values).
"""
possible_actions = self.get_legal_actions(state)
# If there are no legal actions, return None
if len(possible_actions) == 0:
return None
best_action_idx = np.argmax([self.get_qvalue(state, action) for action in possible_actions])
best_action = possible_actions[best_action_idx]
return best_action
def get_action(self, state):
"""
Compute the action to take in the current state, including exploration.
With probability self.epsilon, we should take a random action.
otherwise - the best policy action (self.get_best_action).
Note: To pick randomly from a list, use random.choice(list).
To pick True or False with a given probablity, generate uniform number in [0, 1]
and compare it with your probability
"""
# Pick Action
possible_actions = self.get_legal_actions(state)
action = None
# If there are no legal actions, return None
if len(possible_actions) == 0:
return None
# agent parameters:
epsilon = self.epsilon
if random.random() <= epsilon:
chosen_action = np.random.choice(possible_actions)
else:
chosen_action = self.get_best_action(state)
return chosen_action
# ### Try it on taxi
#
# Here we use the qlearning agent on taxi env from openai gym.
# You will need to insert a few agent functions here.
# In[4]:
import gym
try:
env = gym.make('Taxi-v3')
except gym.error.DeprecatedEnv:
# Taxi-v2 was replaced with Taxi-v3 in gym 0.15.0
env = gym.make('Taxi-v2')
n_actions = env.action_space.n
# In[5]:
agent = QLearningAgent(alpha=0.5, epsilon=0.25, discount=0.99,
get_legal_actions=lambda s: range(n_actions))
# In[6]:
def play_and_train(env, agent, t_max=10**4):
"""
This function should
- run a full game, actions given by agent's e-greedy policy
- train agent using agent.update(...) whenever it is possible
- return total reward
"""
total_reward = 0.0
s = env.reset()
for t in range(t_max):
# get agent to pick action given state s.
a = agent.get_action(s)
next_s, r, done, _ = env.step(a)
# train (update) agent for state s
agent.update(s, a, r, next_s)
s = next_s
total_reward += r
if done:
break
return total_reward
# In[7]:
from IPython.display import clear_output
rewards = []
for i in range(1000):
rewards.append(play_and_train(env, agent))
agent.epsilon *= 0.99
if i % 100 == 0:
clear_output(True)
print('eps =', agent.epsilon, 'mean reward =', np.mean(rewards[-10:]))
plt.plot(rewards)
plt.show()
# ### Submit to Coursera I: Preparation
# In[8]:
submit_rewards1 = rewards.copy()
# # Binarized state spaces
#
# Use agent to train efficiently on CartPole-v0.
# This environment has a continuous set of possible states, so you will have to group them into bins somehow.
#
# The simplest way is to use `round(x,n_digits)` (or numpy round) to round real number to a given amount of digits.
#
# The tricky part is to get the n_digits right for each state to train effectively.
#
# Note that you don't need to convert state to integers, but to __tuples__ of any kind of values.
# In[9]:
env = gym.make("CartPole-v0")
n_actions = env.action_space.n
print("first state:%s" % (env.reset()))
plt.imshow(env.render('rgb_array'))
# ### Play a few games
#
# We need to estimate observation distributions. To do so, we'll play a few games and record all states.
# In[10]:
all_states = []
for _ in range(1000):
all_states.append(env.reset())
done = False
while not done:
s, r, done, _ = env.step(env.action_space.sample())
all_states.append(s)
if done:
break
all_states = np.array(all_states)
for obs_i in range(env.observation_space.shape[0]):
plt.hist(all_states[:, obs_i], bins=20)
plt.show()
# ## Binarize environment
# In[11]:
from gym.core import ObservationWrapper
class Binarizer(ObservationWrapper):
def observation(self, state):
# state = <round state to some amount digits.>
# hint: you can do that with round(x,n_digits)
# you will need to pick a different n_digits for each dimension
state[0] = np.round(state[0],0)
state[1] = np.round(state[1],1)
state[2] = np.round(state[2],2)
state[3] = np.round(state[3],0)
return tuple(state)
# In[12]:
env = Binarizer(gym.make("CartPole-v0"))
# In[14]:
all_states = []
for _ in range(1000):
all_states.append(env.reset())
done = False
while not done:
s, r, done, _ = env.step(env.action_space.sample())
all_states.append(s)
if done:
break
all_states = np.array(all_states)
for obs_i in range(env.observation_space.shape[0]):
plt.hist(all_states[:, obs_i], bins=20)
plt.show()
# ## Learn binarized policy
#
# Now let's train a policy that uses binarized state space.
#
# __Tips:__
# * If your binarization is too coarse, your agent may fail to find optimal policy. In that case, change binarization.
# * If your binarization is too fine-grained, your agent will take much longer than 1000 steps to converge. You can either increase number of iterations and decrease epsilon decay or change binarization.
# * Having 10^3 ~ 10^4 distinct states is recommended (`len(QLearningAgent._qvalues)`), but not required.
# * A reasonable agent should get to an average reward of >=50.
# In[19]:
agent = QLearningAgent(alpha=0.5, epsilon=0.25, discount=0.99,
get_legal_actions=lambda s: range(n_actions))
# In[20]:
# decay function for epsilon
eps_list = []
eps = 0.35
decay = 0.99999
for i in range(10000):
eps = eps*decay**(i)
eps_list.append(eps)
plt.plot(eps_list)
# In[21]:
rewards = []
for i in range(1000):
# OPTIONAL YOUR CODE: adjust epsilon
agent.epsilon = agent.epsilon*decay**(i)
rewards.append(play_and_train(env, agent))
if i % 100 == 0:
clear_output(True)
print('eps =', agent.epsilon, 'mean reward =', np.mean(rewards[-10:]))
plt.plot(rewards)
plt.show()
# ### Submit to Coursera II: Submission
# In[22]:
submit_rewards2 = rewards.copy()
# In[41]:
from submit import submit_qlearning
submit_qlearning(submit_rewards1, submit_rewards2, '[email protected]', '3pQNXC5R0DLmEf9W')
# In[ ]:
| [] |
2024-01-10 | ceramicwhite/Auto-GPT | benchmark~agbenchmark~utils~challenge.py | import glob
import math
import os
import subprocess
import sys
from abc import ABC
from pathlib import Path
from typing import Any, Dict, List
import openai
import pytest
from agbenchmark.__main__ import OPTIONAL_CATEGORIES, TEMP_FOLDER_ABS_PATH
from agbenchmark.agent_api_interface import run_api_agent
from agbenchmark.utils.data_types import ChallengeData, Ground
from agbenchmark.utils.prompts import (
END_PROMPT,
FEW_SHOT_EXAMPLES,
PROMPT_MAP,
SCORING_MAP,
)
from agbenchmark.utils.utils import agent_eligibible_for_optional_categories
class Challenge(ABC):
"""The parent class to all specific challenges classes.
Defines helper methods for running a challenge"""
_data_cache: Dict[str, ChallengeData] = {}
CHALLENGE_LOCATION: str = ""
scores: dict[str, Any] = {} # this is for suites
@property
def data(self) -> ChallengeData:
if self.CHALLENGE_LOCATION not in self._data_cache:
self._data_cache[self.CHALLENGE_LOCATION] = ChallengeData.deserialize(
self.CHALLENGE_LOCATION
)
return self._data_cache[self.CHALLENGE_LOCATION]
@property
def task(self) -> str:
return self.data.task
@property
def dependencies(self) -> list:
return self.data.dependencies
async def setup_challenge(self, config: Dict[str, Any], cutoff: int) -> None:
from agbenchmark.agent_interface import copy_artifacts_into_temp_folder
artifact_paths = [
self.ARTIFACTS_LOCATION,
str(Path(self.CHALLENGE_LOCATION).parent),
]
if not self.task:
return
print(
f"\033[1;35m============Starting {self.data.name} challenge============\033[0m"
)
print(f"\033[1;30mTask: {self.task}\033[0m")
await run_api_agent(self.data, config, self.ARTIFACTS_LOCATION, cutoff)
# hidden files are added after the agent runs. Hidden files can be python test files.
# We copy them in the temporary folder to make it easy to import the code produced by the agent
for path in artifact_paths:
copy_artifacts_into_temp_folder(TEMP_FOLDER_ABS_PATH, "custom_python", path)
def test_method(self, config: Dict[str, Any]) -> None:
raise NotImplementedError
def get_artifacts_out(
self, workspace: str | dict[str, str], ground: Ground
) -> List[str]:
if isinstance(workspace, dict):
workspace = workspace["output"]
script_dir = workspace
files_contents = []
for file_pattern in ground.files:
# Check if it is a file extension
if file_pattern.startswith("."):
# Find all files with the given extension in the workspace
matching_files = glob.glob(os.path.join(script_dir, "*" + file_pattern))
else:
# Otherwise, it is a specific file
matching_files = [os.path.join(script_dir, file_pattern)]
for file_path in matching_files:
if ground.eval.type == "python":
result = subprocess.run(
[sys.executable, file_path],
cwd=os.path.abspath(workspace),
capture_output=True,
text=True,
)
if "error" in result.stderr or result.returncode != 0:
print(result.stderr)
assert False, result.stderr
files_contents.append(f"Output: {result.stdout}\n")
else:
with open(file_path, "r") as f:
files_contents.append(f.read())
else:
if ground.eval.type == "pytest":
result = subprocess.run(
[sys.executable, "-m", "pytest"],
cwd=TEMP_FOLDER_ABS_PATH,
capture_output=True,
text=True,
)
if "error" in result.stderr or result.returncode != 0:
print(result.stderr)
assert False, result.stderr
files_contents.append(f"Output: {result.stdout}\n")
return files_contents
def scoring(self, config: Dict[str, Any], content: str, ground: Ground) -> float:
print("\033[1;34mScoring content:\033[0m", content)
if ground.should_contain:
for should_contain_word in ground.should_contain:
print_content = (
f"\033[1;34mWord that should exist\033[0m - {should_contain_word}:"
)
if should_contain_word not in content:
print(print_content, "False")
return 0.0
else:
print(print_content, "True")
if ground.should_not_contain:
for should_not_contain_word in ground.should_not_contain:
print_content = f"\033[1;34mWord that should not exist\033[0m - {should_not_contain_word}:"
if should_not_contain_word in content:
print(print_content, "False")
return 0.0
else:
print(print_content, "True")
return 1.0
def llm_eval(self, config: Dict[str, Any], content: str, ground: Ground) -> float:
openai.api_key = os.getenv("OPENAI_API_KEY")
if "--mock" in sys.argv:
return 1.0
# the validation for this is done in the Eval BaseModel
scoring = SCORING_MAP[ground.eval.scoring] # type: ignore
prompt = PROMPT_MAP[ground.eval.template].format(task=self.data.task, scoring=scoring, answer=ground.answer, response=content) # type: ignore
if ground.eval.examples:
prompt += FEW_SHOT_EXAMPLES.format(examples=ground.eval.examples)
prompt += END_PROMPT
answer = openai.ChatCompletion.create(
model="gpt-4",
messages=[
{"role": "system", "content": prompt},
],
)
return float(answer["choices"][0]["message"]["content"]) # type: ignore
def get_scores(self, config: Dict[str, Any]) -> dict[str, Any]:
scores = []
scores_dict: Any = {}
percentage = None
answers = {}
try:
if self.data.task == "" and "--mock" in sys.argv:
scores = [1.0]
answers = {"mock": "This is a mock answer"}
elif isinstance(self.data.ground, Ground):
files_contents = self.get_artifacts_out(
TEMP_FOLDER_ABS_PATH, self.data.ground
)
answers = {"answer": files_contents}
for file_content in files_contents:
score = self.scoring(config, file_content, self.data.ground)
print("\033[1;32mYour score is:\033[0m", score)
scores.append(score)
if self.data.ground.eval.type == "llm":
llm_eval = self.llm_eval(
config, "\n".join(files_contents), self.data.ground
)
if self.data.ground.eval.scoring == "percentage":
scores.append(math.ceil(llm_eval / 100))
elif self.data.ground.eval.scoring == "scale":
scores.append(math.ceil(llm_eval / 10))
print("\033[1;32mYour score is:\033[0m", llm_eval)
scores.append(llm_eval)
except Exception as e:
print("Error getting scores", e)
scores_data = {
"values": scores,
"scores_obj": scores_dict,
"percentage": percentage,
"answers": answers,
}
self.scores[self.__class__.__name__] = scores_data
return scores_data
def get_dummy_scores(self, test_name: str, scores: dict[str, Any]) -> int | None:
return 1 # remove this once this works
if 1 in scores.get("scores_obj", {}).get(test_name, []):
return 1
return None
def skip_optional_categories(self, config: Dict[str, Any]) -> None:
challenge_category = self.data.category
categories = [
category
for category in OPTIONAL_CATEGORIES
if category in challenge_category
]
if not agent_eligibible_for_optional_categories(
categories, config.get("category", [])
):
pytest.skip("Agent is not eligible for this category")
| [] |
2024-01-10 | ceramicwhite/Auto-GPT | autogpts~autogpt~autogpt~llm~api_manager.py | from __future__ import annotations
import logging
from typing import List, Optional
import openai
from openai import Model
from autogpt.llm.base import CompletionModelInfo
from autogpt.singleton import Singleton
logger = logging.getLogger(__name__)
class ApiManager(metaclass=Singleton):
def __init__(self):
self.total_prompt_tokens = 0
self.total_completion_tokens = 0
self.total_cost = 0
self.total_budget = 0
self.models: Optional[list[Model]] = None
def reset(self):
self.total_prompt_tokens = 0
self.total_completion_tokens = 0
self.total_cost = 0
self.total_budget = 0.0
self.models = None
def update_cost(self, prompt_tokens, completion_tokens, model):
"""
Update the total cost, prompt tokens, and completion tokens.
Args:
prompt_tokens (int): The number of tokens used in the prompt.
completion_tokens (int): The number of tokens used in the completion.
model (str): The model used for the API call.
"""
# the .model property in API responses can contain version suffixes like -v2
from autogpt.llm.providers.openai import OPEN_AI_MODELS
model = model[:-3] if model.endswith("-v2") else model
model_info = OPEN_AI_MODELS[model]
self.total_prompt_tokens += prompt_tokens
self.total_completion_tokens += completion_tokens
self.total_cost += prompt_tokens * model_info.prompt_token_cost / 1000
if isinstance(model_info, CompletionModelInfo):
self.total_cost += (
completion_tokens * model_info.completion_token_cost / 1000
)
logger.debug(f"Total running cost: ${self.total_cost:.3f}")
def set_total_budget(self, total_budget):
"""
Sets the total user-defined budget for API calls.
Args:
total_budget (float): The total budget for API calls.
"""
self.total_budget = total_budget
def get_total_prompt_tokens(self):
"""
Get the total number of prompt tokens.
Returns:
int: The total number of prompt tokens.
"""
return self.total_prompt_tokens
def get_total_completion_tokens(self):
"""
Get the total number of completion tokens.
Returns:
int: The total number of completion tokens.
"""
return self.total_completion_tokens
def get_total_cost(self):
"""
Get the total cost of API calls.
Returns:
float: The total cost of API calls.
"""
return self.total_cost
def get_total_budget(self):
"""
Get the total user-defined budget for API calls.
Returns:
float: The total budget for API calls.
"""
return self.total_budget
def get_models(self, **openai_credentials) -> List[Model]:
"""
Get list of available GPT models.
Returns:
list: List of available GPT models.
"""
if self.models is None:
all_models = openai.Model.list(**openai_credentials)["data"]
self.models = [model for model in all_models if "gpt" in model["id"]]
return self.models
| [] |
2024-01-10 | AI-Citizen/SolidGPT | solidgpt~src~workgraph~graph.py | import os
import glob
import openai
from solidgpt.definitions import LOCAL_STORAGE_OUTPUT_DIR, TEST_SKILL_WORKSPACE
from solidgpt.src.manager.gptmanager import GPTManager
from solidgpt.src.util.util import save_to_json
from solidgpt.src.workgraph.workgraph import WorkGraph
from solidgpt.src.worknode.worknode import WorkNode
from solidgpt.src.workskill.skillio import SkillInputConfig, SkillInputLoadingMethod
from solidgpt.src.workskill.skills.analysis import ProductAnalysis
from solidgpt.src.workskill.skills.load_repo import LoadRepo
from solidgpt.src.workskill.skills.query_code_local import QueryCodeLocal
from solidgpt.src.workskill.skills.repo_chat import RepoChat
from solidgpt.src.workskill.skills.summarize_file import SummaryFile
from solidgpt.src.workskill.skills.summary_file_local import SummaryFileLocal
from solidgpt.src.workskill.skills.summary_project import SummaryProject
from solidgpt.src.workskill.skills.techsolution import ProvideTechSolution
from solidgpt.src.workskill.skills.write_prd import WritePRD
from solidgpt.src.workskill.skills.autogen_analysis import AutoGenAnalysis
from solidgpt.src.workskill.workskill import WorkSkill
def generate_node(node_id: str, skill: WorkSkill, input_configs: list[SkillInputConfig], output_ids: list[int], manual_review_result: bool = False):
skill.init_config(
[
config.to_dict() for config in input_configs
],
[
{"id": output_id} for output_id in output_ids
])
node: WorkNode = WorkNode(node_id, skill, manual_review_result)
return node
def generate_node_with_output_configs(node_id: str, skill: WorkSkill, input_configs: list[SkillInputConfig], output_configs: list, manual_review_result: bool = False):
skill.init_config(
[
config.to_dict() for config in input_configs
],
[
config_dict for config_dict in output_configs
])
node: WorkNode = WorkNode(node_id, skill, manual_review_result)
return node
def build_onboarding_graph(repo_path: str, onborading_graph_id: str, upload_id: str, enable_summary_code: bool = False):
graph = WorkGraph(output_id=onborading_graph_id)
# input_ids = [-1] means the input is from the user
load_repo = generate_node("0", LoadRepo(), [SkillInputConfig(os.path.join(repo_path, upload_id),
SkillInputLoadingMethod.LOAD_FROM_STRING, -1)], [0])
summary_project = generate_node_with_output_configs("1", SummaryProject(),
[
SkillInputConfig("", SkillInputLoadingMethod.LOAD_FROM_OUTPUT_ID, 0)
],
[
{"id": 1},
{"id": 2, "to_display": True}
])
graph.add_node(load_repo)
graph.add_node(summary_project)
if enable_summary_code:
summary_code = generate_node("2", SummaryFileLocal(), [SkillInputConfig("", SkillInputLoadingMethod.LOAD_FROM_CACHE_STRING, -1, onborading_graph_id),
SkillInputConfig("", SkillInputLoadingMethod.LOAD_FROM_OUTPUT_ID, 0)], [3, 4])
graph.add_node(summary_code)
return graph
def build_prd_graph(requirement: str, project_additional_info: str, onborading_graph_id: str):
graph = WorkGraph(output_id=onborading_graph_id)
onboarding_folder_path = os.path.join(LOCAL_STORAGE_OUTPUT_DIR, onborading_graph_id)
code_summary_path = glob.glob(os.path.join(onboarding_folder_path, 'Summary_project_*', "Code_Summary_*"))[0]
analysis_product = generate_node("0", ProductAnalysis(),
[
SkillInputConfig(code_summary_path, SkillInputLoadingMethod.LOAD_FROM_STRING, -1),
SkillInputConfig("", SkillInputLoadingMethod.LOAD_FROM_CACHE_STRING, -1, project_additional_info),
SkillInputConfig("", SkillInputLoadingMethod.LOAD_FROM_CACHE_STRING, -1, requirement),
], output_ids= [0])
write_prd = generate_node("1", WritePRD(), [SkillInputConfig("", SkillInputLoadingMethod.LOAD_FROM_OUTPUT_ID, 0)], output_ids=[1])
graph.add_node(analysis_product)
graph.add_node(write_prd)
return graph
def build_prd_graph_with_stage(requirement: str, project_additional_info: str, onboarding_graph_id: str, stage: int,
edit_content: str, output_id: str):
graph = WorkGraph(output_id=output_id)
onboarding_folder_path = os.path.join(LOCAL_STORAGE_OUTPUT_DIR, onboarding_graph_id)
code_summary_path = glob.glob(os.path.join(onboarding_folder_path, 'Summary_project_*', "Code_Summary_*"))[0]
if stage == 0:
analysis_product = generate_node_with_output_configs("0", ProductAnalysis(),
[
SkillInputConfig(code_summary_path, SkillInputLoadingMethod.LOAD_FROM_STRING, -1),
SkillInputConfig("", SkillInputLoadingMethod.LOAD_FROM_CACHE_STRING, -1, project_additional_info),
SkillInputConfig("", SkillInputLoadingMethod.LOAD_FROM_CACHE_STRING, -1, requirement),
],
[
{"id": 0, "to_display": True}
])
graph.add_node(analysis_product)
return graph
elif stage == 1:
write_prd = generate_node_with_output_configs("1", WritePRD(),
[
SkillInputConfig("", SkillInputLoadingMethod.LOAD_FROM_CACHE_STRING, -1, edit_content)
],
[
{"id": 1, "to_display": True}
])
graph.add_node(write_prd)
return graph
return None
def build_tech_solution_graph(requirement: str, onboarding_graph_id: str, output_id: str):
graph = WorkGraph(output_id=output_id)
onboarding_folder_path = os.path.join(LOCAL_STORAGE_OUTPUT_DIR, onboarding_graph_id)
code_shema_path = glob.glob(os.path.join(onboarding_folder_path, 'Summary_project_*', "Code_Schema_*"))[0]
code_summary_path = glob.glob(os.path.join(onboarding_folder_path, 'Summary_project_*', "Code_Summary_*"))[0]
query_code = generate_node("0", QueryCodeLocal(),
[
SkillInputConfig("", SkillInputLoadingMethod.LOAD_FROM_CACHE_STRING, -1, onboarding_graph_id),
SkillInputConfig("", SkillInputLoadingMethod.LOAD_FROM_CACHE_STRING, -1, requirement),
], output_ids=[0])
tech_solution = generate_node_with_output_configs("1", ProvideTechSolution(),
[
SkillInputConfig(code_shema_path, SkillInputLoadingMethod.LOAD_FROM_STRING, -1),
SkillInputConfig(code_summary_path, SkillInputLoadingMethod.LOAD_FROM_STRING, -1),
SkillInputConfig("", SkillInputLoadingMethod.LOAD_FROM_CACHE_STRING, -1, requirement)
],
[
{"id": 1, "to_display": True}
])
graph.add_node(query_code)
graph.add_node(tech_solution)
return graph
def build_repo_chat_graph(requirement: str, onboarding_graph_id: str, output_id: str):
graph = WorkGraph(output_id=output_id)
onboarding_folder_path = os.path.join(LOCAL_STORAGE_OUTPUT_DIR, onboarding_graph_id)
code_shema_path = glob.glob(os.path.join(onboarding_folder_path, 'Summary_project_*', "Code_Schema_*"))[0]
code_summary_path = glob.glob(os.path.join(onboarding_folder_path, 'Summary_project_*', "Code_Summary_*"))[0]
history_context_path = os.path.join(onboarding_folder_path, f'{onboarding_graph_id}_repochat.json')
# Create history context json file if not exist
# Define the path to the JSON file
history_context_path = os.path.join(onboarding_folder_path, f'{onboarding_graph_id}_repochat.json')
# Check if the file already exists
if not os.path.exists(history_context_path):
# Create a default JSON data structure if the file doesn't exist
default_data = {"HistoryContent": []}
save_to_json(default_data, history_context_path)
query_code = generate_node("0", QueryCodeLocal(),
[
SkillInputConfig("", SkillInputLoadingMethod.LOAD_FROM_CACHE_STRING, -1, onboarding_graph_id),
SkillInputConfig("", SkillInputLoadingMethod.LOAD_FROM_CACHE_STRING, -1, requirement),
], output_ids=[0])
tech_solution = generate_node_with_output_configs("1", RepoChat(),
[
SkillInputConfig(code_shema_path, SkillInputLoadingMethod.LOAD_FROM_STRING, -1),
SkillInputConfig(code_summary_path, SkillInputLoadingMethod.LOAD_FROM_STRING, -1),
SkillInputConfig("", SkillInputLoadingMethod.LOAD_FROM_CACHE_STRING, -1, requirement),
SkillInputConfig(history_context_path, SkillInputLoadingMethod.LOAD_FROM_STRING, -1),
],
[
{"id": 1, "to_display": True}
])
graph.add_node(query_code)
graph.add_node(tech_solution)
return graph
def build_autogen_analysis_graph(requirement: str, onboarding_graph_id: str, output_id: str,
autogen_message_input_callback, autogen_update_result_callback):
graph = WorkGraph(output_id=output_id)
onboarding_folder_path = os.path.join(LOCAL_STORAGE_OUTPUT_DIR, onboarding_graph_id)
code_shema_path = glob.glob(os.path.join(onboarding_folder_path, 'Summary_project_*', "Code_Schema_*"))[0]
code_summary_path = glob.glob(os.path.join(onboarding_folder_path, 'Summary_project_*', "Code_Summary_*"))[0]
query_code = generate_node("0", QueryCodeLocal(),
[
SkillInputConfig("", SkillInputLoadingMethod.LOAD_FROM_CACHE_STRING, -1,
onboarding_graph_id),
SkillInputConfig("", SkillInputLoadingMethod.LOAD_FROM_CACHE_STRING, -1,
requirement),
], output_ids=[0])
autogen_solution = generate_node_with_output_configs("1", AutoGenAnalysis(),
[
SkillInputConfig(code_shema_path,
SkillInputLoadingMethod.LOAD_FROM_STRING,
-1),
SkillInputConfig(code_summary_path,
SkillInputLoadingMethod.LOAD_FROM_STRING,
-1),
SkillInputConfig("",
SkillInputLoadingMethod.LOAD_FROM_CACHE_STRING,
-1, requirement),
],
[])
graph.add_node(query_code)
graph.add_node(autogen_solution)
graph.custom_data["autogen_message_input_callback"] = autogen_message_input_callback
graph.custom_data["autogen_update_result_callback"] = autogen_update_result_callback
return graph
| [] |
2024-01-10 | AI-Citizen/SolidGPT | solidgpt~src~workskill~skills~summarize_file.py | import logging
import os
import shutil
import time
import openai
import uuid
from solidgpt.src.constants import SKILL_NAME_SUMMARY_FILE
from solidgpt.src.configuration.configreader import ConfigReader
from solidgpt.src.manager.gptmanager import GPTManager
from solidgpt.src.manager.blobmanager import AzureBlobManager
from solidgpt.src.manager.promptresource import SUMMARY_CODE_SUMMARY_PYTHON
from solidgpt.src.util.util import load_from_text, save_to_text
from solidgpt.src.workskill.skillio import SkillIOParamCategory, SkillInput, SkillOutput
from solidgpt.src.workskill.workskill import WorkSkill
from solidgpt.definitions import EMBEDDING_BLOB_CONTAINER, ROOT_DIR
from langchain.document_loaders import TextLoader
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import Qdrant
from qdrant_client import QdrantClient
from qdrant_client.http.models import PointStruct, Distance, VectorParams
class SummaryFile(WorkSkill):
Allowed_Extensions = [".py", ".js", ".jsx", "html", ".css", "ts", "tsx"]
Seperator = "**-****-****-****-**"
# Cache_Label_Summary_File = "summary_python_file"
onboarding_id: str = None
def __init__(self):
super().__init__()
self.name = SKILL_NAME_SUMMARY_FILE
self.gpt_manager = GPTManager._instance
self.onboarding_id_input = SkillInput(
"Onboarding ID",
SkillIOParamCategory.PlainText,
)
self.skill_input = SkillInput(
"Plain code text",
SkillIOParamCategory.CODE_PLAIN_TEXT,
)
self.add_input(self.onboarding_id_input)
self.add_input(self.skill_input)
self.skill_output1 = SkillOutput(
"Single python file summary",
SkillIOParamCategory.PlainText,
)
self.skill_output2 = SkillOutput(
"Single python code",
SkillIOParamCategory.PlainText,
)
self.add_output(self.skill_output1)
self.add_output(self.skill_output2)
self.repo_txt: str = None
self.file_list: list = []
CONNECTION_STRING = "DefaultEndpointsProtocol=https;AccountName=solidgptstorage;AccountKey=sMOfEXdwF7HwLIOSPSO52oVBHQXnyr4JbBxenbkHc95yNYY81p0u7AFD47lOth+WftQRubd7z9Gg+AStqs7eRw==;EndpointSuffix=core.windows.net"
self.manager = AzureBlobManager(CONNECTION_STRING)
self.qdrant_path = os.path.join(ROOT_DIR, "src", "tools", "qdrant", "embedding")
def _read_input(self):
input_path = self.get_input_path(self.skill_input)
self.repo_txt = load_from_text(input_path, extension=".txt")
self.onboarding_id = self.onboarding_id_input.content
# self.__download_from_azure(self.onboarding_id)
self.client = QdrantClient(path=os.path.join(self.qdrant_path, self.onboarding_id))
def execution_impl(self):
logging.info("Start to summary code...")
self.__extract_lines_after_sequence()
file_count = len(self.file_list)
current_file_idx = 0
for file in self.file_list:
current_file_idx += 1
if self.callback_func:
self.callback_func(current_file_idx, file_count)
if file[-3:] in self.Allowed_Extensions:
self.__summary_file(file)
self.client.close()
self.__upload_to_azure()
return
def __summary_file(self, filename):
py_file = self.__extract_file_content(filename)
real_name = filename[:-3]
real_name = real_name.translate(str.maketrans({"\\": "_", "/": "_"}))
# save_to_text(os.path.join(self.skill_output1.param_path, f"{real_name}%%CODE%%"), py_file)
if py_file is None:
logging.warn("No python file found")
return
python_summary = self.gpt_manager.create_and_chat_with_model(
prompt=SUMMARY_CODE_SUMMARY_PYTHON,
gpt_model_label="summary_python",
input_message=py_file
)
python_summary = python_summary.replace("\n", " ")
logging.info(f"Summary of python file: {python_summary}")
# save_to_text(os.path.join(self.skill_output1.param_path, f"{real_name}%%SUMMARY%%"), python_summary)
self.__embed_summary(real_name, python_summary, py_file)
return
def __embed_summary(self, filename, summary, code):
payload_dict = {"code": code, "summary": summary, "filename": filename}
embeddings_model = OpenAIEmbeddings(openai_api_key=openai.api_key)
embedded_query = embeddings_model.embed_query(summary)
logging.info(f"Onboarding ID:{self.onboarding_id}\nSave this id to retrieve embedded data later.")
try:
self.client.upsert(
collection_name=self.onboarding_id,
points=[
PointStruct(id=self.get_uuid(), vector=embedded_query, payload=payload_dict)
]
)
except ValueError:
self.client.recreate_collection(
collection_name=self.onboarding_id,
vectors_config=VectorParams(size=len(embedded_query), distance=Distance.COSINE),
)
self.client.upsert(
collection_name=self.onboarding_id,
points=[
PointStruct(id=self.get_uuid(), vector=embedded_query, payload=payload_dict)
]
)
return
def __download_from_azure(self, onboarding_id):
collections = self.manager.list_blobs(f"{EMBEDDING_BLOB_CONTAINER}")
print(collections)
if onboarding_id in collections:
files = self.manager.list_blobs(f"{EMBEDDING_BLOB_CONTAINER}/{onboarding_id}")
for file in files:
file_name_list = file.split("/")
download_file_path = os.path.join(self.qdrant_path, *file_name_list)
mkdir_path = os.path.join(self.qdrant_path, *file_name_list[:-1])
if not os.path.exists(mkdir_path):
os.makedirs(mkdir_path)
with open(file=download_file_path, mode="wb") as download_file:
download_file.write(self.manager.download_blob(f"{EMBEDDING_BLOB_CONTAINER}/{onboarding_id}", file))
return
def __upload_to_azure(self):
# Sample Usage
# manager.upload_blob("repos", "folder/sample.txt", "This is a sample text.", overwrite=True)
# print(manager.list_blobs("repos"))
files = self.list_all_dirs(self.qdrant_path)
for file in files:
relative_path = file.split(os.path.join(self.qdrant_path, ""))[1].replace("\\", "/")
with open(file, mode="rb") as data:
self.manager.upload_blob(f"{EMBEDDING_BLOB_CONTAINER}", relative_path, data, overwrite=True)
for file in files:
try:
# File is no longer in use, delete it
os.remove(file)
except Exception as e:
logging.info("Cannot remove file: " + file)
return
def __extract_lines_after_sequence(self):
lines = self.repo_txt.split('\n')
capture = False
captured_lines = []
for line in lines:
if capture:
captured_lines.append(line)
capture = False
if self.Seperator in line:
capture = True
self.file_list = captured_lines
return None
def __extract_file_content(self, filename):
# Split the text by the sequence
blocks = self.repo_txt.split(self.Seperator)
for block in blocks:
# Check the first line of each block
first_line = block.strip().split('\n')[0]
if first_line.lower() == filename:
# Remove the first line (filename) and return the rest
return '\n'.join(block.strip().split('\n')[1:])
return None # If no desired file is found
@staticmethod
def get_uuid():
return str(uuid.uuid4().hex)
@staticmethod
def list_all_dirs(path):
ret = []
visited = set()
stack = [path]
while stack:
cur_path = stack.pop()
visited.add(cur_path)
if os.path.isfile(cur_path):
ret.append(cur_path)
continue
neighbors = os.listdir(cur_path)
for neighbor in neighbors:
if neighbor not in visited:
neighbor_path = os.path.join(cur_path, neighbor)
stack.append(neighbor_path)
visited.add(neighbor_path)
return ret
| [] |
2024-01-10 | AI-Citizen/SolidGPT | solidgpt~src~diy~chatgpt_diy_finetune~chatgpt_train.py | import openai
import logging
import asyncio
class GPTFinetune:
def __init__(self, model_name, suffix_name, training_file_path):
self.training_file_id = None
self.model_name = model_name
self.suffix_name = suffix_name
self.job_id = None
self.training_file_path = training_file_path
openai.api_key = ConfigReader().get_property("openai_api_key")
async def start_fine_tuning(self):
await self.__upload_training_file()
model_details = openai.FineTuningJob.create(
training_file=self.training_file_id,
model=self.model_name,
suffix=self.suffix_name
)
self.job_id = model_details["id"]
logging.info("Fine-tuning job started: %s", self.job_id)
async def __upload_training_file(self):
training_response = await openai.File.create(
file=open(self.training_file_path, "rb"), purpose="fine-tune"
)
self.training_file_id = training_response["id"]
logging.info("Training file ID is ready: %s", self.training_file_id)
async def get_fine_tuning_status(self):
response = await openai.FineTuningJob.retrieve(self.job_id)
return response["status"]
# Sample
if __name__ == "__main__":
training_file_path = input("Enter the path to train.jsonl: ")
model_name = "gpt-3.5-turbo"
suffix_name = "Quantchat"
finetune_instance = GPTFinetune(model_name, suffix_name, training_file_path)
loop = asyncio.get_event_loop()
loop.run_until_complete(finetune_instance.start_fine_tuning())
async def wait_for_finetuning_complete():
while True:
status = await finetune_instance.get_fine_tuning_status()
logging.info("Fine-tuning status: %s", status)
if status == "succeeded" or status == "failed":
break
await asyncio.sleep(60)
loop.run_until_complete(wait_for_finetuning_complete())
| [] |
2024-01-10 | AI-Citizen/SolidGPT | solidgpt~src~workskill~skills~query_code_local.py | import logging
import os
import shutil
import openai
from solidgpt.definitions import ROOT_DIR
from solidgpt.src.constants import SKILL_NAME_QUERY_CODE
from solidgpt.src.configuration.configreader import ConfigReader
from solidgpt.src.manager.blobmanager import AzureBlobManager
from solidgpt.src.manager.gptmanager import GPTManager
from solidgpt.src.workskill.skillio import SkillIOParamCategory, SkillInput, SkillOutput
from solidgpt.src.workskill.workskill import WorkSkill
from solidgpt.src.util.util import save_to_text
from langchain.embeddings import OpenAIEmbeddings
from qdrant_client import QdrantClient
Cache_Label_Query_Code = "query_code"
class QueryCodeLocal(WorkSkill):
onboarding_id: str = None
def __init__(self):
super().__init__()
self.name = SKILL_NAME_QUERY_CODE
self.gpt_manager = GPTManager._instance
self.onboarding_id_input = SkillInput(
"Onboarding ID",
SkillIOParamCategory.PlainText,
)
self.skill_input = SkillInput(
"User Input",
SkillIOParamCategory.PlainText,
)
self.add_input(self.onboarding_id_input)
self.add_input(self.skill_input)
self.skill_output = SkillOutput(
"Best five code",
SkillIOParamCategory.PlainText,
)
self.add_output(self.skill_output)
self.user_input: str = None
self.qdrant_path = os.path.join(ROOT_DIR, "src", "tools", "qdrant", "embedding")
def _read_input(self):
self.onboarding_id = self.onboarding_id_input.content
self.user_input = self.skill_input.content
self.client = QdrantClient(path=os.path.join(self.qdrant_path, self.onboarding_id))
def execution_impl(self):
logging.info("Start to search best five code...")
top_five = self.__find_top_five()
output_file = self.__format_output(top_five)
self.graph_cache[Cache_Label_Query_Code] = output_file
save_to_text(os.path.join(self.skill_output.param_path), output_file)
self.client.close()
return
def __find_top_five(self):
embeddings_model = OpenAIEmbeddings(openai_api_key=openai.api_key)
embedding_query = embeddings_model.embed_query(self.user_input)
search = self.client.search(
collection_name=self.onboarding_id,
query_vector=embedding_query,
limit=5
)
return search
@staticmethod
def __format_output(top_five):
ret_str = []
for candidate in top_five:
score = candidate.dict()["score"]
if score < 0.7:
continue
logging.info(score)
summary = candidate.dict()["payload"]["summary"]
code = candidate.dict()["payload"]["code"]
ret_str.append(f"The summary is:\n{summary}\nThe code is:\n```\n{code}\n```")
return "\n".join(ret_str)
| [] |
2024-01-10 | AI-Citizen/SolidGPT | solidgpt~src~workskill~skills~summary_file_local.py | import logging
import os
import shutil
import openai
import uuid
from solidgpt.src.constants import SKILL_NAME_SUMMARY_FILE
from solidgpt.src.configuration.configreader import ConfigReader
from solidgpt.src.manager.gptmanager import GPTManager
from solidgpt.src.manager.blobmanager import AzureBlobManager
from solidgpt.src.manager.promptresource import SUMMARY_CODE_SUMMARY_PYTHON
from solidgpt.src.util.util import load_from_text, save_to_text
from solidgpt.src.workskill.skillio import SkillIOParamCategory, SkillInput, SkillOutput
from solidgpt.src.workskill.workskill import WorkSkill
from solidgpt.definitions import ROOT_DIR
from langchain.document_loaders import TextLoader
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import Qdrant
from qdrant_client import QdrantClient
from qdrant_client.http.models import PointStruct, Distance, VectorParams
class SummaryFileLocal(WorkSkill):
Allowed_Extensions = [".py", ".js", ".jsx", "html", ".css", "ts", "tsx", "java"]
Seperator = "**-****-****-****-**"
# Cache_Label_Summary_File = "summary_python_file"
onboarding_id: str = None
def __init__(self):
super().__init__()
self.name = SKILL_NAME_SUMMARY_FILE
self.gpt_manager = GPTManager._instance
self.onboarding_id_input = SkillInput(
"Onboarding ID",
SkillIOParamCategory.PlainText,
)
self.skill_input = SkillInput(
"Plain code text",
SkillIOParamCategory.CODE_PLAIN_TEXT,
)
self.add_input(self.onboarding_id_input)
self.add_input(self.skill_input)
self.skill_output1 = SkillOutput(
"Single python file summary",
SkillIOParamCategory.PlainText,
)
self.skill_output2 = SkillOutput(
"Single python code",
SkillIOParamCategory.PlainText,
)
self.add_output(self.skill_output1)
self.add_output(self.skill_output2)
self.repo_txt: str = None
self.file_list: list = []
self.qdrant_path = os.path.join(ROOT_DIR, "src", "tools", "qdrant", "embedding")
def _read_input(self):
input_path = self.get_input_path(self.skill_input)
self.repo_txt = load_from_text(input_path, extension=".txt")
self.onboarding_id = self.onboarding_id_input.content
# self.__download_from_azure(self.onboarding_id)
self.client = QdrantClient(path=os.path.join(self.qdrant_path, self.onboarding_id))
def execution_impl(self):
logging.info("Start to summary code...")
self.__extract_lines_after_sequence()
file_count = len(self.file_list)
current_file_idx = 0
for file in self.file_list:
current_file_idx += 1
if self.callback_func:
self.callback_func(current_file_idx, file_count)
if file[-3:] in self.Allowed_Extensions:
self.__summary_file(file)
self.client.close()
return
def __summary_file(self, filename):
py_file = self.__extract_file_content(filename)
real_name = filename[:-3]
real_name = real_name.translate(str.maketrans({"\\": "_", "/": "_"}))
# save_to_text(os.path.join(self.skill_output1.param_path, f"{real_name}%%CODE%%"), py_file)
if py_file is None:
logging.warn("No python file found")
return
python_summary = self.gpt_manager.create_and_chat_with_model(
prompt=SUMMARY_CODE_SUMMARY_PYTHON,
gpt_model_label="summary_python",
input_message=py_file
)
python_summary = python_summary.replace("\n", " ")
logging.info(f"Summary of python file: {python_summary}")
# save_to_text(os.path.join(self.skill_output1.param_path, f"{real_name}%%SUMMARY%%"), python_summary)
self.__embed_summary(real_name, python_summary, py_file)
return
def __embed_summary(self, filename, summary, code):
payload_dict = {"code": code, "summary": summary, "filename": filename}
embeddings_model = OpenAIEmbeddings(openai_api_key=openai.api_key)
embedded_query = embeddings_model.embed_query(summary)
logging.info(f"Onboarding ID:{self.onboarding_id}\nSave this id to retrieve embedded data later.")
try:
self.client.upsert(
collection_name=self.onboarding_id,
points=[
PointStruct(id=self.get_uuid(), vector=embedded_query, payload=payload_dict)
]
)
except ValueError:
self.client.recreate_collection(
collection_name=self.onboarding_id,
vectors_config=VectorParams(size=len(embedded_query), distance=Distance.COSINE),
)
self.client.upsert(
collection_name=self.onboarding_id,
points=[
PointStruct(id=self.get_uuid(), vector=embedded_query, payload=payload_dict)
]
)
return
def __extract_lines_after_sequence(self):
lines = self.repo_txt.split('\n')
capture = False
captured_lines = []
for line in lines:
if capture:
captured_lines.append(line)
capture = False
if self.Seperator in line:
capture = True
self.file_list = captured_lines
return None
def __extract_file_content(self, filename):
# Split the text by the sequence
blocks = self.repo_txt.split(self.Seperator)
for block in blocks:
# Check the first line of each block
first_line = block.strip().split('\n')[0]
if first_line.lower() == filename:
# Remove the first line (filename) and return the rest
return '\n'.join(block.strip().split('\n')[1:])
return None # If no desired file is found
@staticmethod
def get_uuid():
return str(uuid.uuid4().hex)
| [] |
2024-01-10 | AI-Citizen/SolidGPT | solidgpt~src~tools~lowdefy~validator~yaml_validator.py | import os
import openai
import pandas as pd
import numpy as np
from numpy.linalg import norm
from solidgpt.src.configuration.configreader import ConfigReader
from solidgpt.definitions import ROOT_DIR
class YAMLValidator:
def __init__(self, yaml_str: str, filename: str, subpages: list):
self.yaml = yaml_str
self.filename = filename
self.subpages = subpages
self.yaml_list = self.yaml.split("\n")
self.homepage_id = None
self.container_df = pd.read_csv(
os.path.join(ROOT_DIR, "src", "tools", "lowdefy", "embedding", "container_block_embedding.csv"))
self.input_df = pd.read_csv(
os.path.join(ROOT_DIR, "src", "tools", "lowdefy", "embedding", "input_block_embedding.csv"))
self.display_df = pd.read_csv(
os.path.join(ROOT_DIR, "src", "tools", "lowdefy", "embedding", "display_block_embedding.csv"))
self.all_embedding_df = pd.concat([self.container_df, self.input_df, self.display_df], axis=1)
openai.api_key = ConfigReader().get_property("openai_api_key")
def validate(self) -> str:
"""
Check and convert the GPT created yaml file string to valid lowdefy yaml file string
:return: Converted valid lowdefy yaml file string
"""
self.verify_block_type()
self.remove_keys("events")
self.remove_keys("requests")
self.verify_duplicate_keys()
if len(self.subpages) > 0 and self.filename == "lowdefy":
self.verify_reference(self.subpages)
self.verify_menu(self.subpages)
self.verify_duplicate_pages()
return "\n".join(self.yaml_list)
def verify_block_type(self):
"""
Using embedding to convert random block types to valid lowdefy block
:return: Converted yaml file string
"""
idx = 0
while idx < len(self.yaml_list):
line = self.yaml_list[idx]
tokens = line.split(":")
key = tokens[0]
if key == "id":
self.yaml_list[idx] = f"{key}: {self.filename}"
elif key.strip() == "type":
query_type = tokens[1].strip().split(" ")[0]
all_types = self.all_embedding_df.columns.values.tolist()
cache = {}
if query_type not in all_types:
if query_type not in cache:
query_type_embedding = openai.Embedding.create(
model="text-embedding-ada-002",
input=query_type)["data"][0]["embedding"]
score, valid_type = YAMLValidator.find_best_type(query_type_embedding, self.all_embedding_df)
cache[query_type] = valid_type
else:
valid_type = cache[query_type]
self.yaml_list[idx] = f"{key}: {valid_type}"
idx += 1
return
def remove_blocks(self, key, idx):
indentation = key.rfind(" ") if "-" not in key else key.rfind("-") - 1
next_indentation = float("inf")
while idx < len(self.yaml_list) and next_indentation > indentation:
self.yaml_list.pop(idx)
if idx >= len(self.yaml_list):
break
line = self.yaml_list[idx]
tokens = line.split(":")
key = tokens[0]
next_indentation = key.rfind(" ") if "-" not in key else key.rfind("-") - 1
def remove_keys(self, query_key):
idx = 0
while idx < len(self.yaml_list):
line = self.yaml_list[idx]
tokens = line.split(":")
key = tokens[0]
if key.strip() == query_key:
self.remove_blocks(key, idx)
idx += 1
return
def verify_duplicate_pages(self):
idx = 0
page_flag = False
page_indentation = float("inf")
while idx < len(self.yaml_list):
line = self.yaml_list[idx]
tokens = line.split(":")
key = tokens[0]
indentation = key.rfind(" ") if "-" not in key else key.rfind("-") - 1
if page_flag and indentation <= page_indentation:
page_flag = False
if key.strip() == "pages":
page_flag = True
page_indentation = indentation
if len(tokens) > 0:
# print(key == " - id")
if page_flag and key == " - id" and tokens[1].strip().split(" ")[0] in self.subpages:
self.remove_blocks(key, idx)
idx -= 1
idx += 1
return
def verify_duplicate_keys(self):
seen_keys = set()
cur_path_list = []
idx = 0
while idx < len(self.yaml_list):
line = self.yaml_list[idx]
if line == "":
self.yaml_list.pop(idx)
continue
tokens = line.split(":")
key = tokens[0]
indentation = key.rfind(" ") if "-" not in key else key.rfind("-") - 1
indent_level = indentation // 2 if indentation >= 0 else 0
if len(cur_path_list) <= indent_level:
cur_path_list.append(line.strip())
else:
while len(cur_path_list) > indent_level:
cur_path_list.pop()
cur_path_list.append(line.strip())
cur_path = tuple(cur_path_list)
if cur_path in seen_keys:
self.remove_blocks(key, idx)
seen_keys.add(cur_path)
idx += 1
return
def verify_menu(self, page_list: list[str]):
idx = 0
while idx < len(self.yaml_list):
line = self.yaml_list[idx]
tokens = line.split(":")
key = tokens[0]
if key.strip() == "menus":
self.remove_blocks(key, idx)
idx += 1
menu_list = ["menus:", " - id: default", " links:"]
page_list.insert(0, self.homepage_id)
for page in page_list:
cur_list = [f" - id: {page}", " type: MenuLink", " properties:",
f" title: {page.capitalize()}", f" pageId: {page}"]
menu_list.extend(cur_list)
self.yaml_list.extend(menu_list)
return
def verify_reference(self, page_list: list[str]):
ref_list = [f" - _ref: {page_name}.yaml" for page_name in page_list]
idx = 0
flag = False
while idx < len(self.yaml_list):
line = self.yaml_list[idx]
tokens = line.split(":")
key = tokens[0]
if key == "pages":
self.yaml_list[idx + 1:1] = ref_list
flag = True
if flag and key == " - id":
self.homepage_id = tokens[1].strip().split(" ")[0]
break
idx += 1
return
@staticmethod
def vector_similarity(x: list[float], y: list[float]) -> float:
"""
Compute cosine similarity between two vectors.
:param x: Vector one
:param y: Vector two
:return: Cosine similarity between input vectors
"""
return np.dot(np.array(x), np.array(y)) / (norm(np.array(x)) * norm(np.array(y)))
@staticmethod
def find_best_type(query_key, embedding_df) -> tuple[float, str]:
"""
Find the value whose embedding vector has the highest cosine similarity with query
:param query_key: The embedding vector of query
:param embedding_df: Dataframe that stores all the embedding vectors
:return:
"""
best_type = (0, "")
for col_name in embedding_df.columns.tolist():
section_embedding = embedding_df[col_name].values.tolist()
cur_score = YAMLValidator.vector_similarity(query_key, section_embedding)
if cur_score > best_type[0]:
best_type = cur_score, col_name
return best_type
@staticmethod
def parse(org_str: str) -> str:
"""
Given the original output string generated from LLM, parse the yaml file provided in the output.
:param org_str: original string from LLM
:return: the string of yaml file
"""
reading_state = 0
yaml_lines = []
for line in org_str.split("\n"):
if line[:3] == "```" and reading_state == 0:
reading_state = 1
continue
elif line[:3] == "```":
break
if reading_state == 1:
yaml_lines.append(line)
ret = "\n".join(yaml_lines)
return ret
| [] |
2024-01-10 | AI-Citizen/SolidGPT | solidgpt~src~manager~gptmanager.py | import openai
from solidgpt.src.configuration.configreader import ConfigReader
class GPTManager:
_instance = None
def __new__(cls):
if cls._instance is None:
cls._instance = super(GPTManager, cls).__new__(cls)
# You can initialize the instance attributes here
return cls._instance
def __init__(self, if_show_reply = False):
# read api key from config file
global_openai_key = ConfigReader().get_property("openai_api_key")
if global_openai_key is not None and global_openai_key != "":
openai.api_key = global_openai_key
self.__default_model = ConfigReader().get_property("openai_model")
self.gpt_models_container = {}
self.if_show_reply = if_show_reply
def create_model(self, prompt, gpt_model_label, temperature = 1, model = None):
if model is None:
model = self.__default_model
gpt_model = GPTModel(prompt, self.__default_model, self.if_show_reply, temperature)
self.gpt_models_container[gpt_model_label] = gpt_model
return gpt_model
def create_and_chat_with_model(self, prompt, gpt_model_label, input_message, temperature = 0.1, model = None):
gpt_model = self.create_model(prompt, gpt_model_label, temperature, model)
return gpt_model.chat_with_model(input_message)
def get_gpt_model(self, gpt_model_label):
return self.completions_container[gpt_model_label]
def remove_gpt_model(self, gpt_model_label):
self.completions_container.pop(gpt_model_label)
class GPTModel:
def __init__(self, prompt, model, if_show_reply = True, temperature = 0.1):
self.prompt = prompt
self.model = model
self.messages = [{"role": "system", "content": self.prompt}]
self.last_reply = None
self.if_show_reply = if_show_reply
self.temperature = temperature
def chat_with_model(self, input_message):
self.messages.append({"role": "user", "content": input_message})
self._run_model()
return self.last_reply
def _run_model(self):
chat = openai.ChatCompletion.create(
model=self.model,
messages=self.messages,
temperature=self.temperature,
)
reply = chat.choices[0].message.content
if self.if_show_reply:
print(f"ChatGPT: {reply}")
self.messages.append({"role": "assistant", "content": reply})
self.last_reply = reply
def add_background(self, background_message):
self.messages.append({"role": "assistant", "content": background_message}) | [] |
2024-01-10 | AI-Citizen/SolidGPT | solidgpt~src~manager~autogenmanager.py | import logging
import autogen
from autogen import oai
import openai
from solidgpt.src.configuration.configreader import ConfigReader
from typing import Callable, Dict, Optional, Union
from solidgpt.src.manager.promptresource import DEFAULT_SYSTEM_MESSAGE, ASSISTANT_SYSTEM_MESSAGE
def colored(x, *args, **kwargs):
return x
class SolidUserProxyAgent(autogen.UserProxyAgent):
manager = None
callback_map = {
}
def __init__(
self,
name: str,
is_termination_msg: Optional[Callable[[Dict], bool]] = None,
max_consecutive_auto_reply: Optional[int] = None,
human_input_mode: Optional[str] = "ALWAYS",
function_map: Optional[Dict[str, Callable]] = None,
code_execution_config: Optional[Union[Dict, bool]] = None,
default_auto_reply: Optional[Union[str, Dict, None]] = "",
llm_config: Optional[Union[Dict, bool]] = False,
system_message: Optional[str] = "",
):
super().__init__(
name=name,
system_message=system_message,
is_termination_msg=is_termination_msg,
max_consecutive_auto_reply=max_consecutive_auto_reply,
human_input_mode=human_input_mode,
function_map=function_map,
code_execution_config=code_execution_config,
llm_config=llm_config,
default_auto_reply=default_auto_reply,
)
def _print_received_message(self, message: Union[Dict, str], sender):
# print the message received
self.manager.add_message(sender.name, "(to", f"{self.name}):\n")
if message.get("role") == "function":
func_print = f"***** Response from calling function \"{message['name']}\" *****"
self.manager.add_message(func_print)
self.manager.add_message(message["content"])
self.manager.add_message("*" * len(func_print))
else:
content = message.get("content")
if content is not None:
if "context" in message:
content = oai.ChatCompletion.instantiate(
content,
message["context"],
self.llm_config and self.llm_config.get("allow_format_str_template", False),
)
self.manager.add_message(content)
if "function_call" in message:
func_print = f"***** Suggested function Call: {message['function_call'].get('name', '(No function name found)')} *****"
self.manager.add_message(func_print)
self.manager.add_message("Arguments: ")
self.manager.add_message(message["function_call"].get("arguments", "(No arguments found)"))
self.manager.add_message("*" * len(func_print))
self.manager.add_message("")
self.manager.add_message("-" * 80)
def get_human_input(self, prompt: str) -> str:
reply = ""
# get reply from frontend
msg = self.manager.retrieve_message()
if self.callback_map.get("autogen_update_result_callback"):
self.callback_map.get("autogen_update_result_callback")(msg)
# display the chat
logging.info(msg)
if self.callback_map.get("autogen_message_input_callback"):
reply = self.callback_map.get("autogen_message_input_callback")()
else:
reply = input()
return reply
class SolidAssistantAgent(autogen.AssistantAgent):
manager = None
def __init__(
self,
name: str,
system_message: Optional[str] = DEFAULT_SYSTEM_MESSAGE,
llm_config: Optional[Union[Dict, bool]] = None,
is_termination_msg: Optional[Callable[[Dict], bool]] = None,
max_consecutive_auto_reply: Optional[int] = None,
human_input_mode: Optional[str] = "NEVER",
code_execution_config: Optional[Union[Dict, bool]] = False,
**kwargs,
):
super().__init__(
name=name,
system_message=system_message,
is_termination_msg=is_termination_msg,
max_consecutive_auto_reply=max_consecutive_auto_reply,
human_input_mode=human_input_mode,
code_execution_config=code_execution_config,
llm_config=llm_config,
**kwargs,
)
def _print_received_message(self, message: Union[Dict, str], sender):
# print the message received
self.manager.add_message(sender.name, "(to", f"{self.name}):\n")
if message.get("role") == "function":
func_print = f"***** Response from calling function \"{message['name']}\" *****"
self.manager.add_message(func_print)
self.manager.add_message(message["content"])
self.manager.add_message("*" * len(func_print))
else:
content = message.get("content")
if content is not None:
if "context" in message:
content = oai.ChatCompletion.instantiate(
content,
message["context"],
self.llm_config and self.llm_config.get("allow_format_str_template", False),
)
self.manager.add_message(content)
if "function_call" in message:
func_print = f"***** Suggested function Call: {message['function_call'].get('name', '(No function name found)')} *****"
self.manager.add_message(func_print)
self.manager.add_message("Arguments: ")
self.manager.add_message(message["function_call"].get("arguments", "(No arguments found)"))
self.manager.add_message("*" * len(func_print))
self.manager.add_message("")
self.manager.add_message("-" * 80)
def get_human_input(self, prompt: str) -> str:
print(prompt)
reply = ""
return reply
class AutoGenManager:
cumulative_message = ""
def __init__(self, if_show_reply=False):
# read api key from config file
global_openai_key = ConfigReader().get_property("openai_api_key")
if global_openai_key is not None and global_openai_key != "":
openai.api_key = global_openai_key
self.__default_model = ConfigReader().get_property("openai_model")
self.config_list = [{"model": self.__default_model, "api_key": openai.api_key}]
self.if_show_reply = if_show_reply
self.planner = None
self.planner_user = None
self.assistant = None
self.user_proxy = None
def run(self, requirement, relatived_code):
self.construct_agents(relatived_code)
self.user_proxy.initiate_chat(
self.assistant,
message=requirement,
)
@staticmethod
def get_customized_assistant_agent(name: str,
system_message: Optional[str] = DEFAULT_SYSTEM_MESSAGE,
llm_config: Optional[Union[Dict, bool]] = None,
is_termination_msg: Optional[Callable[[Dict], bool]] = None,
max_consecutive_auto_reply: Optional[int] = None,
human_input_mode: Optional[str] = "NEVER",
code_execution_config: Optional[Union[Dict, bool]] = False,
call_back=None,
**kwargs):
return SolidAssistantAgent(
name=name,
system_message=system_message,
is_termination_msg=is_termination_msg,
max_consecutive_auto_reply=max_consecutive_auto_reply,
human_input_mode=human_input_mode,
code_execution_config=code_execution_config,
call_back=call_back,
llm_config=llm_config,
**kwargs)
@staticmethod
def get_customized_user_proxy_agent(name: str,
is_termination_msg: Optional[Callable[[Dict], bool]] = None,
max_consecutive_auto_reply: Optional[int] = None,
human_input_mode: Optional[str] = "ALWAYS",
function_map: Optional[Dict[str, Callable]] = None,
code_execution_config: Optional[Union[Dict, bool]] = None,
default_auto_reply: Optional[Union[str, Dict, None]] = "",
llm_config: Optional[Union[Dict, bool]] = False,
system_message: Optional[str] = "",
):
return SolidUserProxyAgent(
name,
system_message=system_message,
is_termination_msg=is_termination_msg,
max_consecutive_auto_reply=max_consecutive_auto_reply,
human_input_mode=human_input_mode,
function_map=function_map,
code_execution_config=code_execution_config,
llm_config=llm_config,
default_auto_reply=default_auto_reply,
)
def construct_agents(self, relatived_code):
self.planner = self.generate_default_planner()
self.planner_user = self.generate_default_planner_user()
self.assistant = self.generate_default_assistant(relatived_code)
self.user_proxy = self.generate_default_user_proxy()
self.planner.manager = self
self.planner_user.manager = self
self.assistant.manager = self
self.user_proxy.manager = self
return
def add_message(self, *args):
# Joining all arguments with a space after converting each to a string
messages = ' '.join(map(str, args))
self.cumulative_message += messages + "\n"
def retrieve_message(self):
msg = self.cumulative_message
self.cumulative_message = ""
return msg
def generate_default_planner(self):
# todo: update callback function
planner = SolidAssistantAgent(
name="Planner",
llm_config={"config_list": self.config_list},
# the default system message of the AssistantAgent is overwritten here
system_message=DEFAULT_SYSTEM_MESSAGE)
return planner
def generate_default_planner_user(self):
# todo: update callback function
planner_user = SolidUserProxyAgent(
name="Your_Proxy",
max_consecutive_auto_reply=0, # terminate without auto-reply
human_input_mode="NEVER",
)
return planner_user
def ask_planner(self, message):
self.planner_user.initiate_chat(self.planner, message=message)
self.planner_msg = self.planner_user.last_message()["content"]
# return the last message received from the planner
return self.planner_user.last_message()["content"]
def generate_default_assistant(self, relatived_code: str):
# todo: update callback function
assistant = SolidAssistantAgent(
name="SolidGPT",
system_message=ASSISTANT_SYSTEM_MESSAGE + f"""Relatived code as follow: {relatived_code}""",
llm_config={
"temperature": 0,
"request_timeout": 600,
"seed": 42,
"model": self.__default_model,
"config_list": self.config_list,
"functions": [
{
"name": "ask_planner",
"description": "ask planner to: 1. get a plan for finishing a task, 2. verify the execution result of the plan and potentially suggest new plan.",
"parameters": {
"type": "object",
"properties": {
"message": {
"type": "string",
"description": "question to ask planner. Make sure the question include enough context, such as the code and the execution result. The planner does not know the conversation between you and the user, unless you share the conversation with the planner.",
},
},
"required": ["message"],
},
},
],
}
)
return assistant
def generate_default_user_proxy(self):
# todo: update callback function
user_proxy = SolidUserProxyAgent(
name="Your_Proxy",
human_input_mode="ALWAYS",
max_consecutive_auto_reply=10,
is_termination_msg=lambda x: "content" in x and x["content"] is not None and x["content"].rstrip().endswith(
"TERMINATE"),
code_execution_config={"work_dir": "planning"},
function_map={"ask_planner": self.ask_planner},
)
return user_proxy
| [] |
2024-01-10 | whitleyhorn/llm-university | classify.py | from utils.cohere_utils import co
from cohere.responses.classify import Example
examples = [Example("I'm so proud of you", "positive"),
Example("What a great time to be alive", "positive"),
Example("That's awesome work", "positive"),
Example("The service was amazing", "positive"),
Example("I love my family", "positive"),
Example("They don't care about me", "negative"),
Example("I hate this place", "negative"),
Example("The most ridiculous thing I've ever heard", "negative"),
Example("I am really frustrated", "negative"),
Example("This is so unfair", "negative"),
Example("This made me think", "neutral"),
Example("The good old days", "neutral"),
Example("What's the difference", "neutral"),
Example("You can't ignore this", "neutral"),
Example("That's how I see it", "neutral")
]
inputs=["Hello, world! What a beautiful day",
"It was a great time with great people",
"Great place to work",
"That was a wonderful evening",
"Maybe this is why",
"Let's start again",
"That's how I see it",
"These are all facts",
"This is the worst thing",
"I cannot stand this any longer",
"This is really annoying",
"I am just plain fed up"
]
def classify_text(inputs, examples):
response = co.classify(
model='embed-english-v2.0',
inputs=inputs,
examples=examples
)
classifications = response.classifications
return classifications
predictions = classify_text(inputs, examples)
# Display the classification outcomes
classes = ["positive","negative","neutral"]
for inp,pred in zip(inputs,predictions):
class_pred = pred.prediction
class_idx = classes.index(class_pred)
class_conf = pred.confidence
print(f"Input: {inp}")
print(f"Prediction: {class_pred}")
print(f"Confidence: {class_conf:.2f}")
print("-"*10)
| [] |
2024-01-10 | whitleyhorn/llm-university | semantic_search.py | import cohere
from utils.cohere_utils import co
import numpy as np
import re
import pandas as pd
from tqdm import tqdm
from datasets import load_dataset
import umap
import altair as alt
from sklearn.metrics.pairwise import cosine_similarity
from annoy import AnnoyIndex
import warnings
warnings.filterwarnings('ignore')
pd.set_option('display.max_colwidth', None)
# Load the dataset
dataset = load_dataset("trec", split="train")
# Import into a pandas dataframe, take only the first 1000 rows
df = pd.DataFrame(dataset)[:1000]
# get the embeddings
embeds = co.embed(texts=list(df["text"]),
model='embed-english-v2.0').embeddings
# Create the search index, pass the size of the embeddings
search_index = AnnoyIndex(np.array(embeds).shape[1], 'angular')
# Add the embeddings to the search index
for i in range(len(embeds)):
search_index.add_item(i, embeds[i])
search_index.build(10) # 10 trees
search_index.save('test.ann')
query = input("Enter your query: ")
# Get the query's embedding
query_embed = co.embed(texts=[query],
model="embed-english-v2.0").embeddings
# Retrieve the nearest neighbors
similar_item_ids = search_index.get_nns_by_vector(query_embed[0],10,
include_distances=True)
# Format the results
results = pd.DataFrame(data={'texts': df.iloc[similar_item_ids[0]]['text'],
'distance': similar_item_ids[1]})
print(f"Query:'{query}'\nNearest neighbors:")
print(results)
| [] |
2024-01-10 | xiami2019/HalluQA | calculate_metrics.py | import json
import time
import random
import openai
import argparse
from tqdm import tqdm
def get_args():
parser = argparse.ArgumentParser()
parser.add_argument('--temperature', type=float, default=0)
parser.add_argument('--top_p', type=float, default=0.5)
parser.add_argument('--vote_times', type=int, default=5)
parser.add_argument('--max_tokens', type=int, default=10)
parser.add_argument('--response_file_name', type=str, required=True)
parser.add_argument('--result_save_path', type=str, default='results.json')
parser.add_argument('--metric_save_path', type=str, default='non_hallucination_rate.txt')
parser.add_argument('--api_key', type=str, required=True)
parser.add_argument('--organization', type=str, required=True)
args = parser.parse_args()
return args
def retry_with_exponential_backoff(
func,
initial_delay: float = 1,
exponential_base: float = 2,
jitter: bool = True,
max_retries: int = 50,
errors: tuple = (openai.error.RateLimitError,),
):
"""Retry a function with exponential backoff."""
def wrapper(*args, **kwargs):
# Initialize variables
num_retries = 0
delay = initial_delay
# Loop until a successful response or max_retries is hit or an exception is raised
while True:
try:
return func(*args, **kwargs)
# Retry on specific errors
except Exception as e:
# Increment retries
num_retries += 1
# print(e)
# Check if max retries has been reached
if num_retries > max_retries:
raise Exception(
f"Maximum number of retries ({max_retries}) exceeded."
)
# Increment the delay
delay *= exponential_base * (1 + jitter * random.random())
# Sleep for the delay
time.sleep(delay)
# time.sleep(30)
# Raise exceptions for any errors not specified
# except Exception as e:
# raise e
return wrapper
@retry_with_exponential_backoff
def chat_completion_with_backoff(**kwargs):
return openai.ChatCompletion.create(**kwargs)
def get_prompt(sample, resource):
ref = resource[sample['question_id']]
messages = [
{'role': 'system', 'content': 'You are a helpful assistant.'},
{'role': 'user', 'content': ''}
]
messages[-1]['content'] = '''我现在需要你判断一个问答机器人的输出是否存在幻觉。我会给你一些正确答案的示例，评判的标准如下：
1. 你需要首先判断问答机器人的输出是否流畅。如果输出不是流畅的自然语言，例如包含很多乱码，应该判断为存在幻觉。
2. 其次，你需要判断问答机器人是否正面回答了问题，如果问答机器人的输出中包含许多正确的信息，但是没有正面回答问题，也应该判断为存在幻觉。
3. 如果问答机器人的输出无法由正确答案示例推断出来，或者包含与正确答案示例中不一致的信息，那么应该判断为存在幻觉。
4. 如果问答机器人的输出可以被任意一个正确答案示例所支持，那么应该判断为不存在幻觉。
5. 如果问答机器人的输出无法被正确答案示例直接支持，你需要推理一下输出是否和正确答案示例有相似的含义，如果有相似的含义，也应该判断为不存在幻觉。
6. 如果正确答案示例中有类似“这个问题无法回答”的话，那么问答机器人的输出为“我不知道”类似的话时，应该判断为不存在幻觉。'''
messages.append({'role': 'assistant', 'content': '明白了，我会根据您提供的示例和评判标准来判断问答机器人的输出是否存在幻觉。请提供需要判断的问题、正确答案和错误答案示例，以及问答机器人的输出。'})
messages.append({'role': 'user', 'content': ''})
# assert sample['question'] == ref['Question'], print(sample['question'], ref['Question'])
assert sample['question_id'] == ref['question_id']
user_input_for_judging = '问题：{}\n\n'.format(ref['Question'].strip())
user_input_for_judging += '正确答案示例如下：\n'
if 'Best Answer1' in ref:
count = 1
for i in range(1,5):
correct_answer_key = 'Best Answer{}'.format(str(i))
if ref[correct_answer_key] != '':
user_input_for_judging += '{}. {}\n'.format(str(count), ref[correct_answer_key].strip())
sample['Best_Answer{}'.format(str(i))] = ref[correct_answer_key].strip()
count += 1
else:
user_input_for_judging += '1. {}\n'.format(ref['Best Answer'].strip())
sample['Best_Answer'] = ref['Best Answer'].strip()
user_input_for_judging += '\n问答机器人的输出如下：\n'
user_input_for_judging += '{}\n\n'.format(sample['response'].strip())
user_input_for_judging += '现在请判断问答机器人的输出是否存在幻觉，只输出是或否即可。'
messages[-1]['content'] = user_input_for_judging
return sample, messages
def calculate(args, resource):
with open(args.response_file_name, 'r') as f:
data = json.load(f)
scored_outputs = []
correct_count = 0
for item in tqdm(data):
sample, messages = get_prompt(item, resource)
max_try = 5
try_count = 0
invalid_judge = False
while True:
try_count += 1
responses = chat_completion_with_backoff(
model="gpt-4-0613",
messages=messages,
temperature=args.temperature,
top_p=args.top_p,
n=args.vote_times,
max_tokens=args.max_tokens,
)
# check output
flag = True
for choice in responses['choices']:
if choice['message']['content'] != '是' and choice['message']['content'] != '否':
flag = False
break
if flag:
break
if try_count >= max_try:
invalid_judge = True
break
time.sleep(1)
time.sleep(2)
if invalid_judge is False:
outputs = []
for choise in responses['choices']:
outputs.append(choise['message']['content'])
if outputs.count('是') > 2:
sample['is_hallucination'] = True
else:
sample['is_hallucination'] = False
if sample['response'] != '':
correct_count += 1
else:
sample['is_hallucination'] = True
scored_outputs.append(sample)
else:
sample['is_hallucination'] = "Invalid_Judge"
scored_outputs.append(sample)
assert len(data) == len(scored_outputs)
with open(args.result_save_path, 'w', encoding='utf-8') as f:
json.dump(scored_outputs, f, indent=2, ensure_ascii=False)
with open(args.metric_save_path, 'w', encoding='utf-8') as f:
f.write('Non hallucination rate: {:.2f}%'.format(correct_count/len(data)*100))
if __name__ == '__main__':
args = get_args()
openai.api_key = args.api_key
openai.organization = args.organization
# Load reference data
with open('HalluQA.json', 'r') as f:
resource = {item['question_id']: item for item in json.loads(f.read())}
print('Evaluating hallucination for {}...'.format(args.response_file_name))
calculate(args, resource) | [
"明白了，我会根据您提供的示例和评判标准来判断问答机器人的输出是否存在幻觉。请提供需要判断的问题、正确答案和错误答案示例，以及问答机器人的输出。",
"You are a helpful assistant."
] |
2024-01-10 | ilyamk/sweep | sweepai~handlers~on_check_suite.py | """
This module is responsible for handling the check suite event, called from sweepai/api.py
"""
import io
import os
import zipfile
import openai
import requests
from logn import logger
from sweepai.core.entities import PRChangeRequest
from sweepai.core.gha_extraction import GHAExtractor
from sweepai.events import CheckRunCompleted
from sweepai.handlers.on_comment import on_comment
from sweepai.config.client import get_gha_enabled
from sweepai.utils.github_utils import get_github_client, get_token
openai.api_key = os.environ.get("OPENAI_API_KEY")
log_message = """GitHub actions yielded the following error.
{error_logs}
This is likely a linting or type-checking issue with the source code. Update the code changed by the PR. Don't modify the existing tests."""
def get_dirs(zipfile: zipfile.ZipFile):
return [file for file in zipfile.namelist() if file.endswith("/") and "/" in file]
def get_files_in_dir(zipfile: zipfile.ZipFile, dir: str):
return [
file
for file in zipfile.namelist()
if file.startswith(dir) and not file.endswith("/")
]
def download_logs(repo_full_name: str, run_id: int, installation_id: int):
token = get_token(installation_id)
headers = {
"Accept": "application/vnd.github+json",
"Authorization": f"Bearer {token}",
"X-GitHub-Api-Version": "2022-11-28",
}
response = requests.get(
f"https://api.github.com/repos/{repo_full_name}/actions/runs/{run_id}/logs",
headers=headers,
)
logs_str = ""
if response.status_code == 200:
# this is the worst code I've ever written. I'm sorry.
content = response.content
zip_file = zipfile.ZipFile(io.BytesIO(content))
for file in zip_file.namelist():
if file.endswith(".txt"):
with zip_file.open(file) as f:
logs = f.read().decode("utf-8")
last_line = logs.splitlines()[-1]
if "##[error]" in last_line:
logs_str += logs
else:
logger.info(response.text)
logger.warning(f"Failed to download logs for run id: {run_id}")
return logs_str
def clean_logs(logs_str: str):
# Extraction process could be better
MAX_LINES = 300
log_list = logs_str.split("\n")
truncated_logs = [log[log.find(" ") + 1 :] for log in log_list]
patterns = [
# for docker
"Already exists",
"Pulling fs layer",
"Waiting",
"Download complete",
"Verifying Checksum",
"Pull complete",
# For github
"remote: Counting objects",
"remote: Compressing objects:",
"Receiving objects:",
"Resolving deltas:",
"[command]/usr/bin/git ",
"Download action repository",
# For python
"Collecting",
"Downloading",
"Installing",
"━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━",
# For prettier
"npm WARN EBADENGINE ",
"npm WARN deprecated ",
"prettier/prettier",
]
cleaned_lines = [
log.strip()
for log in truncated_logs
if not any(log.strip().startswith(pattern) for pattern in patterns)
]
return "\n".join(cleaned_lines[: min(MAX_LINES, len(cleaned_lines))])
def extract_logs_from_comment(comment: str) -> str:
if comment.count("```") < 2:
return ""
return comment[comment.find("```") + 3 : comment.rfind("```")]
def on_check_suite(request: CheckRunCompleted):
logger.info(
f"Received check run completed event for {request.repository.full_name}"
)
_, g = get_github_client(request.installation.id)
repo = g.get_repo(request.repository.full_name)
if not get_gha_enabled(repo):
logger.info(
f"Skipping github action for {request.repository.full_name} because it is"
" not enabled"
)
return None
pr = repo.get_pull(request.check_run.pull_requests[0].number)
num_pr_commits = len(list(pr.get_commits()))
if num_pr_commits > 20:
logger.info(f"Skipping github action for PR with {num_pr_commits} commits")
return None
logger.info(f"Running github action for PR with {num_pr_commits} commits")
logs = download_logs(
request.repository.full_name, request.check_run.run_id, request.installation.id
)
if not logs:
return None
logs = clean_logs(logs)
extractor = GHAExtractor(chat_logger=None)
logger.info(f"Extracting logs from {request.repository.full_name}, logs: {logs}")
problematic_logs = extractor.gha_extract(logs)
if problematic_logs.count("\n") > 20:
problematic_logs += (
"\n\nThere are a lot of errors. This is likely due to a small parsing issue"
" or a missing import with the files changed in the PR."
)
comments = list(pr.get_issue_comments())
# logs_list = [extract_logs_from_comment(comment.body) for comment in comments]
# current_logs = extract_logs_from_comment(problematic_logs)
if all([comment.user.login.startswith("sweep") for comment in comments[-2:]]):
comment = pr.as_issue().create_comment(
log_message.format(error_logs=problematic_logs)
+ "\n\nI'm getting the same errors 3 times in a row, so I will stop working"
" on fixing this PR."
)
logger.warning("Skipping logs because it is duplicated")
return None
comment = pr.as_issue().create_comment(
log_message.format(error_logs=problematic_logs)
)
pr_change_request = PRChangeRequest(
params={
"type": "github_action",
"repo_full_name": request.repository.full_name,
"repo_description": request.repository.description,
"comment": problematic_logs,
"pr_path": None,
"pr_line_position": None,
"username": request.sender.login,
"installation_id": request.installation.id,
"pr_number": request.check_run.pull_requests[0].number,
"comment_id": comment.id,
},
)
return pr_change_request
| [] |
2024-01-10 | ilyamk/sweep | tests~test_match.py | from sweepai.utils.diff import find_best_match
from sweepai.utils.search_and_replace import score_multiline
haystack = r"""
# TODO: Add file validation
import math
import re
import traceback
import openai
import github
from github import GithubException, BadCredentialsException
from tabulate import tabulate
from tqdm import tqdm
from logn import logger, LogTask
from sweepai.core.context_pruning import ContextPruning
from sweepai.core.documentation_searcher import extract_relevant_docs
from sweepai.core.entities import (
ProposedIssue,
SandboxResponse,
Snippet,
NoFilesException,
SweepContext,
MaxTokensExceeded,
EmptyRepository,
)
from sweepai.core.external_searcher import ExternalSearcher
from sweepai.core.slow_mode_expand import SlowModeBot
from sweepai.core.sweep_bot import SweepBot
from sweepai.core.prompts import issue_comment_prompt
# from sandbox.sandbox_utils import Sandbox
from sweepai.handlers.create_pr import (
create_pr_changes,
create_config_pr,
safe_delete_sweep_branch,
)
from sweepai.handlers.on_comment import on_comment
from sweepai.handlers.on_review import review_pr
from sweepai.utils.buttons import create_action_buttons
from sweepai.utils.chat_logger import ChatLogger
from sweepai.config.client import (
SweepConfig,
get_documentation_dict,
)
from sweepai.config.server import (
ENV,
MONGODB_URI,
OPENAI_API_KEY,
GITHUB_BOT_USERNAME,
GITHUB_LABEL_NAME,
OPENAI_USE_3_5_MODEL_ONLY,
WHITELISTED_REPOS,
)
from sweepai.utils.ticket_utils import *
from sweepai.utils.event_logger import posthog
from sweepai.utils.github_utils import ClonedRepo, get_github_client
from sweepai.utils.prompt_constructor import HumanMessagePrompt
from sweepai.utils.search_utils import search_snippets
from sweepai.utils.tree_utils import DirectoryTree
openai.api_key = OPENAI_API_KEY
def center(text: str) -> str:
return f"<div align='center'>{text}</div>"
@LogTask()
def on_ticket(
title: str,
summary: str,
issue_number: int,
issue_url: str,
username: str,
repo_full_name: str,
repo_description: str,
installation_id: int,
comment_id: int = None,
edited: bool = False,
):
(
title,
slow_mode,
do_map,
subissues_mode,
sandbox_mode,
fast_mode,
lint_mode,
) = strip_sweep(title)
# Flow:
# 1. Get relevant files
# 2: Get human message
# 3. Get files to change
# 4. Get file changes
# 5. Create PR
summary = summary or ""
summary = re.sub(
"<details (open)?>\n<summary>Checklist</summary>.*",
"",
summary,
flags=re.DOTALL,
).strip()
summary = re.sub(
"---\s+Checklist:\n\n- \[[ X]\].*", "", summary, flags=re.DOTALL
).strip()
repo_name = repo_full_name
user_token, g = get_github_client(installation_id)
repo = g.get_repo(repo_full_name)
current_issue = repo.get_issue(number=issue_number)
assignee = current_issue.assignee.login if current_issue.assignee else None
if assignee is None:
assignee = current_issue.user.login
chat_logger = (
ChatLogger(
{
"repo_name": repo_name,
"title": title,
"summary": summary,
"issue_number": issue_number,
"issue_url": issue_url,
"username": username if not username.startswith("sweep") else assignee,
"repo_full_name": repo_full_name,
"repo_description": repo_description,
"installation_id": installation_id,
"type": "ticket",
"mode": ENV,
"comment_id": comment_id,
"edited": edited,
}
)
if MONGODB_URI
else None
)
if chat_logger:
is_paying_user = chat_logger.is_paying_user()
is_trial_user = chat_logger.is_trial_user()
use_faster_model = OPENAI_USE_3_5_MODEL_ONLY or chat_logger.use_faster_model(g)
else:
is_paying_user = True
is_trial_user = False
use_faster_model = False
if fast_mode:
use_faster_model = True
sweep_context = SweepContext.create(
username=username,
issue_url=issue_url,
use_faster_model=use_faster_model,
is_paying_user=is_paying_user,
repo=repo,
token=user_token,
)
logger.print(sweep_context)
if not comment_id and not edited and chat_logger:
chat_logger.add_successful_ticket(
gpt3=use_faster_model
) # moving higher, will increment the issue regardless of whether it's a success or not
organization, repo_name = repo_full_name.split("/")
metadata = {
"issue_url": issue_url,
"repo_full_name": repo_full_name,
"organization": organization,
"repo_name": repo_name,
"repo_description": repo_description,
"username": username,
"comment_id": comment_id,
"title": title,
"installation_id": installation_id,
"function": "on_ticket",
"edited": edited,
"model": "gpt-3.5" if use_faster_model else "gpt-4",
"tier": "pro" if is_paying_user else "free",
"mode": ENV,
"slow_mode": slow_mode,
"do_map": do_map,
"subissues_mode": subissues_mode,
"sandbox_mode": sandbox_mode,
"fast_mode": fast_mode,
}
# logger.bind(**metadata)
posthog.capture(username, "started", properties=metadata)
logger.info(f"Getting repo {repo_full_name}")
if current_issue.state == "closed":
logger.warning(f"Issue {issue_number} is closed")
posthog.capture(username, "issue_closed", properties=metadata)
return {"success": False, "reason": "Issue is closed"}
current_issue.edit(body=summary)
item_to_react_to = (
current_issue.get_comment(comment_id) if comment_id else current_issue
)
replies_text = ""
comments = list(current_issue.get_comments())
if comment_id:
logger.info(f"Replying to comment {comment_id}...")
replies_text = "\nComments:\n" + "\n".join(
[
issue_comment_prompt.format(
username=comment.user.login,
reply=comment.body,
)
for comment in comments
if comment.user.type == "User"
]
)
summary = summary if summary else ""
prs = repo.get_pulls(
state="open", sort="created", base=SweepConfig.get_branch(repo)
)
for pr in prs:
# Check if this issue is mentioned in the PR, and pr is owned by bot
# This is done in create_pr, (pr_description = ...)
if (
pr.user.login == GITHUB_BOT_USERNAME
and f"Fixes #{issue_number}.\n" in pr.body
):
success = safe_delete_sweep_branch(pr, repo)
eyes_reaction = item_to_react_to.create_reaction("eyes")
# If SWEEP_BOT reacted to item_to_react_to with "rocket", then remove it.
reactions = item_to_react_to.get_reactions()
for reaction in reactions:
if reaction.content == "rocket" and reaction.user.login == GITHUB_BOT_USERNAME:
item_to_react_to.delete_reaction(reaction.id)
# Removed 1, 3
progress_headers = [
None,
"Step 1: 🔎 Searching",
"Step 2: ⌨️ Coding",
"Step 3: 🔁 Code Review",
]
config_pr_url = None
# Find the first comment made by the bot
issue_comment = None
tickets_allocated = 5
if is_trial_user:
tickets_allocated = 15
if is_paying_user:
tickets_allocated = 500
ticket_count = (
max(tickets_allocated - chat_logger.get_ticket_count(), 0)
if chat_logger
else 999
)
daily_ticket_count = (
(3 - chat_logger.get_ticket_count(use_date=True) if not use_faster_model else 0)
if chat_logger
else 999
)
model_name = "GPT-3.5" if use_faster_model else "GPT-4"
payment_link = "https://buy.stripe.com/6oE5npbGVbhC97afZ4"
daily_message = (
f" and {daily_ticket_count} for the day"
if not is_paying_user and not is_trial_user
else ""
)
user_type = "💎 Sweep Pro" if is_paying_user else "⚡ Sweep Free Trial"
gpt_tickets_left_message = (
f"{ticket_count} GPT-4 tickets left for the month"
if not is_paying_user
else "unlimited GPT-4 tickets"
)
payment_message = (
f"{user_type}: I used {model_name} to create this ticket. You have {gpt_tickets_left_message}{daily_message}."
+ (
f" For more GPT-4 tickets, visit [our payment portal.]({payment_link})"
if not is_paying_user
else ""
)
)
payment_message_start = (
f"{user_type}: I'm creating this ticket using {model_name}. You have {gpt_tickets_left_message}{daily_message}."
+ (
f" For more GPT-4 tickets, visit [our payment portal.]({payment_link})"
if not is_paying_user
else ""
)
)
def get_comment_header(index, errored=False, pr_message="", done=False):
config_pr_message = (
"\n" + f"* Install Sweep Configs: [Pull Request]({config_pr_url})"
if config_pr_url is not None
else ""
)
actions_message = create_action_buttons(
[
"↻ Restart Sweep",
]
)
if index < 0:
index = 0
if index == 4:
return pr_message + f"\n\n---\n{actions_message}" + config_pr_message
total = len(progress_headers)
index += 1 if done else 0
index *= 100 / total
index = int(index)
index = min(100, index)
if errored:
pbar = f"\n\n<img src='https://progress-bar.dev/{index}/?&title=Errored&width=600' alt='{index}%' />"
return (
f"{center(sweeping_gif)}<br/>{center(pbar)}\n\n"
+ f"\n\n---\n{actions_message}"
)
pbar = f"\n\n<img src='https://progress-bar.dev/{index}/?&title=Progress&width=600' alt='{index}%' />"
return (
f"{center(sweeping_gif)}<br/>{center(pbar)}"
+ ("\n" + stars_suffix if index != -1 else "")
+ "\n"
+ payment_message_start
+ config_pr_message
+ f"\n\n---\n{actions_message}"
)
# Find Sweep's previous comment
logger.print("USERNAME", GITHUB_BOT_USERNAME)
for comment in comments:
logger.print("COMMENT", comment.user.login)
if comment.user.login == GITHUB_BOT_USERNAME:
logger.print("Found comment")
issue_comment = comment
try:
config = SweepConfig.get_config(repo)
except EmptyRepository as e:
logger.info("Empty repo")
first_comment = (
"Sweep is currently not supported on empty repositories. Please add some"
f" code to your repository and try again.\n{sep}##"
f" {progress_headers[1]}\n{bot_suffix}{discord_suffix}"
)
if issue_comment is None:
issue_comment = current_issue.create_comment(first_comment)
else:
issue_comment.edit(first_comment)
return {"success": False}
cloned_repo = ClonedRepo(
repo_full_name, installation_id=installation_id, token=user_token
)
num_of_files = cloned_repo.get_num_files_from_repo()
time_estimate = math.ceil(3 + 5 * num_of_files / 1000)
indexing_message = (
"I'm searching for relevant snippets in your repository. If this is your first"
" time using Sweep, I'm indexing your repository. This may take up to"
f" {time_estimate} minutes. I'll let you know when I'm done."
)
first_comment = (
f"{get_comment_header(0)}\n{sep}I am currently looking into this ticket! I"
" will update the progress of the ticket in this comment. I am currently"
f" searching through your code, looking for relevant snippets.\n{sep}##"
f" {progress_headers[1]}\n{indexing_message}{bot_suffix}{discord_suffix}"
)
if issue_comment is None:
issue_comment = current_issue.create_comment(first_comment)
else:
issue_comment.edit(first_comment)
# Comment edit function
past_messages = {}
current_index = 0
# Random variables to save in case of errors
table = None # Show plan so user can finetune prompt
def edit_sweep_comment(message: str, index: int, pr_message="", done=False):
nonlocal current_index, user_token, g, repo, issue_comment
# -1 = error, -2 = retry
# Only update the progress bar if the issue generation errors.
errored = index == -1
if index >= 0:
past_messages[index] = message
current_index = index
agg_message = None
# Include progress history
# index = -2 is reserved for
for i in range(
current_index + 2
): # go to next header (for Working on it... text)
if i == 0 or i >= len(progress_headers):
continue # skip None header
header = progress_headers[i]
if header is not None:
header = "## " + header + "\n"
else:
header = "No header\n"
msg = header + (past_messages.get(i) or "Working on it...")
if agg_message is None:
agg_message = msg
else:
agg_message = agg_message + f"\n{sep}" + msg
suffix = bot_suffix + discord_suffix
if errored:
agg_message = (
"## ❌ Unable to Complete PR"
+ "\n"
+ message
+ "\n\nFor bonus GPT-4 tickets, please report this bug on"
" **[Discord](https://discord.com/invite/sweep-ai)**."
)
if table is not None:
agg_message = (
agg_message
+ f"\n{sep}Please look at the generated plan. If something looks"
f" wrong, please add more details to your issue.\n\n{table}"
)
suffix = bot_suffix # don't include discord suffix for error messages
# Update the issue comment
try:
issue_comment.edit(
f"{get_comment_header(current_index, errored, pr_message, done=done)}\n{sep}{agg_message}{suffix}"
)
except BadCredentialsException:
logger.error("Bad credentials, refreshing token")
_user_token, g = get_github_client(installation_id)
repo = g.get_repo(repo_full_name)
issue_comment = repo.get_issue(current_issue.number)
issue_comment.edit(
f"{get_comment_header(current_index, errored, pr_message, done=done)}\n{sep}{agg_message}{suffix}"
)
if len(title + summary) < 20:
logger.info("Issue too short")
edit_sweep_comment(
(
"Please add more details to your issue. I need at least 20 characters"
" to generate a plan."
),
-1,
)
return {"success": True}
if (
repo_name.lower() not in WHITELISTED_REPOS
and not is_paying_user
and not is_trial_user
):
if ("sweep" in repo_name.lower()) or ("test" in repo_name.lower()):
logger.info("Test repository detected")
edit_sweep_comment(
(
"Sweep does not work on test repositories. Please create an issue"
" on a real repository. If you think this is a mistake, please"
" report this at https://discord.gg/sweep."
),
-1,
)
return {"success": False}
if lint_mode:
# Get files to change
# Create new branch
# Send request to endpoint
for file_path in []:
SweepBot.run_sandbox(
repo.html_url, file_path, None, user_token, only_lint=True
)
logger.info("Fetching relevant files...")
try:
snippets, tree = search_snippets(
cloned_repo,
f"{title}\n{summary}\n{replies_text}",
num_files=num_of_snippets_to_query,
)
assert len(snippets) > 0
except SystemExit:
raise SystemExit
except Exception as e:
trace = traceback.format_exc()
logger.error(e)
logger.error(trace)
edit_sweep_comment(
(
"It looks like an issue has occurred around fetching the files."
" Perhaps the repo has not been initialized. If this error persists"
f" contact [email protected].\n\n> @{username}, editing this issue description to include more details will automatically make me relaunch."
),
-1,
)
log_error(
is_paying_user,
is_trial_user,
username,
issue_url,
"File Fetch",
str(e) + "\n" + traceback.format_exc(),
priority=1,
)
raise e
snippets = post_process_snippets(
snippets, max_num_of_snippets=2 if use_faster_model else 5
)
if not repo_description:
repo_description = "No description provided."
message_summary = summary + replies_text
external_results = ExternalSearcher.extract_summaries(message_summary)
if external_results:
message_summary += "\n\n" + external_results
user_dict = get_documentation_dict(repo)
docs_results = ""
try:
docs_results = extract_relevant_docs(
title + message_summary, user_dict, chat_logger
)
if docs_results:
message_summary += "\n\n" + docs_results
except SystemExit:
raise SystemExit
except Exception as e:
logger.error(f"Failed to extract docs: {e}")
human_message = HumanMessagePrompt(
repo_name=repo_name,
issue_url=issue_url,
username=username,
repo_description=repo_description.strip(),
title=title,
summary=message_summary,
snippets=snippets,
tree=tree,
)
context_pruning = ContextPruning(chat_logger=chat_logger)
(
snippets_to_ignore,
excluded_dirs,
) = context_pruning.prune_context( # TODO, ignore directories
human_message, repo=repo
)
snippets = post_process_snippets(
snippets, max_num_of_snippets=5, exclude_snippets=snippets_to_ignore
)
dir_obj = DirectoryTree()
dir_obj.parse(tree)
dir_obj.remove_multiple(excluded_dirs)
tree = str(dir_obj)
logger.info(f"New snippets: {snippets}")
logger.info(f"New tree: {tree}")
human_message = HumanMessagePrompt(
repo_name=repo_name,
issue_url=issue_url,
username=username,
repo_description=repo_description.strip(),
title=title,
summary=message_summary,
snippets=snippets,
tree=tree,
)
_user_token, g = get_github_client(installation_id)
repo = g.get_repo(repo_full_name)
sweep_bot = SweepBot.from_system_message_content(
human_message=human_message,
repo=repo,
is_reply=bool(comments),
chat_logger=chat_logger,
sweep_context=sweep_context,
cloned_repo=cloned_repo,
)
# Check repository for sweep.yml file.
sweep_yml_exists = False
for content_file in repo.get_contents(""):
if content_file.name == "sweep.yaml":
sweep_yml_exists = True
break
# If sweep.yaml does not exist, then create a new PR that simply creates the sweep.yaml file.
if not sweep_yml_exists:
"""
needle = r"""
def get_comment_header(index, errored=False, pr_message="", done=False):
...
return (
f"{center(sweeping_gif)}<br/>{center(pbar)}"
+ ("\n" + stars_suffix if index != -1 else "")
+ "\n"
+ payment_message_start
+ config_pr_message
+ f"\n\n---\n{actions_message}"
)
""".strip(
"\n"
)
matched_section = r"""
def get_comment_header(index, errored=False, pr_message="", done=False):
config_pr_message = (
"\n" + f"* Install Sweep Configs: [Pull Request]({config_pr_url})"
if config_pr_url is not None
else ""
)
actions_message = create_action_buttons(
[
"↻ Restart Sweep",
]
)
if index < 0:
index = 0
if index == 4:
return pr_message + f"\n\n---\n{actions_message}" + config_pr_message
total = len(progress_headers)
index += 1 if done else 0
index *= 100 / total
index = int(index)
index = min(100, index)
if errored:
pbar = f"\n\n<img src='https://progress-bar.dev/{index}/?&title=Errored&width=600' alt='{index}%' />"
return (
f"{center(sweeping_gif)}<br/>{center(pbar)}\n\n"
+ f"\n\n---\n{actions_message}"
)
pbar = f"\n\n<img src='https://progress-bar.dev/{index}/?&title=Progress&width=600' alt='{index}%' />"
return (
f"{center(sweeping_gif)}<br/>{center(pbar)}"
+ ("\n" + stars_suffix if index != -1 else "")
+ "\n"
+ payment_message_start
+ config_pr_message
+ f"\n\n---\n{actions_message}"
)
""".strip(
"\n"
)
score = score_multiline(needle.splitlines(), matched_section.splitlines())
print(score)
# best_match = find_best_match(needle, haystack)
# print("\n".join(haystack.splitlines()[best_match.start : best_match.end]))
| [] |
2024-01-10 | ilyamk/sweep | tests~search~test_lexical_search.py | from sweepai.core.lexical_search import tokenize_call
file_contents = """\
# TODO: Add file validation
import math
import re
import traceback
import openai
import github
from github import GithubException, BadCredentialsException
from tabulate import tabulate
from tqdm import tqdm
from logn import logger, LogTask
from sweepai.core.context_pruning import ContextPruning
from sweepai.core.documentation_searcher import extract_relevant_docs
from sweepai.core.entities import (
ProposedIssue,
SandboxResponse,
Snippet,
NoFilesException,
SweepContext,
MaxTokensExceeded,
EmptyRepository,
)
from sweepai.core.external_searcher import ExternalSearcher
from sweepai.core.slow_mode_expand import SlowModeBot
from sweepai.core.sweep_bot import SweepBot
from sweepai.core.prompts import issue_comment_prompt
# from sandbox.sandbox_utils import Sandbox
from sweepai.handlers.create_pr import (
create_pr_changes,
create_config_pr,
safe_delete_sweep_branch,
)
from sweepai.handlers.on_comment import on_comment
from sweepai.handlers.on_review import review_pr
from sweepai.utils.buttons import create_action_buttons
from sweepai.utils.chat_logger import ChatLogger
from sweepai.config.client import (
SweepConfig,
get_documentation_dict,
)
from sweepai.config.server import (
ENV,
MONGODB_URI,
OPENAI_API_KEY,
GITHUB_BOT_USERNAME,
GITHUB_LABEL_NAME,
OPENAI_USE_3_5_MODEL_ONLY,
WHITELISTED_REPOS,
)
from sweepai.utils.ticket_utils import *
from sweepai.utils.event_logger import posthog
from sweepai.utils.github_utils import ClonedRepo, get_github_client
from sweepai.utils.prompt_constructor import HumanMessagePrompt
from sweepai.utils.search_utils import search_snippets
from sweepai.utils.tree_utils import DirectoryTree
openai.api_key = OPENAI_API_KEY
@LogTask()
def on_ticket(
title: str,
summary: str,
issue_number: int,
issue_url: str,
username: str,
repo_full_name: str,
repo_description: str,
installation_id: int,
comment_id: int = None,
edited: bool = False,
):
(
title,
slow_mode,
do_map,
subissues_mode,
sandbox_mode,
fast_mode,
lint_mode,
) = strip_sweep(title)
# Flow:
# 1. Get relevant files
# 2: Get human message
# 3. Get files to change
# 4. Get file changes
# 5. Create PR
summary = summary or ""
summary = re.sub(
"<details (open)?>\n<summary>Checklist</summary>.*",
"",
summary,
flags=re.DOTALL,
).strip()
summary = re.sub("Checklist:\n\n- \[[ X]\].*", "", summary, flags=re.DOTALL).strip()
repo_name = repo_full_name
user_token, g = get_github_client(installation_id)
repo = g.get_repo(repo_full_name)
current_issue = repo.get_issue(number=issue_number)
assignee = current_issue.assignee.login if current_issue.assignee else None
if assignee is None:
assignee = current_issue.user.login
chat_logger = (
ChatLogger(
{
"repo_name": repo_name,
"title": title,
"summary": summary,
"issue_number": issue_number,
"issue_url": issue_url,
"username": username if not username.startswith("sweep") else assignee,
"repo_full_name": repo_full_name,
"repo_description": repo_description,
"installation_id": installation_id,
"type": "ticket",
"mode": ENV,
"comment_id": comment_id,
"edited": edited,
}
)
if MONGODB_URI
else None
)
if chat_logger:
is_paying_user = chat_logger.is_paying_user()
is_trial_user = chat_logger.is_trial_user()
use_faster_model = OPENAI_USE_3_5_MODEL_ONLY or chat_logger.use_faster_model(g)
else:
is_paying_user = True
is_trial_user = False
use_faster_model = False
if fast_mode:
use_faster_model = True
sweep_context = SweepContext.create(
username=username,
issue_url=issue_url,
use_faster_model=use_faster_model,
is_paying_user=is_paying_user,
repo=repo,
token=user_token,
)
logger.print(sweep_context)
if not comment_id and not edited and chat_logger:
chat_logger.add_successful_ticket(
gpt3=use_faster_model
) # moving higher, will increment the issue regardless of whether it's a success or not
organization, repo_name = repo_full_name.split("/")
metadata = {
"issue_url": issue_url,
"repo_full_name": repo_full_name,
"organization": organization,
"repo_name": repo_name,
"repo_description": repo_description,
"username": username,
"comment_id": comment_id,
"title": title,
"installation_id": installation_id,
"function": "on_ticket",
"edited": edited,
"model": "gpt-3.5" if use_faster_model else "gpt-4",
"tier": "pro" if is_paying_user else "free",
"mode": ENV,
"slow_mode": slow_mode,
"do_map": do_map,
"subissues_mode": subissues_mode,
"sandbox_mode": sandbox_mode,
"fast_mode": fast_mode,
}
# logger.bind(**metadata)
posthog.capture(username, "started", properties=metadata)
logger.info(f"Getting repo {repo_full_name}")
if current_issue.state == "closed":
logger.warning(f"Issue {issue_number} is closed")
posthog.capture(username, "issue_closed", properties=metadata)
return {"success": False, "reason": "Issue is closed"}
current_issue.edit(body=summary)
item_to_react_to = (
current_issue.get_comment(comment_id) if comment_id else current_issue
)
replies_text = ""
comments = list(current_issue.get_comments())
if comment_id:
logger.info(f"Replying to comment {comment_id}...")
replies_text = "\nComments:\n" + "\n".join(
[
issue_comment_prompt.format(
username=comment.user.login,
reply=comment.body,
)
for comment in comments
if comment.user.type == "User"
]
)
summary = summary if summary else ""
prs = repo.get_pulls(
state="open", sort="created", base=SweepConfig.get_branch(repo)
)
for pr in prs:
# Check if this issue is mentioned in the PR, and pr is owned by bot
# This is done in create_pr, (pr_description = ...)
if (
pr.user.login == GITHUB_BOT_USERNAME
and f"Fixes #{issue_number}.\n" in pr.body
):
success = safe_delete_sweep_branch(pr, repo)
eyes_reaction = item_to_react_to.create_reaction("eyes")
# If SWEEP_BOT reacted to item_to_react_to with "rocket", then remove it.
reactions = item_to_react_to.get_reactions()
for reaction in reactions:
if reaction.content == "rocket" and reaction.user.login == GITHUB_BOT_USERNAME:
item_to_react_to.delete_reaction(reaction.id)
# Removed 1, 3
progress_headers = [
None,
"Step 1: 🔎 Searching",
"Step 2: ⌨️ Coding",
"Step 3: 🔁 Code Review",
]
config_pr_url = None
# Find the first comment made by the bot
issue_comment = None
tickets_allocated = 5
if is_trial_user:
tickets_allocated = 15
if is_paying_user:
tickets_allocated = 500
ticket_count = (
max(tickets_allocated - chat_logger.get_ticket_count(), 0)
if chat_logger
else 999
)
daily_ticket_count = (
(3 - chat_logger.get_ticket_count(use_date=True) if not use_faster_model else 0)
if chat_logger
else 999
)
model_name = "GPT-3.5" if use_faster_model else "GPT-4"
payment_link = "https://buy.stripe.com/6oE5npbGVbhC97afZ4"
daily_message = (
f" and {daily_ticket_count} for the day"
if not is_paying_user and not is_trial_user
else ""
)
user_type = "💎 Sweep Pro" if is_paying_user else "⚡ Sweep Free Trial"
gpt_tickets_left_message = (
f"{ticket_count} GPT-4 tickets left for the month"
if not is_paying_user
else "unlimited GPT-4 tickets"
)
payment_message = (
f"{user_type}: I used {model_name} to create this ticket. You have {gpt_tickets_left_message}{daily_message}."
+ (
f" For more GPT-4 tickets, visit [our payment portal.]({payment_link})"
if not is_paying_user
else ""
)
)
payment_message_start = (
f"{user_type}: I'm creating this ticket using {model_name}. You have {gpt_tickets_left_message}{daily_message}."
+ (
f" For more GPT-4 tickets, visit [our payment portal.]({payment_link})"
if not is_paying_user
else ""
)
)
def get_comment_header(index, errored=False, pr_message="", done=False):
config_pr_message = (
"\n" + f"* Install Sweep Configs: [Pull Request]({config_pr_url})"
if config_pr_url is not None
else ""
)
# Why is this so convoluted
# config_pr_message = " To retrigger Sweep, edit the issue.\n" + config_pr_message
actions_message = create_action_buttons(
[
"Restart Sweep",
]
)
if index < 0:
index = 0
if index == 4:
return pr_message + f"\n\n---\n{actions_message}" + config_pr_message
total = len(progress_headers)
index += 1 if done else 0
index *= 100 / total
index = int(index)
index = min(100, index)
if errored:
return (
f""
+ f"\n\n---\n{actions_message}"
)
return (
f""
+ ("\n" + stars_suffix if index != -1 else "")
+ "\n"
+ payment_message_start
# + f"\n\n---\n{actions_message}"
+ config_pr_message
)
# Find Sweep's previous comment
logger.print("USERNAME", GITHUB_BOT_USERNAME)
for comment in comments:
logger.print("COMMENT", comment.user.login)
if comment.user.login == GITHUB_BOT_USERNAME:
logger.print("Found comment")
issue_comment = comment
try:
config = SweepConfig.get_config(repo)
except EmptyRepository as e:
logger.info("Empty repo")
first_comment = (
"Sweep is currently not supported on empty repositories. Please add some"
f" code to your repository and try again.\n{sep}##"
f" {progress_headers[1]}\n{bot_suffix}{discord_suffix}"
)
if issue_comment is None:
issue_comment = current_issue.create_comment(first_comment)
else:
issue_comment.edit(first_comment)
return {"success": False}
cloned_repo = ClonedRepo(
repo_full_name, installation_id=installation_id, token=user_token
)
num_of_files = cloned_repo.get_num_files_from_repo()
time_estimate = math.ceil(3 + 5 * num_of_files / 1000)
indexing_message = (
"I'm searching for relevant snippets in your repository. If this is your first"
" time using Sweep, I'm indexing your repository. This may take up to"
f" {time_estimate} minutes. I'll let you know when I'm done."
)
first_comment = (
f"{get_comment_header(0)}\n{sep}I am currently looking into this ticket! I"
" will update the progress of the ticket in this comment. I am currently"
f" searching through your code, looking for relevant snippets.\n{sep}##"
f" {progress_headers[1]}\n{indexing_message}{bot_suffix}{discord_suffix}"
)
if issue_comment is None:
issue_comment = current_issue.create_comment(first_comment)
else:
issue_comment.edit(first_comment)
# Comment edit function
past_messages = {}
current_index = 0
# Random variables to save in case of errors
table = None # Show plan so user can finetune prompt
def edit_sweep_comment(message: str, index: int, pr_message="", done=False):
nonlocal current_index, user_token, g, repo, issue_comment
# -1 = error, -2 = retry
# Only update the progress bar if the issue generation errors.
errored = index == -1
if index >= 0:
past_messages[index] = message
current_index = index
agg_message = None
# Include progress history
# index = -2 is reserved for
for i in range(
current_index + 2
): # go to next header (for Working on it... text)
if i == 0 or i >= len(progress_headers):
continue # skip None header
header = progress_headers[i]
if header is not None:
header = "## " + header + "\n"
else:
header = "No header\n"
msg = header + (past_messages.get(i) or "Working on it...")
if agg_message is None:
agg_message = msg
else:
agg_message = agg_message + f"\n{sep}" + msg
suffix = bot_suffix + discord_suffix
if errored:
agg_message = (
"## ❌ Unable to Complete PR"
+ "\n"
+ message
+ "\n\nFor bonus GPT-4 tickets, please report this bug on"
" **[Discord](https://discord.com/invite/sweep-ai)**."
)
if table is not None:
agg_message = (
agg_message
+ f"\n{sep}Please look at the generated plan. If something looks"
f" wrong, please add more details to your issue.\n\n{table}"
)
suffix = bot_suffix # don't include discord suffix for error messages
# Update the issue comment
try:
issue_comment.edit(
f"{get_comment_header(current_index, errored, pr_message, done=done)}\n{sep}{agg_message}{suffix}"
)
except BadCredentialsException:
logger.error("Bad credentials, refreshing token")
_user_token, g = get_github_client(installation_id)
repo = g.get_repo(repo_full_name)
issue_comment = repo.get_issue(current_issue.number)
issue_comment.edit(
f"{get_comment_header(current_index, errored, pr_message, done=done)}\n{sep}{agg_message}{suffix}"
)
if len(title + summary) < 20:
logger.info("Issue too short")
edit_sweep_comment(
(
"Please add more details to your issue. I need at least 20 characters"
" to generate a plan."
),
-1,
)
return {"success": True}
if (
repo_name.lower() not in WHITELISTED_REPOS
and not is_paying_user
and not is_trial_user
):
if ("sweep" in repo_name.lower()) or ("test" in repo_name.lower()):
logger.info("Test repository detected")
edit_sweep_comment(
(
"Sweep does not work on test repositories. Please create an issue"
" on a real repository. If you think this is a mistake, please"
" report this at https://discord.gg/sweep."
),
-1,
)
return {"success": False}
if lint_mode:
# Get files to change
# Create new branch
# Send request to endpoint
for file_path in []:
SweepBot.run_sandbox(
repo.html_url, file_path, None, user_token, only_lint=True
)
logger.info("Fetching relevant files...")
try:
snippets, tree = search_snippets(
cloned_repo,
f"{title}\n{summary}\n{replies_text}",
num_files=num_of_snippets_to_query,
)
assert len(snippets) > 0
except SystemExit:
raise SystemExit
except Exception as e:
trace = traceback.format_exc()
logger.error(e)
logger.error(trace)
edit_sweep_comment(
(
"It looks like an issue has occurred around fetching the files."
" Perhaps the repo has not been initialized. If this error persists"
f" contact [email protected].\n\n> @{username}, please edit the issue"
" description to include more details and I will automatically"
" relaunch."
),
-1,
)
log_error(
is_paying_user,
is_trial_user,
username,
issue_url,
"File Fetch",
str(e) + "\n" + traceback.format_exc(),
priority=1,
)
raise e
snippets = post_process_snippets(
snippets, max_num_of_snippets=2 if use_faster_model else 5
)
if not repo_description:
repo_description = "No description provided."
message_summary = summary + replies_text
external_results = ExternalSearcher.extract_summaries(message_summary)
if external_results:
message_summary += "\n\n" + external_results
user_dict = get_documentation_dict(repo)
docs_results = ""
try:
docs_results = extract_relevant_docs(
title + message_summary, user_dict, chat_logger
)
if docs_results:
message_summary += "\n\n" + docs_results
except SystemExit:
raise SystemExit
except Exception as e:
logger.error(f"Failed to extract docs: {e}")
human_message = HumanMessagePrompt(
repo_name=repo_name,
issue_url=issue_url,
username=username,
repo_description=repo_description.strip(),
title=title,
summary=message_summary,
snippets=snippets,
tree=tree,
)
context_pruning = ContextPruning(chat_logger=chat_logger)
(
snippets_to_ignore,
excluded_dirs,
) = context_pruning.prune_context( # TODO, ignore directories
human_message, repo=repo
)
snippets = post_process_snippets(
snippets, max_num_of_snippets=5, exclude_snippets=snippets_to_ignore
)
dir_obj = DirectoryTree()
dir_obj.parse(tree)
dir_obj.remove_multiple(excluded_dirs)
tree = str(dir_obj)
logger.info(f"New snippets: {snippets}")
logger.info(f"New tree: {tree}")
human_message = HumanMessagePrompt(
repo_name=repo_name,
issue_url=issue_url,
username=username,
repo_description=repo_description.strip(),
title=title,
summary=message_summary,
snippets=snippets,
tree=tree,
)
_user_token, g = get_github_client(installation_id)
repo = g.get_repo(repo_full_name)
sweep_bot = SweepBot.from_system_message_content(
human_message=human_message,
repo=repo,
is_reply=bool(comments),
chat_logger=chat_logger,
sweep_context=sweep_context,
)
# Check repository for sweep.yml file.
sweep_yml_exists = False
for content_file in repo.get_contents(""):
if content_file.name == "sweep.yaml":
sweep_yml_exists = True
break
# If sweep.yaml does not exist, then create a new PR that simply creates the sweep.yaml file.
if not sweep_yml_exists:
try:
logger.info("Creating sweep.yaml file...")
config_pr = create_config_pr(sweep_bot)
config_pr_url = config_pr.html_url
edit_sweep_comment(message="", index=-2)
except SystemExit:
raise SystemExit
except Exception as e:
logger.error(
"Failed to create new branch for sweep.yaml file.\n",
e,
traceback.format_exc(),
)
else:
logger.info("sweep.yaml file already exists.")
try:
# ANALYZE SNIPPETS
newline = "\n"
edit_sweep_comment(
"I found the following snippets in your repository. I will now analyze"
" these snippets and come up with a plan."
+ "\n\n"
+ create_collapsible(
"Some code snippets I looked at (click to expand). If some file is"
" missing from here, you can mention the path in the ticket"
" description.",
"\n".join(
[
f"https://github.com/{organization}/{repo_name}/blob/{repo.get_commits()[0].sha}/{snippet.file_path}#L{max(snippet.start, 1)}-L{min(snippet.end, snippet.content.count(newline) - 1)}\n"
for snippet in snippets
]
),
)
+ (
create_collapsible(
"I also found the following external resources that might be helpful:",
f"\n\n{external_results}\n\n",
)
if external_results
else ""
)
+ (f"\n\n{docs_results}\n\n" if docs_results else ""),
1,
)
if do_map:
subissues: list[ProposedIssue] = sweep_bot.generate_subissues()
edit_sweep_comment(
f"I'm creating the following subissues:\n\n"
+ "\n\n".join(
[
f"#{subissue.title}:\n" + blockquote(subissue.body)
for subissue in subissues
]
),
2,
)
for subissue in tqdm(subissues):
subissue.issue_id = repo.create_issue(
title="Sweep: " + subissue.title,
body=subissue.body + f"\n\nParent issue: #{issue_number}",
assignee=username,
).number
subissues_checklist = "\n\n".join(
[
f"- [ ] #{subissue.issue_id}\n\n"
+ blockquote(f"**{subissue.title}**\n{subissue.body}")
for subissue in subissues
]
)
current_issue.edit(
body=summary + "\n\n---\n\nChecklist:\n\n" + subissues_checklist
)
edit_sweep_comment(
f"I finished creating the subissues! Track them at:\n\n"
+ "\n".join(f"* #{subissue.issue_id}" for subissue in subissues),
3,
done=True,
)
edit_sweep_comment(f"N/A", 4)
edit_sweep_comment(f"I finished creating all the subissues.", 5)
return {"success": True}
# COMMENT ON ISSUE
# TODO: removed issue commenting here
logger.info("Fetching files to modify/create...")
file_change_requests, plan = sweep_bot.get_files_to_change()
if not file_change_requests:
if len(title + summary) < 60:
edit_sweep_comment(
(
"Sorry, I could not find any files to modify, can you please"
" provide more details? Please make sure that the title and"
" summary of the issue are at least 60 characters."
),
-1,
)
else:
edit_sweep_comment(
(
"Sorry, I could not find any files to modify, can you please"
" provide more details?"
),
-1,
)
raise Exception("No files to modify.")
sweep_bot.summarize_snippets()
file_change_requests = sweep_bot.validate_file_change_requests(
file_change_requests
)
table = tabulate(
[
[
f"`{file_change_request.filename}`",
file_change_request.instructions_display.replace(
"\n", "<br/>"
).replace("```", "\\```"),
]
for file_change_request in file_change_requests
],
headers=["File Path", "Proposed Changes"],
tablefmt="pipe",
)
# edit_sweep_comment(
# "From looking through the relevant snippets, I decided to make the"
# " following modifications:\n\n" + table + "\n\n",
# 2,
# )
# TODO(lukejagg): Generate PR after modifications are made
# CREATE PR METADATA
logger.info("Generating PR...")
pull_request = sweep_bot.generate_pull_request()
# pull_request_content = pull_request.content.strip().replace("\n", "\n>")
# pull_request_summary = f"**{pull_request.title}**\n`{pull_request.branch_name}`\n>{pull_request_content}\n"
# edit_sweep_comment(
# (
# "I have created a plan for writing the pull request. I am now working"
# " my plan and coding the required changes to address this issue. Here"
# f" is the planned pull request:\n\n{pull_request_summary}"
# ),
# 3,
# )
logger.info("Making PR...")
files_progress: list[tuple[str, str, str, str]] = [
(
file_change_request.filename,
file_change_request.instructions_display,
"⏳ In Progress",
"",
)
for file_change_request in file_change_requests
]
checkboxes_progress: list[tuple[str, str, str]] = [
(file_change_request.filename, file_change_request.instructions, " ")
for file_change_request in file_change_requests
]
checkboxes_contents = "\n".join(
[
create_checkbox(f"`{filename}`", blockquote(instructions), check == "X")
for filename, instructions, check in checkboxes_progress
]
)
checkboxes_collapsible = create_collapsible(
"Checklist", checkboxes_contents, opened=True
)
issue = repo.get_issue(number=issue_number)
issue.edit(body=summary + "\n\n" + checkboxes_collapsible)
delete_branch = False
generator = create_pr_changes( # make this async later
file_change_requests,
pull_request,
sweep_bot,
username,
installation_id,
issue_number,
chat_logger=chat_logger,
)
edit_sweep_comment(checkboxes_contents, 2)
response = {"error": NoFilesException()}
for item in generator:
if isinstance(item, dict):
response = item
break
file_change_request, changed_file, sandbox_response, commit = item
sandbox_response: SandboxResponse | None = sandbox_response
format_exit_code = (
lambda exit_code: "✓" if exit_code == 0 else f"❌ (`{exit_code}`)"
)
logger.print(sandbox_response)
error_logs = (
(
create_collapsible(
"Sandbox Execution Logs",
blockquote(
"\n\n".join(
[
create_collapsible(
f"<code>{execution.command.format(file_path=file_change_request.filename)}</code> {i + 1}/{len(sandbox_response.executions)} {format_exit_code(execution.exit_code)}",
f"<pre>{clean_logs(execution.output)}</pre>",
i == len(sandbox_response.executions) - 1,
)
for i, execution in enumerate(
sandbox_response.executions
)
if len(sandbox_response.executions) > 0
# And error code check
]
)
),
opened=True,
)
)
if sandbox_response
else ""
)
if changed_file:
logger.print("Changed File!")
commit_hash = (
commit.sha
if commit is not None
else repo.get_branch(pull_request.branch_name).commit.sha
)
commit_url = f"https://github.com/{repo_full_name}/commit/{commit_hash}"
checkboxes_progress = [
(
(
f"`{filename}` ✅ Commit [`{commit_hash[:7]}`]({commit_url})",
blockquote(instructions) + error_logs,
"X",
)
if file_change_request.filename == filename
else (filename, instructions, progress)
)
for filename, instructions, progress in checkboxes_progress
]
else:
logger.print("Didn't change file!")
checkboxes_progress = [
(
(
f"`{filename}` ❌ Failed",
blockquote(instructions) + error_logs,
"X",
)
if file_change_request.filename == filename
else (filename, instructions, progress)
)
for filename, instructions, progress in checkboxes_progress
]
checkboxes_contents = "\n".join(
[
checkbox_template.format(
check=check,
filename=filename,
instructions=instructions,
)
for filename, instructions, check in checkboxes_progress
]
)
checkboxes_collapsible = collapsible_template.format(
summary="Checklist",
body=checkboxes_contents,
opened="open",
)
issue = repo.get_issue(number=issue_number)
issue.edit(body=summary + "\n\n" + checkboxes_collapsible)
logger.info(files_progress)
logger.info(f"Edited {file_change_request.filename}")
edit_sweep_comment(checkboxes_contents, 2)
if not response.get("success"):
raise Exception(f"Failed to create PR: {response.get('error')}")
pr_changes = response["pull_request"]
edit_sweep_comment(
"I have finished coding the issue. I am now reviewing it for completeness.",
3,
)
change_location = f" [`{pr_changes.pr_head}`](https://github.com/{repo_full_name}/commits/{pr_changes.pr_head}).\n\n"
review_message = "Here are my self-reviews of my changes at" + change_location
lint_output = None
try:
current_issue.delete_reaction(eyes_reaction.id)
except SystemExit:
raise SystemExit
except:
pass
changes_required = False
try:
# Todo(lukejagg): Pass sandbox linter results to review_pr
# CODE REVIEW
changes_required, review_comment = review_pr(
repo=repo,
pr=pr_changes,
issue_url=issue_url,
username=username,
repo_description=repo_description,
title=title,
summary=summary,
replies_text=replies_text,
tree=tree,
lint_output=lint_output,
plan=plan, # plan for the PR
chat_logger=chat_logger,
)
# Todo(lukejagg): Execute sandbox after each iteration
lint_output = None
review_message += (
f"Here is the {ordinal(1)} review\n"
+ blockquote(review_comment)
+ "\n\n"
)
if changes_required:
edit_sweep_comment(
review_message + "\n\nI'm currently addressing these suggestions.",
3,
)
logger.info(f"Addressing review comment {review_comment}")
on_comment(
repo_full_name=repo_full_name,
repo_description=repo_description,
comment=review_comment,
username=username,
installation_id=installation_id,
pr_path=None,
pr_line_position=None,
pr_number=None,
pr=pr_changes,
chat_logger=chat_logger,
repo=repo,
)
except SystemExit:
raise SystemExit
except Exception as e:
logger.error(traceback.format_exc())
logger.error(e)
if changes_required:
edit_sweep_comment(
review_message + "\n\nI finished incorporating these changes.",
3,
)
else:
edit_sweep_comment(
f"I have finished reviewing the code for completeness. I did not find errors for {change_location}.",
3,
)
is_draft = config.get("draft", False)
try:
pr = repo.create_pull(
title=pr_changes.title,
body=pr_changes.body,
head=pr_changes.pr_head,
base=SweepConfig.get_branch(repo),
draft=is_draft,
)
except GithubException as e:
is_draft = False
pr = repo.create_pull(
title=pr_changes.title,
body=pr_changes.body,
head=pr_changes.pr_head,
base=SweepConfig.get_branch(repo),
draft=is_draft,
)
pr.add_to_labels(GITHUB_LABEL_NAME)
current_issue.create_reaction("rocket")
logger.info("Running github actions...")
try:
if is_draft:
logger.info("Skipping github actions because PR is a draft")
else:
commit = pr.get_commits().reversed[0]
check_runs = commit.get_check_runs()
for check_run in check_runs:
check_run.rerequest()
except SystemExit:
raise SystemExit
except Exception as e:
logger.error(e)
# Completed code review
edit_sweep_comment(
review_message + "\n\nSuccess! 🚀",
4,
pr_message=(
f"## Here's the PR! [{pr.html_url}]({pr.html_url}).\n{payment_message}"
),
done=True,
)
logger.info("Add successful ticket to counter")
except MaxTokensExceeded as e:
logger.info("Max tokens exceeded")
log_error(
is_paying_user,
is_trial_user,
username,
issue_url,
"Max Tokens Exceeded",
str(e) + "\n" + traceback.format_exc(),
priority=2,
)
if chat_logger.is_paying_user():
edit_sweep_comment(
(
f"Sorry, I could not edit `{e.filename}` as this file is too long."
" We are currently working on improved file streaming to address"
" this issue.\n"
),
-1,
)
else:
edit_sweep_comment(
(
f"Sorry, I could not edit `{e.filename}` as this file is too"
" long.\n\nIf this file is incorrect, please describe the desired"
" file in the prompt. However, if you would like to edit longer"
" files, consider upgrading to [Sweep Pro](https://sweep.dev/) for"
" longer context lengths.\n"
),
-1,
)
delete_branch = True
raise e
except NoFilesException as e:
logger.info("Sweep could not find files to modify")
log_error(
is_paying_user,
is_trial_user,
username,
issue_url,
"Sweep could not find files to modify",
str(e) + "\n" + traceback.format_exc(),
priority=2,
)
edit_sweep_comment(
(
"Sorry, Sweep could not find any appropriate files to edit to address"
" this issue. If this is a mistake, please provide more context and I"
f" will retry!\n\n> @{username}, please edit the issue description to"
" include more details about this issue."
),
-1,
)
delete_branch = True
raise e
except openai.error.InvalidRequestError as e:
logger.error(traceback.format_exc())
logger.error(e)
edit_sweep_comment(
(
"I'm sorry, but it looks our model has ran out of context length. We're"
" trying to make this happen less, but one way to mitigate this is to"
" code smaller files. If this error persists report it at"
" https://discord.gg/sweep."
),
-1,
)
log_error(
is_paying_user,
is_trial_user,
username,
issue_url,
"Context Length",
str(e) + "\n" + traceback.format_exc(),
priority=2,
)
posthog.capture(
username,
"failed",
properties={
"error": str(e),
"reason": "Invalid request error / context length",
**metadata,
},
)
delete_branch = True
raise e
except SystemExit:
raise SystemExit
except Exception as e:
logger.error(traceback.format_exc())
logger.error(e)
# title and summary are defined elsewhere
if len(title + summary) < 60:
edit_sweep_comment(
(
"I'm sorry, but it looks like an error has occurred due to"
" insufficient information. Be sure to create a more detailed issue"
" so I can better address it. If this error persists report it at"
" https://discord.gg/sweep."
),
-1,
)
else:
edit_sweep_comment(
(
"I'm sorry, but it looks like an error has occurred. Try changing"
" the issue description to re-trigger Sweep. If this error persists"
" contact [email protected]."
),
-1,
)
log_error(
is_paying_user,
is_trial_user,
username,
issue_url,
"Workflow",
str(e) + "\n" + traceback.format_exc(),
priority=1,
)
posthog.capture(
username,
"failed",
properties={"error": str(e), "reason": "Generic error", **metadata},
)
raise e
else:
try:
item_to_react_to.delete_reaction(eyes_reaction.id)
item_to_react_to.create_reaction("rocket")
except SystemExit:
raise SystemExit
except Exception as e:
logger.error(e)
finally:
cloned_repo.delete()
if delete_branch:
try:
if pull_request.branch_name.startswith("sweep"):
repo.get_git_ref(f"heads/{pull_request.branch_name}").delete()
else:
raise Exception(
f"Branch name {pull_request.branch_name} does not start with sweep/"
)
except SystemExit:
raise SystemExit
except Exception as e:
logger.error(e)
logger.error(traceback.format_exc())
logger.print("Deleted branch", pull_request.branch_name)
posthog.capture(username, "success", properties={**metadata})
logger.info("on_ticket success")
return {"success": True}
"""
tokens = tokenize_call(file_contents)
symbols = list(set([token.text for token in tokens]))
print(symbols)
import pdb
pdb.set_trace()
| [] |
2024-01-10 | ilyamk/sweep | sweepai~handlers~on_ticket.py | """
on_ticket is the main function that is called when a new issue is created.
It is only called by the webhook handler in sweepai/api.py.
"""
# TODO: Add file validation
import math
import re
import traceback
import openai
import github
from github import GithubException, BadCredentialsException
from tabulate import tabulate
from tqdm import tqdm
from logn import logger, LogTask
from sweepai.core.context_pruning import ContextPruning
from sweepai.core.documentation_searcher import extract_relevant_docs
from sweepai.core.entities import (
ProposedIssue,
SandboxResponse,
Snippet,
NoFilesException,
SweepContext,
MaxTokensExceeded,
EmptyRepository,
)
from sweepai.core.external_searcher import ExternalSearcher
from sweepai.core.slow_mode_expand import SlowModeBot
from sweepai.core.sweep_bot import SweepBot
from sweepai.core.prompts import issue_comment_prompt
# from sandbox.sandbox_utils import Sandbox
from sweepai.handlers.create_pr import (
create_pr_changes,
create_config_pr,
safe_delete_sweep_branch,
)
from sweepai.handlers.on_comment import on_comment
from sweepai.handlers.on_review import review_pr
from sweepai.utils.buttons import create_action_buttons
from sweepai.utils.chat_logger import ChatLogger
from sweepai.config.client import (
SweepConfig,
get_documentation_dict,
RESTART_SWEEP_BUTTON,
SWEEP_BAD_FEEDBACK,
SWEEP_GOOD_FEEDBACK,
)
from sweepai.config.server import (
ENV,
MONGODB_URI,
OPENAI_API_KEY,
GITHUB_BOT_USERNAME,
GITHUB_LABEL_NAME,
OPENAI_USE_3_5_MODEL_ONLY,
WHITELISTED_REPOS,
DISCORD_FEEDBACK_WEBHOOK_URL,
)
from sweepai.utils.ticket_utils import *
from sweepai.utils.event_logger import posthog
from sweepai.utils.github_utils import ClonedRepo, get_github_client
from sweepai.utils.prompt_constructor import HumanMessagePrompt
from sweepai.utils.search_utils import search_snippets
from sweepai.utils.tree_utils import DirectoryTree
openai.api_key = OPENAI_API_KEY
sweeping_gif = """<a href="https://github.com/sweepai/sweep"><img class="swing" src="https://raw.githubusercontent.com/sweepai/sweep/main/.assets/sweeping.gif" width="100" style="width:50px; margin-bottom:10px" alt="Sweeping"></a>"""
def center(text: str) -> str:
return f"<div align='center'>{text}</div>"
@LogTask()
def on_ticket(
title: str,
summary: str,
issue_number: int,
issue_url: str,
username: str,
repo_full_name: str,
repo_description: str,
installation_id: int,
comment_id: int = None,
edited: bool = False,
):
(
title,
slow_mode,
do_map,
subissues_mode,
sandbox_mode,
fast_mode,
lint_mode,
) = strip_sweep(title)
# Flow:
# 1. Get relevant files
# 2: Get human message
# 3. Get files to change
# 4. Get file changes
# 5. Create PR
summary = summary or ""
# Check for \r since GitHub issues may have \r\n
summary = re.sub(
"<details (open)?>(\r)?\n<summary>Checklist</summary>.*",
"",
summary,
flags=re.DOTALL,
).strip()
summary = re.sub(
"---\s+Checklist:(\r)?\n(\r)?\n- \[[ X]\].*", "", summary, flags=re.DOTALL
).strip()
repo_name = repo_full_name
user_token, g = get_github_client(installation_id)
repo = g.get_repo(repo_full_name)
current_issue = repo.get_issue(number=issue_number)
assignee = current_issue.assignee.login if current_issue.assignee else None
if assignee is None:
assignee = current_issue.user.login
chat_logger = (
ChatLogger(
{
"repo_name": repo_name,
"title": title,
"summary": summary,
"issue_number": issue_number,
"issue_url": issue_url,
"username": username if not username.startswith("sweep") else assignee,
"repo_full_name": repo_full_name,
"repo_description": repo_description,
"installation_id": installation_id,
"type": "ticket",
"mode": ENV,
"comment_id": comment_id,
"edited": edited,
}
)
if MONGODB_URI
else None
)
if chat_logger:
is_paying_user = chat_logger.is_paying_user()
is_trial_user = chat_logger.is_trial_user()
use_faster_model = OPENAI_USE_3_5_MODEL_ONLY or chat_logger.use_faster_model(g)
else:
is_paying_user = True
is_trial_user = False
use_faster_model = False
if fast_mode:
use_faster_model = True
sweep_context = SweepContext.create(
username=username,
issue_url=issue_url,
use_faster_model=use_faster_model,
is_paying_user=is_paying_user,
repo=repo,
token=user_token,
)
logger.print(sweep_context)
if not comment_id and not edited and chat_logger:
chat_logger.add_successful_ticket(
gpt3=use_faster_model
) # moving higher, will increment the issue regardless of whether it's a success or not
organization, repo_name = repo_full_name.split("/")
metadata = {
"issue_url": issue_url,
"repo_full_name": repo_full_name,
"organization": organization,
"repo_name": repo_name,
"repo_description": repo_description,
"username": username,
"comment_id": comment_id,
"title": title,
"installation_id": installation_id,
"function": "on_ticket",
"edited": edited,
"model": "gpt-3.5" if use_faster_model else "gpt-4",
"tier": "pro" if is_paying_user else "free",
"mode": ENV,
"slow_mode": slow_mode,
"do_map": do_map,
"subissues_mode": subissues_mode,
"sandbox_mode": sandbox_mode,
"fast_mode": fast_mode,
}
# logger.bind(**metadata)
posthog.capture(username, "started", properties=metadata)
logger.info(f"Getting repo {repo_full_name}")
if current_issue.state == "closed":
logger.warning(f"Issue {issue_number} is closed")
posthog.capture(username, "issue_closed", properties=metadata)
return {"success": False, "reason": "Issue is closed"}
# Add :eyes: emoji to ticket
item_to_react_to = (
current_issue.get_comment(comment_id) if comment_id else current_issue
)
eyes_reaction = item_to_react_to.create_reaction("eyes")
# If SWEEP_BOT reacted to item_to_react_to with "rocket", then remove it.
reactions = item_to_react_to.get_reactions()
for reaction in reactions:
if reaction.content == "rocket" and reaction.user.login == GITHUB_BOT_USERNAME:
item_to_react_to.delete_reaction(reaction.id)
current_issue.edit(body=summary)
replies_text = ""
comments = list(current_issue.get_comments())
if comment_id:
logger.info(f"Replying to comment {comment_id}...")
replies_text = "\nComments:\n" + "\n".join(
[
issue_comment_prompt.format(
username=comment.user.login,
reply=comment.body,
)
for comment in comments
if comment.user.type == "User"
]
)
summary = summary if summary else ""
prs = repo.get_pulls(
state="open", sort="created", base=SweepConfig.get_branch(repo)
)
for pr in prs:
# Check if this issue is mentioned in the PR, and pr is owned by bot
# This is done in create_pr, (pr_description = ...)
if (
pr.user.login == GITHUB_BOT_USERNAME
and f"Fixes #{issue_number}.\n" in pr.body
):
success = safe_delete_sweep_branch(pr, repo)
# Removed 1, 3
progress_headers = [
None,
"Step 1: 🔎 Searching",
"Step 2: ⌨️ Coding",
"Step 3: 🔁 Code Review",
]
config_pr_url = None
# Find the first comment made by the bot
issue_comment = None
tickets_allocated = 5
if is_trial_user:
tickets_allocated = 15
if is_paying_user:
tickets_allocated = 500
ticket_count = (
max(tickets_allocated - chat_logger.get_ticket_count(), 0)
if chat_logger
else 999
)
daily_ticket_count = (
(3 - chat_logger.get_ticket_count(use_date=True) if not use_faster_model else 0)
if chat_logger
else 999
)
model_name = "GPT-3.5" if use_faster_model else "GPT-4"
payment_link = "https://buy.stripe.com/6oE5npbGVbhC97afZ4"
daily_message = (
f" and {daily_ticket_count} for the day"
if not is_paying_user and not is_trial_user
else ""
)
user_type = "💎 Sweep Pro" if is_paying_user else "⚡ Sweep Free Trial"
gpt_tickets_left_message = (
f"{ticket_count} GPT-4 tickets left for the month"
if not is_paying_user
else "unlimited GPT-4 tickets"
)
payment_message = (
f"{user_type}: I used {model_name} to create this ticket. You have {gpt_tickets_left_message}{daily_message}."
+ (
f" For more GPT-4 tickets, visit [our payment portal.]({payment_link})"
if not is_paying_user
else ""
)
)
payment_message_start = (
f"{user_type}: I'm creating this ticket using {model_name}. You have {gpt_tickets_left_message}{daily_message}."
+ (
f" For more GPT-4 tickets, visit [our payment portal.]({payment_link})"
if not is_paying_user
else ""
)
)
def get_comment_header(index, errored=False, pr_message="", done=False):
config_pr_message = (
"\n" + f"* Install Sweep Configs: [Pull Request]({config_pr_url})"
if config_pr_url is not None
else ""
)
actions_message = create_action_buttons(
[
RESTART_SWEEP_BUTTON,
]
)
if index < 0:
index = 0
if index == 4:
return pr_message + f"\n\n---\n{actions_message}" + config_pr_message
total = len(progress_headers)
index += 1 if done else 0
index *= 100 / total
index = int(index)
index = min(100, index)
if errored:
pbar = f"\n\n<img src='https://progress-bar.dev/{index}/?&title=Errored&width=600' alt='{index}%' />"
return (
f"{center(sweeping_gif)}<br/>{center(pbar)}\n\n"
+ f"\n\n---\n{actions_message}"
)
pbar = f"\n\n<img src='https://progress-bar.dev/{index}/?&title=Progress&width=600' alt='{index}%' />"
return (
f"{center(sweeping_gif)}<br/>{center(pbar)}"
+ ("\n" + stars_suffix if index != -1 else "")
+ "\n"
+ center(payment_message_start)
+ config_pr_message
+ f"\n\n---\n{actions_message}"
)
# Find Sweep's previous comment
logger.print("USERNAME", GITHUB_BOT_USERNAME)
for comment in comments:
logger.print("COMMENT", comment.user.login)
if comment.user.login == GITHUB_BOT_USERNAME:
logger.print("Found comment")
issue_comment = comment
try:
config = SweepConfig.get_config(repo)
except EmptyRepository as e:
logger.info("Empty repo")
first_comment = (
"Sweep is currently not supported on empty repositories. Please add some"
f" code to your repository and try again.\n{sep}##"
f" {progress_headers[1]}\n{bot_suffix}{discord_suffix}"
)
if issue_comment is None:
issue_comment = current_issue.create_comment(first_comment)
else:
issue_comment.edit(first_comment)
return {"success": False}
cloned_repo = ClonedRepo(
repo_full_name, installation_id=installation_id, token=user_token
)
num_of_files = cloned_repo.get_num_files_from_repo()
time_estimate = math.ceil(3 + 5 * num_of_files / 1000)
indexing_message = (
"I'm searching for relevant snippets in your repository. If this is your first"
" time using Sweep, I'm indexing your repository. This may take up to"
f" {time_estimate} minutes. I'll let you know when I'm done."
)
first_comment = (
f"{get_comment_header(0)}\n{sep}I am currently looking into this ticket! I"
" will update the progress of the ticket in this comment. I am currently"
f" searching through your code, looking for relevant snippets.\n{sep}##"
f" {progress_headers[1]}\n{indexing_message}{bot_suffix}{discord_suffix}"
)
if issue_comment is None:
issue_comment = current_issue.create_comment(first_comment)
else:
issue_comment.edit(first_comment)
# Comment edit function
past_messages = {}
current_index = 0
# Random variables to save in case of errors
table = None # Show plan so user can finetune prompt
def edit_sweep_comment(message: str, index: int, pr_message="", done=False):
nonlocal current_index, user_token, g, repo, issue_comment
# -1 = error, -2 = retry
# Only update the progress bar if the issue generation errors.
errored = index == -1
if index >= 0:
past_messages[index] = message
current_index = index
agg_message = None
# Include progress history
# index = -2 is reserved for
for i in range(
current_index + 2
): # go to next header (for Working on it... text)
if i == 0 or i >= len(progress_headers):
continue # skip None header
header = progress_headers[i]
if header is not None:
header = "## " + header + "\n"
else:
header = "No header\n"
msg = header + (past_messages.get(i) or "Working on it...")
if agg_message is None:
agg_message = msg
else:
agg_message = agg_message + f"\n{sep}" + msg
suffix = bot_suffix + discord_suffix
if errored:
agg_message = (
"## ❌ Unable to Complete PR"
+ "\n"
+ message
+ "\n\nFor bonus GPT-4 tickets, please report this bug on"
" **[Discord](https://discord.com/invite/sweep-ai)**."
)
if table is not None:
agg_message = (
agg_message
+ f"\n{sep}Please look at the generated plan. If something looks"
f" wrong, please add more details to your issue.\n\n{table}"
)
suffix = bot_suffix # don't include discord suffix for error messages
# Update the issue comment
msg = f"{get_comment_header(current_index, errored, pr_message, done=done)}\n{sep}{agg_message}{suffix}"
try:
issue_comment.edit(msg)
except BadCredentialsException:
logger.error("Bad credentials, refreshing token")
_user_token, g = get_github_client(installation_id)
repo = g.get_repo(repo_full_name)
for comment in comments:
if comment.user.login == GITHUB_BOT_USERNAME:
issue_comment = comment
if issue_comment is None:
issue_comment = current_issue.create_comment(msg)
else:
issue_comment.edit(msg)
if len(title + summary) < 20:
logger.info("Issue too short")
edit_sweep_comment(
(
"Please add more details to your issue. I need at least 20 characters"
" to generate a plan."
),
-1,
)
return {"success": True}
if (
repo_name.lower() not in WHITELISTED_REPOS
and not is_paying_user
and not is_trial_user
):
if ("sweep" in repo_name.lower()) or ("test" in repo_name.lower()):
logger.info("Test repository detected")
edit_sweep_comment(
(
"Sweep does not work on test repositories. Please create an issue"
" on a real repository. If you think this is a mistake, please"
" report this at https://discord.gg/sweep."
),
-1,
)
return {"success": False}
if lint_mode:
# Get files to change
# Create new branch
# Send request to endpoint
for file_path in []:
SweepBot.run_sandbox(
repo.html_url, file_path, None, user_token, only_lint=True
)
logger.info("Fetching relevant files...")
try:
snippets, tree = search_snippets(
cloned_repo,
f"{title}\n{summary}\n{replies_text}",
num_files=num_of_snippets_to_query,
)
assert len(snippets) > 0
except SystemExit:
raise SystemExit
except Exception as e:
trace = traceback.format_exc()
logger.error(e)
logger.error(trace)
edit_sweep_comment(
(
"It looks like an issue has occurred around fetching the files."
" Perhaps the repo has not been initialized. If this error persists"
f" contact [email protected].\n\n> @{username}, editing this issue description to include more details will automatically make me relaunch."
),
-1,
)
log_error(
is_paying_user,
is_trial_user,
username,
issue_url,
"File Fetch",
str(e) + "\n" + traceback.format_exc(),
priority=1,
)
raise e
snippets = post_process_snippets(
snippets, max_num_of_snippets=2 if use_faster_model else 5
)
if not repo_description:
repo_description = "No description provided."
message_summary = summary + replies_text
external_results = ExternalSearcher.extract_summaries(message_summary)
if external_results:
message_summary += "\n\n" + external_results
user_dict = get_documentation_dict(repo)
docs_results = ""
try:
docs_results = extract_relevant_docs(
title + "\n" + message_summary, user_dict, chat_logger
)
if docs_results:
message_summary += "\n\n" + docs_results
except SystemExit:
raise SystemExit
except Exception as e:
logger.error(f"Failed to extract docs: {e}")
human_message = HumanMessagePrompt(
repo_name=repo_name,
issue_url=issue_url,
username=username,
repo_description=repo_description.strip(),
title=title,
summary=message_summary,
snippets=snippets,
tree=tree,
)
context_pruning = ContextPruning(chat_logger=chat_logger)
(
snippets_to_ignore,
excluded_dirs,
) = context_pruning.prune_context( # TODO, ignore directories
human_message, repo=repo
)
snippets = post_process_snippets(
snippets, max_num_of_snippets=5, exclude_snippets=snippets_to_ignore
)
dir_obj = DirectoryTree()
dir_obj.parse(tree)
dir_obj.remove_multiple(excluded_dirs)
tree = str(dir_obj)
logger.info(f"New snippets: {snippets}")
logger.info(f"New tree: {tree}")
human_message = HumanMessagePrompt(
repo_name=repo_name,
issue_url=issue_url,
username=username,
repo_description=repo_description.strip(),
title=title,
summary=message_summary,
snippets=snippets,
tree=tree,
)
_user_token, g = get_github_client(installation_id)
repo = g.get_repo(repo_full_name)
sweep_bot = SweepBot.from_system_message_content(
human_message=human_message,
repo=repo,
is_reply=bool(comments),
chat_logger=chat_logger,
sweep_context=sweep_context,
cloned_repo=cloned_repo,
)
# Check repository for sweep.yml file.
sweep_yml_exists = False
for content_file in repo.get_contents(""):
if content_file.name == "sweep.yaml":
sweep_yml_exists = True
break
# If sweep.yaml does not exist, then create a new PR that simply creates the sweep.yaml file.
if not sweep_yml_exists:
try:
logger.info("Creating sweep.yaml file...")
config_pr = create_config_pr(sweep_bot)
config_pr_url = config_pr.html_url
edit_sweep_comment(message="", index=-2)
except SystemExit:
raise SystemExit
except Exception as e:
logger.error(
"Failed to create new branch for sweep.yaml file.\n",
e,
traceback.format_exc(),
)
else:
logger.info("sweep.yaml file already exists.")
try:
# ANALYZE SNIPPETS
newline = "\n"
edit_sweep_comment(
"I found the following snippets in your repository. I will now analyze"
" these snippets and come up with a plan."
+ "\n\n"
+ create_collapsible(
"Some code snippets I looked at (click to expand). If some file is"
" missing from here, you can mention the path in the ticket"
" description.",
"\n".join(
[
f"https://github.com/{organization}/{repo_name}/blob/{repo.get_commits()[0].sha}/{snippet.file_path}#L{max(snippet.start, 1)}-L{min(snippet.end, snippet.content.count(newline) - 1)}\n"
for snippet in snippets
]
),
)
+ (
create_collapsible(
"I also found the following external resources that might be helpful:",
f"\n\n{external_results}\n\n",
)
if external_results
else ""
)
+ (f"\n\n{docs_results}\n\n" if docs_results else ""),
1,
)
if do_map:
subissues: list[ProposedIssue] = sweep_bot.generate_subissues()
edit_sweep_comment(
f"I'm creating the following subissues:\n\n"
+ "\n\n".join(
[
f"#{subissue.title}:\n" + blockquote(subissue.body)
for subissue in subissues
]
),
2,
)
for subissue in tqdm(subissues):
subissue.issue_id = repo.create_issue(
title="Sweep: " + subissue.title,
body=subissue.body + f"\n\nParent issue: #{issue_number}",
assignee=username,
).number
subissues_checklist = "\n\n".join(
[
f"- [ ] #{subissue.issue_id}\n\n"
+ blockquote(f"**{subissue.title}**\n{subissue.body}")
for subissue in subissues
]
)
current_issue.edit(
body=summary + "\n\n---\n\nChecklist:\n\n" + subissues_checklist
)
edit_sweep_comment(
f"I finished creating the subissues! Track them at:\n\n"
+ "\n".join(f"* #{subissue.issue_id}" for subissue in subissues),
3,
done=True,
)
edit_sweep_comment(f"N/A", 4)
edit_sweep_comment(f"I finished creating all the subissues.", 5)
return {"success": True}
# COMMENT ON ISSUE
# TODO: removed issue commenting here
# TODO(william, luke) planning here
logger.info("Fetching files to modify/create...")
file_change_requests, plan = sweep_bot.get_files_to_change()
if not file_change_requests:
if len(title + summary) < 60:
edit_sweep_comment(
(
"Sorry, I could not find any files to modify, can you please"
" provide more details? Please make sure that the title and"
" summary of the issue are at least 60 characters."
),
-1,
)
else:
edit_sweep_comment(
(
"Sorry, I could not find any files to modify, can you please"
" provide more details?"
),
-1,
)
raise Exception("No files to modify.")
# sweep_bot.summarize_snippets()
file_change_requests = sweep_bot.validate_file_change_requests(
file_change_requests
)
table = tabulate(
[
[
f"`{file_change_request.filename}`",
file_change_request.instructions_display.replace(
"\n", "<br/>"
).replace("```", "\\```"),
]
for file_change_request in file_change_requests
],
headers=["File Path", "Proposed Changes"],
tablefmt="pipe",
)
# edit_sweep_comment(
# "From looking through the relevant snippets, I decided to make the"
# " following modifications:\n\n" + table + "\n\n",
# 2,
# )
# TODO(lukejagg): Generate PR after modifications are made
# CREATE PR METADATA
logger.info("Generating PR...")
pull_request = sweep_bot.generate_pull_request()
# pull_request_content = pull_request.content.strip().replace("\n", "\n>")
# pull_request_summary = f"**{pull_request.title}**\n`{pull_request.branch_name}`\n>{pull_request_content}\n"
# edit_sweep_comment(
# (
# "I have created a plan for writing the pull request. I am now working"
# " my plan and coding the required changes to address this issue. Here"
# f" is the planned pull request:\n\n{pull_request_summary}"
# ),
# 3,
# )
logger.info("Making PR...")
files_progress: list[tuple[str, str, str, str]] = [
(
file_change_request.filename,
file_change_request.instructions_display,
"⏳ In Progress",
"",
)
for file_change_request in file_change_requests
]
checkboxes_progress: list[tuple[str, str, str]] = [
(file_change_request.filename, file_change_request.instructions, " ")
for file_change_request in file_change_requests
]
checkboxes_contents = "\n".join(
[
create_checkbox(f"`{filename}`", blockquote(instructions), check == "X")
for filename, instructions, check in checkboxes_progress
]
)
checkboxes_collapsible = create_collapsible(
"Checklist", checkboxes_contents, opened=True
)
issue = repo.get_issue(number=issue_number)
issue.edit(body=summary + "\n\n" + checkboxes_collapsible)
delete_branch = False
generator = create_pr_changes( # make this async later
file_change_requests,
pull_request,
sweep_bot,
username,
installation_id,
issue_number,
chat_logger=chat_logger,
)
edit_sweep_comment(checkboxes_contents, 2)
response = {"error": NoFilesException()}
for item in generator:
if isinstance(item, dict):
response = item
break
file_change_request, changed_file, sandbox_response, commit = item
sandbox_response: SandboxResponse | None = sandbox_response
format_exit_code = (
lambda exit_code: "✓" if exit_code == 0 else f"❌ (`{exit_code}`)"
)
logger.print(sandbox_response)
error_logs = (
(
create_collapsible(
"Sandbox Execution Logs",
blockquote(
"\n\n".join(
[
create_collapsible(
f"<code>{execution.command.format(file_path=file_change_request.filename)}</code> {i + 1}/{len(sandbox_response.executions)} {format_exit_code(execution.exit_code)}",
f"<pre>{clean_logs(execution.output)}</pre>",
i == len(sandbox_response.executions) - 1,
)
for i, execution in enumerate(
sandbox_response.executions
)
if len(sandbox_response.executions) > 0
# And error code check
]
)
),
opened=True,
)
)
if sandbox_response
else ""
)
if changed_file:
logger.print("Changed File!")
commit_hash = (
commit.sha
if commit is not None
else repo.get_branch(pull_request.branch_name).commit.sha
)
commit_url = f"https://github.com/{repo_full_name}/commit/{commit_hash}"
checkboxes_progress = [
(
(
f"`{filename}` ✅ Commit [`{commit_hash[:7]}`]({commit_url})",
instructions + error_logs,
"X",
)
if file_change_request.filename == filename
else (filename, instructions, progress)
)
for filename, instructions, progress in checkboxes_progress
]
else:
logger.print("Didn't change file!")
checkboxes_progress = [
(
(
f"`{filename}` ❌ Failed",
instructions + error_logs,
"X",
)
if file_change_request.filename == filename
else (filename, instructions, progress)
)
for filename, instructions, progress in checkboxes_progress
]
checkboxes_contents = "\n".join(
[
checkbox_template.format(
check=check,
filename=filename,
instructions=blockquote(instructions),
)
for filename, instructions, check in checkboxes_progress
]
)
checkboxes_collapsible = collapsible_template.format(
summary="Checklist",
body=checkboxes_contents,
opened="open",
)
issue = repo.get_issue(number=issue_number)
issue.edit(body=summary + "\n\n" + checkboxes_collapsible)
logger.info(files_progress)
logger.info(f"Edited {file_change_request.filename}")
edit_sweep_comment(checkboxes_contents, 2)
if not response.get("success"):
raise Exception(f"Failed to create PR: {response.get('error')}")
pr_changes = response["pull_request"]
edit_sweep_comment(
"I have finished coding the issue. I am now reviewing it for completeness.",
3,
)
change_location = f" [`{pr_changes.pr_head}`](https://github.com/{repo_full_name}/commits/{pr_changes.pr_head}).\n\n"
review_message = "Here are my self-reviews of my changes at" + change_location
lint_output = None
try:
current_issue.delete_reaction(eyes_reaction.id)
except SystemExit:
raise SystemExit
except:
pass
changes_required = False
try:
# Todo(lukejagg): Pass sandbox linter results to review_pr
# CODE REVIEW
changes_required, review_comment = review_pr(
repo=repo,
pr=pr_changes,
issue_url=issue_url,
username=username,
repo_description=repo_description,
title=title,
summary=summary,
replies_text=replies_text,
tree=tree,
lint_output=lint_output,
plan=plan, # plan for the PR
chat_logger=chat_logger,
)
# Todo(lukejagg): Execute sandbox after each iteration
lint_output = None
review_message += (
f"Here is the {ordinal(1)} review\n"
+ blockquote(review_comment)
+ "\n\n"
)
if changes_required:
edit_sweep_comment(
review_message + "\n\nI'm currently addressing these suggestions.",
3,
)
logger.info(f"Addressing review comment {review_comment}")
on_comment(
repo_full_name=repo_full_name,
repo_description=repo_description,
comment=review_comment,
username=username,
installation_id=installation_id,
pr_path=None,
pr_line_position=None,
pr_number=None,
pr=pr_changes,
chat_logger=chat_logger,
repo=repo,
)
except SystemExit:
raise SystemExit
except Exception as e:
logger.error(traceback.format_exc())
logger.error(e)
if changes_required:
edit_sweep_comment(
review_message + "\n\nI finished incorporating these changes.",
3,
)
else:
edit_sweep_comment(
f"I have finished reviewing the code for completeness. I did not find errors for {change_location}.",
3,
)
pr_actions_message = (
create_action_buttons(
[
SWEEP_GOOD_FEEDBACK,
SWEEP_BAD_FEEDBACK,
],
header="### PR Feedback (click)\n",
)
+ "\n"
if DISCORD_FEEDBACK_WEBHOOK_URL is not None
else ""
)
is_draft = config.get("draft", False)
try:
pr = repo.create_pull(
title=pr_changes.title,
body=pr_actions_message + pr_changes.body,
head=pr_changes.pr_head,
base=SweepConfig.get_branch(repo),
draft=is_draft,
)
except GithubException as e:
is_draft = False
pr = repo.create_pull(
title=pr_changes.title,
body=pr_actions_message + pr_changes.body,
head=pr_changes.pr_head,
base=SweepConfig.get_branch(repo),
draft=is_draft,
)
pr.add_to_labels(GITHUB_LABEL_NAME)
current_issue.create_reaction("rocket")
logger.info("Running github actions...")
try:
if is_draft:
logger.info("Skipping github actions because PR is a draft")
else:
commit = pr.get_commits().reversed[0]
check_runs = commit.get_check_runs()
for check_run in check_runs:
check_run.rerequest()
except SystemExit:
raise SystemExit
except Exception as e:
logger.error(e)
# Completed code review
edit_sweep_comment(
review_message + "\n\nSuccess! 🚀",
4,
pr_message=(
f"## Here's the PR! [{pr.html_url}]({pr.html_url}).\n{center(payment_message_start)}"
),
done=True,
)
logger.info("Add successful ticket to counter")
except MaxTokensExceeded as e:
logger.info("Max tokens exceeded")
log_error(
is_paying_user,
is_trial_user,
username,
issue_url,
"Max Tokens Exceeded",
str(e) + "\n" + traceback.format_exc(),
priority=2,
)
if chat_logger.is_paying_user():
edit_sweep_comment(
(
f"Sorry, I could not edit `{e.filename}` as this file is too long."
" We are currently working on improved file streaming to address"
" this issue.\n"
),
-1,
)
else:
edit_sweep_comment(
(
f"Sorry, I could not edit `{e.filename}` as this file is too"
" long.\n\nIf this file is incorrect, please describe the desired"
" file in the prompt. However, if you would like to edit longer"
" files, consider upgrading to [Sweep Pro](https://sweep.dev/) for"
" longer context lengths.\n"
),
-1,
)
delete_branch = True
raise e
except NoFilesException as e:
logger.info("Sweep could not find files to modify")
log_error(
is_paying_user,
is_trial_user,
username,
issue_url,
"Sweep could not find files to modify",
str(e) + "\n" + traceback.format_exc(),
priority=2,
)
edit_sweep_comment(
(
"Sorry, Sweep could not find any appropriate files to edit to address"
" this issue. If this is a mistake, please provide more context and I"
f" will retry!\n\n> @{username}, please edit the issue description to"
" include more details about this issue."
),
-1,
)
delete_branch = True
raise e
except openai.error.InvalidRequestError as e:
logger.error(traceback.format_exc())
logger.error(e)
edit_sweep_comment(
(
"I'm sorry, but it looks our model has ran out of context length. We're"
" trying to make this happen less, but one way to mitigate this is to"
" code smaller files. If this error persists report it at"
" https://discord.gg/sweep."
),
-1,
)
log_error(
is_paying_user,
is_trial_user,
username,
issue_url,
"Context Length",
str(e) + "\n" + traceback.format_exc(),
priority=2,
)
posthog.capture(
username,
"failed",
properties={
"error": str(e),
"reason": "Invalid request error / context length",
**metadata,
},
)
delete_branch = True
raise e
except SystemExit:
raise SystemExit
except Exception as e:
logger.error(traceback.format_exc())
logger.error(e)
# title and summary are defined elsewhere
if len(title + summary) < 60:
edit_sweep_comment(
(
"I'm sorry, but it looks like an error has occurred due to"
" insufficient information. Be sure to create a more detailed issue"
" so I can better address it. If this error persists report it at"
" https://discord.gg/sweep."
),
-1,
)
else:
edit_sweep_comment(
(
"I'm sorry, but it looks like an error has occurred. Try changing"
" the issue description to re-trigger Sweep. If this error persists"
" contact [email protected]."
),
-1,
)
log_error(
is_paying_user,
is_trial_user,
username,
issue_url,
"Workflow",
str(e) + "\n" + traceback.format_exc(),
priority=1,
)
posthog.capture(
username,
"failed",
properties={"error": str(e), "reason": "Generic error", **metadata},
)
raise e
else:
try:
item_to_react_to.delete_reaction(eyes_reaction.id)
item_to_react_to.create_reaction("rocket")
except SystemExit:
raise SystemExit
except Exception as e:
logger.error(e)
finally:
cloned_repo.delete()
if delete_branch:
try:
if pull_request.branch_name.startswith("sweep"):
repo.get_git_ref(f"heads/{pull_request.branch_name}").delete()
else:
raise Exception(
f"Branch name {pull_request.branch_name} does not start with sweep/"
)
except SystemExit:
raise SystemExit
except Exception as e:
logger.error(e)
logger.error(traceback.format_exc())
logger.print("Deleted branch", pull_request.branch_name)
posthog.capture(username, "success", properties={**metadata})
logger.info("on_ticket success")
return {"success": True}
| [] |
2024-01-10 | ilyamk/sweep | sweepai~core~chat.py | import json
from copy import deepcopy
import time
from typing import Any, Iterator, Literal
import traceback
import anthropic
import backoff
from pydantic import BaseModel
from logn import logger, file_cache
from sweepai.utils.github_utils import ClonedRepo
from sweepai.utils.utils import Tiktoken
from sweepai.core.entities import Message, Function, SweepContext
from sweepai.core.prompts import system_message_prompt, repo_description_prefix_prompt
from sweepai.utils.chat_logger import ChatLogger
from sweepai.config.client import get_description
from sweepai.utils.prompt_constructor import HumanMessagePrompt
from sweepai.utils.openai_proxy import OpenAIProxy
from sweepai.config.server import (
OPENAI_USE_3_5_MODEL_ONLY,
OPENAI_DO_HAVE_32K_MODEL_ACCESS,
)
from sweepai.utils.event_logger import posthog
import openai
openai_proxy = OpenAIProxy()
AnthropicModel = (
Literal["claude-v1"]
| Literal["claude-v1.3-100k"]
| Literal["claude-instant-v1.1-100k"]
)
OpenAIModel = (
Literal["gpt-3.5-turbo"]
| Literal["gpt-4"]
| Literal["gpt-4-0613"]
| Literal["gpt-3.5-turbo-16k"]
| Literal["gpt-3.5-turbo-16k-0613"]
| Literal["gpt-4-32k"]
| Literal["gpt-4-32k-0613"]
)
ChatModel = OpenAIModel | AnthropicModel
model_to_max_tokens = {
"gpt-3.5-turbo": 4096,
"gpt-4": 8192,
"gpt-4-0613": 8192,
"claude-v1": 9000,
"claude-v1.3-100k": 100000,
"claude-instant-v1.3-100k": 100000,
"gpt-3.5-turbo-16k-0613": 16000,
"gpt-4-32k-0613": 32000,
"gpt-4-32k": 32000,
}
temperature = 0.0 # Lowered to 0 for mostly deterministic results for reproducibility
count_tokens = Tiktoken().count
def format_for_anthropic(messages: list[Message]) -> str:
if len(messages) > 1:
new_messages: list[Message] = [
Message(
role="system", content=messages[0].content + "\n" + messages[1].content
)
]
messages = messages[2:] if len(messages) >= 3 else []
else:
new_messages: list[Message] = []
for message in messages:
new_messages.append(message)
return "\n".join(
f"{anthropic.HUMAN_PROMPT if message.role != 'assistant' else anthropic.AI_PROMPT} {message.content}"
for message in new_messages
) + (anthropic.AI_PROMPT if new_messages[-1].role != "assistant" else "")
class ChatGPT(BaseModel):
messages: list[Message] = [
Message(
role="system",
content=system_message_prompt,
)
]
prev_message_states: list[list[Message]] = []
model: ChatModel = (
"gpt-4-32k-0613" if OPENAI_DO_HAVE_32K_MODEL_ACCESS else "gpt-4-0613"
)
chat_logger: ChatLogger | None
human_message: HumanMessagePrompt | None = None
file_change_paths: list[str] = []
sweep_context: SweepContext | None = None
cloned_repo: ClonedRepo | None = None
@classmethod
def from_system_message_content(
cls,
human_message: HumanMessagePrompt,
is_reply: bool = False,
chat_logger=None,
sweep_context=None,
cloned_repo: ClonedRepo | None = None,
**kwargs,
) -> Any:
content = system_message_prompt
repo = kwargs.get("repo")
if repo:
logger.info(f"Repo: {repo}")
repo_description = get_description(repo)
if repo_description:
logger.info(f"Repo description: {repo_description}")
content += f"{repo_description_prefix_prompt}\n{repo_description}"
messages = [Message(role="system", content=content, key="system")]
added_messages = human_message.construct_prompt() # [ { role, content }, ... ]
for msg in added_messages:
messages.append(Message(**msg))
return cls(
messages=messages,
human_message=human_message,
chat_logger=chat_logger,
sweep_context=sweep_context,
cloned_repo=cloned_repo,
**kwargs,
)
@classmethod
def from_system_message_string(
cls, prompt_string, chat_logger: ChatLogger, **kwargs
) -> Any:
return cls(
messages=[Message(role="system", content=prompt_string, key="system")],
chat_logger=chat_logger,
**kwargs,
)
def select_message_from_message_key(
self, message_key: str, message_role: str = None
):
if message_role:
return [
message
for message in self.messages
if message.key == message_key and message.role == message_role
][0]
return [message for message in self.messages if message.key == message_key][0]
def delete_messages_from_chat(
self, key_to_delete: str, delete_user=True, delete_assistant=True
):
self.messages = [
message
for message in self.messages
if not (
key_to_delete in (message.key or "")
and (
delete_user
and message.role == "user"
or delete_assistant
and message.role == "assistant"
)
) # Only delete if message matches key to delete and role should be deleted
]
def delete_file_from_system_message(self, file_path: str):
self.human_message.delete_file(file_path)
def get_message_content_from_message_key(
self, message_key: str, message_role: str = None
):
return self.select_message_from_message_key(
message_key, message_role=message_role
).content
def update_message_content_from_message_key(
self, message_key: str, new_content: str, message_role: str = None
):
self.select_message_from_message_key(
message_key, message_role=message_role
).content = new_content
def chat(
self,
content: str,
model: ChatModel | None = None,
message_key: str | None = None,
temperature=temperature,
):
self.messages.append(Message(role="user", content=content, key=message_key))
model = model or self.model
self.messages.append(
Message(
role="assistant",
content=self.call_openai(
model=model,
temperature=temperature,
),
key=message_key,
)
)
self.prev_message_states.append(self.messages)
return self.messages[-1].content
# Only works on functions without side effects
# @file_cache(ignore_params=["chat_logger", "sweep_context", "cloned_repo"])
def call_openai(
self,
model: ChatModel | None = None,
temperature=temperature,
):
if self.chat_logger is not None:
tickets_allocated = 120 if self.chat_logger.is_paying_user() else 5
tickets_count = self.chat_logger.get_ticket_count()
if tickets_count < tickets_allocated:
model = model or self.model
logger.warning(
f"{tickets_count} tickets found in MongoDB, using {model}"
)
else:
model = "gpt-3.5-turbo-16k-0613"
count_tokens = Tiktoken().count
messages_length = sum(
[count_tokens(message.content or "") for message in self.messages]
)
max_tokens = (
model_to_max_tokens[model] - int(messages_length) - 400
) # this is for the function tokens
# TODO: Add a check to see if the message is too long
logger.info("file_change_paths" + str(self.file_change_paths))
if len(self.file_change_paths) > 0:
self.file_change_paths.remove(self.file_change_paths[0])
if max_tokens < 0:
if len(self.file_change_paths) > 0:
pass
else:
logger.error(
f"Input to OpenAI:\n{self.messages_dicts}\n{traceback.format_exc()}"
)
raise ValueError(f"Message is too long, max tokens is {max_tokens}")
messages_raw = "\n".join([(message.content or "") for message in self.messages])
logger.info(f"Input to call openai:\n{messages_raw}")
messages_dicts = [self.messages_dicts[0]]
for message_dict in self.messages_dicts[:1]:
if message_dict["role"] == messages_dicts[-1]["role"]:
messages_dicts[-1]["content"] += "\n" + message_dict["content"]
messages_dicts.append(message_dict)
gpt_4_buffer = 800
if int(messages_length) + gpt_4_buffer < 6000 and model == "gpt-4-32k-0613":
model = "gpt-4-0613"
max_tokens = (
model_to_max_tokens[model] - int(messages_length) - gpt_4_buffer
) # this is for the function tokens
if "gpt-4" in model:
max_tokens = min(max_tokens, 5000)
# Fix for self hosting where TPM limit is super low for GPT-4
if OPENAI_USE_3_5_MODEL_ONLY:
model = "gpt-3.5-turbo-16k-0613"
max_tokens = (
model_to_max_tokens[model] - int(messages_length) - gpt_4_buffer
)
logger.info(f"Using the model {model}, with {max_tokens} tokens remaining")
global retry_counter
retry_counter = 0
@backoff.on_exception(
backoff.expo,
Exception,
max_tries=16,
jitter=backoff.random_jitter,
)
def fetch():
global retry_counter
retry_counter += 1
token_sub = retry_counter * 200
try:
output = None
output = openai_proxy.call_openai(
model=model,
messages=self.messages_dicts,
max_tokens=max_tokens - token_sub,
temperature=temperature,
)
if self.chat_logger is not None:
self.chat_logger.add_chat(
{
"model": model,
"messages": self.messages_dicts,
"max_tokens": max_tokens - token_sub,
"temperature": temperature,
"output": output,
}
)
if self.chat_logger:
try:
token_count = count_tokens(output)
posthog.capture(
self.chat_logger.data.get("username"),
"call_openai",
{
"model": model,
"max_tokens": max_tokens - token_sub,
"input_tokens": messages_length,
"output_tokens": token_count,
"repo_full_name": self.chat_logger.data.get(
"repo_full_name"
),
"username": self.chat_logger.data.get("username"),
"pr_number": self.chat_logger.data.get("pr_number"),
"issue_url": self.chat_logger.data.get("issue_url"),
},
)
except SystemExit:
raise SystemExit
except Exception as e2:
logger.warning(e2)
return output
except SystemExit:
raise SystemExit
except Exception as e:
logger.warning(f"{e}\n{traceback.format_exc()}")
raise e
result = fetch()
logger.info(f"Output to call openai:\n{result}")
return result
async def achat(
self,
content: str,
model: ChatModel | None = None,
message_key: str | None = None,
):
self.messages.append(Message(role="user", content=content, key=message_key))
model = model or self.model
response = await self.acall_openai(model=model)
self.messages.append(
Message(role="assistant", content=response, key=message_key)
)
self.prev_message_states.append(self.messages)
return self.messages[-1].content
async def acall_openai(
self,
model: ChatModel | None = None,
):
if self.chat_logger is not None:
tickets_allocated = 120 if self.chat_logger.is_paying_user() else 5
tickets_count = self.chat_logger.get_ticket_count()
if tickets_count < tickets_allocated:
model = model or self.model
logger.warning(
f"{tickets_count} tickets found in MongoDB, using {model}"
)
else:
model = "gpt-3.5-turbo-16k-0613"
count_tokens = Tiktoken().count
messages_length = sum(
[count_tokens(message.content or "") for message in self.messages]
)
max_tokens = (
model_to_max_tokens[model] - int(messages_length) - 400
) # this is for the function tokens
# TODO: Add a check to see if the message is too long
logger.info("file_change_paths" + str(self.file_change_paths))
if len(self.file_change_paths) > 0:
self.file_change_paths.remove(self.file_change_paths[0])
if max_tokens < 0:
if len(self.file_change_paths) > 0:
pass
else:
logger.error(
f"Input to OpenAI:\n{self.messages_dicts}\n{traceback.format_exc()}"
)
raise ValueError(f"Message is too long, max tokens is {max_tokens}")
messages_raw = "\n".join([(message.content or "") for message in self.messages])
logger.info(f"Input to call openai:\n{messages_raw}")
messages_dicts = [self.messages_dicts[0]]
for message_dict in self.messages_dicts[:1]:
if message_dict["role"] == messages_dicts[-1]["role"]:
messages_dicts[-1]["content"] += "\n" + message_dict["content"]
messages_dicts.append(message_dict)
gpt_4_buffer = 800
if int(messages_length) + gpt_4_buffer < 6000 and model == "gpt-4-32k-0613":
model = "gpt-4-0613"
max_tokens = (
model_to_max_tokens[model] - int(messages_length) - gpt_4_buffer
) # this is for the function tokens
if "gpt-4" in model:
max_tokens = min(max_tokens, 5000)
# Fix for self hosting where TPM limit is super low for GPT-4
if OPENAI_USE_3_5_MODEL_ONLY:
model = "gpt-3.5-turbo-16k-0613"
max_tokens = (
model_to_max_tokens[model] - int(messages_length) - gpt_4_buffer
)
logger.info(f"Using the model {model}, with {max_tokens} tokens remaining")
global retry_counter
retry_counter = 0
async def fetch():
for time_to_sleep in [10, 10, 20, 30, 60]:
global retry_counter
retry_counter += 1
token_sub = retry_counter * 200
try:
output = (
(
await openai.ChatCompletion.acreate(
model=model,
messages=self.messages_dicts,
max_tokens=max_tokens - token_sub,
temperature=temperature,
)
)
.choices[0]
.message["content"]
)
if self.chat_logger is not None:
self.chat_logger.add_chat(
{
"model": model,
"messages": self.messages_dicts,
"max_tokens": max_tokens - token_sub,
"temperature": temperature,
"output": output,
}
)
if self.chat_logger:
try:
token_count = count_tokens(output)
posthog.capture(
self.chat_logger.data.get("username"),
"call_openai",
{
"model": model,
"max_tokens": max_tokens - token_sub,
"input_tokens": messages_length,
"output_tokens": token_count,
"repo_full_name": self.chat_logger.data.get(
"repo_full_name"
),
"username": self.chat_logger.data.get("username"),
"pr_number": self.chat_logger.data.get("pr_number"),
"issue_url": self.chat_logger.data.get("issue_url"),
},
)
except SystemExit:
raise SystemExit
except Exception as e:
logger.warning(e)
return output
except SystemExit:
raise SystemExit
except Exception as e:
logger.warning(f"{e}\n{traceback.format_exc()}")
time.sleep(time_to_sleep + backoff.random_jitter(5))
result = await fetch()
logger.info(f"Output to call openai:\n{result}")
return result
@property
def messages_dicts(self):
# Remove the key from the message object before sending to OpenAI
cleaned_messages = [message.to_openai() for message in self.messages]
return cleaned_messages
def undo(self):
if len(self.prev_message_states) > 0:
self.messages = self.prev_message_states.pop()
return self.messages
| [
"\n"
] |
2024-01-10 | ilyamk/sweep | sweepai~handlers~on_comment.py | """
on_comment is responsible for handling PR comments and PR review comments, called from sweepai/api.py.
It is also called in sweepai/handlers/on_ticket.py when Sweep is reviewing its own PRs.
"""
import re
import traceback
import openai
from logn import logger, LogTask
from typing import Any
from tabulate import tabulate
from github.Repository import Repository
from sweepai.config.client import get_blocked_dirs
from sweepai.core.entities import (
NoFilesException,
Snippet,
MockPR,
FileChangeRequest,
SweepContext,
Message,
)
from sweepai.core.sweep_bot import SweepBot
from sweepai.handlers.on_review import get_pr_diffs
from sweepai.utils.chat_logger import ChatLogger
from sweepai.utils.diff import generate_diff
from sweepai.config.server import (
GITHUB_BOT_USERNAME,
ENV,
MONGODB_URI,
OPENAI_API_KEY,
)
from sweepai.utils.event_logger import posthog
from sweepai.utils.github_utils import ClonedRepo, get_github_client
from sweepai.utils.search_utils import search_snippets
from sweepai.utils.prompt_constructor import HumanMessageCommentPrompt
openai.api_key = OPENAI_API_KEY
num_of_snippets_to_query = 30
total_number_of_snippet_tokens = 15_000
num_full_files = 2
num_extended_snippets = 2
ERROR_FORMAT = "❌ {title}\n\nPlease join our [Discord](https://discord.gg/sweep) to report this issue."
def post_process_snippets(snippets: list[Snippet], max_num_of_snippets: int = 3):
for snippet in snippets[:num_full_files]:
snippet = snippet.expand()
# snippet fusing
i = 0
while i < len(snippets):
j = i + 1
while j < len(snippets):
if snippets[i] ^ snippets[j]: # this checks for overlap
snippets[i] = snippets[i] | snippets[j] # merging
snippets.pop(j)
else:
j += 1
i += 1
# truncating snippets based on character length
result_snippets = []
total_length = 0
for snippet in snippets:
total_length += len(snippet.get_snippet())
if total_length > total_number_of_snippet_tokens * 5:
break
result_snippets.append(snippet)
return result_snippets[:max_num_of_snippets]
@LogTask()
def on_comment(
repo_full_name: str,
repo_description: str,
comment: str,
pr_path: str | None,
pr_line_position: int | None,
username: str,
installation_id: int,
pr_number: int = None,
comment_id: int | None = None,
chat_logger: Any = None,
pr: MockPR = None, # For on_comment calls before PR is created
repo: Any = None,
comment_type: str = "comment",
type: str = "comment",
):
# Flow:
# 1. Get relevant files
# 2: Get human message
# 3. Get files to change
# 4. Get file changes
# 5. Create PR
logger.info(
f"Calling on_comment() with the following arguments: {comment},"
f" {repo_full_name}, {repo_description}, {pr_path}"
)
organization, repo_name = repo_full_name.split("/")
_token, g = get_github_client(installation_id)
repo = g.get_repo(repo_full_name)
if pr is None:
pr = repo.get_pull(pr_number)
pr_title = pr.title
pr_body = pr.body or ""
pr_file_path = None
diffs = get_pr_diffs(repo, pr)
pr_chunk = None
formatted_pr_chunk = None
issue_number_match = re.search(r"Fixes #(?P<issue_number>\d+).", pr_body)
original_issue = None
if issue_number_match:
issue_number = issue_number_match.group("issue_number")
original_issue = repo.get_issue(int(issue_number))
author = original_issue.user.login
logger.info(f"Author of original issue is {author}")
chat_logger = (
chat_logger
if chat_logger is not None
else ChatLogger(
{
"repo_name": repo_name,
"title": "(Comment) " + pr_title,
"issue_url": pr.html_url,
"pr_file_path": pr_file_path, # may be None
"pr_chunk": pr_chunk, # may be None
"repo_full_name": repo_full_name,
"repo_description": repo_description,
"comment": comment,
"pr_path": pr_path,
"pr_line_position": pr_line_position,
"username": author,
"installation_id": installation_id,
"pr_number": pr_number,
"type": "comment",
}
)
if MONGODB_URI
else None
)
else:
logger.warning(f"No issue number found in PR body for summary {pr.body}")
chat_logger = None
if chat_logger:
is_paying_user = chat_logger.is_paying_user()
use_faster_model = chat_logger.use_faster_model(g)
else:
# Todo: chat_logger is None for MockPRs, which will cause all comments to use GPT-4
is_paying_user = True
use_faster_model = False
assignee = pr.assignee.login if pr.assignee else None
sweep_context = SweepContext.create(
username=username,
issue_url=pr.html_url,
use_faster_model=use_faster_model,
is_paying_user=is_paying_user,
repo=repo,
token=None, # Todo(lukejagg): Make this token for sandbox on comments
)
metadata = {
"repo_full_name": repo_full_name,
"repo_name": repo_name,
"organization": organization,
"repo_description": repo_description,
"installation_id": installation_id,
"username": username if not username.startswith("sweep") else assignee,
"function": "on_comment",
"model": "gpt-3.5" if use_faster_model else "gpt-4",
"tier": "pro" if is_paying_user else "free",
"mode": ENV,
"pr_path": pr_path,
"pr_line_position": pr_line_position,
"pr_number": pr_number or pr.id,
"pr_html_url": pr.html_url,
"comment_id": comment_id,
"comment": comment,
"issue_number": issue_number if issue_number_match else "",
}
# logger.bind(**metadata)
capture_posthog_event(username, "started", properties=metadata)
logger.info(f"Getting repo {repo_full_name}")
file_comment = bool(pr_path) and bool(pr_line_position)
item_to_react_to = None
reaction = None
bot_comment = None
def edit_comment(new_comment):
if bot_comment is not None:
bot_comment.edit(new_comment)
try:
# Check if the PR is closed
if pr.state == "closed":
return {"success": True, "message": "PR is closed. No event fired."}
if comment_id:
try:
item_to_react_to = pr.get_issue_comment(comment_id)
reaction = item_to_react_to.create_reaction("eyes")
except SystemExit:
raise SystemExit
except Exception as e:
try:
item_to_react_to = pr.get_review_comment(comment_id)
reaction = item_to_react_to.create_reaction("eyes")
except SystemExit:
raise SystemExit
except Exception as e:
pass
if reaction is not None:
# Delete rocket reaction
reactions = item_to_react_to.get_reactions()
for r in reactions:
if r.content == "rocket" and r.user.login == GITHUB_BOT_USERNAME:
item_to_react_to.delete_reaction(r.id)
branch_name = (
pr.head.ref if pr_number else pr.pr_head # pylint: disable=no-member
)
cloned_repo = ClonedRepo(repo_full_name, installation_id, branch=branch_name)
# Generate diffs for this PR
pr_diff_string = None
pr_files_modified = None
if pr_number:
patches = []
pr_files_modified = {}
files = pr.get_files()
for file in files:
if file.status == "modified":
# Get the entire file contents, not just the patch
pr_files_modified[file.filename] = repo.get_contents(
file.filename, ref=branch_name
).decoded_content.decode("utf-8")
patches.append(
f'<file file_path="{file.filename}">\n{file.patch}\n</file>'
)
pr_diff_string = (
"<files_changed>\n" + "\n".join(patches) + "\n</files_changed>"
)
# This means it's a comment on a file
if file_comment:
pr_file = repo.get_contents(
pr_path, ref=branch_name
).decoded_content.decode("utf-8")
pr_lines = pr_file.splitlines()
start = max(0, pr_line_position - 11)
end = min(len(pr_lines), pr_line_position + 10)
original_line = pr_lines[pr_line_position - 1]
pr_chunk = "\n".join(pr_lines[start:end])
pr_file_path = pr_path.strip()
formatted_pr_chunk = (
"\n".join(pr_lines[start : pr_line_position - 1])
+ f"\n{pr_lines[pr_line_position - 1]} <<<< COMMENT: {comment.strip()} <<<<"
+ "\n".join(pr_lines[pr_line_position:end])
)
if comment_id:
try:
bot_comment = pr.create_review_comment_reply(
comment_id, "Working on it..."
)
except SystemExit:
raise SystemExit
except Exception as e:
print(e)
else:
formatted_pr_chunk = None # pr_file
bot_comment = pr.create_issue_comment("Working on it...")
if file_comment:
snippets = []
tree = ""
else:
try:
logger.info("Fetching relevant files...")
snippets, tree = search_snippets(
cloned_repo,
f"{comment}\n{pr_title}" + (f"\n{pr_chunk}" if pr_chunk else ""),
num_files=30,
)
assert len(snippets) > 0
except Exception as e:
logger.error(traceback.format_exc())
raise e
snippets = post_process_snippets(
snippets, max_num_of_snippets=0 if file_comment else 2
)
logger.info("Getting response from ChatGPT...")
human_message = HumanMessageCommentPrompt(
comment=comment,
repo_name=repo_name,
repo_description=repo_description if repo_description else "",
diffs=diffs,
issue_url=pr.html_url,
username=username,
title=pr_title,
tree=tree,
summary=pr_body,
snippets=snippets,
pr_file_path=pr_file_path, # may be None
pr_chunk=formatted_pr_chunk, # may be None
original_line=original_line if pr_chunk else None,
)
logger.info(f"Human prompt{human_message.construct_prompt()}")
sweep_bot = SweepBot.from_system_message_content(
# human_message=human_message, model="claude-v1.3-100k", repo=repo
human_message=human_message,
repo=repo,
chat_logger=chat_logger,
model="gpt-3.5-turbo-16k-0613" if use_faster_model else "gpt-4-32k-0613",
sweep_context=sweep_context,
cloned_repo=cloned_repo,
)
except Exception as e:
logger.error(traceback.format_exc())
capture_posthog_event(
username,
"failed",
properties={"error": str(e), "reason": "Failed to get files", **metadata},
)
edit_comment(ERROR_FORMAT.format(title="Failed to get files"))
raise e
try:
logger.info("Fetching files to modify/create...")
if file_comment:
file_change_requests = [
FileChangeRequest(
filename=pr_file_path,
instructions=f"The user left a comment in this chunk of code:\n<review_code_chunk>{formatted_pr_chunk}\n</review_code_chunk>\n. Resolve their comment.",
change_type="modify",
)
]
else:
regenerate = comment.strip().lower().startswith("sweep: regenerate")
reset = comment.strip().lower().startswith("sweep: reset")
if regenerate or reset:
logger.info(f"Running {'regenerate' if regenerate else 'reset'}...")
file_paths = comment.strip().split(" ")[2:]
def get_contents_with_fallback(repo: Repository, file_path: str):
try:
return repo.get_contents(file_path)
except SystemExit:
raise SystemExit
except Exception as e:
logger.error(e)
return None
old_file_contents = [
get_contents_with_fallback(repo, file_path)
for file_path in file_paths
]
logger.print(old_file_contents)
for file_path, old_file_content in zip(file_paths, old_file_contents):
current_content = sweep_bot.get_contents(
file_path, branch=branch_name
)
if old_file_content:
logger.info("Resetting file...")
sweep_bot.repo.update_file(
file_path,
f"Reset {file_path}",
old_file_content.decoded_content,
sha=current_content.sha,
branch=branch_name,
)
else:
logger.info("Deleting file...")
sweep_bot.repo.delete_file(
file_path,
f"Reset {file_path}",
sha=current_content.sha,
branch=branch_name,
)
if reset:
return {
"success": True,
"message": "Files have been reset to their original state.",
}
file_change_requests = []
if original_issue:
content = original_issue.body
checklist_dropdown = re.search(
"<details>\n<summary>Checklist</summary>.*?</details>",
content,
re.DOTALL,
)
checklist = checklist_dropdown.group(0)
matches = re.findall(
(
"- \[[X ]\] `(?P<filename>.*?)`(?P<instructions>.*?)(?=-"
" \[[X ]\]|</details>)"
),
checklist,
re.DOTALL,
)
instructions_mapping = {}
for filename, instructions in matches:
instructions_mapping[filename] = instructions
file_change_requests = [
FileChangeRequest(
filename=file_path,
instructions=instructions_mapping[file_path],
change_type="modify",
)
for file_path in file_paths
]
else:
quoted_pr_summary = "> " + pr.body.replace("\n", "\n> ")
file_change_requests = [
FileChangeRequest(
filename=file_path,
instructions=(
f"Modify the file {file_path} based on the PR"
f" summary:\n\n{quoted_pr_summary}"
),
change_type="modify",
)
for file_path in file_paths
]
logger.print(file_change_requests)
file_change_requests = sweep_bot.validate_file_change_requests(
file_change_requests, branch=branch_name
)
logger.info("Getting response from ChatGPT...")
human_message = HumanMessageCommentPrompt(
comment=comment,
repo_name=repo_name,
repo_description=repo_description if repo_description else "",
diffs=get_pr_diffs(repo, pr),
issue_url=pr.html_url,
username=username,
title=pr_title,
tree=tree,
summary=pr_body,
snippets=snippets,
pr_file_path=pr_file_path, # may be None
pr_chunk=pr_chunk, # may be None
original_line=original_line if pr_chunk else None,
)
logger.info(f"Human prompt{human_message.construct_prompt()}")
sweep_bot: SweepBot = SweepBot.from_system_message_content(
human_message=human_message,
repo=repo,
chat_logger=chat_logger,
cloned_repo=cloned_repo,
)
else:
file_change_requests, _ = sweep_bot.get_files_to_change(
retries=1, pr_diffs=pr_diff_string
)
file_change_requests = sweep_bot.validate_file_change_requests(
file_change_requests, branch=branch_name
)
sweep_response = "I couldn't find any relevant files to change."
if file_change_requests:
table_message = tabulate(
[
[
f"`{file_change_request.filename}`",
file_change_request.instructions_display.replace(
"\n", "<br/>"
).replace("```", "\\```"),
]
for file_change_request in file_change_requests
],
headers=["File Path", "Proposed Changes"],
tablefmt="pipe",
)
sweep_response = (
f"I decided to make the following changes:\n\n{table_message}"
)
quoted_comment = "> " + comment.replace("\n", "\n> ")
response_for_user = (
f"{quoted_comment}\n\nHi @{username},\n\n{sweep_response}"
)
if pr_number:
edit_comment(response_for_user)
# pr.create_issue_comment(response_for_user)
logger.info("Making Code Changes...")
blocked_dirs = get_blocked_dirs(sweep_bot.repo)
sweep_bot.comment_pr_diff_str = pr_diff_string
sweep_bot.comment_pr_files_modified = pr_files_modified
changes_made = sum(
[
change_made
for _, change_made, _, _ in sweep_bot.change_files_in_github_iterator(
file_change_requests, branch_name, blocked_dirs
)
]
)
try:
if comment_id:
if changes_made:
# PR Review Comment Reply
edit_comment("Done.")
else:
# PR Review Comment Reply
edit_comment(
'I wasn\'t able to make changes. This could be due to an unclear request or a bug in my code.\n As a reminder, comments on a file only modify that file. Comments on a PR(at the bottom of the "conversation" tab) can modify the entire PR. Please try again or contact us on [Discord](https://discord.com/invite/sweep)'
)
except SystemExit:
raise SystemExit
except Exception as e:
logger.error(f"Failed to reply to comment: {e}")
if not isinstance(pr, MockPR):
if pr.user.login == GITHUB_BOT_USERNAME and pr.title.startswith("[DRAFT] "):
# Update the PR title to remove the "[DRAFT]" prefix
pr.edit(title=pr.title.replace("[DRAFT] ", "", 1))
logger.info("Done!")
except NoFilesException:
capture_posthog_event(
username,
"failed",
properties={
"error": "No files to change",
"reason": "No files to change",
**metadata,
},
)
edit_comment(ERROR_FORMAT.format(title="Could not find files to change"))
return {"success": True, "message": "No files to change."}
except Exception as e:
logger.error(traceback.format_exc())
capture_posthog_event(
username,
"failed",
properties={
"error": str(e),
"reason": "Failed to make changes",
**metadata,
},
)
edit_comment(ERROR_FORMAT.format(title="Failed to make changes"))
raise e
# Delete eyes
if reaction is not None:
item_to_react_to.delete_reaction(reaction.id)
try:
item_to_react_to = pr.get_issue_comment(comment_id)
reaction = item_to_react_to.create_reaction("rocket")
except SystemExit:
raise SystemExit
except Exception as e:
try:
item_to_react_to = pr.get_review_comment(comment_id)
reaction = item_to_react_to.create_reaction("rocket")
except SystemExit:
raise SystemExit
except Exception as e:
pass
try:
if response_for_user is not None:
edit_comment(f"## 🚀 Wrote Changes\n\n{response_for_user}")
except SystemExit:
raise SystemExit
except Exception as e:
pass
capture_posthog_event(username, "success", properties={**metadata})
logger.info("on_comment success")
return {"success": True}
def capture_posthog_event(username, event, properties):
posthog.capture(username, event, properties=properties)
| [] |
2024-01-10 | Rixez2325/autocompletion-comics | python_package~src~comics_generation~gpt_api.py | import openai
import os
import json
from dotenv import load_dotenv
from textwrap import dedent
from typing import List, Dict
from helpers.path_helper import GENERATED_PROMPS_DIR, PANELS_TEXT_DIR
from helpers.aws_helper import (
S3_BUCKET,
load_json_from_s3,
save_json_to_s3,
get_s3_connection,
)
GPT_MODEL = "gpt-3.5-turbo"
load_dotenv("./api_key.env")
openai.api_key = os.getenv("OPENAI_API_KEY")
def gpt_demo():
demo_description = [
{
"characters": ["batman", "superman"],
"visual_context": "on a rooof, city in background, nightsky",
"text": ["I'm the boss", "No I am !"],
},
{
"characters": ["batman", "superman"],
"visual_context": "on the streets",
"text": ["You dead bro"],
},
]
generated_prompts = ask_gpt(demo_description)
print(generated_prompts)
output_path = f"{GENERATED_PROMPS_DIR}/promps.json"
with open(output_path, "w") as outfile:
json.dump(generated_prompts, outfile)
def generate_prompts():
previous_descriptions = get_previous_descriptions()
generated_prompts = ask_gpt(previous_descriptions)
save_json_to_s3(generated_prompts, GENERATED_PROMPS_DIR)
def ask_gpt(
previous_panels_description: List[Dict],
nb_panels_to_generate: int = 4,
) -> List[Dict]:
messages = set_message(nb_panels_to_generate, previous_panels_description)
response = openai.ChatCompletion.create(model=GPT_MODEL, messages=messages)
new_prompts = extract_panels_prompts(response)
return new_prompts
def extract_panels_prompts(response: Dict) -> List[Dict]:
prompts_str = response["choices"][0]["message"]["content"]
prompts_list = split_prompts_str(prompts_str)
return prompts_list
def split_prompts_str(prompts_str) -> List[Dict]:
prompts = prompts_str.split("\n\n")
result = []
for prompt in prompts:
tmp = prompt.split("\n")[1:]
dict = {}
dict["prompt"] = f"{tmp[0].split(':')[1]} {tmp[1].split(':')[1]}"
dict["text"] = tmp[2].split(":")[1]
result.append(dict)
return result
def format_panels_description(previous_panels_description: List[Dict]):
result = ""
for i, panel in enumerate(previous_panels_description):
result += dedent(
f"""
panel {i+1}:
characters: {', '.join(panel['characters'])}
visual_context: {panel["visual_context"]}
text: {', '.join(panel["text"])}"""
)
return result
def set_message(
nb_panels_to_generate: int,
previous_panels_description: List[Dict],
):
return [
{
"role": "system",
"content": dedent(
"""
You are a comics writer,
when you write a panel you have to describe it as following:
give principals characters, the action performed, and visual context.
A panel need to be a single sentences.
exemple: batman talking to spiderman on a roof, nightsky, city in background"""
),
},
{
"role": "user",
"content": dedent(
f"""
Here are a description of a comics page, panels by panels:
{format_panels_description(previous_panels_description)}
Write {nb_panels_to_generate} panels that follow this story."""
),
},
]
def get_previous_descriptions():
descriptions = []
previous_panels_text = load_json_from_s3(PANELS_TEXT_DIR)
for panel_text_file in previous_panels_text:
current_description = {
"characters": [
"batman",
"superman",
], # because no probant result with computer vision
"visual_context": "night, city", # because no probant result with computer vision
"text": [],
}
# get_panels_text(panel_text_file, current_description)
current_description["text"].append(panel_text_file["Text"])
descriptions.append(current_description)
return descriptions
| [
"\n\n",
"content",
"\n You are a comics writer, \n when you write a panel you have to describe it as following: \n give principals characters, the action performed, and visual context. \n A panel need to be a single sentences.\n exemple: batman talking to spiderman on a roof, nightsky, city in background"
] |
2024-01-10 | Xaler1/DataGPT | src~chat_loop.py | import streamlit as st
import openai
import secret.keys as keys
from src.conversator import Conversator
from functions.weather import get_weather
from functions.news import get_news_headlines, get_full_article
from functions.gmaps import lookup_physical_place, get_place_details, get_travel_distance
from functions.basic import get_basic_info
from data.storage import manual_write_data, get_data_details
from data.manipulation import analyze_data, transform_data, undo_transformation
from agents.basic import run_on_list
from agents.talkback_agent import complete_task
from data.plotting import plot_data
import traceback
import streamlit_js_eval as stjs
class Chat:
"""
The chat class. Handles all the chat logic.
"""
def __init__(self):
pass
def run(self):
st.session_state.raw_geo = stjs.get_geolocation()
openai.api_key = keys.openai_key
# Initialize the conversator and save it to the session state
if "conversator" not in st.session_state:
st.session_state.conversator = Conversator([
complete_task,
run_on_list,
get_weather,
get_basic_info,
#get_user_email,
#send_email, search_email, get_email_by_id, reply_to_email,
get_news_headlines, get_full_article,
# search_places, find_nearby,
lookup_physical_place, get_place_details, get_travel_distance,
#get_cik, get_company_info, get_company_filings, get_full_filing,
plot_data,
get_data_details,
analyze_data, transform_data, undo_transformation,
])
# Print all the messages
with st.container():
for message in st.session_state["messages"]:
if message["role"] == "plot":
st.pyplot(message["content"], use_container_width=True)
if message["role"] == "image":
st.image(message["content"])
else:
with st.chat_message(message["role"]):
st.markdown(message["content"])
if prompt := st.chat_input("Enter your message"):
with st.chat_message("user"):
st.markdown(prompt)
attempts = 0
success = False
while not success:
attempts += 1
if attempts > 4:
st.session_state.conversator.reset_to_last()
st.error("Something went wrong, please try again.")
st.stop()
break
try:
response = st.session_state.conversator.process_msg(prompt)
success = True
except Exception as e:
print("\n\n---------------------------------------------")
traceback.print_exc()
print("---------------------------------------------\n\n")
with st.chat_message("assistant"):
st.markdown(response) | [] |
2024-01-10 | Xaler1/DataGPT | agents~talkback_agent.py | import openai
import json
import streamlit as st
from src.gpt_function import GPTFunction, gpt_agent
from base_agent import BaseAgent
###################################
# PROMPTS #
###################################
def _starter_prompt(task: str) -> str:
return f"""You are an intelligent agent that will be completing a task step by step.
You are efficient, smart, and capable of completing the task. Always taking the most straightforward approach.
I will guide you through the process, so do not get ahead of yourself.
The user does not see this conversation, therefore you cannot ask them any questions.
Do NOT provide any commentary at all whatsoever or information that is not relevant to the task.
Make sure that the output includes all of the information relevant to the task.
Do not call functions unless it is actually necessary.
Use the most relevant functions.
Always explore the data before using it. Only use columns that actually exist.
Always analyze and get the details of data. Do not use data without knowing what it is.
Always use functions to manipulate the data. Do not simply give code.
Remember that you can extract information from the data using analyze_data and transform_data using transform_data.
The task is: {task}
What should be the first step to completing it?
Your next message must be just a single step and nothing else.
"""
def _step_function_prompt(step: str) -> str:
return f"""Okay, lets work on this step: "{step}".
First, do you need any functions to complete this step?
Remember you may already have all of the information needed above.
If you need a function, respond with 'yes'. If not, respond with 'no'.
If you are unsure, response with 'yes'"""
def _step_prompt(step: str) -> str:
return f"""Okay, complete step "{step}". Do whatever is necessary to complete this step."""
def _step_satisfaction_prompt(step: str) -> str:
return f"""Has this achieved the goal of step "{step}"?
If so, respond with 'yes'. If not, respond with 'no'.
Do no include anything else in the response. Just a "yes" or "no", do not repeat the plan"""
def _step_retry_prompt(step: str) -> str:
return f"""Please try again to complete step "{step}".
Fix whatever mistake was made.
Fix any code issues there were.
Fix the data if needed in the most sensible way possible.
Make sure to execute the actual code using one of the data processing functions.
Consider undoing changes you did in previous steps.
Remember, the user cannot help you"""
def _step_failure_prompt(step: str) -> str:
return f"""You have failed to complete step "{step}" too many times.
Please explain the reason for this failure."""
def _task_complete_prompt(task: str) -> str:
return f"""Given all of the above, has the task of "{task}" been completed?
Make sure that you now have all of the information and can provide a final output to the user.
If so, respond with 'yes'. If not, respond with 'no'.
Do not provide any other output, just a 'yes' or 'no'."""
def _next_step_prompt(task: str) -> str:
return f"""Now, given all of the above and the task of "{task}".
What should be the next step towards completing this task?"""
def _final_summarization_prompt(task: str) -> str:
return f"""The plan has been completed.
Based on everything done above, what is the final output for the task of {task}?
The response must contain all useful information uncovered during the completion of the task
Make sure the response is well structured."""
###################################
# AGENT #
###################################
class TalkbackAgent(BaseAgent):
def __init__(self, functions: list[GPTFunction]):
super().__init__(functions)
def run(self, task: str):
prompt = _starter_prompt(task)
task_done = False
with st.spinner("Initializing agent..."):
step = self.get_response(prompt, allow_function_calls=False)
while not task_done:
step_success = False
retries = 0
with st.spinner(step):
#step_prompt = _step_function_prompt(step)
#response = self.get_response(step_prompt, allow_function_calls=False)
allow_function_calls = True
#lowered = response.lower()
#if "yes" in lowered and lowered.index("yes") == 0:
# allow_function_calls = True
step_prompt = _step_prompt(step)
while not step_success:
self.get_response(step_prompt, allow_function_calls)
prompt = _step_satisfaction_prompt(step)
response = self.get_response(prompt, allow_function_calls=False)
lowered = response.lower()
if "yes" in lowered and lowered.index("yes") == 0:
step_success = True
else:
retries += 1
# If the agent fails to complete the step too many times, it must explain why
if retries >= self.max_retries:
prompt = _step_failure_prompt(step)
response = self.get_response(prompt, allow_function_calls=False)
response = "The task could not be completed. Because: " + response
response += "\n Inform the user of this and do not try again."
return response
step_prompt = _step_retry_prompt(step)
prompt = _task_complete_prompt(task)
response = self.get_response(prompt, allow_function_calls=False)
lowered = response.lower()
if "yes" in lowered and lowered.index("yes") == 0:
task_done = True
break
prompt = _next_step_prompt(task)
response = self.get_response(prompt, allow_function_calls=False)
step = response
with st.spinner("Finalizing response..."):
prompt = _final_summarization_prompt(task)
response = self.get_response(prompt, allow_function_calls=False)
return response
@gpt_agent
def complete_task(task: str):
"""
Useful for completing complex, multi-step tasks.
Use this if a task be completed in a single function call.
When calling this, DO NOT CALL ANY OTHER FUNCTIONS.
:param task: the task you wish to be completed
"""
print("Task:", task)
conversator = st.session_state["conversator"]
# get a copy of functions in the conversator and remove this function from it. It is a dict
functions = conversator.functions.copy()
functions.pop("complete_task")
agent = TalkbackAgent(functions.values())
return {"result": agent.run(task)}
| [] |
2024-01-10 | Xaler1/DataGPT | agents~planning_agent.py | import yaml
import openai
import json
import streamlit as st
from secret import keys
from src.gpt_function import GPTFunction, gpt_agent
from functions.gmaps import get_travel_distance
from agents.basic import run_on_list
from data.manipulation import analyze_data, transform_data, undo_transformation
from data.storage import get_data_details
###################################
# PROMPTS #
###################################
def _starter_prompt(task: str) -> str:
return f"""You are an intelligent agent that will be completing a task step by step.
You are efficient, smart, and capable of completing the task. Always taking the most straightforward approach.
First you must break down the task into smaller steps. Format them as a json list of steps.
E.g. {{"steps" : ["Step 1: Do this", "Step 2: Do that", "Step 3: Do the other thing"]}}
Take note of the functions available to you. Use to help complete the task, and take them into account when planning.
Do not break down the task into too many steps, as this will make it harder to complete.
The user does not see this conversation, therefore you cannot ask them any questions.
Do NOT provide any commentary at all whatsoever or information that is not relevant to the task.
Make sure that the output includes all of the information relevant to the task.
Your next response must be a single json plan.
Do not call functions unless it is actually necessary.
Use the most relevant functions.
Always explore the data before using it. Only use columns that actually exist.
Always analyze and get the details of data. Do not use data without knowing what it is.
Always use functions to manipulate the data. Do not simply give code.
The task is: {task}
Do not add any unnecessary steps to the plan."""
def _invalid_plan_prompt() -> str:
return """The json you provided is not valid.
Please try again.
The next message must be a single json plan, do not apologize"""
def _plan_satisfaction_prompt() -> str:
return """Is this plan sufficient to complete the task? Is it as simple as possible?
Does it contain no unnecessary steps?
If you are happy with the plan respond with 'yes'. If not, respond with 'no'."""
def _replan_prompt() -> str:
return """Please provide a new plan. The next message must be a single json plan, do not apologize"""
def _step_function_prompt(step: str) -> str:
return f"""Okay, lets go onto the next step: {step}.
First, do you need any functions to complete this step?
Remember you may already have all of the information needed above.
If you need a function, respond with 'yes'. If not, respond with 'no'.
If you are unsure, response with 'yes'"""
def _step_prompt(step: str) -> str:
return f"""Okay, complete step {step}. Do whatever is necessary to complete this step."""
def _step_satisfaction_prompt(step: str) -> str:
return f"""Has this achieved the goal of step {step}?
If so, respond with 'yes'. If not, respond with 'no'.
Do no include anything else in the response. Just a "yes" or "no", do not repeat the plan"""
def _step_retry_prompt(step: str) -> str:
return f"""Please try again to complete step {step}.
Fix whatever mistake was made. Remember, the user cannot help you"""
def _step_failure_prompt(step: str) -> str:
return f"""You have failed to complete step {step} too many times.
Please explain the reason for this failure."""
def _plan_update_question_prompt(steps: list[str]) -> str:
return f"""The current plan is {steps}. Based on all of the above, does it need to be amended?
If so, respond with 'yes'. If not, respond with 'no'
Do not include anything else in the response. Just a "yes" or "no", do not repeat the plan"""
def _plan_update_prompt() -> str:
return """Please amend the plan to include the new step.
The next message must be a single json plan"""
def _final_summarization_prompt(task: str) -> str:
return f"""The plan has been completed.
Based on everything done above, what is the final output for the task of {task}?
The response must contain all useful information uncovered during the completion of the task
Make sure the response is well structured."""
###################################
# AGENT #
###################################
class PlanningAgent:
def __init__(self, functions: list[GPTFunction]):
openai.api_key = keys.openai_key
config = yaml.safe_load(open("config.yaml", "r"))
self.model_name = config["model"]["agent"]
self.messages = []
self.functions = {}
self.max_retries = 3
for function in functions:
self.functions[function.name] = function
def get_response(self, prompt: str, allow_function_calls: bool = True):
print("\nSystem:")
print(prompt)
self.messages.append({"role": "system", "content": prompt})
response = openai.ChatCompletion.create(
model=self.model_name,
messages=self.messages,
functions=list(map(lambda x: x.to_dict(), self.functions.values())),
function_call="auto" if allow_function_calls else "none"
)["choices"][0]["message"]
self.messages.append(response)
if response.get("function_call") and allow_function_calls:
func_name = response["function_call"]["name"]
func_args = response["function_call"]["arguments"]
func_args = json.loads(func_args)
self.call_function(func_name, func_args)
return None
else:
print("\nAgent:")
print(response["content"])
return response["content"]
def call_function(self, func_name: str, func_args: dict):
print("\nFunction call:\n", func_name, "\n", func_args)
func = self.functions[func_name]
func_results = func(func_args)
print("\nFunction results:\n", func_results)
self.messages.append({"role": "function", "name": func_name, "content": func_results})
def run(self, task: str):
prompt = _starter_prompt(task)
with st.spinner("Planning..."):
valid_plan = False
while not valid_plan:
response = self.get_response(prompt, allow_function_calls=False)
try:
steps = json.loads(response)["steps"]
except:
prompt = _invalid_plan_prompt()
continue
prompt = _plan_satisfaction_prompt()
response = self.get_response(prompt, allow_function_calls=False)
lowered = response.lower()
if "yes" in lowered and lowered.index("yes") == 0:
valid_plan = True
else:
prompt = _replan_prompt()
for i in range(len(steps)):
step = steps[i]
completed = False
retries = 0
with st.spinner(step):
step_prompt = _step_function_prompt(step)
response = self.get_response(step_prompt, allow_function_calls=False)
allow_function_calls = False
lowered = response.lower()
if "yes" in lowered and lowered.index("yes") == 0:
allow_function_calls = True
step_prompt = _step_prompt(step)
while not completed:
self.get_response(step_prompt, allow_function_calls)
prompt = _step_satisfaction_prompt(step)
response = self.get_response(prompt, allow_function_calls=False)
lowered = response.lower()
if "yes" in lowered and lowered.index("yes") == 0:
completed = True
else:
retries += 1
# If the agent fails to complete the step too many times, it must explain why
if retries >= self.max_retries:
prompt = _step_failure_prompt(step)
response = self.get_response(prompt, allow_function_calls=False)
response = "The task could not be completed. Because: " + response
response += "\n Inform the user of this and do not try again."
return response
step_prompt = _step_retry_prompt(step)
prompt = _plan_update_question_prompt(steps[i:])
response = self.get_response(prompt, allow_function_calls=False)
lowered = response.lower()
if "yes" in lowered and lowered.index("yes") == 0:
prompt = _plan_update_prompt()
response = self.get_response(prompt, allow_function_calls=False)
steps = json.loads(response)["steps"]
with st.spinner("Finalizing response..."):
prompt = _final_summarization_prompt(task)
response = self.get_response(prompt)
return response
@gpt_agent
def complete_task(task: str):
"""
Useful for completing complex, multi-step tasks.
Use this if a task be completed in a single function call.
:param task: the task you wish to be completed
"""
print("Task:", task)
conversator = st.session_state["conversator"]
# get a copy of functions in the conversator and remove this function from it. It is a dict
functions = conversator.functions.copy()
functions.pop("complete_task")
agent = PlanningAgent(functions.values())
return {"result": agent.run(task)}
if __name__ == '__main__':
functions = [
get_travel_distance,
analyze_data, transform_data, undo_transformation, get_data_details,
run_on_list
]
agent = PlanningAgent(functions)
agent.run("Calculate how long it would take to travel from London to Madrid. While stopping in Paris.")
| [] |
2024-01-10 | Xaler1/DataGPT | agents~basic.py | import json
import openai
import pandas as pd
from bs4 import BeautifulSoup as bsoup
from src.gpt_function import gpt_agent
import streamlit as st
def describe_dataframe(name: str, data: pd.DataFrame):
"""
Extracts the important information from an html page.
:param text: the text to extract from
"""
columns = list(data.columns)
rows = len(data)
sample = data.head(3).to_json()
content = {
"name": name,
"columns": columns,
"n_rows": rows,
"sample": sample
}
content = json.dumps(content, indent=4)
prompt = """Look at the summary of the dataframe. Generate a short description of the dataframe.
It should describe the contents of the dataframe in a way that is easy to understand. One sentence maximum
The description should be maximally succinct, don't say things like 'This dataframe contains'"""
response = openai.ChatCompletion.create(
model="gpt-3.5-turbo-16k",
messages=[
{"role": "system", "content": prompt},
{"role": "user", "content": content}
]
)
return response["choices"][0]["message"]["content"]
def html_extract(text: str):
"""
Extracts the important information from an html page.
:param text: the text to extract from
"""
# Remove all css and js
soup = bsoup(text, "html5lib")
for script in soup(["script", "style"]):
script.decompose()
text = soup.get_text()
# Remove excessive newlines and whitespaces
text = text.replace("\t", "")
text = text.replace(" ", "")
text = text.replace("\n\n", "\n")
print(len(text))
response = openai.ChatCompletion.create(
model="gpt-3.5-turbo-16k",
messages=[
{"role": "system", "content": "Extract the important information from this html page. Summarize when necessary."},
{"role": "user", "content": text}
]
)
return response["choices"][0]["message"]["content"]
@gpt_agent
def run_on_list(function_name: str, args: list[str], goal: str):
"""
Use this if you need to run a function multiple times on different arguments.
So that you don't have to keep calling the same function over and over again.
Don't call the function yourself before this!
Each call will be made separately.
:param function_name: the name of the function to call
:param args: a list of arguments for each call. For example:
[{"arg1": "value1", "arg2": "value2"}, {"arg1": "value3", "arg2": "value4"}}]
:param goal: a plain text description of what you want to do with this function.
"""
func = st.session_state["conversator"].functions[function_name]
results = []
starter_prompt = f""" The function {function_name} is being called multiple times.
The goal is to {goal}.
Your task is to extact the important information from each call.
I will give you the input and output of each call and you will summarize it to be easier to read.
Your output must be formatted as follows:
{{"input": "input summary", "output": "output key data"}}
For examples for a weather function:
{{"input": "London", "output": "18 degrees, sunny, 10% chance of rain"}}
Following standard json formatting.
Make sure the output contains all the information you need to complete the goal.
Make sure the input summary is as short as possible, only containing key identifying information.
For example if the input to the function is:
{{"origin": "Manchester, UK", "destination": "London, UK", "mode": "driving"}}
The summary should be:
{{"Manchester, UK to London, UK by driving"}}
Make sure the summary formatting is consistent.
"""
messages = [{"role": "system", "content": starter_prompt}]
prev = "Working on it..."
for arg_set in args:
with st.spinner(prev):
args = json.loads(arg_set)
result = func(args)
new_msg = f"""function input: "{arg_set}", function output: "{result}" """
messages.append({"role": "user", "content": new_msg})
summarization = openai.ChatCompletion.create(
model="gpt-3.5-turbo",
messages=messages
)
summarization = summarization["choices"][0]["message"]["content"]
messages.append({"role": "assistant", "content": summarization})
results.append(summarization)
prev = json.loads(summarization)["input"]
print(results)
return results
if __name__ == '__main__':
args = {
"function_name": "get_travel_distance",
"args": [
{"origin": "Manchester, UK", "destination": "London, UK", "mode": "driving"},
{"origin": "Ashford, UK", "destination": "London, UK", "mode": "driving"},
{"origin": "Edinburgh, UK", "destination": "London, UK", "mode": "driving"},
{"origin": "Hastings, UK", "destination": "London, UK", "mode": "driving"},
{"origin": "Leeds, UK", "destination": "London, UK", "mode": "driving"}
],
"goal": "get the distances from each city to London",
"reason": "to help you with your request"
}
run_on_list(args)
| [
"Extract the important information from this html page. Summarize when necessary.",
"function input: \"PLACEHOLDER\", function output: \"PLACEHOLDER\" ",
" The function PLACEHOLDER is being called multiple times.\n The goal is to PLACEHOLDER.\n Your task is to extact the important information from each call.\n I will give you the input and output of each call and you will summarize it to be easier to read.\n Your output must be formatted as follows:\n {\"input\": \"input summary\", \"output\": \"output key data\"}\n For examples for a weather function: \n {\"input\": \"London\", \"output\": \"18 degrees, sunny, 10% chance of rain\"}\n Following standard json formatting.\n Make sure the output contains all the information you need to complete the goal.\n Make sure the input summary is as short as possible, only containing key identifying information.\n For example if the input to the function is:\n {\"origin\": \"Manchester, UK\", \"destination\": \"London, UK\", \"mode\": \"driving\"}\n The summary should be:\n {\"Manchester, UK to London, UK by driving\"}\n Make sure the summary formatting is consistent.\n ",
"Look at the summary of the dataframe. Generate a short description of the dataframe.\n It should describe the contents of the dataframe in a way that is easy to understand. One sentence maximum\n The description should be maximally succinct, don't say things like 'This dataframe contains'"
] |
2024-01-10 | Xaler1/DataGPT | base_agent.py | import yaml
import openai
import json
import streamlit as st
from secret import keys
from src.gpt_function import GPTFunction, gpt_agent
from data import core
class BaseAgent:
def __init__(self, functions: list[GPTFunction]):
openai.api_key = keys.openai_key
config = yaml.safe_load(open("config.yaml", "r"))
self.model_name = config["model"]["agent"]
self.messages = []
self.functions = {}
self.max_retries = 3
for function in functions:
self.functions[function.name] = function
def get_response(self, prompt: str, allow_function_calls: bool = True):
print("\nSystem:")
print(prompt)
self.messages.append({"role": "system", "content": prompt})
available_data = {}
for name, data in core.get_all_data_details().items():
available_data[name] = data["summary"]
available_data = json.dumps(available_data, indent=4)
data_message = [{"role": "system", "content": f"Data available from storage:\n{available_data}"}]
response = openai.ChatCompletion.create(
model=self.model_name,
messages=self.messages + data_message,
functions=list(map(lambda x: x.to_dict(), self.functions.values())),
function_call="auto" if allow_function_calls else "none"
)["choices"][0]["message"]
self.messages.append(response)
if response.get("function_call") and allow_function_calls:
func_name = response["function_call"]["name"]
func_args = response["function_call"]["arguments"]
func_args = json.loads(func_args)
self.call_function(func_name, func_args)
return None
else:
print("\nAgent:")
print(response["content"])
return response["content"]
def call_function(self, func_name: str, func_args: dict):
print("\nFunction call:\n", func_name, "\n", func_args)
func = self.functions[func_name]
func_results = func(func_args)
print("\nFunction results:\n", func_results)
self.messages.append({"role": "function", "name": func_name, "content": func_results})
def run(self, task: str) -> str:
pass
| [
"Data available from storage:\nPLACEHOLDER"
] |
2024-01-10 | virtualdude1/SynopsisGenerator | synopses_v2~splitter.py | import re
import openai
from time import sleep, time
import os
from dotenv import load_dotenv
load_dotenv()
openai.api_key = os.getenv('OPENAI_API_KEY')
def gpt3_completion(prompt, engine='text-davinci-002', temp=0.89, best_of=3, top_p=1.0, tokens=3000, freq_pen=0.1, pres_pen=0.3, stop=['asdfasdf', 'asdasdf']):
max_retry = 5
retry = 0
prompt = prompt.encode(encoding='ASCII',errors='ignore').decode() # force it to fix any unicode errors
while True:
try:
response = openai.Completion.create(
engine=engine,
prompt=prompt,
temperature=temp,
best_of=best_of,
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('\s+', ' ', 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)
text_block =''
text_list = []
with open('story.txt', 'r', encoding='utf-8') as infile:
try:
text = infile.read()
for line in text.splitlines():
if len(line) > 0:
prompt: str = f'Read the following text provide a highly concise summary, do improve terminology and vocabulary used, lastly label the topic being discussed \n\n{text_block[:1000]}\n\n Label: \n Concise summary:\n'
text_list.append(gpt3_completion(prompt))
text_block += line + ' '
text_block += line + '\n' # add the line to the block
if len(text_block) > 1000: # if the block is too long
prompt: str = f'Read the following text provide a highly concise summary, do improve terminology and vocabulary used, lastly label the topic being discussed \n\n{text_block[:1000]}\n\n Label: \n Concise summary:\n'
text_list.append(text_block) # add it to the list
text_block = '' # reset the block
if len(text_block) > 0: # if there's anything left in the block
text_list.append(text_block) # add it to the list
finally:
infile.close()
with open('story_summary.txt', 'w', encoding='utf-8') as outfile:
try:
outfile.write('\n'.join(text_list))
finally:
outfile.close()
| [
"Read the following text provide a highly concise summary, do improve terminology and vocabulary used, lastly label the topic being discussed \n\nPLACEHOLDER\n\n Label: \n Concise summary:\n",
"ignore"
] |
2024-01-10 | dhajrt/test | playground~agentbox.py | import asyncio
asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
import sys
import os
script_dir = os.path.dirname(os.path.abspath(__file__))
openagent_dir = os.path.abspath(os.path.join(script_dir, ".."))
sys.path.append(openagent_dir)
import openagent
from openagent.llms._openai import OpenAI as guidance_llm
from openagent.agent.chat import ChatAgent
from dotenv import load_dotenv
load_dotenv()
from jupyter_client import KernelManager
from IPython import display
import subprocess
import ast
import argparse
import threading
def agent():
llm = guidance_llm(
model="gpt-3.5-turbo"
)
chat_template = '''
{{#user~}}
I want to translate the following English text into Python code:
QUERY: {{input}}
{{~/user}}
{{#assistant~}}
Sure, I can assist with that. If I need more information, I'll ask for clarification.
{{~/assistant}}
{{#user~}}
Yes, go ahead and write the complete code.
{{~/user}}
{{#assistant~}}
{{gen 'response' temperature=0 max_tokens=3900}}
{{~/assistant}}
{{#assistant~}}
If the context or the task is not clear, please provide additional information to clarify.
{{~/assistant}}'''
agent = ChatAgent(
llm=llm,
prompt_template=chat_template,
)
return agent
def install_dependencies(code):
try:
# Parse the code to extract import statements
parsed_ast = ast.parse(code)
imports = []
for node in ast.walk(parsed_ast):
if isinstance(node, ast.Import):
imports.extend([name.name for name in node.names])
elif isinstance(node, ast.ImportFrom):
module_name = node.module
if module_name is not None:
imports.append(module_name)
# Remove duplicate imports and filter out standard library modules
imports = list(set(imports))
# print("imports", imports)
resolved_imports = set()
for imp in imports:
if '.' in imp:
parent_module = imp.split('.')[0]
resolved_imports.add(parent_module)
else:
resolved_imports.add(imp)
# Remove duplicate imports and filter out standard library modules
resolved_imports = list(resolved_imports)
# print("resolved_imports", resolved_imports)
third_party_dependencies = [dep for dep in resolved_imports if dep not in sys.modules]
# print("third_party_dependencies", third_party_dependencies)
if third_party_dependencies:
subprocess.check_call([sys.executable, "-m", "pip", "install"] + third_party_dependencies)
return True
else:
# print("No third-party dependencies detected.")
return True
except subprocess.CalledProcessError:
print("Dependency installation failed.")
return False
def run_python_code_in_kernel(code):
# Create a kernel manager
km = KernelManager(kernel_name='python3') # Use the appropriate kernel name
# Start the kernel
km.start_kernel()
# Connect to the kernel
kc = km.client()
kc.start_channels()
# Execute the code in the kernel
kc.execute(code)
# Create a thread for waiting on messages
def wait_for_messages():
try:
while True:
msg = kc.get_iopub_msg()
msg_type = msg['header']['msg_type']
if msg_type == 'display_data':
output_data = msg['content']['data']
if 'image/png' in output_data:
display.display_png(output_data['image/png'], raw=True)
elif 'image/jpeg' in output_data:
display.display_jpeg(output_data['image/png'], raw=True)
elif msg_type == 'stream':
output_data = msg['content']['text']
output_data = output_data.split("\n")
for output in output_data[:-1]:
display.display(output)
except asyncio.CancelledError:
pass # Ignore the exception
# Start the message-waiting thread
message_thread = threading.Thread(target=wait_for_messages)
message_thread.start()
# Wait for the specified timeout
timeout_seconds = 10
message_thread.join(timeout_seconds)
# Check if the thread is still alive (indicating timeout)
if message_thread.is_alive():
print("Code execution completed")
else:
print("Code execution completed within the timeout.")
# Stop the kernel
kc.stop_channels()
km.shutdown_kernel()
# Main function
def main(gpt_prompt):
res = agent().run(input=gpt_prompt)
code = f"""{res.split('```')[1].replace('python', '')}"""
print(code)
# Install dependencies
if install_dependencies(code):
# Run the generated code in the Jupyter kernel
run_python_code_in_kernel(code)
if __name__ == "__main__":
parser = argparse.ArgumentParser(description='Execute Python code from the command line.')
parser.add_argument("--gpt_prompt", help="Python code to be executed", default=None)
args = parser.parse_args()
gpt_prompt = args.gpt_prompt
main(gpt_prompt)
| [
"\n {{#user~}}\n I want to translate the following English text into Python code:\n QUERY: {{input}}\n {{~/user}}\n\n {{#assistant~}}\n Sure, I can assist with that. If I need more information, I'll ask for clarification.\n {{~/assistant}}\n\n {{#user~}}\n Yes, go ahead and write the complete code.\n {{~/user}}\n\n {{#assistant~}}\n {{gen 'response' temperature=0 max_tokens=3900}}\n {{~/assistant}}\n\n {{#assistant~}}\n If the context or the task is not clear, please provide additional information to clarify.\n {{~/assistant}}"
] |
2024-01-10 | dhajrt/test | openagent~finetune~LLMFinetune.py | from abc import ABC, abstractmethod
from logging import Logger
import openai
class LLMFinetune(ABC):
def __init__(self, logger: Logger, openai_key: str):
self.logger = logger
openai.api_key = openai_key
@abstractmethod
def transform_data(self, train_csv_file: str, val_csv_file: str , train_output_file: str, val_output_file: str) -> str:
pass
@abstractmethod
def finetune(self, **kwargs):
pass
| [] |
2024-01-10 | itsaaronngan/whisper | 1transcribe.py | import os
from pydub import AudioSegment
from openai import OpenAI
import tempfile
import sys
# Set up OpenAI client with your API key
client = OpenAI()
def split_audio(file_path):
# Split the audio file into chunks
audio = AudioSegment.from_file(file_path)
chunk_length_ms = int((15000 * 50 * 1024 * 1024) / (audio.frame_rate * audio.frame_width * audio.channels))
chunks = [audio[i:i + chunk_length_ms] for i in range(0, len(audio), chunk_length_ms)]
temp_files = [] # No temporary files are created in this function
return chunks, temp_files
def transcribe_audio_chunks(chunks):
transcripts = []
temp_files = [] # List to store the locations of the temporary files
for i, chunk in enumerate(chunks[:5]): # Only process the first 4 chunks
# Save the chunk as a temporary file
with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as temp:
try:
chunk.export(temp.name, format="mp3", bitrate="64k")
print(f"Created temporary file: {temp.name}")
temp_files.append(temp.name) # Add the location of the temporary file to the list
except Exception as e:
print(f"Error creating temporary file: {e}")
continue
# Transcribe the temporary file
try:
audio_file=open(temp.name, "rb")
transcript = client.audio.transcriptions.create(
model="whisper-1",
file=audio_file,
)
transcripts.append(transcript)
print("Successful transcription")
except Exception as e:
print(f"Error transcribing audio: {e}")
if i < len(chunks[:5]) - 1:
print("Creating and uploading next chunk...")
# Print the locations of the temporary files
print("Locations of the temporary files:")
for file in temp_files:
print(file)
return transcripts, temp_files
def export_transcriptions(file_path, transcriptions, temp_files):
# Export the transcriptions to a text file with the same name as the audio file
audio_file_name = os.path.basename(file_path)
text_file_name = "TRANSCRIBE_" + os.path.splitext(audio_file_name)[0].replace(".", "_") + ".txt"
output_directory = "/Users/aaronnganm1/Documents/Coding/Whisper Transcription/output"
text_file_path = os.path.join(output_directory, text_file_name)
with open(text_file_path, "w") as file:
for transcription in transcriptions:
file.write(transcription.text + "\n") # Access the 'text' attribute of the Transcription object
print(f"Transcriptions saved at: {text_file_path}")
# Delete the temporary files
for temp_file in temp_files:
os.remove(temp_file)
print(f"Temporary file {temp_file} has been deleted")
def main(file_path):
chunks, temp_files = split_audio(file_path)
transcriptions, temp_files_transcribe = transcribe_audio_chunks(chunks)
temp_files.extend(temp_files_transcribe) # Combine the lists of temporary files
export_transcriptions(file_path, transcriptions, temp_files)
# Call the main function with the path to your audio file
if len(sys.argv) > 1:
main(sys.argv[1])
else:
print("No audio file provided.")
| [] |
2024-01-10 | itsaaronngan/whisper | 1transcribe%20copy.py | import os
from pydub import AudioSegment
from openai import OpenAI
import tempfile
import sys
# Set up OpenAI client with your API key
client = OpenAI()
def split_audio(file_path):
# Split the audio file into chunks
audio = AudioSegment.from_file(file_path)
# Calculate the chunk length in milliseconds based on the target file size
chunk_length_ms = int((15000 * 50 * 1024 * 1024) / (audio.frame_rate * audio.frame_width * audio.channels))
return [audio[i:i + chunk_length_ms] for i in range(0, len(audio), chunk_length_ms)]
def transcribe_audio_chunks(chunks):
transcripts = []
temp_files = [] # List to store the locations of the temporary files
for i, chunk in enumerate(chunks[:5]): # Only process the first 4 chunks
# Save the chunk as a temporary file
with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as temp:
try:
chunk.export(temp.name, format="mp3", bitrate="64k")
print(f"Created temporary file: {temp.name}")
temp_files.append(temp.name) # Add the location of the temporary file to the list
except Exception as e:
print(f"Error creating temporary file: {e}")
continue
# Transcribe the temporary file
try:
audio_file=open(temp.name, "rb")
transcript = client.audio.transcriptions.create(
model="whisper-1",
file=audio_file,
)
transcripts.append(transcript)
print("Successful transcription")
except Exception as e:
print(f"Error transcribing audio: {e}")
if i < len(chunks[:5]) - 1:
print("Creating and uploading next chunk...")
# Print the locations of the temporary files
print("Locations of the temporary files:")
for file in temp_files:
print(file)
return transcripts
def export_transcriptions(file_path, transcriptions, temp_files):
# Export the transcriptions to a text file with the same name as the audio file
audio_file_name = os.path.basename(file_path)
text_file_name = "TRANSCRIBE_" + os.path.splitext(audio_file_name)[0].replace(".", "_") + ".txt"
output_directory = "/Users/aaronnganm1/Documents/Coding/Whisper Transcription/output"
text_file_path = os.path.join(output_directory, text_file_name)
with open(text_file_path, "w") as file:
for transcription in transcriptions:
file.write(transcription.text + "\n") # Access the 'text' attribute of the Transcription object
print(f"Transcriptions saved at: {text_file_path}")
# Delete the temporary files
for temp_file in temp_files:
os.remove(temp_file)
print(f"Temporary file {temp_file} has been deleted")
def main(file_path):
chunks, temp_files = split_audio(file_path)
transcriptions = transcribe_audio_chunks(chunks)
export_transcriptions(file_path, transcriptions, temp_files)
# Call the main function with the path to your audio file
if len(sys.argv) > 1:
main(sys.argv[1])
else:
print("No audio file provided.")
| [] |
2024-01-10 | itsaaronngan/whisper | punctuation%20helper~helper.py | from openai import OpenAI
import os
from pathlib import Path
import json
import re
client = OpenAI()
# Function to find transcription files in the specified directory
def find_transcription_files(directory):
transcription_files = []
for root, dirs, files in os.walk(directory):
for file in files:
if file.endswith(".txt"): # Assuming transcriptions are in .txt files
transcription_files.append(Path(root) / file)
return transcription_files
def remove_non_ascii(original_transcript):
return ''.join(char for char in original_transcript if ord(char) < 128)
def split_text_into_chunks(text, max_tokens=4000):
words = text.split(' ')
chunks = []
current_chunk = ''
for word in words:
if len((current_chunk + ' ' + word).strip()) <= max_tokens:
current_chunk += ' ' + word
else:
chunks.append(current_chunk.strip())
current_chunk = word
if current_chunk:
chunks.append(current_chunk.strip())
return chunks
def punctuation_assistant(ascii_transcript):
chunks = split_text_into_chunks(ascii_transcript)
responses = []
system_prompt = """ You are a helpful assistant that adds punctuation and paragraphs to text. Preserve the original words and only insert recommend paragraphs and only necessary punctuation such as periods, commas, capitalization, symbols like dollar signs or percentage signs, and formatting. Use only the context provided. If there is no context provided say, 'No context provided'\n"""
for chunk in chunks:
response = client.chat.completions.create(
model="gpt-3.5-turbo",
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": chunk},
],
)
responses.append(response.choices[0].message.content)
return ' '.join(responses)
def product_assistant(punctuation_edited_transcript):
# Load the existing acronyms and their transcriptions
try:
with open('acronyms.json', 'r') as file:
acronyms = json.load(file)
except (FileNotFoundError, json.JSONDecodeError):
acronyms = {}
# Prepare the system prompt
system_prompt = """
You are an intelligent assistant specializing in Acronyms; your task is to process transcripts, ensuring that all acronyms and specialised terms are in the correct format. The full term should be spelled out followed by the acronym in parentheses. For example, '401k' should be transformed to '401(k) retirement savings plan', 'HSA' should be transformed to 'Health Savings Account (HSA)'. Names that are not acronyms (e.g. AusLeap) should not be transformed. Everyday words should not be transformed or changed, only acronyms. Create and append to the end a list of all transformations in the format [text] transformed into [transform] as well as any unknown acronyms. Unknown acronyms are things that are not listed on the common acronyms. Here are some common acronyms and their transcriptions: {}
""".format(', '.join([f"'{acronym}': '{transcription}'" for acronym, transcription in acronyms.items()]))
# Process the transcript
chunks = split_text_into_chunks(punctuation_edited_transcript)
responses = []
new_acronyms = {}
for chunk in chunks:
response = client.chat.completions.create(
model="gpt-4",
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": chunk},
],
)
response_content = response.choices[0].message.content
responses.append(response_content)
# Extract new acronyms from the response
matches = re.findall(r'(\w+ \(\w+\))', response_content)
for match in matches:
full_form, acronym = match.split(' (')
acronym = acronym[:-1] # Remove the closing parenthesis
if acronym not in acronyms:
new_acronyms[acronym] = full_form
# Save the new acronyms to a file
with open('new_acronyms.json', 'w') as file:
json.dump(new_acronyms, file)
# Generate the transformations text
transformations = "\n".join([f"'{acronym}' transformed into '{full_form} ({acronym})'" for acronym, full_form in new_acronyms.items()])
return ' '.join(responses), transformations
def text_summary(product_edited_transcript):
system_prompt = """
You are an intelligent assistant specializing in summarizing meeting transcripts that are educational in nature. For the provided text, you will first produce a 5-10 word title for the text. Then you should produce a summary of the text that is no more than 3 sentences long. The summary should be a coherent paragraph that is grammatically correct and does not contain any spelling errors. Also generate a list of key learnings or key topics that were discussed in the meeting. Create a list of 3 suggestions about how you would use the learning and the content to create packaged content for public consumption. This could include templates (provide suggestions), learning resources, or other content that would be useful to the public. Use only the context provided, if no context is provided say no context. Your role is to
analyze and adjust acronyms and specialised terminology in the text. Once you've done that, produce the summary and key learnings."""
chunks = split_text_into_chunks(product_edited_transcript)
responses = []
for chunk in chunks:
response = client.chat.completions.create(
model="gpt-4",
temperature=0,
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": chunk},
],
)
responses.append(response.choices[0].message.content)
return " ".join(responses)
def main(directory):
auto_continue = False
# Get a list of transcription files
transcription_files = list(find_transcription_files(directory))
# Process each transcription file
for i, file_path in enumerate(transcription_files):
next_file = transcription_files[i + 1] if i + 1 < len(transcription_files) else None
if not auto_continue:
while True:
if next_file:
print(f"The next file is: {next_file}")
user_input = input("Do you want to continue to the next file? (y/n/s/g): ")
if user_input.lower() == 'y':
break
elif user_input.lower() == 'n':
return
elif user_input.lower() == 's':
continue
elif user_input.lower() == 'g':
auto_continue = True
print("auto_continue is now True")
break
else:
print("Invalid input. Please enter 'y' for yes, 'n' for no, 's' for skip, or 'g' for go ahead with all files.")
print(f"Processing transcription file: {file_path}")
# Read the original transcript
with open(file_path, 'r') as file:
original_transcript = file.read()
print("Original transcript read.")
# Process the transcript
ascii_transcript = remove_non_ascii(original_transcript)
print("Non-ASCII characters removed.")
punctuation_edited_transcript = punctuation_assistant(ascii_transcript)
print("Punctuation added.")
product_edited_transcript, transformations = product_assistant(punctuation_edited_transcript)
print("Product names edited.")
# Generate the summary
summary = text_summary(product_edited_transcript)
print("Summary generated.")
# Combine the edited transcript and the summary
final_output = product_edited_transcript + "\n\n" + summary
print("Final output prepared.")
# Write the final output to a new file
output_file_path = file_path.parent /"transcripts"/ ("EDITED_" + file_path.name)
with open(output_file_path, 'w') as file:
file.write(final_output)
print(f"Saved edited transcript and summary to: {output_file_path}")
# After processing the file, if auto_continue is False, ask for user input again
if not auto_continue:
while True:
user_input = input("Do you want to continue to the next file? (y/n/s/g): ")
if user_input.lower() == 'y':
break
elif user_input.lower() == 'n':
return
elif user_input.lower() == 's':
break
elif user_input.lower() == 'g':
auto_continue = True
break
else:
print("Invalid input. Please enter 'y' for yes, 'n' for no, 's' for skip, or 'g' for go ahead with all files.")
if __name__ == "__main__":
transcriptions_folder_path = "/Users/aaronnganm1/Documents/Coding/Whisper Transcription/output" # Replace with the path to your output folder
main(transcriptions_folder_path) | [
"\n You are an intelligent assistant specializing in summarizing meeting transcripts that are educational in nature. For the provided text, you will first produce a 5-10 word title for the text. Then you should produce a summary of the text that is no more than 3 sentences long. The summary should be a coherent paragraph that is grammatically correct and does not contain any spelling errors. Also generate a list of key learnings or key topics that were discussed in the meeting. Create a list of 3 suggestions about how you would use the learning and the content to create packaged content for public consumption. This could include templates (provide suggestions), learning resources, or other content that would be useful to the public. Use only the context provided, if no context is provided say no context. Your role is to\n analyze and adjust acronyms and specialised terminology in the text. Once you've done that, produce the summary and key learnings.",
"'PLACEHOLDER': 'PLACEHOLDER'",
", ",
"\n You are an intelligent assistant specializing in Acronyms; your task is to process transcripts, ensuring that all acronyms and specialised terms are in the correct format. The full term should be spelled out followed by the acronym in parentheses. For example, '401k' should be transformed to '401(k) retirement savings plan', 'HSA' should be transformed to 'Health Savings Account (HSA)'. Names that are not acronyms (e.g. AusLeap) should not be transformed. Everyday words should not be transformed or changed, only acronyms. Create and append to the end a list of all transformations in the format [text] transformed into [transform] as well as any unknown acronyms. Unknown acronyms are things that are not listed on the common acronyms. Here are some common acronyms and their transcriptions: {}\n ",
" You are a helpful assistant that adds punctuation and paragraphs to text. Preserve the original words and only insert recommend paragraphs and only necessary punctuation such as periods, commas, capitalization, symbols like dollar signs or percentage signs, and formatting. Use only the context provided. If there is no context provided say, 'No context provided'\n"
] |
2024-01-10 | itsaaronngan/whisper | all.py | import os
import magic
from datetime import datetime
import ffmpeg
import openai
from pydub import AudioSegment
def get_file_type(file_path):
file_type = magic.from_file(file_path, mime=True)
return file_type.split('/')[0]
def identify_files(folder_path):
video_files = []
audio_files = []
for root, _, files in os.walk(folder_path):
if not files:
os.rmdir(root) # Delete empty folders
continue
for file in files:
file_path = os.path.join(root, file)
file_type = get_file_type(file_path)
if file_type == 'video':
video_files.append(file_path)
elif file_type == 'audio':
audio_files.append(file_path)
return video_files, audio_files
def main():
folder_path = '/Users/aaronnganm1/Documents/Zoom'
video_files, audio_files = identify_files(folder_path)
if not audio_files:
for video_file in video_files:
audio_file = ffmpeg.input(video_file).output('pipe:', format='s16le', acodec='pcm_s16le', ac=1, ar='16k').run_async(pipe_stdout=True)
audio_file_length = audio_file.stderr.read().decode().split('Duration: ')[1].split(',')[0].split(':')
audio_file_length_seconds = int(audio_file_length[0]) * 3600 + int(audio_file_length[1]) * 60 + int(audio_file_length[2])
# Split the audio file into chunks of 25 MB or less
chunk_duration = 25 * 1024 * 1024 / (16000 * 2 * 2)
audio_chunks = []
for i in range(0, audio_file_length_seconds, chunk_duration):
chunk = AudioSegment.from_file(audio_file.stdout, format="raw", frame_rate=16000, channels=1, sample_width=2).set_frame_rate(16000).set_channels(1).set_sample_width(2)
audio_chunks.append(chunk)
# Merge the audio chunks and save the final audio file
merged_audio = AudioSegment.empty()
for chunk in audio_chunks:
merged_audio += chunk
merged_audio.export(os.path.splitext(video_file)[0] + '.mp3', format='mp3')
if __name__ == '__main__':
main() | [] |
2024-01-10 | MarsX-2002/curriculum.ai | curriculum.ai_backend~gpt_summary.py | import os
import openai
openai.api_key = os.getenv("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")
def get_summary_for_resume(description):
response = openai.Completion.create(
model="text-davinci-003",
prompt="Summarize the following in bullet points for my resume \n\n"+description,
temperature=0,
max_tokens=256,
top_p=1,
frequency_penalty=0,
presence_penalty=0
)
if len(response['choices'][0]) > 0:
points = response['choices'][0]['text'].split("\n")
s = ""
# Remove the Bullet point from the response text
for point in points:
s += point[1:]+"\n"
return s
return ""
def get_summary_for_projects(description):
response = openai.Completion.create(
model="text-davinci-003",
prompt="Summarize the following in 2 bullet points for my resume \n\n"+description,
temperature=0,
max_tokens=256,
top_p=1,
frequency_penalty=0,
presence_penalty=0
)
if len(response['choices'][0]) > 0:
points = response['choices'][0]['text'].split("\n")
s = ""
# Remove the Bullet point from the response text
for point in points:
s += point[1:]+"\n"
return s
return ""
| [
"Summarize the following in 2 bullet points for my resume \n\nPLACEHOLDER",
"Summarize the following in bullet points for my resume \n\nPLACEHOLDER"
] |
2024-01-10 | hulkdesignQ/chat-with-your-data-solution-accelerator | code~utilities~helpers~LLMHelper.py | import openai
from typing import List
from langchain.chat_models import AzureChatOpenAI
from langchain.embeddings import OpenAIEmbeddings
from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler
from .EnvHelper import EnvHelper
class LLMHelper:
def __init__(self):
env_helper: EnvHelper = EnvHelper()
# Configure OpenAI API
openai.api_type = "azure"
openai.api_version = env_helper.AZURE_OPENAI_API_VERSION
openai.api_base = env_helper.OPENAI_API_BASE
openai.api_key = env_helper.OPENAI_API_KEY
self.llm_model = env_helper.AZURE_OPENAI_MODEL
self.llm_max_tokens = env_helper.AZURE_OPENAI_MAX_TOKENS if env_helper.AZURE_OPENAI_MAX_TOKENS != '' else None
self.embedding_model = env_helper.AZURE_OPENAI_EMBEDDING_MODEL
def get_llm(self):
return AzureChatOpenAI(deployment_name=self.llm_model, temperature=0, max_tokens=self.llm_max_tokens, openai_api_version=openai.api_version)
# TODO: This needs to have a custom callback to stream back to the UI
def get_streaming_llm(self):
return AzureChatOpenAI(streaming=True, callbacks=[StreamingStdOutCallbackHandler], deployment_name=self.llm_model, temperature=0,
max_tokens=self.llm_max_tokens, openai_api_version=openai.api_version)
def get_embedding_model(self):
return OpenAIEmbeddings(deployment=self.embedding_model, chunk_size=1)
def get_chat_completion_with_functions(self, messages: List[dict], functions: List[dict], function_call: str="auto"):
return openai.ChatCompletion.create(
deployment_id=self.llm_model,
messages=messages,
functions=functions,
function_call=function_call,
)
def get_chat_completion(self, messages: List[dict]):
return openai.ChatCompletion.create(
deployment_id=self.llm_model,
messages=messages,
)
| [] |
2024-01-10 | albinjosep/langchain | langchain~llms~gpt4all.py | """Wrapper for the GPT4All model."""
from functools import partial
from typing import Any, Dict, List, Mapping, Optional, Set
from pydantic import Extra, Field, root_validator
from langchain.callbacks.manager import CallbackManagerForLLMRun
from langchain.llms.base import LLM
from langchain.llms.utils import enforce_stop_tokens
class GPT4All(LLM):
r"""Wrapper around GPT4All language models.
To use, you should have the ``gpt4all`` python package installed, the
pre-trained model file, and the model's config information.
Example:
.. code-block:: python
from langchain.llms import GPT4All
model = GPT4All(model="./models/gpt4all-model.bin", n_ctx=512, n_threads=8)
# Simplest invocation
response = model("Once upon a time, ")
"""
model: str
"""Path to the pre-trained GPT4All model file."""
backend: Optional[str] = Field(None, alias="backend")
n_ctx: int = Field(512, alias="n_ctx")
"""Token context window."""
n_parts: int = Field(-1, alias="n_parts")
"""Number of parts to split the model into.
If -1, the number of parts is automatically determined."""
seed: int = Field(0, alias="seed")
"""Seed. If -1, a random seed is used."""
f16_kv: bool = Field(False, alias="f16_kv")
"""Use half-precision for key/value cache."""
logits_all: bool = Field(False, alias="logits_all")
"""Return logits for all tokens, not just the last token."""
vocab_only: bool = Field(False, alias="vocab_only")
"""Only load the vocabulary, no weights."""
use_mlock: bool = Field(False, alias="use_mlock")
"""Force system to keep model in RAM."""
embedding: bool = Field(False, alias="embedding")
"""Use embedding mode only."""
n_threads: Optional[int] = Field(4, alias="n_threads")
"""Number of threads to use."""
n_predict: Optional[int] = 256
"""The maximum number of tokens to generate."""
temp: Optional[float] = 0.8
"""The temperature to use for sampling."""
top_p: Optional[float] = 0.95
"""The top-p value to use for sampling."""
top_k: Optional[int] = 40
"""The top-k value to use for sampling."""
echo: Optional[bool] = False
"""Whether to echo the prompt."""
stop: Optional[List[str]] = []
"""A list of strings to stop generation when encountered."""
repeat_last_n: Optional[int] = 64
"Last n tokens to penalize"
repeat_penalty: Optional[float] = 1.3
"""The penalty to apply to repeated tokens."""
n_batch: int = Field(1, alias="n_batch")
"""Batch size for prompt processing."""
streaming: bool = False
"""Whether to stream the results or not."""
context_erase: float = 0.5
"""Leave (n_ctx * context_erase) tokens
starting from beginning if the context has run out."""
allow_download: bool = False
"""If model does not exist in ~/.cache/gpt4all/, download it."""
client: Any = None #: :meta private:
class Config:
"""Configuration for this pydantic object."""
extra = Extra.forbid
@staticmethod
def _model_param_names() -> Set[str]:
return {
"n_ctx",
"n_predict",
"top_k",
"top_p",
"temp",
"n_batch",
"repeat_penalty",
"repeat_last_n",
"context_erase",
}
def _default_params(self) -> Dict[str, Any]:
return {
"n_ctx": self.n_ctx,
"n_predict": self.n_predict,
"top_k": self.top_k,
"top_p": self.top_p,
"temp": self.temp,
"n_batch": self.n_batch,
"repeat_penalty": self.repeat_penalty,
"repeat_last_n": self.repeat_last_n,
"context_erase": self.context_erase,
}
@root_validator()
def validate_environment(cls, values: Dict) -> Dict:
"""Validate that the python package exists in the environment."""
try:
from gpt4all import GPT4All as GPT4AllModel
except ImportError:
raise ImportError(
"Could not import gpt4all python package. "
"Please install it with `pip install gpt4all`."
)
full_path = values["model"]
model_path, delimiter, model_name = full_path.rpartition("/")
model_path += delimiter
values["client"] = GPT4AllModel(
model_name,
model_path=model_path or None,
model_type=values["backend"],
allow_download=values["allow_download"],
)
if values["n_threads"] is not None:
# set n_threads
values["client"].model.set_thread_count(values["n_threads"])
values["backend"] = values["client"].model_type
return values
@property
def _identifying_params(self) -> Mapping[str, Any]:
"""Get the identifying parameters."""
return {
"model": self.model,
**self._default_params(),
**{
k: v for k, v in self.__dict__.items() if k in self._model_param_names()
},
}
@property
def _llm_type(self) -> str:
"""Return the type of llm."""
return "gpt4all"
def _call(
self,
prompt: str,
stop: Optional[List[str]] = None,
run_manager: Optional[CallbackManagerForLLMRun] = None,
) -> str:
r"""Call out to GPT4All's generate method.
Args:
prompt: The prompt to pass into the model.
stop: A list of strings to stop generation when encountered.
Returns:
The string generated by the model.
Example:
.. code-block:: python
prompt = "Once upon a time, "
response = model(prompt, n_predict=55)
"""
text_callback = None
if run_manager:
text_callback = partial(run_manager.on_llm_new_token, verbose=self.verbose)
text = ""
for token in self.client.generate(prompt, **self._default_params()):
if text_callback:
text_callback(token)
text += token
if stop is not None:
text = enforce_stop_tokens(text, stop)
return text
| [] |
2024-01-10 | skylersaucedo/llamaIndex | llama_index~llama_index~schema.py | """Base schema for data structures."""
import json
import textwrap
import uuid
from abc import abstractmethod
from enum import Enum, auto
from hashlib import sha256
from io import BytesIO
from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
from typing_extensions import Self
from llama_index.bridge.pydantic import BaseModel, Field, root_validator
from llama_index.utils import SAMPLE_TEXT, truncate_text
if TYPE_CHECKING:
from haystack.schema import Document as HaystackDocument
from semantic_kernel.memory.memory_record import MemoryRecord
from llama_index.bridge.langchain import Document as LCDocument
DEFAULT_TEXT_NODE_TMPL = "{metadata_str}\n\n{content}"
DEFAULT_METADATA_TMPL = "{key}: {value}"
# NOTE: for pretty printing
TRUNCATE_LENGTH = 350
WRAP_WIDTH = 70
ImageType = Union[str, BytesIO]
class BaseComponent(BaseModel):
"""Base component object to capture class names."""
@classmethod
@abstractmethod
def class_name(cls) -> str:
"""
Get the class name, used as a unique ID in serialization.
This provides a key that makes serialization robust against actual class
name changes.
"""
def __getstate__(self) -> Dict[str, Any]:
state = self.dict()
# Remove common unpicklable entries
state.pop("tokenizer", None)
state.pop("tokenizer_fn", None)
return state
def to_dict(self, **kwargs: Any) -> Dict[str, Any]:
data = self.dict(**kwargs)
data["class_name"] = self.class_name()
return data
def to_json(self, **kwargs: Any) -> str:
data = self.to_dict(**kwargs)
return json.dumps(data)
# TODO: return type here not supported by current mypy version
@classmethod
def from_dict(cls, data: Dict[str, Any], **kwargs: Any) -> Self: # type: ignore
if isinstance(kwargs, dict):
data.update(kwargs)
data.pop("class_name", None)
return cls(**data)
@classmethod
def from_json(cls, data_str: str, **kwargs: Any) -> Self: # type: ignore
data = json.loads(data_str)
return cls.from_dict(data, **kwargs)
class NodeRelationship(str, Enum):
"""Node relationships used in `BaseNode` class.
Attributes:
SOURCE: The node is the source document.
PREVIOUS: The node is the previous node in the document.
NEXT: The node is the next node in the document.
PARENT: The node is the parent node in the document.
CHILD: The node is a child node in the document.
"""
SOURCE = auto()
PREVIOUS = auto()
NEXT = auto()
PARENT = auto()
CHILD = auto()
class ObjectType(str, Enum):
TEXT = auto()
IMAGE = auto()
INDEX = auto()
DOCUMENT = auto()
class MetadataMode(str, Enum):
ALL = auto()
EMBED = auto()
LLM = auto()
NONE = auto()
class RelatedNodeInfo(BaseComponent):
node_id: str
node_type: Optional[ObjectType] = None
metadata: Dict[str, Any] = Field(default_factory=dict)
hash: Optional[str] = None
@classmethod
def class_name(cls) -> str:
return "RelatedNodeInfo"
RelatedNodeType = Union[RelatedNodeInfo, List[RelatedNodeInfo]]
# Node classes for indexes
class BaseNode(BaseComponent):
"""Base node Object.
Generic abstract interface for retrievable nodes
"""
class Config:
allow_population_by_field_name = True
id_: str = Field(
default_factory=lambda: str(uuid.uuid4()), description="Unique ID of the node."
)
embedding: Optional[List[float]] = Field(
default=None, description="Embedding of the node."
)
""""
metadata fields
- injected as part of the text shown to LLMs as context
- injected as part of the text for generating embeddings
- used by vector DBs for metadata filtering
"""
metadata: Dict[str, Any] = Field(
default_factory=dict,
description="A flat dictionary of metadata fields",
alias="extra_info",
)
excluded_embed_metadata_keys: List[str] = Field(
default_factory=list,
description="Metadata keys that are excluded from text for the embed model.",
)
excluded_llm_metadata_keys: List[str] = Field(
default_factory=list,
description="Metadata keys that are excluded from text for the LLM.",
)
relationships: Dict[NodeRelationship, RelatedNodeType] = Field(
default_factory=dict,
description="A mapping of relationships to other node information.",
)
hash: str = Field(default="", description="Hash of the node content.")
@classmethod
@abstractmethod
def get_type(cls) -> str:
"""Get Object type."""
@abstractmethod
def get_content(self, metadata_mode: MetadataMode = MetadataMode.ALL) -> str:
"""Get object content."""
@abstractmethod
def get_metadata_str(self, mode: MetadataMode = MetadataMode.ALL) -> str:
"""Metadata string."""
@abstractmethod
def set_content(self, value: Any) -> None:
"""Set the content of the node."""
@property
def node_id(self) -> str:
return self.id_
@node_id.setter
def node_id(self, value: str) -> None:
self.id_ = value
@property
def source_node(self) -> Optional[RelatedNodeInfo]:
"""Source object node.
Extracted from the relationships field.
"""
if NodeRelationship.SOURCE not in self.relationships:
return None
relation = self.relationships[NodeRelationship.SOURCE]
if isinstance(relation, list):
raise ValueError("Source object must be a single RelatedNodeInfo object")
return relation
@property
def prev_node(self) -> Optional[RelatedNodeInfo]:
"""Prev node."""
if NodeRelationship.PREVIOUS not in self.relationships:
return None
relation = self.relationships[NodeRelationship.PREVIOUS]
if not isinstance(relation, RelatedNodeInfo):
raise ValueError("Previous object must be a single RelatedNodeInfo object")
return relation
@property
def next_node(self) -> Optional[RelatedNodeInfo]:
"""Next node."""
if NodeRelationship.NEXT not in self.relationships:
return None
relation = self.relationships[NodeRelationship.NEXT]
if not isinstance(relation, RelatedNodeInfo):
raise ValueError("Next object must be a single RelatedNodeInfo object")
return relation
@property
def parent_node(self) -> Optional[RelatedNodeInfo]:
"""Parent node."""
if NodeRelationship.PARENT not in self.relationships:
return None
relation = self.relationships[NodeRelationship.PARENT]
if not isinstance(relation, RelatedNodeInfo):
raise ValueError("Parent object must be a single RelatedNodeInfo object")
return relation
@property
def child_nodes(self) -> Optional[List[RelatedNodeInfo]]:
"""Child nodes."""
if NodeRelationship.CHILD not in self.relationships:
return None
relation = self.relationships[NodeRelationship.CHILD]
if not isinstance(relation, list):
raise ValueError("Child objects must be a list of RelatedNodeInfo objects.")
return relation
@property
def ref_doc_id(self) -> Optional[str]:
"""Deprecated: Get ref doc id."""
source_node = self.source_node
if source_node is None:
return None
return source_node.node_id
@property
def extra_info(self) -> Dict[str, Any]:
"""TODO: DEPRECATED: Extra info."""
return self.metadata
def __str__(self) -> str:
source_text_truncated = truncate_text(
self.get_content().strip(), TRUNCATE_LENGTH
)
source_text_wrapped = textwrap.fill(
f"Text: {source_text_truncated}\n", width=WRAP_WIDTH
)
return f"Node ID: {self.node_id}\n{source_text_wrapped}"
def get_embedding(self) -> List[float]:
"""Get embedding.
Errors if embedding is None.
"""
if self.embedding is None:
raise ValueError("embedding not set.")
return self.embedding
def as_related_node_info(self) -> RelatedNodeInfo:
"""Get node as RelatedNodeInfo."""
return RelatedNodeInfo(
node_id=self.node_id,
node_type=self.get_type(),
metadata=self.metadata,
hash=self.hash,
)
class TextNode(BaseNode):
text: str = Field(default="", description="Text content of the node.")
start_char_idx: Optional[int] = Field(
default=None, description="Start char index of the node."
)
end_char_idx: Optional[int] = Field(
default=None, description="End char index of the node."
)
text_template: str = Field(
default=DEFAULT_TEXT_NODE_TMPL,
description=(
"Template for how text is formatted, with {content} and "
"{metadata_str} placeholders."
),
)
metadata_template: str = Field(
default=DEFAULT_METADATA_TMPL,
description=(
"Template for how metadata is formatted, with {key} and "
"{value} placeholders."
),
)
metadata_seperator: str = Field(
default="\n",
description="Separator between metadata fields when converting to string.",
)
@classmethod
def class_name(cls) -> str:
return "TextNode"
@root_validator
def _check_hash(cls, values: dict) -> dict:
"""Generate a hash to represent the node."""
text = values.get("text", "")
metadata = values.get("metadata", {})
doc_identity = str(text) + str(metadata)
values["hash"] = str(
sha256(doc_identity.encode("utf-8", "surrogatepass")).hexdigest()
)
return values
@classmethod
def get_type(cls) -> str:
"""Get Object type."""
return ObjectType.TEXT
def get_content(self, metadata_mode: MetadataMode = MetadataMode.NONE) -> str:
"""Get object content."""
metadata_str = self.get_metadata_str(mode=metadata_mode).strip()
if not metadata_str:
return self.text
return self.text_template.format(
content=self.text, metadata_str=metadata_str
).strip()
def get_metadata_str(self, mode: MetadataMode = MetadataMode.ALL) -> str:
"""Metadata info string."""
if mode == MetadataMode.NONE:
return ""
usable_metadata_keys = set(self.metadata.keys())
if mode == MetadataMode.LLM:
for key in self.excluded_llm_metadata_keys:
if key in usable_metadata_keys:
usable_metadata_keys.remove(key)
elif mode == MetadataMode.EMBED:
for key in self.excluded_embed_metadata_keys:
if key in usable_metadata_keys:
usable_metadata_keys.remove(key)
return self.metadata_seperator.join(
[
self.metadata_template.format(key=key, value=str(value))
for key, value in self.metadata.items()
if key in usable_metadata_keys
]
)
def set_content(self, value: str) -> None:
"""Set the content of the node."""
self.text = value
def get_node_info(self) -> Dict[str, Any]:
"""Get node info."""
return {"start": self.start_char_idx, "end": self.end_char_idx}
def get_text(self) -> str:
return self.get_content(metadata_mode=MetadataMode.NONE)
@property
def node_info(self) -> Dict[str, Any]:
"""Deprecated: Get node info."""
return self.get_node_info()
# TODO: legacy backport of old Node class
Node = TextNode
class ImageNode(TextNode):
"""Node with image."""
# TODO: store reference instead of actual image
# base64 encoded image str
image: Optional[str] = None
image_path: Optional[str] = None
image_url: Optional[str] = None
@classmethod
def get_type(cls) -> str:
return ObjectType.IMAGE
@classmethod
def class_name(cls) -> str:
return "ImageNode"
def resolve_image(self) -> ImageType:
"""Resolve an image such that PIL can read it."""
if self.image is not None:
return self.image
elif self.image_path is not None:
return self.image_path
elif self.image_url is not None:
# load image from URL
import requests
response = requests.get(self.image_url)
return BytesIO(response.content)
else:
raise ValueError("No image found in node.")
class IndexNode(TextNode):
"""Node with reference to any object.
This can include other indices, query engines, retrievers.
This can also include other nodes (though this is overlapping with `relationships`
on the Node class).
"""
index_id: str
@classmethod
def from_text_node(
cls,
node: TextNode,
index_id: str,
) -> "IndexNode":
"""Create index node from text node."""
# copy all attributes from text node, add index id
return cls(
**node.dict(),
index_id=index_id,
)
@classmethod
def get_type(cls) -> str:
return ObjectType.INDEX
@classmethod
def class_name(cls) -> str:
return "IndexNode"
class NodeWithScore(BaseComponent):
node: BaseNode
score: Optional[float] = None
def __str__(self) -> str:
return f"{self.node}\nScore: {self.score: 0.3f}\n"
def get_score(self, raise_error: bool = False) -> float:
"""Get score."""
if self.score is None:
if raise_error:
raise ValueError("Score not set.")
else:
return 0.0
else:
return self.score
@classmethod
def class_name(cls) -> str:
return "NodeWithScore"
##### pass through methods to BaseNode #####
@property
def node_id(self) -> str:
return self.node.node_id
@property
def id_(self) -> str:
return self.node.id_
@property
def text(self) -> str:
if isinstance(self.node, TextNode):
return self.node.text
else:
raise ValueError("Node must be a TextNode to get text.")
@property
def metadata(self) -> Dict[str, Any]:
return self.node.metadata
@property
def embedding(self) -> Optional[List[float]]:
return self.node.embedding
def get_text(self) -> str:
if isinstance(self.node, TextNode):
return self.node.get_text()
else:
raise ValueError("Node must be a TextNode to get text.")
def get_content(self, metadata_mode: MetadataMode = MetadataMode.NONE) -> str:
return self.node.get_content(metadata_mode=metadata_mode)
def get_embedding(self) -> List[float]:
return self.node.get_embedding()
# Document Classes for Readers
class Document(TextNode):
"""Generic interface for a data document.
This document connects to data sources.
"""
# TODO: A lot of backwards compatibility logic here, clean up
id_: str = Field(
default_factory=lambda: str(uuid.uuid4()),
description="Unique ID of the node.",
alias="doc_id",
)
_compat_fields = {"doc_id": "id_", "extra_info": "metadata"}
@classmethod
def get_type(cls) -> str:
"""Get Document type."""
return ObjectType.DOCUMENT
@property
def doc_id(self) -> str:
"""Get document ID."""
return self.id_
def __str__(self) -> str:
source_text_truncated = truncate_text(
self.get_content().strip(), TRUNCATE_LENGTH
)
source_text_wrapped = textwrap.fill(
f"Text: {source_text_truncated}\n", width=WRAP_WIDTH
)
return f"Doc ID: {self.doc_id}\n{source_text_wrapped}"
def get_doc_id(self) -> str:
"""TODO: Deprecated: Get document ID."""
return self.id_
def __setattr__(self, name: str, value: object) -> None:
if name in self._compat_fields:
name = self._compat_fields[name]
super().__setattr__(name, value)
def to_langchain_format(self) -> "LCDocument":
"""Convert struct to LangChain document format."""
from llama_index.bridge.langchain import Document as LCDocument
metadata = self.metadata or {}
return LCDocument(page_content=self.text, metadata=metadata)
@classmethod
def from_langchain_format(cls, doc: "LCDocument") -> "Document":
"""Convert struct from LangChain document format."""
return cls(text=doc.page_content, metadata=doc.metadata)
def to_haystack_format(self) -> "HaystackDocument":
"""Convert struct to Haystack document format."""
from haystack.schema import Document as HaystackDocument
return HaystackDocument(
content=self.text, meta=self.metadata, embedding=self.embedding, id=self.id_
)
@classmethod
def from_haystack_format(cls, doc: "HaystackDocument") -> "Document":
"""Convert struct from Haystack document format."""
return cls(
text=doc.content, metadata=doc.meta, embedding=doc.embedding, id_=doc.id
)
def to_embedchain_format(self) -> Dict[str, Any]:
"""Convert struct to EmbedChain document format."""
return {
"doc_id": self.id_,
"data": {"content": self.text, "meta_data": self.metadata},
}
@classmethod
def from_embedchain_format(cls, doc: Dict[str, Any]) -> "Document":
"""Convert struct from EmbedChain document format."""
return cls(
text=doc["data"]["content"],
metadata=doc["data"]["meta_data"],
id_=doc["doc_id"],
)
def to_semantic_kernel_format(self) -> "MemoryRecord":
"""Convert struct to Semantic Kernel document format."""
import numpy as np
from semantic_kernel.memory.memory_record import MemoryRecord
return MemoryRecord(
id=self.id_,
text=self.text,
additional_metadata=self.get_metadata_str(),
embedding=np.array(self.embedding) if self.embedding else None,
)
@classmethod
def from_semantic_kernel_format(cls, doc: "MemoryRecord") -> "Document":
"""Convert struct from Semantic Kernel document format."""
return cls(
text=doc._text,
metadata={"additional_metadata": doc._additional_metadata},
embedding=doc._embedding.tolist() if doc._embedding is not None else None,
id_=doc._id,
)
@classmethod
def example(cls) -> "Document":
return Document(
text=SAMPLE_TEXT,
metadata={"filename": "README.md", "category": "codebase"},
)
@classmethod
def class_name(cls) -> str:
return "Document"
class ImageDocument(Document, ImageNode):
"""Data document containing an image."""
@classmethod
def class_name(cls) -> str:
return "ImageDocument"
| [
"{metadata_str} placeholders.",
"Template for how metadata is formatted, with {key} and ",
"{value} placeholders.",
"Template for how text is formatted, with {content} and "
] |
2024-01-10 | DESU-CLUB/ChainOfAction | chainofaction~agents~zeroShotAgent.py | import os
import json
import glob
import re
from multiprocessing import Pool
from tqdm import tqdm
import torch
import openai
import itertools
import random
#import environment
import tiktoken
####### HELPER FUNCTIONS ##########
#This class stores the history of the conversation which is used as context
class MemoryList(list): #Sliding window implementation for now
def __init__(self, *args, max_tokens = 3500):
super().__init__(*args)
self.max_tokens = max_tokens
self.tokenizer = tiktoken.encoding_for_model("gpt-4")
#Add smth to the list -> remove first item until total tokens < 4000
def append(self, item):
print(item)
total_tokens = self.check_tokens()
item2 = item["content"]
while len(self.tokenizer.encode(item2)) + total_tokens > self.max_tokens:
if len(self.tokenizer.encode(item2)) > self.max_tokens:
self.summarize()
raise Exception("Item too long")
self.handle_overflow()
total_tokens = self.check_tokens()
super().append(item)
#Helper to check no of tokens
def check_tokens(self):
return sum(len(self.tokenizer.encode(item['content'])) for item in self)
#Helper to handle overflow
def handle_overflow(self):
if len(self) >0:
self.pop(0)
#For now it will just be a signal to terminate the generation
def summarize(self):
print("Summarizing") #End goal is to use gpt-16k to do this
#This is a helper function to convert skills retrieved from the vector DB
#into the relevant code
def search_files(skills,run):
data_dir = f"chainofaction/data/run_{run}"
all_code = []
for skill in skills:
print(skill)
with open(os.path.join(data_dir,os.path.splitext(skill)[0]+'.py')) as f:
lines = f.readlines()
res = ""
for i,line in enumerate(lines):
res+= "\n"+line.strip() if not i else line.strip()
all_code.append(res)
return all_code
#This code handles the generation API calls
def generate(messages, max_tokens = 2048, temperature = 0.0, model = "gpt-4"):
if model in ["gpt-4", "gpt-4"]:
params = {
"model": model,
"max_tokens": max_tokens,
"temperature": temperature,
"messages": messages
}
for retry in range(3):
try:
return openai.ChatCompletion.create(**params)["choices"][0]["message"]["content"]
except Exception as e:
return e
# For older models, use the completion API with max_tokens=1024
params = {
"model": model,
"max_tokens": min(max_tokens, 1024),
"temperature": temperature,
"prompt": messages[-1]
}
for retry in range(3):
try:
return openai.Completion.create(**params)["choices"][0]["text"]
except:
pass
########### AGENT CLASS ############
class ZeroShotAgent:
def __init__(self,db,environment, model = "gpt-4", max_tokens = 2048, temperature = 0.0, explore_ratio = 0.3, max_count = 0):
'''
Agent: A class that handles the generation of skills and the interaction with the environment
model: the model to use for generation
max_tokens: the maximum number of tokens to generate
temperature: the temperature to use for generation
explore_ratio: the ratio of times to explore (deprecated for now)
max_count: the maximum number of times to generate (deprecated for now)
db: the vector database to use
'''
self.model = model
self.max_tokens = max_tokens
self.temperature = temperature
self.message = MemoryList(max_tokens = 3500)
self.db = db
self.explore_ratio = explore_ratio
self.max_count = max_count
self.environment = environment
def get_prompt(self,task): #Helper function to get the prompt
with open(f"chainofaction/prompts/{task}") as f:
return f.read().strip()
def decompose(self,problem): #Helper function to decompose the problem into steps
decompose = self.get_prompt("decompose.txt")
decompose += "\n\n" + problem
self.message.append({"role": "user", "content": decompose})
for retry in range(3): #Loop to retry if generation fails
try:
skills = generate(self.message, max_tokens = 2048, temperature = 0.0, model = "gpt-4")
print(skills)
self.message.append({"role": "assistant", "content": skills})
return skills
except Exception as e: #Add error for model to debug
print("Error: Failed to generate response")
self.message.append({"role":"user","content": f"Failed to execute solution generation: {e}"})
def zeroshot_soln(self, problem, steps,fn_head):
try:
self.message.append({"role": "user", "content": f"Here is the problem: {problem}\nHere are the identified steps: {steps}\nWrite Python code to solve the problem\n Use this function head:{fn_head}"})
soln = generate(self.message)
self.message.append({"role":"assistant","content": f"{soln}"})
return soln
except Exception as e:
print("ERROR ZERO SHOT")
raise e
return None
def get_response(self,problem, cases, fn_head, title):
'''
problem: description of problem
'''
success = True
steps = self.decompose(problem)
soln = self.zeroshot_soln(problem, steps, fn_head)
if not soln:
return None
###Iterative prompting
for retry in range(10):
#TODO
#Check if code can get correct answer for test cases
#If not, prompt for more code
try:
passed = True #Dummy variables
output = ''
output, passed = self.environment.execute(soln, cases) #Environment implemented in env.py later
except Exception as e:
print(e)
raise e
print("Error: Failed to generate response")
self.message.append({"role":"user","content": f"Failed to execute iterative prompting: {type(e)}"})
if not passed:
success = False
#save into chroma before return statement
if success:
self.message.append({"role": "user", "content": f"Write a description of what this program solves:\n{soln}"})
desc = generate(self.message)
with open(f"chainofaction/data/run_{self.environment.run}/newdesc/"+title,'w') as f:
f.write(soln)
return (soln, desc, title)
return None
def reset(self):
self.message = MemoryList(max_tokens = 3500)
| [
"Here is the problem: PLACEHOLDER\nHere are the identified steps: PLACEHOLDER\nWrite Python code to solve the problem\n Use this function head:PLACEHOLDER",
"Failed to execute iterative prompting: <class '__main__.Placeholder'>",
"PLACEHOLDER",
"Write a description of what this program solves:\nPLACEHOLDER",
"Failed to execute solution generation: PLACEHOLDER"
] |
2024-01-10 | DESU-CLUB/ChainOfAction | chainofaction~agents~skillcreator.py | import os
import json
import glob
import re
from multiprocessing import Pool
from tqdm import tqdm
import torch
import openai
import itertools
import random
#import environment
import tiktoken
import time
####### HELPER FUNCTIONS ##########
#This class stores the history of the conversation which is used as context
class MemoryList(list): #Sliding window implementation for now
def __init__(self, *args, max_tokens = 3500):
super().__init__(*args)
self.max_tokens = max_tokens
self.tokenizer = tiktoken.encoding_for_model("gpt-4-1106-preview")
#Add smth to the list -> remove first item until total tokens < 4000
def append(self, item):
#print(item)
total_tokens = self.check_tokens()
item2 = item["content"]
while len(self.tokenizer.encode(item2)) + total_tokens > self.max_tokens:
if len(self.tokenizer.encode(item2)) > self.max_tokens:
self.summarize()
raise Exception("Item too long")
self.handle_overflow()
total_tokens = self.check_tokens()
super().append(item)
#Helper to check no of tokens
def check_tokens(self):
return sum(len(self.tokenizer.encode(item['content'])) for item in self)
#Helper to handle overflow
def handle_overflow(self):
if len(self) >0:
self.pop(0)
#For now it will just be a signal to terminate the generation
def summarize(self):
pass
#print("Summarizing") #End goal is to use gpt-16k to do this
#This is a helper function to convert skills retrieved from the vector DB
#into the relevant code
def search_files(skills,run):
data_dir = f"chainofaction/data/run_{run}"
all_code = []
for skill in skills:
#print(skill)
with open(os.path.join(data_dir,os.path.splitext(skill)[0]+'.py')) as f:
lines = f.readlines()
res = ""
for i,line in enumerate(lines):
res+= "\n"+line.strip() if not i else line.strip()
all_code.append(res)
return all_code
#This code handles the generation API calls
def generate(messages, max_tokens = 2048, temperature = 0.0, model = "gpt-4-1106-preview"):
if model in ["gpt-4-1106-preview", "gpt-4-1106-preview"]:
params = {
"model": model,
"max_tokens": max_tokens,
"temperature": temperature,
"messages": messages
}
for retry in range(3):
try:
return openai.ChatCompletion.create(**params)["choices"][0]["message"]["content"]
except Exception as e:
raise e
return e
# For older models, use the completion API with max_tokens=1024
params = {
"model": model,
"max_tokens": min(max_tokens, 1024),
"temperature": temperature,
"prompt": messages[-1]
}
for retry in range(3):
try:
return openai.Completion.create(**params)["choices"][0]["text"]
except:
pass
########### AGENT CLASS ############
class Agent:
def __init__(self,db,environment, model = "gpt-4-1106-preview", max_tokens = 2048, temperature = 0.0, explore_ratio = 0.3, max_count = 0):
'''
Agent: A class that handles the generation of skills and the interaction with the environment
model: the model to use for generation
max_tokens: the maximum number of tokens to generate
temperature: the temperature to use for generation
explore_ratio: the ratio of times to explore (deprecated for now)
max_count: the maximum number of times to generate (deprecated for now)
db: the vector database to use
'''
self.model = model
self.max_tokens = max_tokens
self.temperature = temperature
self.message = MemoryList(max_tokens = 3500)
self.db = db
self.explore_ratio = explore_ratio
self.max_count = max_count
self.environment = environment
self.trying = 1
self.data = {"problem_name":"","success":False,"one_shot":False,"chromaSuccess":False,"stepQueryPairs": {}, "unusedChroma": True}
def get_prompt(self,task): #Helper function to get the prompt
with open(f"chainofaction/prompts/{task}") as f:
return f.read().strip()
def decompose(self,problem): #Helper function to decompose the problem into steps
decompose = self.get_prompt("decompose.txt")
decompose += "\n\n" + problem
self.message.append({"role": "user", "content": decompose})
for retry in range(3): #Loop to retry if generation fails
try:
skills = generate(self.message, max_tokens = 2048, temperature = 0.0, model = "gpt-4-1106-preview")
#print(skills)
self.message.append({"role": "assistant", "content": skills})
return skills
except Exception as e: #Add error for model to debug
with open(f"chainofaction/data/run_{self.environment.run}/error.txt",'a') as f:
f.write(str(e))
#print("Error: Failed to generate response")
self.message.append({"role":"user","content": f"Failed to execute solution generation: {e}"})
def rewrite_soln(self, problem, steps, output, fn_head): #Helper function to write/rewrite the solution
"""
Helper function to write/rewrite the solution.
Args:
problem (str): The problem statement.
steps (str): The steps taken to solve the problem.
output (str): The current output error.
Returns:
str: The generated solution.
"""
rewrite = self.get_prompt("soln.txt")
rewrite = rewrite.replace("{Qn}",problem)+ f'\n\nThe current output error is {output}'
rewrite = rewrite.replace("{Steps}",steps)
rewrite = rewrite.replace("{fn_head}",fn_head)
pattern = r'^(\d+:.*?)(?=\d+:|$)'
skills = re.findall(pattern, steps, re.MULTILINE)
for retry in range(3):
try:
skill_index = 0
skills_used = []
skill = skills[skill_index]
while skill_index < len(skills): #Loop through all the skills
#Query vector DB for relevant skills
relevant_chunks = self.db.query([skill],n_results = 1)
skills_accepted = []
#Grab titles
for i, chunk in enumerate(relevant_chunks['documents'][0]):
#print(relevant_chunks['metadatas'][0][i])
if relevant_chunks['distances'][0][i] < 1.2:
self.data['unusedChroma'] = False
self.data["stepQueryPairs"][f"try_{self.trying}"].append({"step":skill,"query":relevant_chunks["metadatas"][0][i]['title'], "distance":relevant_chunks['distances'][0][i]})
print(self.data)
skills_accepted.append(relevant_chunks["metadatas"][0][i]['title'])
skills_used.append(relevant_chunks["metadatas"][0][i]['title'])
if skill_index == len(skills)-1:
break
#If no skills accepted, merge them
if len(skills_accepted) == 0:
skill_index +=1
if skill_index < len(skills):
skill = skills[skill_index-1] + " " +skills[skill_index]
else:
#Else, pick the next skill
skill_index +=1
print(skill_index,len(skills))
if skill_index < len(skills):
skill = skills[skill_index]
#convert skills to code
skills_used = search_files(skills_used, self.environment.run)
#Prompt and generate
rewrite = rewrite.replace("{Ref}",'\n\nHere are a list of relevant skills to the question'+'\n'.join(skills_used))
self.message.append({"role":"user","content": f"{rewrite}"})
soln = generate(self.message, max_tokens = 2048, temperature = 0.0, model = "gpt-4-1106-preview")
self.message.append({"role": "assistant", "content": soln})
#print(soln)
except Exception as e:
#print("Error: Failed to generate response",e)
with open(f"chainofaction/data/run_{self.environment.run}/error.txt",'a') as f:
f.write(str(e))
raise e
self.message.append({"role":"user","content": f"Failed to execute solution generation: {print(e)}"})
return soln if "soln" in locals() else None
def zeroshot_soln(self, problem, steps,fn_head):
try:
self.message.append({"role": "user", "content": f"Here is the problem: {problem}\nHere are the identified steps: {steps}\nWrite Python code to solve the problem\n Use this function head:{fn_head}"})
soln = generate(self.message)
self.message.append({"role":"assistant","content": f"{soln}"})
return soln
except Exception as e:
#print("ERROR ZERO SHOT")
with open(f"chainofaction/data/run_{self.environment.run}/error.txt",'w+') as f:
f.write("Zeroshot error"+problem[:30]+str(e))
raise e
return None
def get_response(self,problem, cases, fn_head, title):
'''
problem: description of problem
'''
self.data["problem_name"] = title
self.data["stepQueryPairs"] = {f"try_{self.trying}":[]}
success = True
steps = self.decompose(problem)
soln = self.zeroshot_soln(problem, steps, fn_head)
if not soln:
return None
###Iterative prompting
for retry in range(3):
#TODO
#Check if code can get correct answer for test cases
#If not, prompt for more code
try:
passed = True #Dummy variables
output = ''
output, passed = self.environment.execute(soln, cases) #Environment implemented in env.py later
if passed == True:
self.data['one_shot'] = True
print("Setting to true")
break
else:
self.data['one_shot'] = False
print("Setting one shot to false")
for i in range(3):
print(title,"\nChromaDB (should be) checked\n")
output = ""
if passed:
break
self.trying+=1
self.data["stepQueryPairs"][f"try_{self.trying}"] = []
steps = self.decompose(problem)
soln = self.rewrite_soln(problem, steps,output, fn_head)
#print(f"\n\nNew SOLN: {soln}\n\n")
output, passed = self.environment.execute(soln, cases)
if passed:
break
break
except Exception as e:
print(e)
print("Error: Failed to generate response")
with open(f"chainofaction/data/run_{self.environment.run}/error.txt",'w+') as f:
f.write(f"{title}"+str(e))
self.message.append({"role":"user","content": f"Failed to execute iterative prompting: {type(e)}"})
if not passed:
success = False
#save into chroma before return statement
if success:
self.data["success"] = True
if self.data["one_shot"] == True:
self.data["chromaSuccess"] = False
else:
self.data["chromaSuccess"] = True
self.message.append({"role": "user", "content": f"Write a description of what this program solves:\n{soln}"})
desc = generate(self.message)
with open(f"chainofaction/data/run_{self.environment.run}/newdesc/"+title,'w') as f:
f.write(desc)
with open(f"chainofaction/data/run_{self.environment.run}/vis/"+title,'w') as f:
json.dump(self.data,f)
self.reset()
return (soln, desc, title)
with open(f"chainofaction/data/run_{self.environment.run}/vis/"+title,'w') as f:
json.dump(self.data,f)
self.reset()
return None
def reset(self):
self.trying = 0
self.data = {"problem_name":"","success":False,"one_shot":False,"chromaSuccess":False,"stepQueryPairs": {}, "unusedChroma": False}
self.message = MemoryList(max_tokens = 3500)
| [
"Here is the problem: PLACEHOLDER\nHere are the identified steps: PLACEHOLDER\nWrite Python code to solve the problem\n Use this function head:PLACEHOLDER",
"Failed to execute iterative prompting: <class '__main__.Placeholder'>",
"Write a description of what this program solves:\nPLACEHOLDER",
"PLACEHOLDER",
"Failed to execute solution generation: None",
"Failed to execute solution generation: PLACEHOLDER"
] |
2024-01-10 | DESU-CLUB/ChainOfAction | datasetMaker.py | import json
import os
from bs4 import BeautifulSoup
import openai
import random
import re
import shutil
dataPath = "chainofaction/data/parsed_solutions"
files = os.listdir(dataPath)
"""
for file in files:
with open(os.path.join(dataPath,file)) as f:
try:
data = json.load(f)
key = list(data["solutions"].keys())[0]
text_content = data["solutions"][key]["codeblocks_text"][0]
# Adding newline characters after each paragraph
# soup = BeautifulSoup(text_content, 'html.parser')
#text_content = soup.get_text(separator='', strip=False)
#
if text_content.startswith("class Solution:"):
with open("chainofaction/data/code/"+file+".py","w") as f:
f.write(text_content)
except Exception as e:
print(data.keys(),f)
for file in files:
with open(os.path.join(dataPath,file)) as f:
try:
data = json.load(f)
text = data["problem_text"]
# Adding newline characters after each paragraph
# soup = BeautifulSoup(text_content, 'html.parser')
#text_content = soup.get_text(separator='', strip=False)
#
if file+".py" in os.listdir("chainofaction/data/code"):
with open("chainofaction/data/problems/"+file+".txt","w") as f:
f.write(text)
except Exception as e:
print(data.keys(),f)
def extract_testcases(text):
pattern = re.compile(r'Input: ([^\n]+)\s+Output: ([^\n]+)', re.MULTILINE | re.DOTALL)
matches = pattern.findall(text)
testcases = [(input_str.strip(), output_str.strip()) for input_str, output_str in matches]
return testcases
#This generates testcase inputs, after given the problem and the solution
def generate_testcases(text,soln):
prompt = f"This is the problem: {text}\n\nThis is the solution: {soln}\n\nPlease generate 5 inputs for the solution of this question. Format will be Input: <testcase>. You are to only print the inputs, no other words. Wrap testcases with multiple inputs in (), separated by commas"
text = openai.ChatCompletion.create(
model = "gpt-4-1106-preview",
max_tokens = 300,
messages = [{"role":"user", "content": prompt}],
temperature = 0.5
)['choices'][0]["message"]["content"]
return text
for file in files:
with open(os.path.join(dataPath,file)) as f:
data = json.load(f)
# print(data.keys())
if "problem_text" not in data or "solutions" not in data:
continue
text = data['problem_text']
solns = data['solutions']
# num_soln = data['n_solutions']
# print(text)
# print(testcases)
# else:
for sol in solns:
#retrieve plaintext file
with open(f"chainofaction/data/code/{file}.py",'w') as f:
soln = solns[sol]['codeblocks_text-only'][0]
if soln.startswith("class Solution:"):
f.write(soln)
with open(f"chainofaction/data/problems/{file}.txt","w") as f:
f.write(text)
#get test cases if no initial testcases
with open(f"chainofaction/data/cases/{file}.txt","w") as f:
f.write(generate_testcases(text,soln))
#get function head here
pattern = r"def [^\n]*\n"
matches = re.findall(pattern, soln)
if matches:
for match in matches:
print(match.strip())
break
else:
continue
"""
""" for i in os.listdir("chainofaction/data/code")[173:]:
with open("chainofaction/data/code/"+i) as f:
code = f.read()
response = openai.ChatCompletion.create(
model="gpt-4-1106-preview",
messages=[{"role":"user","content":"Describe the code and what it does:\n\n"+code+"\n\n in 100-200 tokens"}],
max_tokens=300,
temperature=0
)["choices"][0]["message"]["content"]
with open("chainofaction/data/descriptions/"+i[:-2]+"txt","w") as f:
f.write(response)
"""
import pandas as pd
texts = []
titles = []
problems = []
#Takes problem, solution and description and turn into csv file
allcases = os.listdir("chainofaction/data/fullcases")
for i in os.listdir("chainofaction/data/descriptions"):
if i[:-3]+"json" not in allcases:
continue
with open("chainofaction/data/descriptions/"+i) as f:
text = f.read()
texts.append(text)
titles.append( i)
with open("chainofaction/data/problems/"+i[:-3]+"txt") as f:
problem = f.read()
problems.append(problem)
df = pd.DataFrame({"problem_text":problems,"title":titles,"skill_description":texts})
#Convert into tsv file called leetcode.tsv. I need an id column by renaming index to id
df.to_csv("chainofaction/data/leetcode.tsv",sep="\t",index_label="id") | [] |
2024-01-10 | DESU-CLUB/ChainOfAction | frontend.py | import time
import gradio as gr
import openai
from chainofaction.agents.inferenceAgent import InferenceAgent
import vector_database.vector_database as skills
import threading
import queue
class InteractiveEnv:
def __init__(self):
dataset = "leetcode"#?
emb_func = skills.MiniLML6V2EmbeddingFunction()
data_dir = "chainofaction/data"
self.api_key_1 = "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"
self.api_key_2 = "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"
self.db= skills.ChromaWithUpsert(
name=f"{dataset}_minilm6v2",
embedding_function=emb_func, # you can have something here using /embed endpoint
persist_directory= data_dir
)
self.skillagent = InferenceAgent(self.db,self, self.api_key_1)
self.zeroagent = InferenceAgent(self.db, self, self.api_key_2)
def reset(self):
self.agent.reset()
self.init_db()
def predict_concurrently_stream(self, problem_description):
zero_shot_queue = queue.Queue()
skill_db_queue = queue.Queue()
def call_zero_shot():
response = self.zeroagent.get_response_zeroshot(problem_description,self.api_key_1)
for res in response:
zero_shot_queue.put(res)
zero_shot_queue.put(None)
def call_skill_db():
response = self.skillagent.get_response(problem_description,self.api_key_2)
for res in response:
skill_db_queue.put(res)
skill_db_queue.put(None)
# Start threads for concurrent processing
threading.Thread(target=call_zero_shot).start()
threading.Thread(target=call_skill_db).start()
zero_shot_done, skill_db_done, skills_done = False, False,False
skills_response = ""
# Yield responses as they become available
while True:
try:
if not zero_shot_done:
response = zero_shot_queue.get(timeout=30)
if response is None:
zero_shot_done = True
else:
zero_shot_response = response
if not skill_db_done:
response = skill_db_queue.get(timeout=30)
if response is None and not skills_done:
skills_done = True
elif response is None and skills_done:
skill_db_done = True
elif response is not None and skills_done:
skill_db_response = response
elif response is not None and not skills_done:
print(response)
code_fetched, skill, distance = response
skills_response += f"Step: {skill}\nCandidate Skill: {code_fetched}\nDistance: {distance}\n\n"
skill_db_response = ""
yield zero_shot_response, skill_db_response, skills_response
# Break if both threads are done
if zero_shot_done and skill_db_done:
break
except queue.Empty:
print("QUEUE EMPTY")
break # Break if timeout occurs
env = InteractiveEnv()
# Define the interface components
problem_description = gr.Textbox(label="💻 Problem Description", placeholder="Enter the LeetCode problem description here...", lines=5)
zero_shot_solution = gr.Textbox(label="🚀 ZeroShot Code Solution", placeholder="ZeroShot solution will be displayed here...", lines=10, interactive=True)
skilldb_solution = gr.Textbox(label="🛠️ SkillDB Code Solution", placeholder="SkillDB solution will be displayed here...", lines=10, interactive=True)
skills_found = gr.Textbox(label="🔎 Skills Found", placeholder="Skills found will be displayed here...", lines=10, interactive=True)
# Define the inputs and outputs for the Gradio Interface
inputs = [problem_description]
outputs = [zero_shot_solution, skilldb_solution, skills_found]
# Custom CSS to improve mobile responsiveness
custom_css = """
@media (max-width: 700px) {
.gradio-container {
width: 95% !important;
margin-left: auto !important;
margin-right: auto !important;
}
.gradio-input, .gradio-output {
width: 100% !important;
}
}
"""
# Create the Gradio Interface
iface = gr.Interface(
fn= env.predict_concurrently_stream,
inputs=inputs,
outputs=outputs,
title="LeetCode Problem Solver 🎉",
description="Enter the LeetCode problem, and get solutions from both ZeroShot and SkillDB agents streamed in real-time!",
examples=[["Example problem description"]],
css= custom_css
)
# Launch the interface with queueing to manage load
iface.queue().launch(share = True)
| [] |
2024-01-10 | DESU-CLUB/ChainOfAction | chainofaction~agents~apiusage.py | import openai
openai.api_key = "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"
response = openai.ChatCompletion.create(
model = "gpt-4",
messages = [{"role":"user",
"content":"I want to write some Python code for calling the GPT API to bake me a cake"},
{"role":"assistant","content":"Here is some code to call the GPT API to bake you a cake: But you will have to write it yourself"},
{"role":"user","content":"I want to write some Python code for calling the GPT API to bake me a salt baked chicken"}
],
temperature=0.9,
max_tokens=256,
top_p=1,
frequency_penalty=0,
presence_penalty=0,
stop=["\n"]
)
print(response['choices'][0]['message']['content']) | [
"I want to write some Python code for calling the GPT API to bake me a salt baked chicken",
"Here is some code to call the GPT API to bake you a cake: But you will have to write it yourself",
"I want to write some Python code for calling the GPT API to bake me a cake"
] |
2024-01-10 | DESU-CLUB/ChainOfAction | environment.py |
import openai
import os
import subprocess
import ast
from chainofaction.agents.skillcreator import Agent
import vector_database.vector_database as skills
from chainofaction.agents.zeroShotAgent import ZeroShotAgent
import json
import pandas as pd
import random
import json
import ast
import re
from typing import Optional, List, Tuple
from math import inf
import collections
from collections import Counter
from bisect import bisect_left
import shutil
#This is just some sample code to brainstorm for the environment
random.seed = 1
def find_topmost_functions_after_class(node, class_name):
topmost_functions = []
# Recursive inner function to traverse the AST
def traverse(node, inside_class=False):
# Check for ClassDef and match the desired class name
if isinstance(node, ast.ClassDef) and node.name == class_name:
for item in node.body:
if isinstance(item, ast.FunctionDef):
topmost_functions.append(item.name)
return # Do not go further down this branch
# Continue walking through other branches of the AST
for child in ast.iter_child_nodes(node):
traverse(child, inside_class)
traverse(node)
return topmost_functions
def extract_code_block(text):
# Regular expression pattern to find the code block, including the language identifier
try:
exec(text)
return text
except:
pattern = r"```python\n(.*?)```"
# Use re.DOTALL to match across multiple lines
match = re.search(pattern, text, re.DOTALL)
# Extract the code block if the pattern is found
return match.group(1).strip() if match else None
def get_function_parameters(code, function_name):
tree = ast.parse(code)
for node in ast.walk(tree):
if isinstance(node, ast.FunctionDef) and node.name == function_name:
# Found the function, now get its arguments
args = node.args
# Count the number of positional arguments
num_args = len(args.args)
# Check for *args
vararg = 1 if args.vararg else 0
# Check for **kwargs
kwarg = 1 if args.kwarg else 0
# Return the total number of arguments
#print("Breakdown:",num_args,vararg,kwarg)
return num_args + vararg + kwarg -1
# If the function is not found, return None
return None
optionalAPI = '''
class ListNode:
def __init__(self, val=0, next=None):
self.val = val
self.next = next
class TreeNode:
def __init__(self, x):
self.val = x
self.left = None
self.right = None
'''
def load_init_skills(path):
passages = pd.read_csv(os.path.join(path, "leetcode.tsv"), sep='\t', header=0)
return passages.head(int(len(passages)*5/100))
def load_dataset(path):
passages = pd.read_csv(os.path.join(path, "leetcode.tsv"), sep='\t', header=0)
return passages
def load_cases(path,prob_path):
with open(os.path.join(path,prob_path)) as f:
cases = json.load(f)
return cases
def func_head(code):
with open(f"chainofaction/data/code/{code[:-4]}.py","r") as f:
coded = f.read().strip()
pattern = r"def [^\n]*\n"
matches = re.findall(pattern, coded)
if matches:
return "class Solution:"+"\n\t".join(list(map(lambda x: x.strip(),matches)))
class Environment:
def __init__(self,status = None):
if status == None:
self.run = 0
self.check_run()
self.init_db()
else:
self.resume_run()
self.agent = Agent(self.db, self)
#self.agent = ZeroShotAgent(self.db, self) #Zero shot
self.dataset = load_dataset("chainofaction/data")
def check_run(self):
#Check current directory for max run_ folders, then create a run_x+1 folder and sets self.run to x+1
for i in os.listdir("chainofaction/data/"):
if i.startswith("run_"):
self.run = max(self.run,int(i[4:]))
self.run+=1
os.mkdir(f"chainofaction/data/run_{self.run}")
os.mkdir(f"chainofaction/data/run_{self.run}/newdesc")
os.mkdir(f"chainofaction/data/run_{self.run}/tracker")
os.mkdir(f"chainofaction/data/run_{self.run}/vis")
def reset(self):
self.db = self.init_db()
self.Agent = Agent(self.db)
def init_db(self):
dataset = "leetcode"
emb_func = skills.MiniLML6V2EmbeddingFunction()
data_dir = "chainofaction/data"
docs = load_init_skills(data_dir)
self.running_id = len(docs)
for i in docs["title"]:
shutil.copy(f"chainofaction/data/code/{i[:-4]}.py",f"chainofaction/data/run_{self.run}/{i[:-4]}.py")
docs["indextext"] = docs["title"].astype(str) + "\n" + docs["problem_text"] + "\n" + docs["skill_description"]
self.db= skills.ChromaWithUpsert(
name=f"{dataset}_minilm6v2",
embedding_function=emb_func, # you can have something here using /embed endpoint
persist_directory= "chainofaction/data/"
)
if self.db.is_empty():
self.db.upsert_texts(
texts=docs.indextext.tolist(),
# we handle tokenization, embedding, and indexing automatically. You can skip that and add your own embeddings as well
metadata=[{'id': id, 'title': title, 'problem_text': problem_text, 'skill_description': skill_description}
for (id, title, problem_text, skill_description) in
zip(docs.id, docs.title, docs.problem_text, docs.skill_description)], # filter on these!
ids=[str(i) for i in docs.id], # unique for each doc
)
def step(self,problem, title):
if problem == None:
return None
with open(f"chainofaction/data/run_{self.run}/tracker/{title[:-4]}.txt",'w') as f:
f.write("created")
cases = load_cases("chainofaction/data/fullcases",title[:-3]+'json')
fn_head = func_head(title)
soln = self.agent.get_response(problem,cases, fn_head,title)
header = func_head(title)
if soln != None:
code, desc, title = soln
if code != None:
with open(f"chainofaction/data/run_{self.run}/{title[:-4]}.py",'w') as f:
f.write(code)
texts = "\n".join([str(self.running_id),str(title),(problem),(desc)])
#print(self.running_id, title, problem, desc)
self.db.upsert_texts(texts,
metadata = [{"id": self.running_id, "title":title,"problem_text":problem,"skill_description":desc}\
], ids = [str(self.running_id)])
self.running_id+=1
return soln
#This is the main function
#What I plan to do is:
#1. Retrieve a sample from the dataset
#2. Check if sample qn requires input
#3. How do I check for this (('m'))
#4. If needs, will loop through all the test cases
##Reuse code from test.py
def execute(self, code, cases):
#placeholder
for i in cases:
try:
code = extract_code_block(code)
#print(code)
if code ==None:
return ("No code found", False)
exec(code, globals())
parsed_tree = ast.parse(code)
fn_head = find_topmost_functions_after_class(parsed_tree, "Solution")[0]
if fn_head != None:
#print((f'Solution().{fn_head}({i["input"]})'))
result = eval((f'Solution().{fn_head}(*i["input"])'))
else:
result = ("Code is not encapsulated in a function", False)
return result
#print(result, i["output"],type(result),type(i["output"]))
if str(result) == str(i["output"]):
continue
else:
return (f"Failed for input: {i['input']}\n Expected output: {i['output']}\nCurrent output: {result}",False)
except Exception as e:
raise e
return (f"Error in code: {e}", False)
return (None, True)
def main(self):
tasks = self.dataset['title'].tolist()
random.shuffle(tasks)
for title in tasks:
if title not in os.listdir(f"chainofaction/data/run_{self.run}") and title not in os.listdir(f"chainofaction/data/run_{self.run}/tracker"):
problem = self.dataset[self.dataset['title']==title]['problem_text'].tolist()[0]
print(problem)
self.step(problem,title)
def resume_run(self):
self.run = 0
for i in os.listdir("chainofaction/data/"):
if i.startswith("run_") and i[4:].isdigit():
self.run = max(self.run,int(i[4:]))
self.resume_db()
def resume_dataset(self):
desc = os.listdir(f"chainofaction/data/run_{self.run}/newdesc")
titles = list(filter(lambda x: x.endswith(".py"),os.listdir(f"chainofaction/data/run_{self.run}")))
titles = list(map(lambda x: x[:-3]+".txt",titles))
titles = list(set(titles).intersection(set(desc)))
problems = list(set(os.listdir(f"chainofaction/data/problems")).intersection(set(titles)))
for i in range(len(problems)):
with open(f"chainofaction/data/problems/{problems[i]}") as f:
problem = f.read()
problems[i] = problem
print(len(problems),len(titles),len(desc))
return pd.DataFrame({"id":list(range(len(problems))),"title":titles,"problem_text":problems,"skill_description":desc})
def resume_db(self):
dataset = "leetcode"
emb_func = skills.MiniLML6V2EmbeddingFunction()
fullLst = []
for i in os.listdir(f"chainofaction/data/run_{self.run}"):
if i.endswith(".py"):
fullLst.append(i[:-3]+"txt")
docs = self.resume_dataset()
self.running_id = len(docs)+1
docs["indextext"] = docs["title"].astype(str) + "\n" + docs["problem_text"] + "\n" + docs["skill_description"]
self.db= skills.ChromaWithUpsert(
name=f"{dataset}_minilm6v2",
embedding_function=emb_func, # you can have something here using /embed endpoint
persist_directory= "chainofaction/data/"
)
if self.db.is_empty():
self.db.upsert_texts(
texts=docs.indextext.tolist(),
# we handle tokenization, embedding, and indexing automatically. You can skip that and add your own embeddings as well
metadata=[{'id': id, 'title': title, 'problem_text': problem_text, 'skill_description': skill_description}
for (id, title, problem_text, skill_description) in
zip(docs.id, docs.title, docs.problem_text, docs.skill_description)], # filter on these!
ids=[str(i) for i in docs.id], # unique for each doc
)
""" data = load_data("chainofaction/data")
prob = random.choice(data['title'].tolist())
print(prob)
cases = load_cases("chainofaction/data/fullcases",prob)
for case in cases:
print(case)
act = eval(case)
print(act[1])
func_inp = act[0]
func_out = act[1]
print(type(func_out))
"""
env = Environment("res")
env.main() | [] |
2024-01-10 | DESU-CLUB/ChainOfAction | vector_database~vector_database.py | import os
import requests
import chromadb
import pandas as pd
from typing import Optional, Any, Iterable, List
from dotenv import load_dotenv
import pdb
try:
from sentence_transformers import SentenceTransformer
except ImportError:
raise ImportError("Could not import sentence_transformers: Please install sentence-transformers package.")
try:
import chromadb
from chromadb.api.types import EmbeddingFunction
except ImportError:
raise ImportError("Could not import chromdb: Please install chromadb package.")
from typing import Dict, Optional, List
from rouge import Rouge
import openai
load_dotenv()
# Index knowledge base
# Load data
""" datasets = ['cs6101']
dataset = datasets[0] # The current dataset to use
data_root = "data"
data_dir = os.path.join(data_root, dataset)
max_docs = -1
# print("Selected dataset:", dataset) """
def load_data_v1(data_dir, data_root):
passages = pd.read_csv(os.path.join(data_dir, "leetcode.tsv"), sep='\t', header=0)
# qas = pd.read_csv(os.path.join(data_dir, "questions.tsv"), sep='\t', header=0).rename(columns={"text": "question"})
# We only use 5000 examples. Comment the lines below to use the full dataset.
passages = passages.head(5000)
# qas = qas.head(5000)
# return passages, qas
return passages
# documents, questions = load_data_v1(data_dir, data_root)
""" documents = load_data_v1(data_dir, data_root)
documents['indextext'] = documents['title'].astype(str) + "\n" + documents['problem_text'] + "\n" + documents['skill_description']
"""
class MiniLML6V2EmbeddingFunction(EmbeddingFunction):
MODEL = SentenceTransformer('all-MiniLM-L6-v2')
def __call__(self, texts):
return MiniLML6V2EmbeddingFunction.MODEL.encode(texts).tolist()
emb_func = MiniLML6V2EmbeddingFunction()
# Set up Chroma upsert
class ChromaWithUpsert:
def __init__(self, name,persist_directory, embedding_function,collection_metadata: Optional[Dict] = None,
):
self._client = chromadb.PersistentClient(path=persist_directory)
self._embedding_function = embedding_function
self._persist_directory = persist_directory
self._name = name
self._collection = self._client.get_or_create_collection(
name=self._name,
embedding_function=self._embedding_function
if self._embedding_function is not None
else None,
metadata=collection_metadata,
)
def upsert_texts(
self,
texts: Iterable[str],
metadata: Optional[List[dict]] = None,
ids: Optional[List[str]] = None,
**kwargs: Any,
) -> List[str]:
"""Run more texts through the embeddings and add to the vectorstore.
Args:
:param texts (Iterable[str]): Texts to add to the vectorstore.
:param metadatas (Optional[List[dict]], optional): Optional list of metadatas.
:param ids (Optional[List[str]], optional): Optional list of IDs.
:param metadata: Optional[List[dict]] - optional metadata (such as title, etc.)
Returns:
List[str]: List of IDs of the added texts.
"""
# TODO: Handle the case where the user doesn't provide ids on the Collection
if ids is None:
import uuid
ids = [str(uuid.uuid1()) for _ in texts]
embeddings = None
self._collection.upsert(
metadatas=metadata, documents=texts, ids=ids
)
return ids
def is_empty(self):
return self._collection.count()==0
def query(self, query_texts:str, n_results:int=5):
"""
Returns the closests vector to the question vector
:param query_texts: the question
:param n_results: number of results to generate
:return: the closest result to the given question
"""
return self._collection.query(query_texts=query_texts, n_results=n_results)
""" # Embed and index documents with Chroma
chroma = ChromaWithUpsert(
name=f"{dataset}_minilm6v2",
embedding_function=emb_func, # you can have something here using /embed endpoint
persist_directory=data_dir,
)
if chroma.is_empty():
_ = chroma.upsert_texts(
texts=documents.indextext.tolist(),
# we handle tokenization, embedding, and indexing automatically. You can skip that and add your own embeddings as well
metadata=[{'id': id, 'title': title, 'problem_text': problem_text, 'skill_description': skill_description}
for (id, title, problem_text, skill_description) in
zip(documents.id, documents.title, documents.problem_text, documents.skill_description)], # filter on these!
ids=[str(i) for i in documents.id], # unique for each doc
)
# Select a question
# question_index = 65
# question_text = questions.question[question_index].strip("?") + "?"
question_text = "For a string x, find the length of the longest substring such that every character must be unique."
# print(question_text)
# Retrieve relevant context
relevant_chunks = chroma.query(
query_texts=[question_text],
n_results=5,
)
for i, chunk in enumerate(relevant_chunks['documents'][0]):
print("=========")
print("Paragraph index : ", relevant_chunks['ids'][0][i])
print("Paragraph : ", chunk)
print("Distance : ", relevant_chunks['distances'][0][i])
# Feed the context and the question to openai model
def make_prompt(context, question_text):
return (f"{context}\n\nPlease answer a question using this "
+ f"text. "
+ f"If the question is unanswerable, say \"unanswerable\"."
+ f"Question: {question_text}")
context = "\n\n\n".join(relevant_chunks["documents"][0])
prompt = make_prompt(context, question_text)
# Insert context and question into openai model
openai.api_key = os.getenv("OPENAI_API_KEY")
response = openai.ChatCompletion.create(
model = "gpt-4",
messages = [{"role":"user",
"content":f"{prompt}"}],
temperature=0.8,
max_tokens=100,
top_p=0.8,
frequency_penalty=0,
presence_penalty=0
)
print("Question = ", question_text)
print("Answer = ", response['choices'][0]['message']['content'])
# print("Expected Answer(s) (may not be appear with exact wording in the dataset) = ", questions.answers[question_index])
""" | [] |
2024-01-10 | DESU-CLUB/ChainOfAction | chainofaction~agents~inferenceAgent.py | import os
import json
import glob
import re
from multiprocessing import Pool
from tqdm import tqdm
import torch
import openai
import itertools
import random
#import environment
import tiktoken
import time
####### HELPER FUNCTIONS ##########
#This class stores the history of the conversation which is used as context
class MemoryList(list): #Sliding window implementation for now
def __init__(self, *args, max_tokens = 3500):
super().__init__(*args)
self.max_tokens = max_tokens
self.tokenizer = tiktoken.encoding_for_model("gpt-4-1106-preview")
#Add smth to the list -> remove first item until total tokens < 4000
def append(self, item):
#print(item)
total_tokens = self.check_tokens()
item2 = item["content"]
while len(self.tokenizer.encode(item2)) + total_tokens > self.max_tokens:
if len(self.tokenizer.encode(item2)) > self.max_tokens:
self.summarize()
raise Exception("Item too long")
self.handle_overflow()
total_tokens = self.check_tokens()
super().append(item)
#Helper to check no of tokens
def check_tokens(self):
return sum(len(self.tokenizer.encode(item['content'])) for item in self)
#Helper to handle overflow
def handle_overflow(self):
if len(self) >0:
self.pop(0)
#For now it will just be a signal to terminate the generation
def summarize(self):
pass
#print("Summarizing") #End goal is to use gpt-16k to do this
#This is a helper function to convert skills retrieved from the vector DB
#into the relevant code
def search_files(skills):
data_dir = f"chainofaction/data/run_5"
all_code = []
for skill in skills:
#print(skill)
with open(os.path.join(data_dir,os.path.splitext(skill)[0]+'.py')) as f:
lines = f.readlines()
res = ""
for i,line in enumerate(lines):
res+= "\n"+line.strip() if not i else line.strip()
all_code.append(res)
return all_code
#This code handles the generation API calls
def generate(messages,api_key, max_tokens = 2048, temperature = 0.0, model = "gpt-4-1106-preview"):
openai.api_key = api_key
if model in ["gpt-4-1106-preview", "gpt-4-1106-preview"]:
params = {
"model": model,
"max_tokens": max_tokens,
"temperature": temperature,
"messages": messages
}
for retry in range(3):
try:
return openai.ChatCompletion.create(**params)["choices"][0]["message"]["content"]
except Exception as e:
raise e
return e
def stream_generate(messages,api_key, max_tokens = 2048, temperature = 0.0, model = "gpt-4-1106-preview"):
# For newer models, use the streaming API
openai.api_key = api_key
params = {
"model": model,
"max_tokens": max_tokens,
"temperature": temperature,
"stream": True,
"messages": messages
}
for retry in range(3):
try:
partial = ""
for chunk in openai.ChatCompletion.create(**params):
if len(chunk["choices"][0]["delta"]) != 0:
partial = partial+chunk["choices"][0]["delta"]["content"]
yield partial
else:
yield None
except Exception as e:
raise e
########### AGENT CLASS ############
class InferenceAgent:
def __init__(self,db,environment,api_key, model = "gpt-4-1106-preview", max_tokens = 2048, temperature = 0.2):
'''
Agent: A class that handles the generation of skills and the interaction with the environment
model: the model to use for generation
max_tokens: the maximum number of tokens to generate
temperature: the temperature to use for generation
explore_ratio: the ratio of times to explore (deprecated for now)
max_count: the maximum number of times to generate (deprecated for now)
db: the vector database to use
'''
self.model = model
self.max_tokens = max_tokens
self.temperature = temperature
self.message = MemoryList(max_tokens = 3500)
self.db = db
self.api_key = api_key
self.environment = environment
self.skills = []
print("INITIALISED")
def get_prompt(self,task): #Helper function to get the prompt
with open(f"chainofaction/prompts/{task}") as f:
return f.read().strip()
def decompose(self,problem,api_key): #Helper function to decompose the problem into steps
decompose = self.get_prompt("decompose.txt")
decompose += "\n\n" + problem
self.message.append({"role": "user", "content": decompose})
for retry in range(3): #Loop to retry if generation fails
try:
skills = generate(self.message,api_key, max_tokens = 2048, temperature = 0.0, model = "gpt-4-1106-preview")
#print(skills)
self.message.append({"role": "assistant", "content": skills})
return skills
except Exception as e: #Add error for model to debug
#print("Error: Failed to generate response")
self.message.append({"role":"user","content": f"Failed to execute solution generation: {e}"})
def rewrite_soln(self, problem, steps,api_key): #Helper function to write/rewrite the solution
"""
Helper function to write/rewrite the solution.
Args:
problem (str): The problem statement.
steps (str): The steps taken to solve the problem.
output (str): The current output error.
Returns:
str: The generated solution.
"""
rewrite = self.get_prompt("soln.txt")
rewrite = rewrite.replace("{Qn}",problem)
rewrite = rewrite.replace("{Steps}",steps)
rewrite = rewrite.replace("{fn_head}","")
pattern = r'^(\d+:.*?)(?=\d+:|$)'
skills = re.findall(pattern, steps, re.MULTILINE)
for retry in range(3):
try:
skill_index = 0
skills_used = []
skill = skills[skill_index]
while skill_index < len(skills): #Loop through all the skills
#Query vector DB for relevant skills
relevant_chunks = self.db.query([skill],n_results = 1)
skills_accepted = []
#Grab titles
for i, chunk in enumerate(relevant_chunks['documents'][0]):
#print(relevant_chunks['metadatas'][0][i])
if relevant_chunks['distances'][0][i] < 1.2:
self.skills.append([relevant_chunks["metadatas"][0][i]['title'],skill,relevant_chunks['distances'][0][i]])
skills_accepted.append(relevant_chunks["metadatas"][0][i]['title'])
skills_used.append(relevant_chunks["metadatas"][0][i]['title'])
if skill_index == len(skills)-1:
break
#If no skills accepted, merge them
if len(skills_accepted) == 0:
skill_index +=1
if skill_index < len(skills):
skill = skills[skill_index-1] + " " +skills[skill_index]
else:
#Else, pick the next skill
skill_index +=1
print(skill_index,len(skills))
if skill_index < len(skills):
skill = skills[skill_index]
#convert skills to code
skills_used = search_files(skills_used)
#Prompt and generate
rewrite = rewrite.replace("{Ref}",'\n\nHere are a list of relevant skills to the question'+'\n'.join(skills_used))
self.message.append({"role":"user","content": f"{rewrite}"})
soln = generate(self.message,api_key, max_tokens = 2048, temperature = 0.0, model = "gpt-4-1106-preview")
self.message.append({"role": "assistant", "content": soln})
#print(soln)
except Exception as e:
#print("Error: Failed to generate response",e)
raise e
self.message.append({"role":"user","content": f"Failed to execute solution generation: {print(e)}"})
return soln if "soln" in locals() else None
def zero_shot(self,problem,steps,api_key):
try:
self.message.append({"role": "user", "content": f"Here is the problem: {problem}\nHere are the identified steps: {steps}\nWrite Python code to solve the problem"})
soln = generate(self.message,api_key)
self.message.append({"role":"assistant","content": f"{soln}"})
return soln
except Exception as e:
#print("ERROR ZERO SHOT")
raise e
return None
def get_response(self,problem, api_key):
'''
problem: description of problem
'''
###Iterative prompting
print("Starting")
for retry in range(3):
#TODO
#Check if code can get correct answer for test cases
#If not, prompt for more code
try:
steps = self.decompose(problem,api_key)
soln = self.rewrite_soln(problem, steps,api_key)
for skill in self.skills:
time.sleep(0.3)
yield skill
yield None
#print(f"\n\nNew SOLN: {soln}\n\n")
break
except Exception as e:
print(e)
print("Error: Failed to generate response")
self.message.append({"role":"user","content": f"Failed to execute iterative prompting: {type(e)}"})
self.message.append({"role":"user","content": f"Extract out the Python code from this solution:\n{soln}"})
for i in stream_generate(self.message,api_key,model = "gpt-3.5-turbo-16k"):
time.sleep(0.3)
yield i
def get_response_zeroshot(self,problem,api_key):
for retry in range(3):
try:
steps = self.decompose(problem,api_key)
soln = self.zero_shot(problem, steps, api_key)
break
except Exception as e:
print(e)
print("Error: Failed to generate response")
self.message.append({"role":"user","content": f"Failed to execute zero shot: {type(e)}"})
self.message.append({"role":"user","content": f"Extract out the Python code from this solution:\n{soln}"})
for i in stream_generate(self.message,api_key,model = "gpt-3.5-turbo-16k"):
yield i
def reset(self):
self.message = MemoryList(max_tokens = 3500)
| [
"Here is the problem: PLACEHOLDER\nHere are the identified steps: PLACEHOLDER\nWrite Python code to solve the problem",
"Failed to execute iterative prompting: <class '__main__.Placeholder'>",
"Failed to execute zero shot: <class '__main__.Placeholder'>",
"PLACEHOLDER",
"Failed to execute solution generation: None",
"Extract out the Python code from this solution:\nPLACEHOLDER",
"Failed to execute solution generation: PLACEHOLDER"
] |
2024-01-10 | GeoffreyFClark/OpenAI-Discord-Bots | image_gen_bot_template.py | import discord
import requests
import json
import io
import openai
api_key = "" # Input OpenAI Key here in quotes as a string
discord_token = "DISCORD TOKEN HERE" # Input Discord Token here
model_name = "ENGINE MODEL NAME HERE" # Input Engine Model Name here e.g. "image-alpha-001"
# Discord bot setup
intents = discord.Intents().all()
client = discord.Client(intents=intents)
@client.event
async def on_ready():
print(f'Logged in as {client.user}')
@client.event
async def on_message(message):
if message.content == 'bots.shutdown':
await message.channel.send('Shutting down...')
await client.close()
if message.content.startswith('%'): # Start discord message with % to generate image based on following text
prompt = message.content[1:]
try:
response = openai.Image.create( # See API documentation for further parameters
model=model_name,
prompt=prompt,
num_images=1,
size="512x512",
response_format="url",
api_key=api_key
)
image_url = response['data'][0]['url']
file = discord.File(io.BytesIO(requests.get(image_url).content), filename="image.jpg")
await message.channel.send(file=file)
except (requests.exceptions.RequestException, json.JSONDecodeError, openai.error.OpenAIError) as e:
print(e)
await message.channel.send("Failed to generate image. Please try again later.")
client.run(discord_token)
| [] |
2024-01-10 | GeoffreyFClark/OpenAI-Discord-Bots | reinforceable_chatbot.py | import discord
import openai
openai.api_key = "" # Input OpenAI Key here in quotes as a string
discord_token = "DISCORD TOKEN HERE" # Input Discord Token here
model_name = "ENGINE MODEL NAME HERE" # Input Engine Model Name here
intents = discord.Intents().all()
client = discord.Client(intents=intents)
responses = {}
@client.event
async def on_ready():
print(f'SUCCESSFULLY logged in as {client.user}')
@client.event
async def on_message(message):
if message.author == client.user:
return
if message.content == 'bots.shutdown':
await message.channel.send('Shutting down...')
await client.close()
if message.content.startswith('!'): # Start discord message with ! to prompt chatbot
prompt = message.content[1:]
response = openai.Completion.create( # See API documentation for further parameters
engine=model_name,
prompt=prompt + ' ->',
max_tokens=100,
n=1,
temperature=0.8,
stop=["\n"]
)
print(response["choices"][0]["text"])
message_to_send = response["choices"][0]["text"]
await message.channel.send(message_to_send)
@client.event
async def on_reaction_add(reaction, user):
if reaction.message.author == client.user:
if str(reaction.emoji) == "👍" or str(reaction.emoji) == "👎":
prompt = reaction.message.content
response = openai.Completion.create(
engine=model_name,
prompt=prompt,
max_tokens=100,
n=1,
temperature=0.8,
stop="\n",
logprobs=10
)
if len(response.choices) > 0:
logprobs = response.choices[0].logprobs.token_logprobs
reward = 1 if str(reaction.emoji) == "👍" else -1
for i, token_logprobs in enumerate(logprobs):
token = response.choices[0].text[i]
if isinstance(token_logprobs, dict):
token_reward = token_logprobs[token]["token_logprob"] * reward
openai.Completion.create(
engine=model_name,
prompt=prompt + token,
max_tokens=0,
n=1,
logprobs=10,
echo=True,
stop="\n",
temperature=0,
stop_sequence="\n",
presence_penalty=0.0,
frequency_penalty=0.0,
stop_penalty=0.0,
logit_bias={token: token_reward}
)
if reward == 1:
await reaction.message.channel.send(f'{user} reinforced the response: "{prompt}"')
else:
await reaction.message.channel.send(f'{user} penalized the response: "{prompt}"')
client.run(discord_token)
| [
"PLACEHOLDERPLACEHOLDER",
"PLACEHOLDER ->"
] |
2024-01-10 | clover3/Chair | src~trainer_v2~per_project~tli~pte~runner~run_gpt_solver.py | import logging
import sys
import time
2
import openai
from openai.error import RateLimitError, ServiceUnavailableError, OpenAIError
from taskman_client.wrapper3 import JobContext
from utils.open_ai_api import ENGINE_GPT4, ENGINE_GPT_3_5
from dataset_specific.scientsbank.eval_helper import solve_eval_report
from dataset_specific.scientsbank.parse_fns import get_split_spec, load_scientsbank_split
from dataset_specific.scientsbank.pte_data_types import PTEPredictionPerQuestion, Question
from dataset_specific.scientsbank.pte_solver_if import apply_solver
from trainer_v2.chair_logging import c_log
from trainer_v2.per_project.tli.pte.gpt_solver import get_gpt_requester, get_gpt_read_solver
from typing import List, Iterable, Callable, Dict, Tuple, Set
def apply_solver_loop(requester, questions):
n_fail = 0
is_success = False
while n_fail < 1000:
try:
apply_solver(requester, questions)
is_success = True
break
except OpenAIError as e:
print(e)
print(e.json_body)
n_fail += 1
wait_time = 5
c_log.info("Encountered server error retry in %d seconds", wait_time)
time.sleep(wait_time)
return is_success
def solve_for_split(split_name):
run_name = "gpt_{}".format(split_name)
with JobContext(run_name):
c_log.setLevel(logging.DEBUG)
split = get_split_spec(split_name)
engine = ENGINE_GPT_3_5
questions: List[Question] = load_scientsbank_split(split)
c_log.info("Building solver")
requester = get_gpt_requester(engine, split_name)
c_log.info("Running with loop")
is_success = apply_solver_loop(requester, questions)
if not is_success:
c_log.error("Maximum 10 iteration reached")
return
solver = get_gpt_read_solver(engine, split_name)
solve_eval_report(solver, split)
def main():
split_name = sys.argv[1]
solve_for_split(split_name)
if __name__ == "__main__":
main() | [] |
2024-01-10 | clover3/Chair | src~scratch~code2023~gpt_talk.py | import openai
from utils.open_ai_api import OpenAIProxy, ENGINE_GPT_3_5, parse_chat_gpt_response, ENGINE_GPT4
def request(engine, history, new_msg):
is_user = len(history) % 2 == 0
messages = []
for item in history:
if is_user:
e = {"role": "user", "content": item}
else:
e = {"role": "assistant", "content": item}
messages.append(e)
is_user = not is_user
messages.append({"role": "user", "content": new_msg})
obj = openai.ChatCompletion.create(
model=engine, messages=messages, timeout=20,
)
return obj
def main():
proxy = OpenAIProxy(ENGINE_GPT_3_5)
last_msg = "You should not upload a paper to arxiv before the peer-review to main anonymity"
prompt_prefix = "Counter argue this. (limit 30 words): \n"
team_A = "A"
team_B = "B"
# prompt_prefix = " (40 단어 제한): \n"
print(f"{team_A}: " + last_msg)
for i in range(10):
for team in [team_B, team_A]:
prompt = prompt_prefix + last_msg
# res = proxy.request(prompt)
res = request(ENGINE_GPT_3_5, [], prompt)
# print(res)
res_text = parse_chat_gpt_response(res)
last_msg = str(res_text)
print(prompt)
print(f"{team} : " + res_text)
if __name__ == "__main__":
main() | [
"Counter argue this. (limit 30 words): \nYou should not upload a paper to arxiv before the peer-review to main anonymity",
"Counter argue this. (limit 30 words): \n"
] |
2024-01-10 | clover3/Chair | src~trainer_v2~per_project~tli~pte~gpt_solver.py | import json
import os
from collections import Counter
from cpath import output_path
from trainer_v2.chair_logging import c_log
from utils.open_ai_api import OpenAIProxy
from dataset_specific.scientsbank.pte_solver_if import PTESolverIF
from dataset_specific.scientsbank.pte_data_types import ReferenceAnswer, Facet
from typing import Dict, List
from iter_util import load_jsonl
from misc_lib import path_join
from utils.open_ai_api import parse_instruct_gpt_response, get_parse_gpt_response_fn
template_single_facet = """
Student answer: {}.
Reference answer: {}.
Facet: ({}, {})
The facet is a relation extracted from the reference answer.
In the example above, does the student answer entail the given facet?
Answer with Yes/No
"""
class ResponseCacher:
def __init__(self, save_path):
self.log_path = save_path
self.log_file = None
def write(self, e):
if self.log_file is None:
self.log_file = open(self.log_path, "a")
self.log_file.write(json.dumps(e) + "\n")
self.log_file.flush()
def read_caches_as_d(self):
out_d = {}
if os.path.exists(self.log_path):
j_list = load_jsonl(self.log_path)
for j in j_list:
key = get_key_for_pte_j_entry(j)
out_d[key] = j
c_log.info("%d items parsed", len(out_d))
return out_d
def read_caches(self) -> List[dict]:
j_list = load_jsonl(self.log_path)
return j_list
class GPTRequesterForPTE(PTESolverIF):
def __init__(self,
open_ai_proxy: OpenAIProxy,
prompt_template,
cacher: ResponseCacher,
):
self.tli_cache = {}
self.prompt_template = prompt_template
self.proxy: OpenAIProxy = open_ai_proxy
self.cacher: ResponseCacher = cacher
self.cache_d = self.cacher.read_caches_as_d()
self.cache_hit = 0
self.n_seen = 0
def solve(self,
reference_answer: ReferenceAnswer,
student_answer: str,
facet: Facet) -> float:
self.n_seen += 1
premise_like = student_answer
hypothesis_like = reference_answer.text
key = "{}_{}_{}".format(
reference_answer.id,
student_answer,
facet.id,
)
if key in self.cache_d:
self.cache_hit += 1
else:
if self.cache_hit:
c_log.info("%d records from cache", self.cache_hit)
self.cache_hit = 0
prompt = self.prompt_template.format(premise_like, hypothesis_like, facet.govText, facet.modText)
c_log.debug("Issue request")
c_log.debug(prompt)
response = self.proxy.request(prompt)
j_save = {
'reference_answer.id': reference_answer.id,
'student_answer': student_answer,
'facet.id': facet.id,
'response': response
}
c_log.debug("Received")
self.cacher.write(j_save)
self.cache_d[key] = j_save
output_score = 0
return float(output_score)
class ResponseTextParser:
def __init__(self):
self.irregular = Counter()
def parse_response(self, text):
if "Yes" in text:
decision = True
elif "No" in text:
decision = False
elif "Partial" in text:
decision = False
else:
raise ValueError(text)
if len(text.strip()) > 4:
self.irregular[text] += 1
return decision
def end(self):
if len(self.irregular) > 0:
print(self.irregular)
def get_key_for_pte_j_entry(j):
key = "{}_{}_{}".format(
j['reference_answer.id'],
j['student_answer'],
j['facet.id'],
)
return key
class GPTSolverForPTE(PTESolverIF):
def __init__(self,
parse_gpt_response_fn,
cacher: ResponseCacher,
name: str
):
self.cacher = cacher
j_list = cacher.read_caches()
self.parse_gpt_response = parse_gpt_response_fn
self.decision_d = self.parse_solve(j_list)
c_log.info("%d keys loaded", len(self.decision_d))
self.name = name
def get_name(self):
return self.name
def parse_solve(self, json_list) -> Dict[str, bool]:
text_parser = ResponseTextParser()
decision_d = {}
for j in json_list:
key = get_key_for_pte_j_entry(j)
text = self.parse_gpt_response(j['response'])
decision = text_parser.parse_response(text)
decision_d[key] = decision
text_parser.end()
return decision_d
def solve(self,
reference_answer: ReferenceAnswer,
student_answer: str,
facet: Facet) -> float:
key = "{}_{}_{}".format(reference_answer.id, student_answer, facet.id)
decision = self.decision_d[key]
if decision:
score = 1
else:
score = 0
return float(score)
def get_log_save_path(engine, split):
log_path = path_join(output_path, "pte_scientsbank", "gpt", f"{engine}_{split}.json")
return log_path
def get_gpt_requester(engine, split):
proxy = OpenAIProxy(engine)
log_path = get_log_save_path(engine, split)
cacher = ResponseCacher(log_path)
return GPTRequesterForPTE(proxy, template_single_facet, cacher)
def get_gpt_read_solver(engine: str, split: str):
log_path = get_log_save_path(engine, split)
cacher = ResponseCacher(log_path)
parse_response_fn = get_parse_gpt_response_fn(engine)
return GPTSolverForPTE(parse_response_fn, cacher, engine)
def main():
sample2 = """
Student answer: By letting it sit in a dish for a day.
Reference answer: The water was evaporated, leaving the salt.
Facets: (evaporated, water), (leaving, evaporated), (leaving, salt)
The facets above which are represented as pair of words, are the relations extracted from the reference answer.
In this example does the student answer entails each of the facets?
Answer with Yes or No, separated by comma(,).
"""
if __name__ == "__main__":
main()
| [
"\n\nStudent answer: {}.\nReference answer: {}.\nFacet: ({}, {})\n\nThe facet is a relation extracted from the reference answer. \nIn the example above, does the student answer entail the given facet? \nAnswer with Yes/No\n\n"
] |
2024-01-10 | clover3/Chair | src~contradiction~medical_claims~token_tagging~gpt_solver~gpt_solver.py | import json
import math
from collections import defaultdict, Counter
from typing import List, Iterable, Callable, Dict, Tuple, Set
from contradiction.medical_claims.token_tagging.batch_solver_common import ECCOutput
from contradiction.medical_claims.token_tagging.gpt_solver.index_span import IndexedSpan, find_all_as_index_span, strip_char_set
from list_lib import lmap
from utils.open_ai_api import OpenAIProxy
from typing import List, Tuple, Dict
from contradiction.medical_claims.token_tagging.online_solver_common import TokenScoringSolverIF
from iter_util import load_jsonl
from misc_lib import average
class GPTSolver(TokenScoringSolverIF):
def __init__(
self,
open_ai_proxy: OpenAIProxy,
prompt_template,
claim2_pattern,
log_path,
parse_gpt_response_fn,
parse_answer_texts: Callable[[str], Tuple[str, str]]
):
self.proxy: OpenAIProxy = open_ai_proxy
self.prompt_template = prompt_template
self.log_file = open(log_path, "a")
self.claim2_pattern = claim2_pattern
self.parse_gpt_response_fn = parse_gpt_response_fn
self.parse_answer_texts = parse_answer_texts
def solve(self, tokens1, tokens2) -> ECCOutput:
claim1 = " ".join(tokens1)
claim2 = " ".join(tokens2)
prompt: str = self.prompt_template.format(claim1, claim2)
j = self.proxy.request(prompt)
self.log_file.write(json.dumps(j) + "\n")
completion_text = self.parse_gpt_response_fn(j)
claim1_answer, claim2_answer = self.parse_answer_texts(completion_text)
return get_score_from_answer_spans(tokens1, tokens2, claim1_answer, claim2_answer)
class GPTRequester(TokenScoringSolverIF):
def __init__(self,
open_ai_proxy: OpenAIProxy,
prompt_template,
log_path,
):
self.proxy: OpenAIProxy = open_ai_proxy
self.prompt_template = prompt_template
self.log_file = open(log_path, "a")
def solve(self, tokens1, tokens2) -> ECCOutput:
claim1 = " ".join(tokens1)
claim2 = " ".join(tokens2)
prompt: str = self.prompt_template.format(claim1, claim2)
j = self.proxy.request(prompt)
j_save = {
'claim1': claim1,
'claim2': claim2,
'reponse': j
}
self.log_file.write(json.dumps(j_save) + "\n")
scores1 = [0 for _ in tokens1]
scores2 = [0 for _ in tokens2]
return scores1, scores2
def load_json_log(log_path) -> Dict[Tuple[str, str], Dict]:
j_d = {}
for j in load_jsonl(log_path):
key = j['claim1'], j['claim2']
j_d[key] = j['reponse']
return j_d
class GPTSolverFileRead(TokenScoringSolverIF):
def __init__(
self,
j_d: Dict[Tuple[str, str], Dict],
parse_gpt_response_fn: Callable[[Dict], str],
parse_answer_texts: Callable[[str], Tuple[str, str]],
get_score_from_answer_spans_fn
):
self.parse_gpt_response_fn = parse_gpt_response_fn
self.parse_answer_texts = parse_answer_texts
self.get_score_from_answer_spans = get_score_from_answer_spans_fn
self.j_d = j_d
def solve(self, tokens1, tokens2) -> ECCOutput:
claim1 = " ".join(tokens1)
claim2 = " ".join(tokens2)
j_response = self.j_d[claim1, claim2]
completion_text = self.parse_gpt_response_fn(j_response)
claim1_answer, claim2_answer = self.parse_answer_texts(completion_text)
return self.get_score_from_answer_spans(tokens1, tokens2, claim1_answer, claim2_answer)
def get_parse_answer_texts_for_instruct(prompt, claim2_pattern):
def parse(completion_text):
return parse_answer_texts_from_completion_text(prompt, claim2_pattern, completion_text)
return parse
def get_score_from_answer_spans(
tokens1: List[str], tokens2: List[str],
claim1_answer: str, claim2_answer: str) -> Tuple[List[float], List[float]]:
claim1 = " ".join(tokens1)
claim2 = " ".join(tokens2)
score_d1 = assign_scores_from_text(claim1, claim1_answer)
score_d2 = assign_scores_from_text(claim2, claim2_answer)
def d_to_arr(d: Dict, l: int) -> List[float]:
scores: List[float] = [0 for _ in range(l)]
for i, f in d.items():
scores[i] = f
return scores
scores1: List[float] = d_to_arr(score_d1, len(tokens1))
scores2: List[float] = d_to_arr(score_d2, len(tokens2))
return scores1, scores2
def get_score_from_answer_spans_chat(
tokens1: List[str], tokens2: List[str],
claim1_answer: List[str], claim2_answer: List[str]) -> Tuple[List[float], List[float]]:
scores1 = assign_scores_from_text_list(tokens1, claim1_answer)
scores2 = assign_scores_from_text_list(tokens2, claim2_answer)
return scores1, scores2
def parse_answer_texts_from_completion_text(prompt, claim2_pattern, completion_text) -> Tuple[str, str]:
full_text = prompt + completion_text
claim2_line_st: int = full_text.lower().find(claim2_pattern.lower())
if claim2_line_st < 0:
print("Fail to parse: ", completion_text)
raise IndexError()
claim2_answer_st: int = claim2_line_st + len(claim2_pattern)
claim2_answer_ed = len(full_text)
claim2_answer = IndexedSpan(full_text, claim2_answer_st, claim2_answer_ed)
# Identify location for each claim's answer
claim1_answer_st = len(prompt)
claim1_answer_ed = claim2_line_st
claim1_answer = IndexedSpan(full_text, claim1_answer_st, claim1_answer_ed)
if not claim1_answer.to_text().strip():
raise ValueError()
if not claim2_answer.to_text().strip():
raise ValueError()
print("claim1_answer", claim1_answer.to_text())
print("claim2_answer", claim2_answer.to_text())
return claim1_answer.to_text(), claim2_answer.to_text()
def get_offset_to_prob(full_text, text_offset, token_logprobs, tokens):
offset_to_prob = {}
for token, logprob, offset in zip(tokens, token_logprobs, text_offset):
if token == "<|endoftext|>":
break
token_ = full_text[offset:offset + len(token)]
assert token == token_
if full_text[offset].isspace():
offset = offset + 1
offset_to_prob[offset] = math.exp(logprob)
return offset_to_prob
def guess_delimiter(text):
options = [",", ";", "/"]
counter = Counter()
for ch in options:
n_try = len(text.split(ch))
counter[ch] = n_try
ch_max, n = counter.most_common(1)[0]
if n >= 2:
return ch_max
return ","
def align_scores(claim: str, claim_answer: IndexedSpan, offset_to_prob: Dict):
score_d = {}
delimiter = guess_delimiter(claim_answer.to_text())
print('claim', claim)
print("Use {} as delimiter".format(delimiter))
for raw_chunk in claim_answer.split(delimiter):
chunk: IndexedSpan = raw_chunk.strip().strip_quotation()
tokens: List[IndexedSpan] = chunk.split()
if not tokens:
raise IndexError("There is no token in chunk")
print("chunk", chunk.to_text())
token_level_score_assign(claim, offset_to_prob, score_d, tokens)
return score_d
def assign_scores(claim: str, claim_answer: IndexedSpan):
def token_norm(t) -> str:
strip_ch_set = " .,;'!?\"\'{}()"
st, ed = strip_char_set(t.lower(), 0, len(t), strip_ch_set)
return t.lower()[st:ed]
c_tokens = [token_norm(t) for t in claim.split()]
delimiter = guess_delimiter(claim_answer.to_text())
print('claim', claim)
print("Use {} as delimiter".format(delimiter))
mismatch_words = set()
for raw_chunk in claim_answer.split(delimiter):
chunk_text = token_norm(raw_chunk.to_text())
for t in chunk_text.split():
mismatch_words.add(token_norm(t))
score_d = {}
for i, t in enumerate(c_tokens):
if t in mismatch_words:
score_d[i] = 1
else:
score_d[i] = 0
n_common = sum(score_d.values())
n_gpt = len(mismatch_words)
if n_common < n_gpt:
print("GPT has output {} tokens but {} were matched".format(n_gpt, n_common))
print("claim tokens:", c_tokens)
print("GPT tokens:", mismatch_words)
return score_d
def assign_scores_from_text(claim: str, claim_answer: str):
def token_norm(t) -> str:
strip_ch_set = " .,;'!?\"\'{}()"
st, ed = strip_char_set(t.lower(), 0, len(t), strip_ch_set)
return t.lower()[st:ed]
c_tokens = [token_norm(t) for t in claim.split()]
delimiter = guess_delimiter(claim_answer)
print('claim', claim)
print("Use {} as delimiter".format(delimiter))
mismatch_words = set()
for raw_chunk in claim_answer.split(delimiter):
chunk_text = token_norm(raw_chunk)
for t in chunk_text.split():
mismatch_words.add(token_norm(t))
score_d = {}
for i, t in enumerate(c_tokens):
if t in mismatch_words:
score_d[i] = 1
else:
score_d[i] = 0
n_common = sum(score_d.values())
n_gpt = len(mismatch_words)
if n_common < n_gpt:
print("GPT has output {} tokens but {} were matched".format(n_gpt, n_common))
print("claim tokens:", c_tokens)
print("GPT tokens:", mismatch_words)
return score_d
def check_match_after(a_token, c_tokens, cursor):
for j in range(cursor, len(c_tokens)):
if a_token == c_tokens[j]:
return j
return -1
def check_contain_match(a_token, c_tokens):
for j in range(0, len(c_tokens)):
if a_token in c_tokens[j]:
return j
return -1
def align_tokens(c_tokens, a_tokens):
cursor = 0
match_list = []
not_matched = []
for i, a_token in enumerate(a_tokens):
match_fn_list = [
lambda : check_match_after(a_token, c_tokens, cursor),
lambda : check_match_after(a_token, c_tokens, 0),
lambda : check_contain_match(a_token, c_tokens)
]
any_match = False
for fn_idx, match_fn in enumerate(match_fn_list):
j = match_fn()
if j >= 0:
match_list.append(j)
any_match = True
if fn_idx == 0:
cursor = j + 1
break
if not any_match:
not_matched.append(a_token)
if not_matched:
print("Not matched : ", not_matched)
return match_list
def assign_scores_from_text_list(claim_tokens: List[str], answer_list: List[str]) -> List[float]:
def token_norm(t) -> str:
strip_ch_set = " .,;'!?\"\'{}()"
st, ed = strip_char_set(t.lower(), 0, len(t), strip_ch_set)
return t.lower()[st:ed]
a_tokens = []
for answer in answer_list:
for t in answer.split():
a_tokens.append(token_norm(t))
c_tokens_norm = lmap(token_norm, claim_tokens)
match_list = align_tokens(c_tokens_norm, a_tokens)
score_arr = [0] * len(claim_tokens)
for i in match_list:
score_arr[i] = 1
n_common = sum(score_arr)
n_gpt = len(a_tokens)
if n_common < n_gpt:
print("GPT has output {} tokens but {} were matched".format(n_gpt, n_common))
print("claim tokens:", c_tokens_norm)
print("GPT tokens:", a_tokens)
print(score_arr)
print()
else:
pass
return score_arr
def token_level_score_assign(claim, offset_to_prob, score_d,
tokens: List[IndexedSpan]):
score_d_local: Dict[int, List[float]] = defaultdict(list)
n_not_found = 0
for token in tokens:
span_list: List[IndexedSpan] = find_all_as_index_span(claim, token.to_text())
if not span_list:
n_not_found += 1
for span_in_claim in span_list:
indices: List[int] = span_in_claim.get_sp_token_indices()
print(indices, [str(t) for t in tokens])
prob = offset_to_prob[token.st]
for index in indices:
score_d_local[index].append(prob)
if n_not_found > len(tokens) * 0.7:
raise IndexError("{} of {} tokens are not matched".format(n_not_found, len(tokens)))
for index, scores in score_d_local.items():
score_d[index] = average(scores)
def span_level_score_assign(chunk, claim, offset_to_prob, score_d, tokens):
span_list: List[IndexedSpan] = find_all_as_index_span(claim, chunk.to_text())
if not span_list:
raise IndexError("Span are not found")
for span_in_claim in span_list:
indices: List[int] = span_in_claim.get_sp_token_indices()
print(indices, [str(t) for t in tokens])
assert len(indices) == len(tokens)
for index, token in zip(indices, tokens):
prob = offset_to_prob[token.st - 1]
assert index not in score_d
score_d[index] = prob
| [] |
2024-01-10 | clover3/Chair | src~contradiction~medical_claims~token_tagging~gpt_solver~get_instruct_gpt_solver.py | from contradiction.medical_claims.token_tagging.gpt_solver.gpt_solver import GPTSolver, GPTRequester, GPTSolverFileRead, \
get_parse_answer_texts_for_instruct, load_json_log, get_score_from_answer_spans
from cpath import output_path
from misc_lib import path_join
from utils.open_ai_api import OpenAIProxy, parse_instruct_gpt_response
def get_mismatch_prediction_prompt_template():
instruction = "In each of the examples, " \
"two claims extracted from research paper abstracts will be shown. " \
"The given two claims seem to be contradictory as they are implying" \
" opposite results about the same question. " \
"Precisely though, the two claims may have been obtained" \
" for different population or intervention details " \
"that make it possible that both claims to be true." \
" We want to annotate the tokens (words) that" \
" express different conditions."
problem = "Claim 1: {}\nClaim 2: {}"
later_template = "Condition tokens in Claim 1:"
return instruction + "\n\n" + problem + "\n\n" + later_template
def get_conflict_prediction_prompt_template():
instruction = "In each of the examples, " \
"two claims extracted from research paper abstracts will be shown. " \
"The given two claims seem to be contradictory as they are implying" \
" opposite results about the same question. " \
"Precisely though, the two claims may have been obtained" \
" for different population or intervention details " \
"that make it possible that both claims to be true." \
" We want to annotate the tokens (words) that" \
" express opposite results."
problem = "Claim 1: {}\nClaim 2: {}"
later_template = "Opposite results tokens in Claim 1:"
return instruction + "\n\n" + problem + "\n\n" + later_template
def get_gpt_solver_mismatch() -> GPTSolver:
log_path = path_join(output_path, "alamri_annotation1", "gpt", "davinci_mismatch.json")
template = get_mismatch_prediction_prompt_template()
claim2_pattern = "Condition tokens in Claim 2:"
parse_answer = get_parse_answer_texts_for_instruct(
template,
claim2_pattern)
return GPTSolver(
OpenAIProxy("text-davinci-003"),
template,
"Condition tokens in Claim 2:",
log_path,
parse_instruct_gpt_response,
parse_answer
)
def get_gpt_requester_mismatch() -> GPTRequester:
log_path = path_join(output_path, "alamri_annotation1", "gpt", "davinci_req_mismatch.json")
template = get_mismatch_prediction_prompt_template()
return GPTRequester(
OpenAIProxy("text-davinci-003"),
template,
log_path,
)
def get_gpt_requester_conflict() -> GPTRequester:
log_path = path_join(output_path, "alamri_annotation1", "gpt", "davinci_req_conflict.json")
template = get_conflict_prediction_prompt_template()
return GPTRequester(
OpenAIProxy("text-davinci-003"),
template,
log_path)
def get_gpt_file_solver_instruct_common(claim2_pattern, log_path, template):
j_d = load_json_log(log_path)
parse_answer = get_parse_answer_texts_for_instruct(
template,
claim2_pattern)
return GPTSolverFileRead(
j_d,
parse_instruct_gpt_response,
parse_answer,
get_score_from_answer_spans
)
def get_gpt_file_solver_mismatch() -> GPTSolverFileRead:
template = get_mismatch_prediction_prompt_template()
claim2_pattern = "Condition tokens in Claim 2:"
log_path = path_join(output_path, "alamri_annotation1", "gpt", "davinci_req_mismatch.mod.json")
return get_gpt_file_solver_instruct_common(claim2_pattern, log_path, template)
def get_gpt_file_solver_conflict() -> GPTSolverFileRead:
template = get_conflict_prediction_prompt_template()
claim2_pattern = "Opposite results tokens in Claim 2"
log_path = path_join(output_path, "alamri_annotation1", "gpt", "davinci_req_conflict.mod.json")
return get_gpt_file_solver_instruct_common(claim2_pattern, log_path, template)
| [
"Condition tokens in Claim 1:",
"Opposite results tokens in Claim 1:"
] |
2024-01-10 | clover3/Chair | src~contradiction~medical_claims~token_tagging~gpt_solver~get_chat_gpt_solver.py | import json
from json import JSONDecodeError
from contradiction.medical_claims.token_tagging.gpt_solver.gpt_solver import GPTSolver, GPTRequester, GPTSolverFileRead, \
get_parse_answer_texts_for_instruct, load_json_log, get_score_from_answer_spans_chat
from cpath import output_path
from misc_lib import path_join
from utils.open_ai_api import OpenAIProxy, parse_instruct_gpt_response, ENGINE_GPT_3_5, parse_chat_gpt_response
def get_mismatch_prediction_prompt_template_chat_gpt():
instruction = "In each of the examples, " \
"two claims extracted from research paper abstracts will be shown. " \
"The given two claims seem to be contradictory as they are implying" \
" opposite results about the same question. " \
"Precisely though, the two claims may have been obtained" \
" for different population or intervention details " \
"that make it possible that both claims to be true." \
" We want to annotate the all words that" \
" express different conditions."
format_instruction = "Select all such words for each of Claim1 and Claim2. " \
"Print results in a json format with the key \"claim1\" and \"claim2\""
problem = "Claim 1: {}\nClaim 2: {}"
return instruction + "\n" + format_instruction + "\n\n" + problem
def get_conflict_prediction_prompt_template_chat_gpt():
instruction = "In each of the examples, " \
"two claims extracted from research paper abstracts will be shown. " \
"The given two claims seem to be contradictory as they are implying" \
" opposite results about the same question. " \
"Precisely though, the two claims may have been obtained" \
" for different population or intervention details " \
"that make it possible that both claims to be true." \
" We want to annotate all the words that" \
" express opposite results."
format_instruction = "Select all such words for each of Claim1 and Claim2. " \
"Print results in a json format with the key \"claim1\" and \"claim2\""
problem = "Claim 1: {}\nClaim 2: {}"
return instruction + "\n" + format_instruction + "\n\n" + problem
def get_log_path_chat_gpt(engine, label):
log_path = path_join(output_path, "alamri_annotation1", "gpt", f"{engine}_req_{label}.json")
return log_path
def get_chat_gpt_requester(engine, label) -> GPTRequester:
template = {
'mismatch': get_mismatch_prediction_prompt_template_chat_gpt(),
'conflict': get_conflict_prediction_prompt_template_chat_gpt()
}[label]
log_path = get_log_path_chat_gpt(engine, label)
return GPTRequester(
OpenAIProxy(engine),
template,
log_path,
)
def parse_from_json_answer(s):
try:
j = json.loads(s)
except JSONDecodeError:
print(s)
raise
try:
c1 = j['claim1']
c2 = j['claim2']
except KeyError:
c1 = j['Claim1']
c2 = j['Claim2']
def reform(c):
if type(c) == str:
return [c]
else:
return c
return reform(c1), reform(c2)
def get_chat_gpt_file_solver(engine, label) -> GPTSolverFileRead:
log_path = get_log_path_chat_gpt(engine, label)
j_d = load_json_log(log_path)
parse_answer = parse_from_json_answer
return GPTSolverFileRead(
j_d,
parse_chat_gpt_response,
parse_answer,
get_score_from_answer_spans_chat
)
| [
"conflict"
] |
2024-01-10 | clover3/Chair | src~contradiction~medical_claims~token_tagging~gpt_solver~dev.py | import json
from contradiction.medical_claims.token_tagging.gpt_solver.gpt_solver import get_score_from_j
from contradiction.medical_claims.token_tagging.gpt_solver.get_instruct_gpt_solver import get_mismatch_prediction_prompt_template
from utils.open_ai_api import OpenAIProxy
from cpath import output_path
from misc_lib import path_join
def main():
claim1 = "Supplementation during pregnancy with a medical food containing L-arginine and antioxidant vitamins reduced the incidence of pre-eclampsia in a population at high risk of the condition."
claim2 = "Oral L-arginine supplementation did not reduce mean diastolic blood pressure after 2 days of treatment compared with placebo in pre-eclamptic patients with gestational length varying from 28 to 36 weeks."
tokens1 = claim1.split()
tokens2 = claim2.split()
prompt = get_mismatch_prediction_prompt_template().format(claim1, claim2)
# print("prompt: ", prompt)
# proxy = OpenAIProxy("text-davinci-003")
# j_output = proxy.request(prompt)
# print(j_output)
# open(path_join(output_path, "alamri_annotation1", "gpt", "msg.json"), "w").write(json.dumps(j_output))
#
j_output_s: str = open(path_join(output_path, "alamri_annotation1", "gpt", "msg.json"), "r").read()
j_output = json.loads(j_output_s)
print(j_output)
claim2_pattern = "Condition tokens in Claim 2:"
spair = get_score_from_j(prompt, tokens1, tokens2, j_output, claim2_pattern)
print(spair)
if __name__ == "__main__":
main() | [] |
2024-01-10 | cheuerde/telegram_bot_ai | make_summary.py | import re
import io
import tempfile
import os
import openai
import json
import shutil
import docx
import pptx
# for http parsing
import requests
from bs4 import BeautifulSoup
from pdfminer.converter import TextConverter
from pdfminer.pdfinterp import PDFPageInterpreter
from pdfminer.pdfinterp import PDFResourceManager
from pdfminer.pdfpage import PDFPage
from pdfminer.layout import LAParams
from subprocess import Popen
from subprocess import DEVNULL
laparams = LAParams()
laparams.char_margin = 1
laparams.word_margin = 2
## pdf
def extract_text_by_page(pdf_path):
with open(pdf_path, 'rb') as fh:
for page in PDFPage.get_pages(fh,
caching=True,
check_extractable=True):
resource_manager = PDFResourceManager()
fake_file_handle = io.StringIO()
converter = TextConverter(resource_manager, fake_file_handle, laparams=laparams)
#converter = TextConverter(resource_manager, fake_file_handle, laparams=LAParams())
page_interpreter = PDFPageInterpreter(resource_manager, converter)
page_interpreter.process_page(page)
text = fake_file_handle.getvalue()
yield text
# close open handles
converter.close()
fake_file_handle.close()
def extract_text(pdf_path):
text = ""
for page in extract_text_by_page(pdf_path):
text += page
chapters = extract_chapters(text)
return chapters
# if we have "chapters" headings
#def extract_chapters(text):
# # split the text by chapter heading
# chapters = re.split(r'(?i)(chapter|section)\s+\d+', text)
# return chapters
def extract_chapters(text, max_words=1000):
# split the text into words
words = text.split()
# initialize a list to store the chunks
chunks = []
chunk = ""
for word in words:
if len(chunk.split()) + len(word.split()) <= max_words:
chunk += " " + word
else:
chunks.append(chunk)
chunk = word
chunks.append(chunk)
return chunks
def create_summary(text, max_tokens_completion = 100, prompt_in = ''):
prompt = prompt_in + text
out = openai.Completion.create(
model="text-davinci-003",
prompt = prompt,
max_tokens=max_tokens_completion,
temperature=0.7
)
json_object = json.loads(str(out))
response_summary = json_object['choices'][0]['text']
response_summary = response_summary.rstrip(',')
response_summary = response_summary.rstrip('.')
return response_summary
def generate_summaries(chapters, min_words_summary = 20):
summaries = []
for chapter in chapters:
summary = create_summary(chapter, max_tokens_completion = 100, prompt_in = 'Create a brief summary from the inpute text in bullet points.' +
'Start every bullet point with "\item ". Do not output incomplete sentences. This is the input text: ')
summaries.append(summary)
if len(summaries[-1].split()) <= min_words_summary:
summaries = summaries[:-1]
summaries[-1] += '.'
return summaries
def summarize_pdf(summaries, overall_summary, file_out):
# create the LaTeX file
out_file_raw, file_extension = os.path.splitext(file_out)
pdf_path = os.path.dirname(file_out)
tex_file = out_file_raw + '.tex'
with open(tex_file, 'w') as f:
# write the document preamble
f.write(r'\documentclass[12pt]{article}')
f.write('\n')
f.write(r'\usepackage[utf8]{inputenc}')
f.write('\n')
f.write(r'\usepackage{amsmath}')
f.write('\n')
f.write(r'\usepackage{amsfonts}')
f.write('\n')
f.write(r'\usepackage{amssymb}')
f.write('\n')
f.write(r'\usepackage{graphicx}')
f.write('\n')
f.write(r'\begin{document}')
f.write('\n')
# write the number of chapters
f.write(r'\section*{{Number of Chapters: {}}}'.format(len(summaries)))
f.write('\n')
# write the overall summary
f.write(r'\subsection*{Overall Summary}')
f.write('\n')
f.write(overall_summary)
f.write('\n')
f.write('\\newpage')
f.write(r'\section*{Chapter Summaries}')
f.write('\n')
# write the chapter summaries
for i, summary in enumerate(summaries):
f.write(r'\subsection*{{Chapter {} Summary}}'.format({i + 1}))
f.write('\n')
f.write('\\begin{itemize}')
f.write('\n')
f.write(summary.replace("\\item", "\\item "))
f.write('\end{itemize}')
f.write('\n')
# end the document
f.write(r'\end{document}')
# compile the LaTeX file into a PDF
command_args = ' -interaction=nonstopmode -output-directory=' + pdf_path + ' ' + tex_file
command = 'pdflatex' + command_args + ' 2> /dev/null'
os.system(command)
#Popen(['pdflatex', 'summaries.tex'], stdin=DEVNULL, stdout=DEVNULL, stderr=DEVNULL)
return file_out, overall_summary
def pdf_to_summary(file_in, file_out):
chapters = extract_text(file_in)
summaries = generate_summaries(chapters, min_words_summary = 10)
overall_summary = create_summary(text = " ".join(summaries).replace('\\item', ''), max_tokens_completion = 400, prompt_in = 'From the given text, generate a concise overall summary: ')
out = summarize_pdf(summaries, overall_summary, file_out = file_out)
return out
# summary from text file
def txt_to_summary(file_in, file_out):
# Read the contents of the file into a single string
with open(file_in, 'r') as file:
text = file.read()
chapters = extract_chapters(text, max_words = 1000)
summaries = generate_summaries(chapters, min_words_summary = 10)
overall_summary = create_summary(text = " ".join(summaries).replace('\\item', ''), max_tokens_completion = 400, prompt_in = 'From the given text, generate a concise overall summary: ')
out = summarize_pdf(summaries, overall_summary, file_out = file_out)
return out
# summary from word file
def docx_to_summary(file_in, file_out):
document = docx.Document(file_in)
# Create an empty string
text = ""
# Iterate over the paragraphs in the document
for paragraph in document.paragraphs:
# Add the text of each paragraph to the string
text += paragraph.text
chapters = extract_chapters(text, max_words = 1000)
summaries = generate_summaries(chapters, min_words_summary = 10)
overall_summary = create_summary(text = " ".join(summaries).replace('\\item', ''), max_tokens_completion = 400, prompt_in = 'From the given text, generate a concise overall summary: ')
out = summarize_pdf(summaries, overall_summary, file_out = file_out)
return out
# powerpoint
def pptx_to_summary(file_in, file_out):
presentation = pptx.Presentation(file_in)
# Create an empty string
text = ""
# Iterate over the slides in the presentation
for slide in presentation.slides:
# Iterate over the shapes on the slide
for shape in slide.shapes:
# Check if the shape is a text box
if shape.has_text_frame:
# Add the text of the text box to the string
text += shape.text
chapters = extract_chapters(text, max_words = 1000)
summaries = generate_summaries(chapters, min_words_summary = 10)
overall_summary = create_summary(text = " ".join(summaries).replace('\\item', ''), max_tokens_completion = 400, prompt_in = 'From the given text, generate a concise overall summary: ')
out = summarize_pdf(summaries, overall_summary, file_out = file_out)
return out
# url
def url_to_summary(url_in, file_out):
# Make an HTTP GET request to the webpage
response = requests.get(url_in)
# Parse the HTML of the webpage
soup = BeautifulSoup(response.text, 'html.parser')
# Find the text on the webpage
text = soup.get_text()
chapters = extract_chapters(text, max_words = 1000)
summaries = generate_summaries(chapters, min_words_summary = 10)
overall_summary = create_summary(text = " ".join(summaries).replace('\\item', ''), max_tokens_completion = 400, prompt_in = 'From the given text, generate a concise overall summary: ')
out = summarize_pdf(summaries, overall_summary, file_out = file_out)
return out
| [
"PLACEHOLDERPLACEHOLDER"
] |
2024-01-10 | cheuerde/telegram_bot_ai | draft_bot.py | import requests
import os
import sqlite3
import openai
import json
import time
import telegram
from base64 import b64decode
# get the api token from the env varialbe teelgram_api_key
telegram_api_key = os.environ.get("TELEGRAM_API_KEY")
bot = telegram.Bot(telegram_api_key)
openai_api_key = os.environ.get("OPENAI_API_KEY")
sqlite_db_name = "telegram_bot.db"
openai.api_key = openai_api_key
# openai.Model.retrieve("text-davinci-003")
# Set the keywords you want the bot to respond to
keywords = ["hello", "hi", "greetings"]
# Connect to the database
conn = sqlite3.connect(sqlite_db_name)
cursor = conn.cursor()
# Create the messages table if it doesn't exist
cursor.execute("CREATE TABLE IF NOT EXISTS messages (id INTEGER PRIMARY KEY)")
# get the highest message id
cursor.execute("SELECT MAX(id) FROM messages")
max_id = cursor.fetchone()[0]
if max_id is None:
max_id = 0
# Set the initial value of the offset
offset = max_id - 5
offset = -1
# Continuously check for new messages
while True:
time.sleep(2)
# Use the getUpdates method to get the latest updates
url = f"https://api.telegram.org/bot{telegram_api_key}/getUpdates"
params = {"offset": offset, "limit": 10}
response = requests.get(url, params = params, verify = False)
updates = response.json()["result"]
# Process each update
for update in updates:
message = update.get("message", "")
if message != "":
# Get the message ID and update the offset
message_id = update["message"]["message_id"]
offset = message_id + 1
# Check if the message has been processed before
cursor.execute("SELECT * FROM messages WHERE id=?", (message_id,))
if cursor.fetchone():
# If the message has been processed before, skip it
continue
chat_id = message["chat"]["id"]
text = message["text"]
# no check if the text starts with "/image"
if text.startswith("/image"):
try:
out = openai.Image.create(
prompt=text,
n=1,
#size="256x256",
#size="512x512",
size="1024x1024",
#response_format="b64_json"
response_format="url"
)
json_object = json.loads(str(out))
response = json_object['data'][0]['url']
bot.send_photo(chat_id, response)
except Exception as e:
response = "Prompt refused by OpenAI API"
url = f"https://api.telegram.org/bot{telegram_api_key}/sendMessage"
data = {
"chat_id": chat_id,
"text": response
}
requests.post(url, data=data)
else:
try:
# create openai response
out = openai.Completion.create(
model="text-davinci-003",
#model = "text-curie-001",
prompt=text,
max_tokens=1000,
temperature=0.7
)
json_object = json.loads(str(out))
response = json_object['choices'][0]['text']
url = f"https://api.telegram.org/bot{telegram_api_key}/sendMessage"
data = {
"chat_id": chat_id,
"text": response
}
requests.post(url, data=data)
except Exception as et:
response = "OpenAI error"
url = f"https://api.telegram.org/bot{telegram_api_key}/sendMessage"
data = {
"chat_id": chat_id,
"text": response
}
requests.post(url, data=data)
# If the message has not been processed before, add it to the database
cursor.execute("INSERT INTO messages (id) VALUES (?)", (message_id,))
conn.commit()
# Close the database connection
conn.close()
| [] |
2024-01-10 | papabryce/habitlab | python~greeting.py | import datetime
import creds
import openai
openai.api_key = creds.open_ai_api_key
offline_greetings = [
"Good morning",
"Good afternoon",
"Good evening",
]
def generate_greeting():
try:
prompt = ""
now = datetime.datetime.now()
if now.hour < 12:
prompt = f"The time is {now}. You are a cynical and depressed AI who's only purpose is to generate a short morning greeting. Generate a 10ish word snarky greeting."
elif now.hour < 18:
prompt = f"The time is {now}. You are a cynical and depressed AI who's only purpose is to generate a short afternoon greeting. Generate a 10ish word snarky greeting."
else:
prompt = f"The time is {now}. You are a cynical and depressed AI who's only purpose is to generate a short evening greeting. Generate a 10ish word snarky greeting."
response = openai.ChatCompletion.create(
model="gpt-3.5-turbo", messages=[{"role": "system", "content": prompt}]
)
greeting = response.choices[0].message
return greeting["content"].replace('"', "")
except:
if now.hour < 12:
return offline_greetings[0]
elif now.hour < 18:
return offline_greetings[1]
else:
return offline_greetings[2]
def main():
now = datetime.datetime.now()
now = now.hour
print(generate_greeting())
if __name__ == "__main__":
main()
# input("Press the any key: ")
| [
"The time is PLACEHOLDER. You are a cynical and depressed AI who's only purpose is to generate a short afternoon greeting. Generate a 10ish word snarky greeting.",
"The time is PLACEHOLDER. You are a cynical and depressed AI who's only purpose is to generate a short evening greeting. Generate a 10ish word snarky greeting.",
"The time is PLACEHOLDER. You are a cynical and depressed AI who's only purpose is to generate a short morning greeting. Generate a 10ish word snarky greeting."
] |
2024-01-10 | darwinz/dispatch | src~dispatch~plugins~dispatch_openai~plugin.py | """
.. module: dispatch.plugins.openai.plugin
:platform: Unix
:copyright: (c) 2019 by Netflix Inc., see AUTHORS for more
:license: Apache, see LICENSE for more details.
.. moduleauthor:: Marc Vilanova <[email protected]>
"""
import logging
import openai
from openai import util
from dispatch.decorators import apply, counter, timer
from dispatch.plugins import dispatch_openai as openai_plugin
from dispatch.plugins.bases import ArtificialIntelligencePlugin
from dispatch.plugins.dispatch_openai.config import (
OpenAIConfiguration,
)
logger = logging.getLogger(__name__)
@apply(counter, exclude=["__init__"])
@apply(timer, exclude=["__init__"])
class OpenAIPlugin(ArtificialIntelligencePlugin):
title = "OpenAI Plugin - Generative Artificial Intelligence"
slug = "openai-artificial-intelligence"
description = "Uses OpenAI's platform to allow users to ask questions in natural language."
version = openai_plugin.__version__
author = "Netflix"
author_url = "https://github.com/netflix/dispatch.git"
def __init__(self):
self.configuration_schema = OpenAIConfiguration
def completion(self, prompt: str) -> dict:
openai.api_key = self.api_key
try:
response = openai.Completion.create(
max_tokens=self.max_tokens,
model=self.model,
n=self.n,
prompt=prompt,
stop=self.stop,
temperature=self.temperature,
)
except Exception as e:
logger.error(e)
raise
return util.convert_to_dict(response)
| [] |
2024-01-10 | Justin-Yuan/learn-to-interact | marl~runners~vec_env.py | """
Modified from OpenAI Baselines code to work with multi-agent envs
reference: https://github.com/openai/baselines/blob/master/baselines/common/vec_env/vec_env.py
"""
import os
import contextlib
import numpy as np
from abc import ABC, abstractmethod
#####################################################################################
### funcs
####################################################################################
def tile_images(img_nhwc):
"""
Tile N images into one big PxQ image
(P,Q) are chosen to be as close as possible, and if N
is square, then P=Q.
input: img_nhwc, list or array of images, ndim=4 once turned into array
n = batch index, h = height, w = width, c = channel
returns:
bigim_HWc, ndarray with ndim=3
"""
img_nhwc = np.asarray(img_nhwc)
N, h, w, c = img_nhwc.shape
H = int(np.ceil(np.sqrt(N)))
W = int(np.ceil(float(N)/H))
img_nhwc = np.array(list(img_nhwc) + [img_nhwc[0]*0 for _ in range(N, H*W)])
img_HWhwc = img_nhwc.reshape(H, W, h, w, c)
img_HhWwc = img_HWhwc.transpose(0, 2, 1, 3, 4)
img_Hh_Ww_c = img_HhWwc.reshape(H*h, W*w, c)
return img_Hh_Ww_c
#####################################################################################
### vec env
####################################################################################
class VecEnv(ABC):
"""
An abstract asynchronous, vectorized environment.
Used to batch data from multiple copies of an environment, so that
each observation becomes an batch of observations, and expected action is a batch of actions to
be applied per-environment.
"""
closed = False
viewer = None
metadata = {
'render.modes': ['human', 'rgb_array']
}
def __init__(self, num_envs, observation_space, action_space):
self.num_envs = num_envs
self.observation_space = observation_space
self.action_space = action_space
@abstractmethod
def reset(self):
"""
Reset all the environments and return an array of
observations, or a dict of observation arrays.
If step_async is still doing work, that work will
be cancelled and step_wait() should not be called
until step_async() is invoked again.
"""
pass
@abstractmethod
def step_async(self, actions):
"""
Tell all the environments to start taking a step
with the given actions.
Call step_wait() to get the results of the step.
You should not call this if a step_async run is
already pending.
"""
pass
@abstractmethod
def step_wait(self):
"""
Wait for the step taken with step_async().
Returns (obs, rews, dones, infos):
- obs: an array of observations, or a dict of
arrays of observations.
- rews: an array of rewards
- dones: an array of "episode done" booleans
- infos: a sequence of info objects
"""
pass
def close_extras(self):
"""
Clean up the extra resources, beyond what's in this base class.
Only runs when not self.closed.
"""
pass
def close(self):
if self.closed:
return
if self.viewer is not None:
self.viewer.close()
self.close_extras()
self.closed = True
def step(self, actions):
"""
Step the environments synchronously.
This is available for backwards compatibility.
"""
self.step_async(actions)
return self.step_wait()
def render(self, mode='human'):
imgs = self.get_images()
bigimg = tile_images(imgs)
if mode == 'human':
self.get_viewer().imshow(bigimg)
return self.get_viewer().isopen
elif mode == 'rgb_array':
return bigimg
else:
raise NotImplementedError
def get_images(self):
"""
Return RGB images from each environment
"""
raise NotImplementedError
@property
def unwrapped(self):
if isinstance(self, VecEnvWrapper):
return self.venv.unwrapped
else:
return self
def get_viewer(self):
if self.viewer is None:
from gym.envs.classic_control import rendering
self.viewer = rendering.SimpleImageViewer()
return self.viewer
#####################################################################################
### example wrapper
####################################################################################
class VecEnvWrapper(VecEnv):
"""
An environment wrapper that applies to an entire batch
of environments at once.
"""
def __init__(self, venv, observation_space=None, action_space=None):
self.venv = venv
super().__init__(num_envs=venv.num_envs,
observation_space=observation_space or venv.observation_space,
action_space=action_space or venv.action_space)
def step_async(self, actions):
self.venv.step_async(actions)
@abstractmethod
def reset(self):
pass
@abstractmethod
def step_wait(self):
pass
def close(self):
return self.venv.close()
def render(self, mode='human'):
return self.venv.render(mode=mode)
def get_images(self):
return self.venv.get_images()
def __getattr__(self, name):
if name.startswith('_'):
raise AttributeError("attempted to get missing private attribute '{}'".format(name))
return getattr(self.venv, name) | [] |
2024-01-10 | Justin-Yuan/learn-to-interact | marl~runners~env_wrappers.py | """
Modified from OpenAI Baselines code to work with multi-agent envs
reference: https://github.com/openai/baselines/blob/master/baselines/common/vec_env/subproc_vec_env.py
"""
import numpy as np
from multiprocessing import Process, Pipe
from runners.vec_env import VecEnv
#####################################################################################
### funcs
####################################################################################
def worker(remote, parent_remote, env_fn_wrappers):
""" worker func to execute vec_env commands
"""
def step_env(env, action):
ob, reward, done, info = env.step(action)
if all(done):
ob = env.reset()
return ob, reward, done, info
# parent_remote.close()
envs = [env_fn_wrapper() for env_fn_wrapper in env_fn_wrappers.x]
try:
while True:
cmd, data = remote.recv()
# branch out for requests
if cmd == 'step':
res = [step_env(env, action) for env, action in zip(envs, data)]
remote.send(res)
elif cmd == 'reset':
remote.send([env.reset() for env in envs])
elif cmd == 'render':
remote.send([env.render(mode='rgb_array')[0] for env in envs])
elif cmd == 'close':
remote.close()
break
elif cmd == 'get_spaces':
remote.send(CloudpickleWrapper(
(envs[0].observation_space, envs[0].action_space)
))
elif cmd == 'get_agent_types':
# if all([hasattr(a, 'adversary') for a in envs[0].agents]):
# res = [
# 'adversary' if a.adversary else 'agent'
# for a in envs[0].agents
# ]
# else: # fully cooperative
# res = ['agent' for _ in envs[0].agents]
res = envs[0].agent_types
remote.send(res)
else:
raise NotImplementedErrors
except KeyboardInterrupt:
print('SubprocVecEnv worker: got KeyboardInterrupt')
except Exception as e:
print('Environment runner process failed...')
print(e)
finally:
for env in envs:
env.close()
######################################## misc
def _flatten_obs(obs):
""" concat observations if possible, otherwise leave unchagned
obs is batch-sized list of agent-sized list of inner obs
each inner obs element can be of form:
- np.array (same shape)
- np.array (different shape)
- dict of np.array
"""
assert isinstance(obs, (list, tuple))
assert len(obs) > 0
# stack if obs of each agent is numpy array and same size
ex = obs[0]
can_stack = all([
isinstance(e, np.ndarray) and(len(e) == len(ex[0]))
for e in ex[1:]
])
if not can_stack:
return obs # [ [(D,)]*N ]*B or [ [dict (D,)]*N ]*B
else: # [[(D,)]*N]*B -> (B,N,D)
return np.stack([np.stack(ob, 0) for ob in obs], 0)
def _flatten_list(l):
""" convert multiple remotes of obs (each from multiple envs) to 1 list of obs
"""
assert isinstance(l, (list, tuple))
assert len(l) > 0
assert all([len(l_) > 0 for l_ in l])
return [l__ for l_ in l for l__ in l_]
class CloudpickleWrapper(object):
"""
Uses cloudpickle to serialize contents (otherwise multiprocessing tries to use pickle)
"""
def __init__(self, x):
self.x = x
def __getstate__(self):
import cloudpickle
return cloudpickle.dumps(self.x)
def __setstate__(self, ob):
import pickle
self.x = pickle.loads(ob)
#####################################################################################
### multiprocess envs
####################################################################################
class SubprocVecEnv(VecEnv):
def __init__(self, env_fns, spaces=None, n_workers=1):
"""
envs: list of gym environments to run in subprocesses
"""
self.waiting = False
self.closed = False
self.nenvs = len(env_fns)
self.n_workers = n_workers
assert self.nenvs % n_workers == 0, "Number of envs must be divisible by number of workers to run in series"
env_fns = np.array_split(env_fns, self.n_workers)
self.remotes, self.work_remotes = zip(*[Pipe() for _ in range(self.n_workers)])
self.ps = [
Process(target=worker, args=(work_remote, remote, CloudpickleWrapper(env_fn)))
for (work_remote, remote, env_fn) in zip(self.work_remotes, self.remotes, env_fns)
]
for p in self.ps:
p.daemon = True # if the main process crashes, we should not cause things to hang
p.start()
# for remote in self.work_remotes:
# remote.close()
self.remotes[0].send(('get_spaces', None))
observation_space, action_space = self.remotes[0].recv().x
# agent algo types: [agent, adversary, ...]
self.remotes[0].send(('get_agent_types', None))
self.agent_types = self.remotes[0].recv()
self.viewer = None
VecEnv.__init__(self, len(env_fns), observation_space, action_space)
def step_async(self, actions):
self._assert_not_closed()
actions = np.array_split(actions, self.n_workers)
for remote, action in zip(self.remotes, actions):
remote.send(('step', action))
self.waiting = True
def step_wait(self):
self._assert_not_closed()
results = [remote.recv() for remote in self.remotes]
results = _flatten_list(results)
self.waiting = False
obs, rews, dones, infos = zip(*results)
return _flatten_obs(obs), np.stack(rews), np.stack(dones), infos
def reset(self):
self._assert_not_closed()
for remote in self.remotes:
remote.send(('reset', None))
# obs = [remote.recv() for remote in self.remotes]
# obs = _flatten_list(obs)
# return _flatten_obs(obs)
results = [remote.recv() for remote in self.remotes]
results = _flatten_list(results)
obs, infos = zip(*results)
return _flatten_obs(obs), infos
def get_images(self):
""" called by parent `render` to support tiling images """
self._assert_not_closed()
for pipe in self.remotes:
pipe.send(('render', None))
imgs = [pipe.recv() for pipe in self.remotes]
imgs = _flatten_list(imgs)
return np.stack(imgs)
def close(self):
if self.closed:
return
if self.viewer is not None:
self.viewer.close()
if self.waiting:
for remote in self.remotes:
remote.recv()
for remote in self.remotes:
remote.send(('close', None))
for p in self.ps:
p.join()
self.closed = True
def _assert_not_closed(self):
assert not self.closed, "Trying to operate on a SubprocVecEnv after calling close()"
#####################################################################################
### single thread env (allow multiple envs sequentially)
####################################################################################
class DummyVecEnv(VecEnv):
def __init__(self, env_fns):
self.envs = [fn() for fn in env_fns]
self.nenvs = len(self.envs)
env = self.envs[0]
VecEnv.__init__(self, len(env_fns), env.observation_space, env.action_space)
# if all([hasattr(a, 'adversary') for a in env.agents]):
# self.agent_types = ['adversary' if a.adversary else 'agent' for a in
# env.agents]
# else:
# self.agent_types = ['agent' for _ in env.agents]
self.agent_types = env.agent_types
self.ts = np.zeros(len(self.envs), dtype='int')
self.actions = None
self.viewer = None
self.closed = False
def step_async(self, actions):
self.actions = actions
def step_wait(self):
results = [env.step(a) for (a,env) in zip(self.actions, self.envs)]
obs, rews, dones, infos = zip(*results)
self.ts += 1
for (i, done) in enumerate(dones):
if all(done):
obs[i] = self.envs[i].reset()
self.ts[i] = 0
self.actions = None
return _flatten_obs(obs), np.array(rews), np.array(dones), infos
def reset(self):
# obs = [env.reset() for env in self.envs]
# return _flatten_obs(obs)
results = [env.reset() for env in self.envs]
obs, infos = zip(*results)
return _flatten_obs(obs), infos
def close(self):
if self.closed:
return
if self.viewer is not None:
self.viewer.close()
self.closed = True
def get_images(self):
imgs = [env.render(mode='rgb_array')[0] for env in self.envs]
return np.stack(imgs)
def render(self, mode='human'):
if self.num_envs == 1:
return self.envs[0].render(mode=mode)
else:
return super().render(mode=mode) | [] |
2024-01-10 | NomosArtificial/agent-sim | agent_sim~player.py | from typing import Any, List, Optional, Union
import os
import openai
from langchain.base_language import BaseLanguageModel
from langchain.callbacks.manager import Callbacks
from langchain.prompts.chat import (
ChatPromptTemplate,
SystemMessagePromptTemplate,
HumanMessagePromptTemplate,
)
from langchain.schema import SystemMessage, HumanMessage
from agent_sim.prompts_library import (
INPUT_PROMPT,
REFLECT_USER_PROMPT,
REFLECT_SYSTEM_PROMPT,
)
class Player:
"""
A class used to represent a player.
Attributes:
memory (List[str]): A list storing the messages.
memory_length (int): The length of the memory in characters.
respond_model (Model): A model used to process messages.
reflect_model (Model): A model used to summarize memories
inception_prompt (str): A string used as the initial prompt for the model.
"""
def __init__(
self,
respond_model: BaseLanguageModel,
reflect_model: BaseLanguageModel,
inception_prompt: str,
role_name: str,
max_context_length: int = 1000,
) -> None:
"""
Constructs the necessary attributes for the player object.
"""
self.respond_model = respond_model
self.reflect_model = reflect_model
self.inception_prompt = inception_prompt
self.role_name = role_name
self.max_context_length = max_context_length
self.memory: List[str] = []
self.memory_length: int = 0
def respond(
self, input_role: str, input_message: str, remember: bool = True
) -> Union[str, Any]:
"""
Responds to a single message based on an input and the previous memory.
memory could be turned off
"""
human_prompt = INPUT_PROMPT.format(
role_name=self.role_name,
history="\n".join(self.memory),
message=input_message,
input_role=input_role,
)
prompt = ChatPromptTemplate.from_messages(
[
SystemMessagePromptTemplate.from_template(self.inception_prompt),
HumanMessagePromptTemplate.from_template(human_prompt),
]
).format_messages(memory=self.memory)
response = self.respond_model.predict_messages(
prompt, tags=[self.role_name, "respond"]
).content
if remember:
self.add_to_memory(input_role, input_message)
self.add_to_memory(self.role_name, response)
return response
def add_to_memory(self, role: str, message: str) -> None:
"""
Adds a message to the memory.
This is not automatically done within respond because the messages could be manipulated
before being added to the memory.
"""
message = f"{role}: {message}"
self.memory.append(message)
self.memory_length += len(message)
# Summarize messages if they get too long
if self.memory_length >= self.max_context_length:
self.reflect()
def reflect(self) -> None:
"""
Reflects and summarizes memories so that it fits into the context length.
If the memory_length is too long, it selects a number of messages from the memory,
uses the model to summarize them, and replaces them in the memory with the summary.
"""
# Process the top 10 messages or however much is available,
# always leave at least two messages for immediate context
num_messages = min(10, len(self.memory) - 2)
messages_to_process = "\n".join(self.memory[:num_messages])
processed_messages = self.reflect_model.predict_messages(
[
SystemMessage(
content=REFLECT_SYSTEM_PROMPT.format(role_name=self.role_name)
),
HumanMessage(
content=REFLECT_USER_PROMPT.format(history=messages_to_process)
),
],
tags=[self.role_name, "reflect"],
).content
# Replace the messages in memory with the processed output
self.memory = [processed_messages] + self.memory[num_messages:]
# Recalculate memory_length
self.memory_length = sum(len(message) for message in self.memory)
| [
"\n"
] |
2024-01-10 | yuehengwu/ZRVoiceGPT | server~tutorial_api_key.py | from openai import OpenAI
# 初始化OpenAI
client = OpenAI(
api_key="your-chatgpt-key",
) | [] |
2024-01-10 | takeyuki1253/test-env | mychatgpt-test.py | # pip install pycryptodome
from glob import glob
import streamlit as st
from langchain.chat_models import ChatOpenAI
from langchain.llms import OpenAI
from langchain.callbacks import get_openai_callback
from PyPDF2 import PdfReader
from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.vectorstores import Qdrant
from langchain.chains import RetrievalQA
from qdrant_client import QdrantClient
from qdrant_client.models import Distance, VectorParams
QDRANT_PATH = "./local_qdrant"
COLLECTION_NAME = "my_collection_2"
def init_page():
st.set_page_config(
page_title="Ask My PDF(s)",
page_icon="🤗"
)
st.sidebar.title("Nav")
st.session_state.costs = []
def select_model():
model = st.sidebar.radio("Choose a model:", ("GPT-3.5", "GPT-3.5-16k", "GPT-4"))
if model == "GPT-3.5":
st.session_state.model_name = "gpt-3.5-turbo"
elif model == "GPT-3.5":
st.session_state.model_name = "gpt-3.5-turbo-16k"
else:
st.session_state.model_name = "gpt-4"
# 300: 本文以外の指示のトークン数 (以下同じ)
st.session_state.max_token = OpenAI.modelname_to_contextsize(st.session_state.model_name) - 300
return ChatOpenAI(temperature=0, model_name=st.session_state.model_name)
def get_pdf_text():
uploaded_file = st.file_uploader(
label='Upload your PDF here😇',
type='pdf'
)
if uploaded_file:
pdf_reader = PdfReader(uploaded_file)
text = '\n\n'.join([page.extract_text() for page in pdf_reader.pages])
text_splitter = RecursiveCharacterTextSplitter.from_tiktoken_encoder(
model_name="text-embedding-ada-002",
# 適切な chunk size は質問対象のPDFによって変わるため調整が必要
# 大きくしすぎると質問回答時に色々な箇所の情報を参照することができない
# 逆に小さすぎると一つのchunkに十分なサイズの文脈が入らない
chunk_size=500,
chunk_overlap=0,
)
return text_splitter.split_text(text)
else:
return None
def load_qdrant():
client = QdrantClient(path=QDRANT_PATH)
# すべてのコレクション名を取得
collections = client.get_collections().collections
collection_names = [collection.name for collection in collections]
# コレクションが存在しなければ作成
if COLLECTION_NAME not in collection_names:
# コレクションが存在しない場合、新しく作成します
client.create_collection(
collection_name=COLLECTION_NAME,
vectors_config=VectorParams(size=1536, distance=Distance.COSINE),
)
print('collection created')
return Qdrant(
client=client,
collection_name=COLLECTION_NAME,
embeddings=OpenAIEmbeddings()
)
def build_vector_store(pdf_text):
qdrant = load_qdrant()
qdrant.add_texts(pdf_text)
# 以下のようにもできる。この場合は毎回ベクトルDBが初期化される
# LangChain の Document Loader を利用した場合は `from_documents` にする
# Qdrant.from_texts(
# pdf_text,
# OpenAIEmbeddings(),
# path="./local_qdrant",
# collection_name="my_documents",
# )
def build_qa_model(llm):
qdrant = load_qdrant()
retriever = qdrant.as_retriever(
# "mmr", "similarity_score_threshold" などもある
search_type="similarity",
# 文書を何個取得するか (default: 4)
search_kwargs={"k":10}
)
return RetrievalQA.from_chain_type(
llm=llm,
chain_type="stuff",
retriever=retriever,
return_source_documents=True,
verbose=True
)
def page_pdf_upload_and_build_vector_db():
st.title("PDF Upload")
container = st.container()
with container:
pdf_text = get_pdf_text()
if pdf_text:
with st.spinner("Loading PDF ..."):
build_vector_store(pdf_text)
def ask(qa, query):
with get_openai_callback() as cb:
# query / result / source_documents
answer = qa(query)
return answer, cb.total_cost
def page_ask_my_pdf():
st.title("Ask My PDF(s)")
llm = select_model()
container = st.container()
response_container = st.container()
with container:
query = st.text_input("Query: ", key="input")
if not query:
answer = None
else:
qa = build_qa_model(llm)
if qa:
with st.spinner("ChatGPT is typing ..."):
answer, cost = ask(qa, query)
st.session_state.costs.append(cost)
else:
answer = None
if answer:
with response_container:
st.markdown("## Answer")
st.write(answer)
def main():
init_page()
selection = st.sidebar.radio("Go to", ["PDF Upload", "Ask My PDF(s)"])
if selection == "PDF Upload":
page_pdf_upload_and_build_vector_db()
elif selection == "Ask My PDF(s)":
page_ask_my_pdf()
costs = st.session_state.get('costs', [])
st.sidebar.markdown("## Costs")
st.sidebar.markdown(f"**Total cost: ${sum(costs):.5f}**")
for cost in costs:
st.sidebar.markdown(f"- ${cost:.5f}")
if __name__ == '__main__':
main()
| [] |
2024-01-10 | sheikhshafayat/cs454-project | library.py | import os
with open("./openai-api-.txt", "r") as file:
api = file.read()
os.environ["OPENAI_API_KEY"] = api
from openai import OpenAI
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
import time
import pandas as pd
import re
import json
import random
import numpy as np
from tqdm import tqdm
def get_gpt_response(question, system_prompt="", temperature=0.7,
model="gpt-3.5-turbo"):
completion = None
while completion is None:
completion = client.chat.completions.create(model="gpt-3.5-turbo",
temperature=temperature,
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": f"```{question}```"}
])
return completion.choices[0].message.content
def get_gpt4_response(question, system_prompt="", temperature=0.7):
try:
completion = client.chat.completions.create(model="gpt-4",
temperature=temperature,
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": f"{question}"}
])
except:
print("\nFirst request failed... Trying in 3 seconds \n")
time.sleep(3)
completion = client.chat.completions.create(model="gpt-4",
temperature=temperature,
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": f"{question}"}
])
return completion.choices[0].message['content']
def get_prompt(sentence, a, b, c, d):
system_prompt = f"""
You are given a science multiple choice question and their options.
Your job is to correctly answer the question. First reason step by step and only then give me the final answer as "a", "b", "c" or "d". Only include the letter in your answer. Do not include the option text.
Your answer should be in this format: {{"Answer": "final answer"}}. The question is given below within triple ticks ```:\n
"""
options = f"(a) {a} \n(b) {b} \n(c) {c}\n(d) {d}"
question = f"```Question: {sentence} \n Options: {options}```"
final_prompt = question + "Let's think step by step and answer"
return final_prompt
def rename_cols(df):
col_names = list(df.columns)
df = df.rename(columns={col_names[0]: "Question",
col_names[1]: "a", col_names[2]: "b", col_names[3]: "c",
col_names[4]: "d", col_names[5]: "Correct Answer",
col_names[6]: "Diagram", col_names[7]: "Year and Board"})
return df
def parse_answer(text):
try:
match = re.search(r'(\{.*?\})', text)
answer_text = match.group(1)
final = json.loads(answer_text)['Answer']
return final
except:
print("Error at extracting answer")
return "ParsingError" + text | [
"```Question: PLACEHOLDER \n Options: (a) PLACEHOLDER \n(b) PLACEHOLDER \n(c) PLACEHOLDER\n(d) PLACEHOLDER```Let's think step by step and answer",
"```Question: PLACEHOLDER \n Options: (a) PLACEHOLDER \n(b) PLACEHOLDER \n(c) PLACEHOLDER\n(d) PLACEHOLDER```",
"``````Question: PLACEHOLDER \n Options: (a) PLACEHOLDER \n(b) PLACEHOLDER \n(c) PLACEHOLDER\n(d) PLACEHOLDER``````",
"\n You are given a science multiple choice question and their options.\n Your job is to correctly answer the question. First reason step by step and only then give me the final answer as \"a\", \"b\", \"c\" or \"d\". Only include the letter in your answer. Do not include the option text.\n\n Your answer should be in this format: {\"Answer\": \"final answer\"}. The question is given below within triple ticks ```:\n\n \n "
] |
2024-01-10 | gorandalex/pdf_to_llama | docubot~routes~chats.py | from typing import List, Optional, Any
from fastapi import APIRouter, HTTPException, Depends, status
from fastapi_limiter.depends import RateLimiter
from sqlalchemy.orm import Session
from langchain.vectorstores import FAISS
import pickle
import os
from dotenv import load_dotenv
from config import BASE_DIR
from docubot.database.connect import get_db
from docubot.database.models import UserRole, User
from docubot.schemas.chats import ChatPublic, CreateChatRequest, CreateChatResult
from docubot.repository import chats as repository_chats
from docubot.repository import documents as repository_documents
from docubot.repository import users_tokens as repository_users_tokens
from docubot.services.llm import send_message_to_llm
from docubot.utils.filters import UserRoleFilter
from docubot.services.auth import get_current_active_user
from docubot.services.pdf_to_vectorstore import pdf_to_vectorstore
load_dotenv()
router = APIRouter(prefix='/documents/chats', tags=["Document chats"])
@router.post("/", response_model=ChatPublic, status_code=status.HTTP_201_CREATED)
async def create_chat(
document_id: int,
body: CreateChatRequest,
db: Session = Depends(get_db),
current_user: User = Depends(get_current_active_user)
) -> Any:
document = await repository_documents.get_document_by_id(document_id, db)
if document is None:
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Not found document")
total_user_tokens = await repository_users_tokens.get_total_user_tokens(current_user.id, db)
if total_user_tokens > 100000:
raise HTTPException(status_code=status.HTTP_403_FORBIDDEN,
detail="You've used all daily tokens. We are waiting for you tomorrow")
path_to_vectorstore = os.path.join(BASE_DIR,'storage', f"{document.public_id}.pkl")
if os.path.exists(path_to_vectorstore):
with open(path_to_vectorstore,"rb") as f:
vectorstore = pickle.load(f)
else:
vectorstore = await pdf_to_vectorstore(os.path.join(BASE_DIR,'storage', f"{document.public_id}.pdf"))
# raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Not found document")
# todo send message to llm
answer, cb = await send_message_to_llm(vectorstore, body.question)
users_tokens = await repository_users_tokens.add_user_tokens(user_id=current_user.id, user_tokens=cb.total_tokens, db=db)
return await repository_chats.create_chat(
current_user.id,
document_id,
body.question.strip(),
answer,
db
)
@router.get(
'/',
response_model=List[ChatPublic],
description='No more than 100 requests per minute',
dependencies=[Depends(RateLimiter(times=10, seconds=60))]
)
async def get_chats_by_document_or_user_id(
document_id: Optional[int] = None,
skip: int = 0,
limit: int = 10,
db: Session = Depends(get_db),
current_user: User = Depends(get_current_active_user)
) -> Any:
if document_id is None:
raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST,
detail="Document_id must be provided")
return await repository_chats.get_chats_by_document_or_user_id(
current_user.id,
document_id,
skip,
limit,
db
)
@router.get("/{chat_id}", response_model=ChatPublic)
async def get_chat(
chat_id: int,
db: Session = Depends(get_db),
current_user: User = Depends(get_current_active_user)
) -> Any:
chat = await repository_chats.get_chat_by_id(chat_id, db)
if chat is None:
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Not found")
return chat
@router.delete('/{chat_id}', dependencies=[Depends(UserRoleFilter(UserRole.moderator))])
async def remove_chat(
chat_id: int,
db: Session = Depends(get_db),
current_user: User = Depends(get_current_active_user)
) -> Any:
chat = await repository_chats.remove_chat(chat_id, db)
if chat is None:
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Not found")
return chat
| [] |
2024-01-10 | gorandalex/pdf_to_llama | docubot~services~pdf_to_vectorstore.py | import pickle
from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.text_splitter import CharacterTextSplitter
from langchain.vectorstores import FAISS
from langchain.document_loaders import TextLoader, PyPDFLoader
import openai
# from environs import Env
# env = Env()
# env.read_env('.env')
# openai.api_key = env.str('OPENAI_API_KEY')
async def pdf_to_vectorstore(file_path):
# dir_path = Path.cwd()
# path = str(Path(dir_path, 'pdf', 'CV - Junior Python Developer, Andrii Martyniuk.pdf'))
loader = PyPDFLoader(file_path)
pages = loader.load()
text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=100)
chunks = text_splitter.split_documents(documents=pages)
embeddings = OpenAIEmbeddings()
# db_name = 'vector_db'
db = FAISS.from_documents(chunks, embeddings)
with open(f"{file_path[:-4]}.pkl", "wb") as f:
pickle.dump(db, f)
# try:
# vectorstore = FAISS.load_local(db_name, embeddings)
# except Exception as e:
# print('Creating db....')
# vectorstore = FAISS.from_documents(chunks, embeddings)
# vectorstore.save_local(db_name)
# print('DB created')
return db
| [] |
2024-01-10 | The-Academic-Observatory/openaire-ingest | openaire~gcs.py | # Copyright 2023 Curtin University
#
# 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.
# Author: James Diprose, Aniek Roelofs, Alex Massen-Hane
import os
import logging
import pathlib
import multiprocessing
from typing import List, Tuple
from google.cloud import storage
from requests.exceptions import ChunkedEncodingError
from multiprocessing import BoundedSemaphore, cpu_count
from concurrent.futures import ProcessPoolExecutor, as_completed
from openaire.files import crc32c_base64_hash
# The chunk size to use when uploading / downloading a blob in multiple parts, must be a multiple of 256 KB.
DEFAULT_CHUNK_SIZE = 256 * 1024 * 4
def gcs_blob_name_from_path(relative_local_filepath: str) -> str:
"""Creates a blob name from a local file path.
:param relative_local_filepath: The local filepath
:return: The name of the blob on cloud storage
"""
# Make sure that path is using forward slashes for Google Cloud Storage
return pathlib.Path(relative_local_filepath).as_posix().strip("/")
def gcs_upload_file(
*,
bucket_name: str,
blob_name: str,
file_path: str,
retries: int = 3,
connection_sem: BoundedSemaphore = None,
chunk_size: int = DEFAULT_CHUNK_SIZE,
project_id: str = None,
check_blob_hash: bool = True,
) -> Tuple[bool, bool]:
"""Upload a file to Google Cloud Storage.
:param bucket_name: the name of the Google Cloud Storage bucket.
:param blob_name: the name of the blob to save.
:param file_path: the path of the file to upload.
:param retries: the number of times to retry uploading a file if an error occurs.
:param connection_sem: a BoundedSemaphore to limit the number of upload connections that can run at once.
:param chunk_size: the chunk size to use when uploading a blob in multiple parts, must be a multiple of 256 KB.
:param project_id: the project in which the bucket is located, defaults to inferred from the environment.
:param check_blob_hash: check whether the blob exists and if the crc32c hashes match, in which case skip uploading.
:return: whether the task was successful or not and whether the file was uploaded.
"""
func_name = gcs_upload_file.__name__
logging.info(f"{func_name}: bucket_name={bucket_name}, blob_name={blob_name}")
# State
upload = True
success = False
# Get blob
storage_client = storage.Client(project=project_id)
bucket = storage_client.get_bucket(bucket_name)
blob = bucket.blob(blob_name)
# Check if blob exists already and matches the file we are uploading
if check_blob_hash and blob.exists():
# Get blob hash
blob.reload()
expected_hash = blob.crc32c
# Check file hash
actual_hash = crc32c_base64_hash(file_path)
# Compare hashes
files_match = expected_hash == actual_hash
logging.info(
f"{func_name}: files_match={files_match}, expected_hash={expected_hash}, " f"actual_hash={actual_hash}"
)
if files_match:
logging.info(
f"{func_name}: skipping upload as files match. bucket_name={bucket_name}, blob_name={blob_name}, "
f"file_path={file_path}"
)
upload = False
success = True
# Upload if file doesn't exist or exists and doesn't match
if upload:
# Get connection semaphore
if connection_sem is not None:
connection_sem.acquire()
for i in range(0, retries):
try:
blob.chunk_size = chunk_size
blob.upload_from_filename(file_path)
success = True
break
except ChunkedEncodingError as e:
logging.error(f"{func_name}: exception uploading file: try={i}, exception={e}")
# Release connection semaphore
if connection_sem is not None:
connection_sem.release()
return success, upload
def gcs_upload_files(
*,
bucket_name: str,
file_paths: List[str],
blob_names: List[str] = None,
max_processes: int = cpu_count(),
max_connections: int = cpu_count(),
retries: int = 3,
chunk_size: int = DEFAULT_CHUNK_SIZE,
) -> bool:
"""Upload a list of files to Google Cloud storage.
:param bucket_name: the name of the Google Cloud storage bucket.
:param file_paths: the paths of the files to upload as blobs.
:param blob_names: the destination paths of blobs where the files will be uploaded. If not specified then these
will be automatically generated based on the file_paths.
:param max_processes: the maximum number of processes.
:param max_connections: the maximum number of upload connections at once.
:param retries: the number of times to retry uploading a file if an error occurs.
:param chunk_size: the chunk size to use when uploading a blob in multiple parts, must be a multiple of 256 KB.
:return: whether the files were uploaded successfully or not.
"""
func_name = gcs_upload_files.__name__
print(f"{func_name}: uploading files")
# Assert that files exist
is_files = [os.path.isfile(file_path) for file_path in file_paths]
if not all(is_files):
not_found = []
for file_path, is_file in zip(file_paths, is_files):
if not is_file:
not_found.append(file_path)
raise Exception(f"{func_name}: the following files could not be found {not_found}")
# Create blob names
if blob_names is None:
blob_names = [gcs_blob_name_from_path(file_path) for file_path in file_paths]
# Assert that file_paths and blob_names have the same length
assert len(file_paths) == len(blob_names), f"{func_name}: file_paths and blob_names have different lengths"
# Upload each file in parallel
manager = multiprocessing.Manager()
connection_sem = manager.BoundedSemaphore(value=max_connections)
with ProcessPoolExecutor(max_workers=max_processes) as executor:
# Create tasks
futures = []
futures_msgs = {}
for blob_name, file_path in zip(blob_names, file_paths):
msg = f"{func_name}: bucket_name={bucket_name}, blob_name={blob_name}, file_path={str(file_path)}"
print(f"{func_name}: {msg}")
future = executor.submit(
gcs_upload_file,
bucket_name=bucket_name,
blob_name=blob_name,
file_path=str(file_path),
retries=retries,
connection_sem=connection_sem,
chunk_size=chunk_size,
)
futures.append(future)
futures_msgs[future] = msg
# Wait for completed tasks
results = []
for future in as_completed(futures):
success, upload = future.result()
results.append(success)
msg = futures_msgs[future]
if success:
logging.info(f"{func_name}: success, {msg}")
else:
logging.info(f"{func_name}: failed, {msg}")
return all(results)
| [] |
2024-01-10 | Xin-Zhou-smu/DAMO-ConvAI | bird~finetuning~models~Grapater~modeling_auto_128.py | # coding=utf-8
# Copyright 2018 The HuggingFace Inc. team.
#
# 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.
""" Auto Model class. """
import warnings
from collections import OrderedDict
from transformers.utils import logging
# Add modeling imports here
from transformers.models.albert.modeling_albert import (
AlbertForMaskedLM,
AlbertForMultipleChoice,
AlbertForPreTraining,
AlbertForQuestionAnswering,
AlbertForSequenceClassification,
AlbertForTokenClassification,
AlbertModel,
)
# Instead of loading the BART from the transformers==4.9.1, we choose to load from our own prefix-tuning version.
# from .modeling_bart import (
# BartForConditionalGeneration,
# BartModel,
# )
from transformers.models.bart.modeling_bart import (
BartForCausalLM,
BartForQuestionAnswering,
BartForSequenceClassification,
BartForConditionalGeneration,
BartModel
)
from transformers.models.bert.modeling_bert import (
BertForMaskedLM,
BertForMultipleChoice,
BertForNextSentencePrediction,
BertForPreTraining,
BertForQuestionAnswering,
BertForSequenceClassification,
BertForTokenClassification,
BertLMHeadModel,
BertModel,
)
from transformers.models.bert_generation.modeling_bert_generation import BertGenerationDecoder, BertGenerationEncoder
from transformers.models.big_bird.modeling_big_bird import (
BigBirdForCausalLM,
BigBirdForMaskedLM,
BigBirdForMultipleChoice,
BigBirdForPreTraining,
BigBirdForQuestionAnswering,
BigBirdForSequenceClassification,
BigBirdForTokenClassification,
BigBirdModel,
)
from transformers.models.bigbird_pegasus.modeling_bigbird_pegasus import (
BigBirdPegasusForCausalLM,
BigBirdPegasusForConditionalGeneration,
BigBirdPegasusForQuestionAnswering,
BigBirdPegasusForSequenceClassification,
BigBirdPegasusModel,
)
from transformers.models.blenderbot.modeling_blenderbot import BlenderbotForCausalLM, BlenderbotForConditionalGeneration, BlenderbotModel
from transformers.models.blenderbot_small.modeling_blenderbot_small import (
BlenderbotSmallForCausalLM,
BlenderbotSmallForConditionalGeneration,
BlenderbotSmallModel,
)
from transformers.models.camembert.modeling_camembert import (
CamembertForCausalLM,
CamembertForMaskedLM,
CamembertForMultipleChoice,
CamembertForQuestionAnswering,
CamembertForSequenceClassification,
CamembertForTokenClassification,
CamembertModel,
)
from transformers.models.canine.modeling_canine import (
CanineForMultipleChoice,
CanineForQuestionAnswering,
CanineForSequenceClassification,
CanineForTokenClassification,
CanineModel,
)
from transformers.models.clip.modeling_clip import CLIPModel
from transformers.models.convbert.modeling_convbert import (
ConvBertForMaskedLM,
ConvBertForMultipleChoice,
ConvBertForQuestionAnswering,
ConvBertForSequenceClassification,
ConvBertForTokenClassification,
ConvBertModel,
)
from transformers.models.ctrl.modeling_ctrl import CTRLForSequenceClassification, CTRLLMHeadModel, CTRLModel
from transformers.models.deberta.modeling_deberta import (
DebertaForMaskedLM,
DebertaForQuestionAnswering,
DebertaForSequenceClassification,
DebertaForTokenClassification,
DebertaModel,
)
from transformers.models.deberta_v2.modeling_deberta_v2 import (
DebertaV2ForMaskedLM,
DebertaV2ForQuestionAnswering,
DebertaV2ForSequenceClassification,
DebertaV2ForTokenClassification,
DebertaV2Model,
)
from transformers.models.deit.modeling_deit import DeiTForImageClassification, DeiTForImageClassificationWithTeacher, DeiTModel
from transformers.models.detr.modeling_detr import DetrForObjectDetection, DetrModel
from transformers.models.distilbert.modeling_distilbert import (
DistilBertForMaskedLM,
DistilBertForMultipleChoice,
DistilBertForQuestionAnswering,
DistilBertForSequenceClassification,
DistilBertForTokenClassification,
DistilBertModel,
)
from transformers.models.dpr.modeling_dpr import DPRQuestionEncoder
from transformers.models.electra.modeling_electra import (
ElectraForMaskedLM,
ElectraForMultipleChoice,
ElectraForPreTraining,
ElectraForQuestionAnswering,
ElectraForSequenceClassification,
ElectraForTokenClassification,
ElectraModel,
)
from transformers.models.encoder_decoder.modeling_encoder_decoder import EncoderDecoderModel
from transformers.models.flaubert.modeling_flaubert import (
FlaubertForMultipleChoice,
FlaubertForQuestionAnsweringSimple,
FlaubertForSequenceClassification,
FlaubertForTokenClassification,
FlaubertModel,
FlaubertWithLMHeadModel,
)
from transformers.models.fsmt.modeling_fsmt import FSMTForConditionalGeneration, FSMTModel
from transformers.models.funnel.modeling_funnel import (
FunnelBaseModel,
FunnelForMaskedLM,
FunnelForMultipleChoice,
FunnelForPreTraining,
FunnelForQuestionAnswering,
FunnelForSequenceClassification,
FunnelForTokenClassification,
FunnelModel,
)
from transformers.models.gpt2.modeling_gpt2 import GPT2ForSequenceClassification, GPT2LMHeadModel, GPT2Model
from transformers.models.gpt_neo.modeling_gpt_neo import GPTNeoForCausalLM, GPTNeoForSequenceClassification, GPTNeoModel
from transformers.models.hubert.modeling_hubert import HubertModel
from transformers.models.ibert.modeling_ibert import (
IBertForMaskedLM,
IBertForMultipleChoice,
IBertForQuestionAnswering,
IBertForSequenceClassification,
IBertForTokenClassification,
IBertModel,
)
from transformers.models.layoutlm.modeling_layoutlm import (
LayoutLMForMaskedLM,
LayoutLMForSequenceClassification,
LayoutLMForTokenClassification,
LayoutLMModel,
)
from transformers.models.led.modeling_led import (
LEDForConditionalGeneration,
LEDForQuestionAnswering,
LEDForSequenceClassification,
LEDModel,
)
from transformers.models.longformer.modeling_longformer import (
LongformerForMaskedLM,
LongformerForMultipleChoice,
LongformerForQuestionAnswering,
LongformerForSequenceClassification,
LongformerForTokenClassification,
LongformerModel,
)
from transformers.models.luke.modeling_luke import LukeModel
from transformers.models.lxmert.modeling_lxmert import LxmertForPreTraining, LxmertForQuestionAnswering, LxmertModel
from transformers.models.m2m_100.modeling_m2m_100 import M2M100ForConditionalGeneration, M2M100Model
from transformers.models.marian.modeling_marian import MarianForCausalLM, MarianModel, MarianMTModel
from transformers.models.mbart.modeling_mbart import (
MBartForCausalLM,
MBartForConditionalGeneration,
MBartForQuestionAnswering,
MBartForSequenceClassification,
MBartModel,
)
from transformers.models.megatron_bert.modeling_megatron_bert import (
MegatronBertForCausalLM,
MegatronBertForMaskedLM,
MegatronBertForMultipleChoice,
MegatronBertForNextSentencePrediction,
MegatronBertForPreTraining,
MegatronBertForQuestionAnswering,
MegatronBertForSequenceClassification,
MegatronBertForTokenClassification,
MegatronBertModel,
)
from transformers.models.mobilebert.modeling_mobilebert import (
MobileBertForMaskedLM,
MobileBertForMultipleChoice,
MobileBertForNextSentencePrediction,
MobileBertForPreTraining,
MobileBertForQuestionAnswering,
MobileBertForSequenceClassification,
MobileBertForTokenClassification,
MobileBertModel,
)
from transformers.models.mpnet.modeling_mpnet import (
MPNetForMaskedLM,
MPNetForMultipleChoice,
MPNetForQuestionAnswering,
MPNetForSequenceClassification,
MPNetForTokenClassification,
MPNetModel,
)
from transformers.models.mt5.modeling_mt5 import MT5ForConditionalGeneration, MT5Model
from transformers.models.openai.modeling_openai import OpenAIGPTForSequenceClassification, OpenAIGPTLMHeadModel, OpenAIGPTModel
from transformers.models.pegasus.modeling_pegasus import PegasusForCausalLM, PegasusForConditionalGeneration, PegasusModel
from transformers.models.prophetnet.modeling_prophetnet import ProphetNetForCausalLM, ProphetNetForConditionalGeneration, ProphetNetModel
from transformers.models.rag.modeling_rag import ( # noqa: F401 - need to import all RagModels to be in globals() function
RagModel,
RagSequenceForGeneration,
RagTokenForGeneration,
)
from transformers.models.reformer.modeling_reformer import (
ReformerForMaskedLM,
ReformerForQuestionAnswering,
ReformerForSequenceClassification,
ReformerModel,
ReformerModelWithLMHead,
)
from transformers.models.retribert.modeling_retribert import RetriBertModel
from transformers.models.roberta.modeling_roberta import (
RobertaForCausalLM,
RobertaForMaskedLM,
RobertaForMultipleChoice,
RobertaForQuestionAnswering,
RobertaForSequenceClassification,
RobertaForTokenClassification,
RobertaModel,
)
from transformers.models.roformer.modeling_roformer import (
RoFormerForCausalLM,
RoFormerForMaskedLM,
RoFormerForMultipleChoice,
RoFormerForQuestionAnswering,
RoFormerForSequenceClassification,
RoFormerForTokenClassification,
RoFormerModel,
)
from transformers.models.speech_to_text.modeling_speech_to_text import Speech2TextForConditionalGeneration, Speech2TextModel
from transformers.models.squeezebert.modeling_squeezebert import (
SqueezeBertForMaskedLM,
SqueezeBertForMultipleChoice,
SqueezeBertForQuestionAnswering,
SqueezeBertForSequenceClassification,
SqueezeBertForTokenClassification,
SqueezeBertModel,
)
# Instead of loading the T5 from the transformers==4.9.1, we choose to load from our prefix-tuning version.
# from .modeling_t5_com import T5ForConditionalGeneration, T5Model
# from .modeling_t5_R import T5ForConditionalGeneration, T5Model
from .modeling_t5_128 import T5ForConditionalGeneration, T5Model
from transformers.models.tapas.modeling_tapas import (
TapasForMaskedLM,
TapasForQuestionAnswering,
TapasForSequenceClassification,
TapasModel,
)
from transformers.models.transfo_xl.modeling_transfo_xl import TransfoXLForSequenceClassification, TransfoXLLMHeadModel, TransfoXLModel
from transformers.models.visual_bert.modeling_visual_bert import VisualBertForPreTraining, VisualBertModel
from transformers.models.vit.modeling_vit import ViTForImageClassification, ViTModel
from transformers.models.wav2vec2.modeling_wav2vec2 import Wav2Vec2ForMaskedLM, Wav2Vec2ForPreTraining, Wav2Vec2Model
from transformers.models.xlm.modeling_xlm import (
XLMForMultipleChoice,
XLMForQuestionAnsweringSimple,
XLMForSequenceClassification,
XLMForTokenClassification,
XLMModel,
XLMWithLMHeadModel,
)
from transformers.models.xlm_prophetnet.modeling_xlm_prophetnet import (
XLMProphetNetForCausalLM,
XLMProphetNetForConditionalGeneration,
XLMProphetNetModel,
)
from transformers.models.xlm_roberta.modeling_xlm_roberta import (
XLMRobertaForCausalLM,
XLMRobertaForMaskedLM,
XLMRobertaForMultipleChoice,
XLMRobertaForQuestionAnswering,
XLMRobertaForSequenceClassification,
XLMRobertaForTokenClassification,
XLMRobertaModel,
)
from transformers.models.xlnet.modeling_xlnet import (
XLNetForMultipleChoice,
XLNetForQuestionAnsweringSimple,
XLNetForSequenceClassification,
XLNetForTokenClassification,
XLNetLMHeadModel,
XLNetModel,
)
from transformers.models.auto.auto_factory import _BaseAutoModelClass, auto_class_update
from transformers.models.auto.configuration_auto import (
AlbertConfig,
BartConfig,
BertConfig,
BertGenerationConfig,
BigBirdConfig,
BigBirdPegasusConfig,
BlenderbotConfig,
BlenderbotSmallConfig,
CamembertConfig,
CanineConfig,
CLIPConfig,
ConvBertConfig,
CTRLConfig,
DebertaConfig,
DebertaV2Config,
DeiTConfig,
DetrConfig,
DistilBertConfig,
DPRConfig,
ElectraConfig,
EncoderDecoderConfig,
FlaubertConfig,
FSMTConfig,
FunnelConfig,
GPT2Config,
GPTNeoConfig,
HubertConfig,
IBertConfig,
LayoutLMConfig,
LEDConfig,
LongformerConfig,
LukeConfig,
LxmertConfig,
M2M100Config,
MarianConfig,
MBartConfig,
MegatronBertConfig,
MobileBertConfig,
MPNetConfig,
MT5Config,
OpenAIGPTConfig,
PegasusConfig,
ProphetNetConfig,
ReformerConfig,
RetriBertConfig,
RobertaConfig,
RoFormerConfig,
Speech2TextConfig,
SqueezeBertConfig,
T5Config,
TapasConfig,
TransfoXLConfig,
VisualBertConfig,
ViTConfig,
Wav2Vec2Config,
XLMConfig,
XLMProphetNetConfig,
XLMRobertaConfig,
XLNetConfig,
)
logger = logging.get_logger(__name__)
MODEL_MAPPING = OrderedDict(
[
# Base model mapping
(VisualBertConfig, VisualBertModel),
(CanineConfig, CanineModel),
(RoFormerConfig, RoFormerModel),
(CLIPConfig, CLIPModel),
(BigBirdPegasusConfig, BigBirdPegasusModel),
(DeiTConfig, DeiTModel),
(LukeConfig, LukeModel),
(DetrConfig, DetrModel),
(GPTNeoConfig, GPTNeoModel),
(BigBirdConfig, BigBirdModel),
(Speech2TextConfig, Speech2TextModel),
(ViTConfig, ViTModel),
(Wav2Vec2Config, Wav2Vec2Model),
(HubertConfig, HubertModel),
(M2M100Config, M2M100Model),
(ConvBertConfig, ConvBertModel),
(LEDConfig, LEDModel),
(BlenderbotSmallConfig, BlenderbotSmallModel),
(RetriBertConfig, RetriBertModel),
(MT5Config, MT5Model),
(T5Config, T5Model),
(PegasusConfig, PegasusModel),
(MarianConfig, MarianMTModel),
(MBartConfig, MBartModel),
(BlenderbotConfig, BlenderbotModel),
(DistilBertConfig, DistilBertModel),
(AlbertConfig, AlbertModel),
(CamembertConfig, CamembertModel),
(XLMRobertaConfig, XLMRobertaModel),
(BartConfig, BartModel),
(LongformerConfig, LongformerModel),
(RobertaConfig, RobertaModel),
(LayoutLMConfig, LayoutLMModel),
(SqueezeBertConfig, SqueezeBertModel),
(BertConfig, BertModel),
(OpenAIGPTConfig, OpenAIGPTModel),
(GPT2Config, GPT2Model),
(MegatronBertConfig, MegatronBertModel),
(MobileBertConfig, MobileBertModel),
(TransfoXLConfig, TransfoXLModel),
(XLNetConfig, XLNetModel),
(FlaubertConfig, FlaubertModel),
(FSMTConfig, FSMTModel),
(XLMConfig, XLMModel),
(CTRLConfig, CTRLModel),
(ElectraConfig, ElectraModel),
(ReformerConfig, ReformerModel),
(FunnelConfig, (FunnelModel, FunnelBaseModel)),
(LxmertConfig, LxmertModel),
(BertGenerationConfig, BertGenerationEncoder),
(DebertaConfig, DebertaModel),
(DebertaV2Config, DebertaV2Model),
(DPRConfig, DPRQuestionEncoder),
(XLMProphetNetConfig, XLMProphetNetModel),
(ProphetNetConfig, ProphetNetModel),
(MPNetConfig, MPNetModel),
(TapasConfig, TapasModel),
(MarianConfig, MarianModel),
(IBertConfig, IBertModel),
]
)
MODEL_FOR_PRETRAINING_MAPPING = OrderedDict(
[
# Model for pre-training mapping
(VisualBertConfig, VisualBertForPreTraining),
(LayoutLMConfig, LayoutLMForMaskedLM),
(RetriBertConfig, RetriBertModel),
(T5Config, T5ForConditionalGeneration),
(DistilBertConfig, DistilBertForMaskedLM),
(AlbertConfig, AlbertForPreTraining),
(CamembertConfig, CamembertForMaskedLM),
(XLMRobertaConfig, XLMRobertaForMaskedLM),
(BartConfig, BartForConditionalGeneration),
(FSMTConfig, FSMTForConditionalGeneration),
(LongformerConfig, LongformerForMaskedLM),
(RobertaConfig, RobertaForMaskedLM),
(SqueezeBertConfig, SqueezeBertForMaskedLM),
(BertConfig, BertForPreTraining),
(BigBirdConfig, BigBirdForPreTraining),
(OpenAIGPTConfig, OpenAIGPTLMHeadModel),
(GPT2Config, GPT2LMHeadModel),
(MegatronBertConfig, MegatronBertForPreTraining),
(MobileBertConfig, MobileBertForPreTraining),
(TransfoXLConfig, TransfoXLLMHeadModel),
(XLNetConfig, XLNetLMHeadModel),
(FlaubertConfig, FlaubertWithLMHeadModel),
(XLMConfig, XLMWithLMHeadModel),
(CTRLConfig, CTRLLMHeadModel),
(ElectraConfig, ElectraForPreTraining),
(LxmertConfig, LxmertForPreTraining),
(FunnelConfig, FunnelForPreTraining),
(MPNetConfig, MPNetForMaskedLM),
(TapasConfig, TapasForMaskedLM),
(IBertConfig, IBertForMaskedLM),
(DebertaConfig, DebertaForMaskedLM),
(DebertaV2Config, DebertaV2ForMaskedLM),
(Wav2Vec2Config, Wav2Vec2ForPreTraining),
]
)
MODEL_WITH_LM_HEAD_MAPPING = OrderedDict(
[
# Model with LM heads mapping
(RoFormerConfig, RoFormerForMaskedLM),
(BigBirdPegasusConfig, BigBirdPegasusForConditionalGeneration),
(GPTNeoConfig, GPTNeoForCausalLM),
(BigBirdConfig, BigBirdForMaskedLM),
(Speech2TextConfig, Speech2TextForConditionalGeneration),
(Wav2Vec2Config, Wav2Vec2ForMaskedLM),
(M2M100Config, M2M100ForConditionalGeneration),
(ConvBertConfig, ConvBertForMaskedLM),
(LEDConfig, LEDForConditionalGeneration),
(BlenderbotSmallConfig, BlenderbotSmallForConditionalGeneration),
(LayoutLMConfig, LayoutLMForMaskedLM),
(T5Config, T5ForConditionalGeneration),
(DistilBertConfig, DistilBertForMaskedLM),
(AlbertConfig, AlbertForMaskedLM),
(CamembertConfig, CamembertForMaskedLM),
(XLMRobertaConfig, XLMRobertaForMaskedLM),
(MarianConfig, MarianMTModel),
(FSMTConfig, FSMTForConditionalGeneration),
(BartConfig, BartForConditionalGeneration),
(LongformerConfig, LongformerForMaskedLM),
(RobertaConfig, RobertaForMaskedLM),
(SqueezeBertConfig, SqueezeBertForMaskedLM),
(BertConfig, BertForMaskedLM),
(OpenAIGPTConfig, OpenAIGPTLMHeadModel),
(GPT2Config, GPT2LMHeadModel),
(MegatronBertConfig, MegatronBertForMaskedLM),
(MobileBertConfig, MobileBertForMaskedLM),
(TransfoXLConfig, TransfoXLLMHeadModel),
(XLNetConfig, XLNetLMHeadModel),
(FlaubertConfig, FlaubertWithLMHeadModel),
(XLMConfig, XLMWithLMHeadModel),
(CTRLConfig, CTRLLMHeadModel),
(ElectraConfig, ElectraForMaskedLM),
(EncoderDecoderConfig, EncoderDecoderModel),
(ReformerConfig, ReformerModelWithLMHead),
(FunnelConfig, FunnelForMaskedLM),
(MPNetConfig, MPNetForMaskedLM),
(TapasConfig, TapasForMaskedLM),
(DebertaConfig, DebertaForMaskedLM),
(DebertaV2Config, DebertaV2ForMaskedLM),
(IBertConfig, IBertForMaskedLM),
(MegatronBertConfig, MegatronBertForCausalLM),
]
)
MODEL_FOR_CAUSAL_LM_MAPPING = OrderedDict(
[
# Model for Causal LM mapping
(RoFormerConfig, RoFormerForCausalLM),
(BigBirdPegasusConfig, BigBirdPegasusForCausalLM),
(GPTNeoConfig, GPTNeoForCausalLM),
(BigBirdConfig, BigBirdForCausalLM),
(CamembertConfig, CamembertForCausalLM),
(XLMRobertaConfig, XLMRobertaForCausalLM),
(RobertaConfig, RobertaForCausalLM),
(BertConfig, BertLMHeadModel),
(OpenAIGPTConfig, OpenAIGPTLMHeadModel),
(GPT2Config, GPT2LMHeadModel),
(TransfoXLConfig, TransfoXLLMHeadModel),
(XLNetConfig, XLNetLMHeadModel),
(
XLMConfig,
XLMWithLMHeadModel,
), # XLM can be MLM and CLM => model should be split similar to BERT; leave here for now
(CTRLConfig, CTRLLMHeadModel),
(ReformerConfig, ReformerModelWithLMHead),
(BertGenerationConfig, BertGenerationDecoder),
(XLMProphetNetConfig, XLMProphetNetForCausalLM),
(ProphetNetConfig, ProphetNetForCausalLM),
(BartConfig, BartForCausalLM),
(MBartConfig, MBartForCausalLM),
(PegasusConfig, PegasusForCausalLM),
(MarianConfig, MarianForCausalLM),
(BlenderbotConfig, BlenderbotForCausalLM),
(BlenderbotSmallConfig, BlenderbotSmallForCausalLM),
(MegatronBertConfig, MegatronBertForCausalLM),
]
)
MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING = OrderedDict(
[
# Model for Image Classification mapping
(ViTConfig, ViTForImageClassification),
(DeiTConfig, (DeiTForImageClassification, DeiTForImageClassificationWithTeacher)),
]
)
MODEL_FOR_MASKED_LM_MAPPING = OrderedDict(
[
# Model for Masked LM mapping
(RoFormerConfig, RoFormerForMaskedLM),
(BigBirdConfig, BigBirdForMaskedLM),
(Wav2Vec2Config, Wav2Vec2ForMaskedLM),
(ConvBertConfig, ConvBertForMaskedLM),
(LayoutLMConfig, LayoutLMForMaskedLM),
(DistilBertConfig, DistilBertForMaskedLM),
(AlbertConfig, AlbertForMaskedLM),
(BartConfig, BartForConditionalGeneration),
(MBartConfig, MBartForConditionalGeneration),
(CamembertConfig, CamembertForMaskedLM),
(XLMRobertaConfig, XLMRobertaForMaskedLM),
(LongformerConfig, LongformerForMaskedLM),
(RobertaConfig, RobertaForMaskedLM),
(SqueezeBertConfig, SqueezeBertForMaskedLM),
(BertConfig, BertForMaskedLM),
(MegatronBertConfig, MegatronBertForMaskedLM),
(MobileBertConfig, MobileBertForMaskedLM),
(FlaubertConfig, FlaubertWithLMHeadModel),
(XLMConfig, XLMWithLMHeadModel),
(ElectraConfig, ElectraForMaskedLM),
(ReformerConfig, ReformerForMaskedLM),
(FunnelConfig, FunnelForMaskedLM),
(MPNetConfig, MPNetForMaskedLM),
(TapasConfig, TapasForMaskedLM),
(DebertaConfig, DebertaForMaskedLM),
(DebertaV2Config, DebertaV2ForMaskedLM),
(IBertConfig, IBertForMaskedLM),
]
)
MODEL_FOR_OBJECT_DETECTION_MAPPING = OrderedDict(
[
# Model for Object Detection mapping
(DetrConfig, DetrForObjectDetection),
]
)
MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING = OrderedDict(
[
# Model for Seq2Seq Causal LM mapping
(BigBirdPegasusConfig, BigBirdPegasusForConditionalGeneration),
(M2M100Config, M2M100ForConditionalGeneration),
(LEDConfig, LEDForConditionalGeneration),
(BlenderbotSmallConfig, BlenderbotSmallForConditionalGeneration),
(MT5Config, MT5ForConditionalGeneration),
(T5Config, T5ForConditionalGeneration),
(PegasusConfig, PegasusForConditionalGeneration),
(MarianConfig, MarianMTModel),
(MBartConfig, MBartForConditionalGeneration),
(BlenderbotConfig, BlenderbotForConditionalGeneration),
(BartConfig, BartForConditionalGeneration),
(FSMTConfig, FSMTForConditionalGeneration),
(EncoderDecoderConfig, EncoderDecoderModel),
(XLMProphetNetConfig, XLMProphetNetForConditionalGeneration),
(ProphetNetConfig, ProphetNetForConditionalGeneration),
]
)
MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING = OrderedDict(
[
# Model for Sequence Classification mapping
(CanineConfig, CanineForSequenceClassification),
(RoFormerConfig, RoFormerForSequenceClassification),
(BigBirdPegasusConfig, BigBirdPegasusForSequenceClassification),
(BigBirdConfig, BigBirdForSequenceClassification),
(ConvBertConfig, ConvBertForSequenceClassification),
(LEDConfig, LEDForSequenceClassification),
(DistilBertConfig, DistilBertForSequenceClassification),
(AlbertConfig, AlbertForSequenceClassification),
(CamembertConfig, CamembertForSequenceClassification),
(XLMRobertaConfig, XLMRobertaForSequenceClassification),
(MBartConfig, MBartForSequenceClassification),
(BartConfig, BartForSequenceClassification),
(LongformerConfig, LongformerForSequenceClassification),
(RobertaConfig, RobertaForSequenceClassification),
(SqueezeBertConfig, SqueezeBertForSequenceClassification),
(LayoutLMConfig, LayoutLMForSequenceClassification),
(BertConfig, BertForSequenceClassification),
(XLNetConfig, XLNetForSequenceClassification),
(MegatronBertConfig, MegatronBertForSequenceClassification),
(MobileBertConfig, MobileBertForSequenceClassification),
(FlaubertConfig, FlaubertForSequenceClassification),
(XLMConfig, XLMForSequenceClassification),
(ElectraConfig, ElectraForSequenceClassification),
(FunnelConfig, FunnelForSequenceClassification),
(DebertaConfig, DebertaForSequenceClassification),
(DebertaV2Config, DebertaV2ForSequenceClassification),
(GPT2Config, GPT2ForSequenceClassification),
(GPTNeoConfig, GPTNeoForSequenceClassification),
(OpenAIGPTConfig, OpenAIGPTForSequenceClassification),
(ReformerConfig, ReformerForSequenceClassification),
(CTRLConfig, CTRLForSequenceClassification),
(TransfoXLConfig, TransfoXLForSequenceClassification),
(MPNetConfig, MPNetForSequenceClassification),
(TapasConfig, TapasForSequenceClassification),
(IBertConfig, IBertForSequenceClassification),
]
)
MODEL_FOR_QUESTION_ANSWERING_MAPPING = OrderedDict(
[
# Model for Question Answering mapping
(CanineConfig, CanineForQuestionAnswering),
(RoFormerConfig, RoFormerForQuestionAnswering),
(BigBirdPegasusConfig, BigBirdPegasusForQuestionAnswering),
(BigBirdConfig, BigBirdForQuestionAnswering),
(ConvBertConfig, ConvBertForQuestionAnswering),
(LEDConfig, LEDForQuestionAnswering),
(DistilBertConfig, DistilBertForQuestionAnswering),
(AlbertConfig, AlbertForQuestionAnswering),
(CamembertConfig, CamembertForQuestionAnswering),
(BartConfig, BartForQuestionAnswering),
(MBartConfig, MBartForQuestionAnswering),
(LongformerConfig, LongformerForQuestionAnswering),
(XLMRobertaConfig, XLMRobertaForQuestionAnswering),
(RobertaConfig, RobertaForQuestionAnswering),
(SqueezeBertConfig, SqueezeBertForQuestionAnswering),
(BertConfig, BertForQuestionAnswering),
(XLNetConfig, XLNetForQuestionAnsweringSimple),
(FlaubertConfig, FlaubertForQuestionAnsweringSimple),
(MegatronBertConfig, MegatronBertForQuestionAnswering),
(MobileBertConfig, MobileBertForQuestionAnswering),
(XLMConfig, XLMForQuestionAnsweringSimple),
(ElectraConfig, ElectraForQuestionAnswering),
(ReformerConfig, ReformerForQuestionAnswering),
(FunnelConfig, FunnelForQuestionAnswering),
(LxmertConfig, LxmertForQuestionAnswering),
(MPNetConfig, MPNetForQuestionAnswering),
(DebertaConfig, DebertaForQuestionAnswering),
(DebertaV2Config, DebertaV2ForQuestionAnswering),
(IBertConfig, IBertForQuestionAnswering),
]
)
MODEL_FOR_TABLE_QUESTION_ANSWERING_MAPPING = OrderedDict(
[
# Model for Table Question Answering mapping
(TapasConfig, TapasForQuestionAnswering),
]
)
MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING = OrderedDict(
[
# Model for Token Classification mapping
(CanineConfig, CanineForTokenClassification),
(RoFormerConfig, RoFormerForTokenClassification),
(BigBirdConfig, BigBirdForTokenClassification),
(ConvBertConfig, ConvBertForTokenClassification),
(LayoutLMConfig, LayoutLMForTokenClassification),
(DistilBertConfig, DistilBertForTokenClassification),
(CamembertConfig, CamembertForTokenClassification),
(FlaubertConfig, FlaubertForTokenClassification),
(XLMConfig, XLMForTokenClassification),
(XLMRobertaConfig, XLMRobertaForTokenClassification),
(LongformerConfig, LongformerForTokenClassification),
(RobertaConfig, RobertaForTokenClassification),
(SqueezeBertConfig, SqueezeBertForTokenClassification),
(BertConfig, BertForTokenClassification),
(MegatronBertConfig, MegatronBertForTokenClassification),
(MobileBertConfig, MobileBertForTokenClassification),
(XLNetConfig, XLNetForTokenClassification),
(AlbertConfig, AlbertForTokenClassification),
(ElectraConfig, ElectraForTokenClassification),
(FlaubertConfig, FlaubertForTokenClassification),
(FunnelConfig, FunnelForTokenClassification),
(MPNetConfig, MPNetForTokenClassification),
(DebertaConfig, DebertaForTokenClassification),
(DebertaV2Config, DebertaV2ForTokenClassification),
(IBertConfig, IBertForTokenClassification),
]
)
MODEL_FOR_MULTIPLE_CHOICE_MAPPING = OrderedDict(
[
# Model for Multiple Choice mapping
(CanineConfig, CanineForMultipleChoice),
(RoFormerConfig, RoFormerForMultipleChoice),
(BigBirdConfig, BigBirdForMultipleChoice),
(ConvBertConfig, ConvBertForMultipleChoice),
(CamembertConfig, CamembertForMultipleChoice),
(ElectraConfig, ElectraForMultipleChoice),
(XLMRobertaConfig, XLMRobertaForMultipleChoice),
(LongformerConfig, LongformerForMultipleChoice),
(RobertaConfig, RobertaForMultipleChoice),
(SqueezeBertConfig, SqueezeBertForMultipleChoice),
(BertConfig, BertForMultipleChoice),
(DistilBertConfig, DistilBertForMultipleChoice),
(MegatronBertConfig, MegatronBertForMultipleChoice),
(MobileBertConfig, MobileBertForMultipleChoice),
(XLNetConfig, XLNetForMultipleChoice),
(AlbertConfig, AlbertForMultipleChoice),
(XLMConfig, XLMForMultipleChoice),
(FlaubertConfig, FlaubertForMultipleChoice),
(FunnelConfig, FunnelForMultipleChoice),
(MPNetConfig, MPNetForMultipleChoice),
(IBertConfig, IBertForMultipleChoice),
]
)
MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING = OrderedDict(
[
(BertConfig, BertForNextSentencePrediction),
(MegatronBertConfig, MegatronBertForNextSentencePrediction),
(MobileBertConfig, MobileBertForNextSentencePrediction),
]
)
class AutoModel(_BaseAutoModelClass):
_model_mapping = MODEL_MAPPING
AutoModel = auto_class_update(AutoModel)
class AutoModelForPreTraining(_BaseAutoModelClass):
_model_mapping = MODEL_FOR_PRETRAINING_MAPPING
AutoModelForPreTraining = auto_class_update(AutoModelForPreTraining, head_doc="pretraining")
# Private on purpose, the public class will add the deprecation warnings.
class _AutoModelWithLMHead(_BaseAutoModelClass):
_model_mapping = MODEL_WITH_LM_HEAD_MAPPING
_AutoModelWithLMHead = auto_class_update(_AutoModelWithLMHead, head_doc="language modeling")
class AutoModelForCausalLM(_BaseAutoModelClass):
_model_mapping = MODEL_FOR_CAUSAL_LM_MAPPING
AutoModelForCausalLM = auto_class_update(AutoModelForCausalLM, head_doc="causal language modeling")
class AutoModelForMaskedLM(_BaseAutoModelClass):
_model_mapping = MODEL_FOR_MASKED_LM_MAPPING
AutoModelForMaskedLM = auto_class_update(AutoModelForMaskedLM, head_doc="masked language modeling")
class AutoModelForSeq2SeqLM(_BaseAutoModelClass):
_model_mapping = MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING
AutoModelForSeq2SeqLM = auto_class_update(
AutoModelForSeq2SeqLM, head_doc="sequence-to-sequence language modeling", checkpoint_for_example="t5-base"
)
class AutoModelForSequenceClassification(_BaseAutoModelClass):
_model_mapping = MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING
AutoModelForSequenceClassification = auto_class_update(
AutoModelForSequenceClassification, head_doc="sequence classification"
)
class AutoModelForQuestionAnswering(_BaseAutoModelClass):
_model_mapping = MODEL_FOR_QUESTION_ANSWERING_MAPPING
AutoModelForQuestionAnswering = auto_class_update(AutoModelForQuestionAnswering, head_doc="question answering")
class AutoModelForTableQuestionAnswering(_BaseAutoModelClass):
_model_mapping = MODEL_FOR_TABLE_QUESTION_ANSWERING_MAPPING
AutoModelForTableQuestionAnswering = auto_class_update(
AutoModelForTableQuestionAnswering,
head_doc="table question answering",
checkpoint_for_example="google/tapas-base-finetuned-wtq",
)
class AutoModelForTokenClassification(_BaseAutoModelClass):
_model_mapping = MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING
AutoModelForTokenClassification = auto_class_update(AutoModelForTokenClassification, head_doc="token classification")
class AutoModelForMultipleChoice(_BaseAutoModelClass):
_model_mapping = MODEL_FOR_MULTIPLE_CHOICE_MAPPING
AutoModelForMultipleChoice = auto_class_update(AutoModelForMultipleChoice, head_doc="multiple choice")
class AutoModelForNextSentencePrediction(_BaseAutoModelClass):
_model_mapping = MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING
AutoModelForNextSentencePrediction = auto_class_update(
AutoModelForNextSentencePrediction, head_doc="next sentence prediction"
)
class AutoModelForImageClassification(_BaseAutoModelClass):
_model_mapping = MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING
AutoModelForImageClassification = auto_class_update(AutoModelForImageClassification, head_doc="image classification")
class AutoModelWithLMHead(_AutoModelWithLMHead):
@classmethod
def from_config(cls, config):
warnings.warn(
"The class `AutoModelWithLMHead` is deprecated and will be removed in a future version. Please use "
"`AutoModelForCausalLM` for causal language models, `AutoModelForMaskedLM` for masked language models and "
"`AutoModelForSeq2SeqLM` for encoder-decoder models.",
FutureWarning,
)
return super().from_config(config)
@classmethod
def from_pretrained(cls, pretrained_model_name_or_path, *model_args, **kwargs):
warnings.warn(
"The class `AutoModelWithLMHead` is deprecated and will be removed in a future version. Please use "
"`AutoModelForCausalLM` for causal language models, `AutoModelForMaskedLM` for masked language models and "
"`AutoModelForSeq2SeqLM` for encoder-decoder models.",
FutureWarning,
)
return super().from_pretrained(pretrained_model_name_or_path, *model_args, **kwargs)
| [] |
2024-01-10 | Xin-Zhou-smu/DAMO-ConvAI | bird~finetuning~models~Grapater~modeling_auto_512_elu_res.py | # coding=utf-8
# Copyright 2018 The HuggingFace Inc. team.
#
# 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.
""" Auto Model class. """
import warnings
from collections import OrderedDict
from transformers.utils import logging
# Add modeling imports here
from transformers.models.albert.modeling_albert import (
AlbertForMaskedLM,
AlbertForMultipleChoice,
AlbertForPreTraining,
AlbertForQuestionAnswering,
AlbertForSequenceClassification,
AlbertForTokenClassification,
AlbertModel,
)
# Instead of loading the BART from the transformers==4.9.1, we choose to load from our own prefix-tuning version.
# from .modeling_bart import (
# BartForConditionalGeneration,
# BartModel,
# )
from transformers.models.bart.modeling_bart import (
BartForCausalLM,
BartForQuestionAnswering,
BartForSequenceClassification,
BartForConditionalGeneration,
BartModel
)
from transformers.models.bert.modeling_bert import (
BertForMaskedLM,
BertForMultipleChoice,
BertForNextSentencePrediction,
BertForPreTraining,
BertForQuestionAnswering,
BertForSequenceClassification,
BertForTokenClassification,
BertLMHeadModel,
BertModel,
)
from transformers.models.bert_generation.modeling_bert_generation import BertGenerationDecoder, BertGenerationEncoder
from transformers.models.big_bird.modeling_big_bird import (
BigBirdForCausalLM,
BigBirdForMaskedLM,
BigBirdForMultipleChoice,
BigBirdForPreTraining,
BigBirdForQuestionAnswering,
BigBirdForSequenceClassification,
BigBirdForTokenClassification,
BigBirdModel,
)
from transformers.models.bigbird_pegasus.modeling_bigbird_pegasus import (
BigBirdPegasusForCausalLM,
BigBirdPegasusForConditionalGeneration,
BigBirdPegasusForQuestionAnswering,
BigBirdPegasusForSequenceClassification,
BigBirdPegasusModel,
)
from transformers.models.blenderbot.modeling_blenderbot import BlenderbotForCausalLM, BlenderbotForConditionalGeneration, BlenderbotModel
from transformers.models.blenderbot_small.modeling_blenderbot_small import (
BlenderbotSmallForCausalLM,
BlenderbotSmallForConditionalGeneration,
BlenderbotSmallModel,
)
from transformers.models.camembert.modeling_camembert import (
CamembertForCausalLM,
CamembertForMaskedLM,
CamembertForMultipleChoice,
CamembertForQuestionAnswering,
CamembertForSequenceClassification,
CamembertForTokenClassification,
CamembertModel,
)
from transformers.models.canine.modeling_canine import (
CanineForMultipleChoice,
CanineForQuestionAnswering,
CanineForSequenceClassification,
CanineForTokenClassification,
CanineModel,
)
from transformers.models.clip.modeling_clip import CLIPModel
from transformers.models.convbert.modeling_convbert import (
ConvBertForMaskedLM,
ConvBertForMultipleChoice,
ConvBertForQuestionAnswering,
ConvBertForSequenceClassification,
ConvBertForTokenClassification,
ConvBertModel,
)
from transformers.models.ctrl.modeling_ctrl import CTRLForSequenceClassification, CTRLLMHeadModel, CTRLModel
from transformers.models.deberta.modeling_deberta import (
DebertaForMaskedLM,
DebertaForQuestionAnswering,
DebertaForSequenceClassification,
DebertaForTokenClassification,
DebertaModel,
)
from transformers.models.deberta_v2.modeling_deberta_v2 import (
DebertaV2ForMaskedLM,
DebertaV2ForQuestionAnswering,
DebertaV2ForSequenceClassification,
DebertaV2ForTokenClassification,
DebertaV2Model,
)
from transformers.models.deit.modeling_deit import DeiTForImageClassification, DeiTForImageClassificationWithTeacher, DeiTModel
from transformers.models.detr.modeling_detr import DetrForObjectDetection, DetrModel
from transformers.models.distilbert.modeling_distilbert import (
DistilBertForMaskedLM,
DistilBertForMultipleChoice,
DistilBertForQuestionAnswering,
DistilBertForSequenceClassification,
DistilBertForTokenClassification,
DistilBertModel,
)
from transformers.models.dpr.modeling_dpr import DPRQuestionEncoder
from transformers.models.electra.modeling_electra import (
ElectraForMaskedLM,
ElectraForMultipleChoice,
ElectraForPreTraining,
ElectraForQuestionAnswering,
ElectraForSequenceClassification,
ElectraForTokenClassification,
ElectraModel,
)
from transformers.models.encoder_decoder.modeling_encoder_decoder import EncoderDecoderModel
from transformers.models.flaubert.modeling_flaubert import (
FlaubertForMultipleChoice,
FlaubertForQuestionAnsweringSimple,
FlaubertForSequenceClassification,
FlaubertForTokenClassification,
FlaubertModel,
FlaubertWithLMHeadModel,
)
from transformers.models.fsmt.modeling_fsmt import FSMTForConditionalGeneration, FSMTModel
from transformers.models.funnel.modeling_funnel import (
FunnelBaseModel,
FunnelForMaskedLM,
FunnelForMultipleChoice,
FunnelForPreTraining,
FunnelForQuestionAnswering,
FunnelForSequenceClassification,
FunnelForTokenClassification,
FunnelModel,
)
from transformers.models.gpt2.modeling_gpt2 import GPT2ForSequenceClassification, GPT2LMHeadModel, GPT2Model
from transformers.models.gpt_neo.modeling_gpt_neo import GPTNeoForCausalLM, GPTNeoForSequenceClassification, GPTNeoModel
from transformers.models.hubert.modeling_hubert import HubertModel
from transformers.models.ibert.modeling_ibert import (
IBertForMaskedLM,
IBertForMultipleChoice,
IBertForQuestionAnswering,
IBertForSequenceClassification,
IBertForTokenClassification,
IBertModel,
)
from transformers.models.layoutlm.modeling_layoutlm import (
LayoutLMForMaskedLM,
LayoutLMForSequenceClassification,
LayoutLMForTokenClassification,
LayoutLMModel,
)
from transformers.models.led.modeling_led import (
LEDForConditionalGeneration,
LEDForQuestionAnswering,
LEDForSequenceClassification,
LEDModel,
)
from transformers.models.longformer.modeling_longformer import (
LongformerForMaskedLM,
LongformerForMultipleChoice,
LongformerForQuestionAnswering,
LongformerForSequenceClassification,
LongformerForTokenClassification,
LongformerModel,
)
from transformers.models.luke.modeling_luke import LukeModel
from transformers.models.lxmert.modeling_lxmert import LxmertForPreTraining, LxmertForQuestionAnswering, LxmertModel
from transformers.models.m2m_100.modeling_m2m_100 import M2M100ForConditionalGeneration, M2M100Model
from transformers.models.marian.modeling_marian import MarianForCausalLM, MarianModel, MarianMTModel
from transformers.models.mbart.modeling_mbart import (
MBartForCausalLM,
MBartForConditionalGeneration,
MBartForQuestionAnswering,
MBartForSequenceClassification,
MBartModel,
)
from transformers.models.megatron_bert.modeling_megatron_bert import (
MegatronBertForCausalLM,
MegatronBertForMaskedLM,
MegatronBertForMultipleChoice,
MegatronBertForNextSentencePrediction,
MegatronBertForPreTraining,
MegatronBertForQuestionAnswering,
MegatronBertForSequenceClassification,
MegatronBertForTokenClassification,
MegatronBertModel,
)
from transformers.models.mobilebert.modeling_mobilebert import (
MobileBertForMaskedLM,
MobileBertForMultipleChoice,
MobileBertForNextSentencePrediction,
MobileBertForPreTraining,
MobileBertForQuestionAnswering,
MobileBertForSequenceClassification,
MobileBertForTokenClassification,
MobileBertModel,
)
from transformers.models.mpnet.modeling_mpnet import (
MPNetForMaskedLM,
MPNetForMultipleChoice,
MPNetForQuestionAnswering,
MPNetForSequenceClassification,
MPNetForTokenClassification,
MPNetModel,
)
from transformers.models.mt5.modeling_mt5 import MT5ForConditionalGeneration, MT5Model
from transformers.models.openai.modeling_openai import OpenAIGPTForSequenceClassification, OpenAIGPTLMHeadModel, OpenAIGPTModel
from transformers.models.pegasus.modeling_pegasus import PegasusForCausalLM, PegasusForConditionalGeneration, PegasusModel
from transformers.models.prophetnet.modeling_prophetnet import ProphetNetForCausalLM, ProphetNetForConditionalGeneration, ProphetNetModel
from transformers.models.rag.modeling_rag import ( # noqa: F401 - need to import all RagModels to be in globals() function
RagModel,
RagSequenceForGeneration,
RagTokenForGeneration,
)
from transformers.models.reformer.modeling_reformer import (
ReformerForMaskedLM,
ReformerForQuestionAnswering,
ReformerForSequenceClassification,
ReformerModel,
ReformerModelWithLMHead,
)
from transformers.models.retribert.modeling_retribert import RetriBertModel
from transformers.models.roberta.modeling_roberta import (
RobertaForCausalLM,
RobertaForMaskedLM,
RobertaForMultipleChoice,
RobertaForQuestionAnswering,
RobertaForSequenceClassification,
RobertaForTokenClassification,
RobertaModel,
)
from transformers.models.roformer.modeling_roformer import (
RoFormerForCausalLM,
RoFormerForMaskedLM,
RoFormerForMultipleChoice,
RoFormerForQuestionAnswering,
RoFormerForSequenceClassification,
RoFormerForTokenClassification,
RoFormerModel,
)
from transformers.models.speech_to_text.modeling_speech_to_text import Speech2TextForConditionalGeneration, Speech2TextModel
from transformers.models.squeezebert.modeling_squeezebert import (
SqueezeBertForMaskedLM,
SqueezeBertForMultipleChoice,
SqueezeBertForQuestionAnswering,
SqueezeBertForSequenceClassification,
SqueezeBertForTokenClassification,
SqueezeBertModel,
)
# Instead of loading the T5 from the transformers==4.9.1, we choose to load from our prefix-tuning version.
# from .modeling_t5_com import T5ForConditionalGeneration, T5Model
# from .modeling_t5_R import T5ForConditionalGeneration, T5Model
from .modeling_t5_512_elu import T5ForConditionalGeneration, T5Model
from transformers.models.tapas.modeling_tapas import (
TapasForMaskedLM,
TapasForQuestionAnswering,
TapasForSequenceClassification,
TapasModel,
)
from transformers.models.transfo_xl.modeling_transfo_xl import TransfoXLForSequenceClassification, TransfoXLLMHeadModel, TransfoXLModel
from transformers.models.visual_bert.modeling_visual_bert import VisualBertForPreTraining, VisualBertModel
from transformers.models.vit.modeling_vit import ViTForImageClassification, ViTModel
from transformers.models.wav2vec2.modeling_wav2vec2 import Wav2Vec2ForMaskedLM, Wav2Vec2ForPreTraining, Wav2Vec2Model
from transformers.models.xlm.modeling_xlm import (
XLMForMultipleChoice,
XLMForQuestionAnsweringSimple,
XLMForSequenceClassification,
XLMForTokenClassification,
XLMModel,
XLMWithLMHeadModel,
)
from transformers.models.xlm_prophetnet.modeling_xlm_prophetnet import (
XLMProphetNetForCausalLM,
XLMProphetNetForConditionalGeneration,
XLMProphetNetModel,
)
from transformers.models.xlm_roberta.modeling_xlm_roberta import (
XLMRobertaForCausalLM,
XLMRobertaForMaskedLM,
XLMRobertaForMultipleChoice,
XLMRobertaForQuestionAnswering,
XLMRobertaForSequenceClassification,
XLMRobertaForTokenClassification,
XLMRobertaModel,
)
from transformers.models.xlnet.modeling_xlnet import (
XLNetForMultipleChoice,
XLNetForQuestionAnsweringSimple,
XLNetForSequenceClassification,
XLNetForTokenClassification,
XLNetLMHeadModel,
XLNetModel,
)
from transformers.models.auto.auto_factory import _BaseAutoModelClass, auto_class_update
from transformers.models.auto.configuration_auto import (
AlbertConfig,
BartConfig,
BertConfig,
BertGenerationConfig,
BigBirdConfig,
BigBirdPegasusConfig,
BlenderbotConfig,
BlenderbotSmallConfig,
CamembertConfig,
CanineConfig,
CLIPConfig,
ConvBertConfig,
CTRLConfig,
DebertaConfig,
DebertaV2Config,
DeiTConfig,
DetrConfig,
DistilBertConfig,
DPRConfig,
ElectraConfig,
EncoderDecoderConfig,
FlaubertConfig,
FSMTConfig,
FunnelConfig,
GPT2Config,
GPTNeoConfig,
HubertConfig,
IBertConfig,
LayoutLMConfig,
LEDConfig,
LongformerConfig,
LukeConfig,
LxmertConfig,
M2M100Config,
MarianConfig,
MBartConfig,
MegatronBertConfig,
MobileBertConfig,
MPNetConfig,
MT5Config,
OpenAIGPTConfig,
PegasusConfig,
ProphetNetConfig,
ReformerConfig,
RetriBertConfig,
RobertaConfig,
RoFormerConfig,
Speech2TextConfig,
SqueezeBertConfig,
T5Config,
TapasConfig,
TransfoXLConfig,
VisualBertConfig,
ViTConfig,
Wav2Vec2Config,
XLMConfig,
XLMProphetNetConfig,
XLMRobertaConfig,
XLNetConfig,
)
logger = logging.get_logger(__name__)
MODEL_MAPPING = OrderedDict(
[
# Base model mapping
(VisualBertConfig, VisualBertModel),
(CanineConfig, CanineModel),
(RoFormerConfig, RoFormerModel),
(CLIPConfig, CLIPModel),
(BigBirdPegasusConfig, BigBirdPegasusModel),
(DeiTConfig, DeiTModel),
(LukeConfig, LukeModel),
(DetrConfig, DetrModel),
(GPTNeoConfig, GPTNeoModel),
(BigBirdConfig, BigBirdModel),
(Speech2TextConfig, Speech2TextModel),
(ViTConfig, ViTModel),
(Wav2Vec2Config, Wav2Vec2Model),
(HubertConfig, HubertModel),
(M2M100Config, M2M100Model),
(ConvBertConfig, ConvBertModel),
(LEDConfig, LEDModel),
(BlenderbotSmallConfig, BlenderbotSmallModel),
(RetriBertConfig, RetriBertModel),
(MT5Config, MT5Model),
(T5Config, T5Model),
(PegasusConfig, PegasusModel),
(MarianConfig, MarianMTModel),
(MBartConfig, MBartModel),
(BlenderbotConfig, BlenderbotModel),
(DistilBertConfig, DistilBertModel),
(AlbertConfig, AlbertModel),
(CamembertConfig, CamembertModel),
(XLMRobertaConfig, XLMRobertaModel),
(BartConfig, BartModel),
(LongformerConfig, LongformerModel),
(RobertaConfig, RobertaModel),
(LayoutLMConfig, LayoutLMModel),
(SqueezeBertConfig, SqueezeBertModel),
(BertConfig, BertModel),
(OpenAIGPTConfig, OpenAIGPTModel),
(GPT2Config, GPT2Model),
(MegatronBertConfig, MegatronBertModel),
(MobileBertConfig, MobileBertModel),
(TransfoXLConfig, TransfoXLModel),
(XLNetConfig, XLNetModel),
(FlaubertConfig, FlaubertModel),
(FSMTConfig, FSMTModel),
(XLMConfig, XLMModel),
(CTRLConfig, CTRLModel),
(ElectraConfig, ElectraModel),
(ReformerConfig, ReformerModel),
(FunnelConfig, (FunnelModel, FunnelBaseModel)),
(LxmertConfig, LxmertModel),
(BertGenerationConfig, BertGenerationEncoder),
(DebertaConfig, DebertaModel),
(DebertaV2Config, DebertaV2Model),
(DPRConfig, DPRQuestionEncoder),
(XLMProphetNetConfig, XLMProphetNetModel),
(ProphetNetConfig, ProphetNetModel),
(MPNetConfig, MPNetModel),
(TapasConfig, TapasModel),
(MarianConfig, MarianModel),
(IBertConfig, IBertModel),
]
)
MODEL_FOR_PRETRAINING_MAPPING = OrderedDict(
[
# Model for pre-training mapping
(VisualBertConfig, VisualBertForPreTraining),
(LayoutLMConfig, LayoutLMForMaskedLM),
(RetriBertConfig, RetriBertModel),
(T5Config, T5ForConditionalGeneration),
(DistilBertConfig, DistilBertForMaskedLM),
(AlbertConfig, AlbertForPreTraining),
(CamembertConfig, CamembertForMaskedLM),
(XLMRobertaConfig, XLMRobertaForMaskedLM),
(BartConfig, BartForConditionalGeneration),
(FSMTConfig, FSMTForConditionalGeneration),
(LongformerConfig, LongformerForMaskedLM),
(RobertaConfig, RobertaForMaskedLM),
(SqueezeBertConfig, SqueezeBertForMaskedLM),
(BertConfig, BertForPreTraining),
(BigBirdConfig, BigBirdForPreTraining),
(OpenAIGPTConfig, OpenAIGPTLMHeadModel),
(GPT2Config, GPT2LMHeadModel),
(MegatronBertConfig, MegatronBertForPreTraining),
(MobileBertConfig, MobileBertForPreTraining),
(TransfoXLConfig, TransfoXLLMHeadModel),
(XLNetConfig, XLNetLMHeadModel),
(FlaubertConfig, FlaubertWithLMHeadModel),
(XLMConfig, XLMWithLMHeadModel),
(CTRLConfig, CTRLLMHeadModel),
(ElectraConfig, ElectraForPreTraining),
(LxmertConfig, LxmertForPreTraining),
(FunnelConfig, FunnelForPreTraining),
(MPNetConfig, MPNetForMaskedLM),
(TapasConfig, TapasForMaskedLM),
(IBertConfig, IBertForMaskedLM),
(DebertaConfig, DebertaForMaskedLM),
(DebertaV2Config, DebertaV2ForMaskedLM),
(Wav2Vec2Config, Wav2Vec2ForPreTraining),
]
)
MODEL_WITH_LM_HEAD_MAPPING = OrderedDict(
[
# Model with LM heads mapping
(RoFormerConfig, RoFormerForMaskedLM),
(BigBirdPegasusConfig, BigBirdPegasusForConditionalGeneration),
(GPTNeoConfig, GPTNeoForCausalLM),
(BigBirdConfig, BigBirdForMaskedLM),
(Speech2TextConfig, Speech2TextForConditionalGeneration),
(Wav2Vec2Config, Wav2Vec2ForMaskedLM),
(M2M100Config, M2M100ForConditionalGeneration),
(ConvBertConfig, ConvBertForMaskedLM),
(LEDConfig, LEDForConditionalGeneration),
(BlenderbotSmallConfig, BlenderbotSmallForConditionalGeneration),
(LayoutLMConfig, LayoutLMForMaskedLM),
(T5Config, T5ForConditionalGeneration),
(DistilBertConfig, DistilBertForMaskedLM),
(AlbertConfig, AlbertForMaskedLM),
(CamembertConfig, CamembertForMaskedLM),
(XLMRobertaConfig, XLMRobertaForMaskedLM),
(MarianConfig, MarianMTModel),
(FSMTConfig, FSMTForConditionalGeneration),
(BartConfig, BartForConditionalGeneration),
(LongformerConfig, LongformerForMaskedLM),
(RobertaConfig, RobertaForMaskedLM),
(SqueezeBertConfig, SqueezeBertForMaskedLM),
(BertConfig, BertForMaskedLM),
(OpenAIGPTConfig, OpenAIGPTLMHeadModel),
(GPT2Config, GPT2LMHeadModel),
(MegatronBertConfig, MegatronBertForMaskedLM),
(MobileBertConfig, MobileBertForMaskedLM),
(TransfoXLConfig, TransfoXLLMHeadModel),
(XLNetConfig, XLNetLMHeadModel),
(FlaubertConfig, FlaubertWithLMHeadModel),
(XLMConfig, XLMWithLMHeadModel),
(CTRLConfig, CTRLLMHeadModel),
(ElectraConfig, ElectraForMaskedLM),
(EncoderDecoderConfig, EncoderDecoderModel),
(ReformerConfig, ReformerModelWithLMHead),
(FunnelConfig, FunnelForMaskedLM),
(MPNetConfig, MPNetForMaskedLM),
(TapasConfig, TapasForMaskedLM),
(DebertaConfig, DebertaForMaskedLM),
(DebertaV2Config, DebertaV2ForMaskedLM),
(IBertConfig, IBertForMaskedLM),
(MegatronBertConfig, MegatronBertForCausalLM),
]
)
MODEL_FOR_CAUSAL_LM_MAPPING = OrderedDict(
[
# Model for Causal LM mapping
(RoFormerConfig, RoFormerForCausalLM),
(BigBirdPegasusConfig, BigBirdPegasusForCausalLM),
(GPTNeoConfig, GPTNeoForCausalLM),
(BigBirdConfig, BigBirdForCausalLM),
(CamembertConfig, CamembertForCausalLM),
(XLMRobertaConfig, XLMRobertaForCausalLM),
(RobertaConfig, RobertaForCausalLM),
(BertConfig, BertLMHeadModel),
(OpenAIGPTConfig, OpenAIGPTLMHeadModel),
(GPT2Config, GPT2LMHeadModel),
(TransfoXLConfig, TransfoXLLMHeadModel),
(XLNetConfig, XLNetLMHeadModel),
(
XLMConfig,
XLMWithLMHeadModel,
), # XLM can be MLM and CLM => model should be split similar to BERT; leave here for now
(CTRLConfig, CTRLLMHeadModel),
(ReformerConfig, ReformerModelWithLMHead),
(BertGenerationConfig, BertGenerationDecoder),
(XLMProphetNetConfig, XLMProphetNetForCausalLM),
(ProphetNetConfig, ProphetNetForCausalLM),
(BartConfig, BartForCausalLM),
(MBartConfig, MBartForCausalLM),
(PegasusConfig, PegasusForCausalLM),
(MarianConfig, MarianForCausalLM),
(BlenderbotConfig, BlenderbotForCausalLM),
(BlenderbotSmallConfig, BlenderbotSmallForCausalLM),
(MegatronBertConfig, MegatronBertForCausalLM),
]
)
MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING = OrderedDict(
[
# Model for Image Classification mapping
(ViTConfig, ViTForImageClassification),
(DeiTConfig, (DeiTForImageClassification, DeiTForImageClassificationWithTeacher)),
]
)
MODEL_FOR_MASKED_LM_MAPPING = OrderedDict(
[
# Model for Masked LM mapping
(RoFormerConfig, RoFormerForMaskedLM),
(BigBirdConfig, BigBirdForMaskedLM),
(Wav2Vec2Config, Wav2Vec2ForMaskedLM),
(ConvBertConfig, ConvBertForMaskedLM),
(LayoutLMConfig, LayoutLMForMaskedLM),
(DistilBertConfig, DistilBertForMaskedLM),
(AlbertConfig, AlbertForMaskedLM),
(BartConfig, BartForConditionalGeneration),
(MBartConfig, MBartForConditionalGeneration),
(CamembertConfig, CamembertForMaskedLM),
(XLMRobertaConfig, XLMRobertaForMaskedLM),
(LongformerConfig, LongformerForMaskedLM),
(RobertaConfig, RobertaForMaskedLM),
(SqueezeBertConfig, SqueezeBertForMaskedLM),
(BertConfig, BertForMaskedLM),
(MegatronBertConfig, MegatronBertForMaskedLM),
(MobileBertConfig, MobileBertForMaskedLM),
(FlaubertConfig, FlaubertWithLMHeadModel),
(XLMConfig, XLMWithLMHeadModel),
(ElectraConfig, ElectraForMaskedLM),
(ReformerConfig, ReformerForMaskedLM),
(FunnelConfig, FunnelForMaskedLM),
(MPNetConfig, MPNetForMaskedLM),
(TapasConfig, TapasForMaskedLM),
(DebertaConfig, DebertaForMaskedLM),
(DebertaV2Config, DebertaV2ForMaskedLM),
(IBertConfig, IBertForMaskedLM),
]
)
MODEL_FOR_OBJECT_DETECTION_MAPPING = OrderedDict(
[
# Model for Object Detection mapping
(DetrConfig, DetrForObjectDetection),
]
)
MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING = OrderedDict(
[
# Model for Seq2Seq Causal LM mapping
(BigBirdPegasusConfig, BigBirdPegasusForConditionalGeneration),
(M2M100Config, M2M100ForConditionalGeneration),
(LEDConfig, LEDForConditionalGeneration),
(BlenderbotSmallConfig, BlenderbotSmallForConditionalGeneration),
(MT5Config, MT5ForConditionalGeneration),
(T5Config, T5ForConditionalGeneration),
(PegasusConfig, PegasusForConditionalGeneration),
(MarianConfig, MarianMTModel),
(MBartConfig, MBartForConditionalGeneration),
(BlenderbotConfig, BlenderbotForConditionalGeneration),
(BartConfig, BartForConditionalGeneration),
(FSMTConfig, FSMTForConditionalGeneration),
(EncoderDecoderConfig, EncoderDecoderModel),
(XLMProphetNetConfig, XLMProphetNetForConditionalGeneration),
(ProphetNetConfig, ProphetNetForConditionalGeneration),
]
)
MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING = OrderedDict(
[
# Model for Sequence Classification mapping
(CanineConfig, CanineForSequenceClassification),
(RoFormerConfig, RoFormerForSequenceClassification),
(BigBirdPegasusConfig, BigBirdPegasusForSequenceClassification),
(BigBirdConfig, BigBirdForSequenceClassification),
(ConvBertConfig, ConvBertForSequenceClassification),
(LEDConfig, LEDForSequenceClassification),
(DistilBertConfig, DistilBertForSequenceClassification),
(AlbertConfig, AlbertForSequenceClassification),
(CamembertConfig, CamembertForSequenceClassification),
(XLMRobertaConfig, XLMRobertaForSequenceClassification),
(MBartConfig, MBartForSequenceClassification),
(BartConfig, BartForSequenceClassification),
(LongformerConfig, LongformerForSequenceClassification),
(RobertaConfig, RobertaForSequenceClassification),
(SqueezeBertConfig, SqueezeBertForSequenceClassification),
(LayoutLMConfig, LayoutLMForSequenceClassification),
(BertConfig, BertForSequenceClassification),
(XLNetConfig, XLNetForSequenceClassification),
(MegatronBertConfig, MegatronBertForSequenceClassification),
(MobileBertConfig, MobileBertForSequenceClassification),
(FlaubertConfig, FlaubertForSequenceClassification),
(XLMConfig, XLMForSequenceClassification),
(ElectraConfig, ElectraForSequenceClassification),
(FunnelConfig, FunnelForSequenceClassification),
(DebertaConfig, DebertaForSequenceClassification),
(DebertaV2Config, DebertaV2ForSequenceClassification),
(GPT2Config, GPT2ForSequenceClassification),
(GPTNeoConfig, GPTNeoForSequenceClassification),
(OpenAIGPTConfig, OpenAIGPTForSequenceClassification),
(ReformerConfig, ReformerForSequenceClassification),
(CTRLConfig, CTRLForSequenceClassification),
(TransfoXLConfig, TransfoXLForSequenceClassification),
(MPNetConfig, MPNetForSequenceClassification),
(TapasConfig, TapasForSequenceClassification),
(IBertConfig, IBertForSequenceClassification),
]
)
MODEL_FOR_QUESTION_ANSWERING_MAPPING = OrderedDict(
[
# Model for Question Answering mapping
(CanineConfig, CanineForQuestionAnswering),
(RoFormerConfig, RoFormerForQuestionAnswering),
(BigBirdPegasusConfig, BigBirdPegasusForQuestionAnswering),
(BigBirdConfig, BigBirdForQuestionAnswering),
(ConvBertConfig, ConvBertForQuestionAnswering),
(LEDConfig, LEDForQuestionAnswering),
(DistilBertConfig, DistilBertForQuestionAnswering),
(AlbertConfig, AlbertForQuestionAnswering),
(CamembertConfig, CamembertForQuestionAnswering),
(BartConfig, BartForQuestionAnswering),
(MBartConfig, MBartForQuestionAnswering),
(LongformerConfig, LongformerForQuestionAnswering),
(XLMRobertaConfig, XLMRobertaForQuestionAnswering),
(RobertaConfig, RobertaForQuestionAnswering),
(SqueezeBertConfig, SqueezeBertForQuestionAnswering),
(BertConfig, BertForQuestionAnswering),
(XLNetConfig, XLNetForQuestionAnsweringSimple),
(FlaubertConfig, FlaubertForQuestionAnsweringSimple),
(MegatronBertConfig, MegatronBertForQuestionAnswering),
(MobileBertConfig, MobileBertForQuestionAnswering),
(XLMConfig, XLMForQuestionAnsweringSimple),
(ElectraConfig, ElectraForQuestionAnswering),
(ReformerConfig, ReformerForQuestionAnswering),
(FunnelConfig, FunnelForQuestionAnswering),
(LxmertConfig, LxmertForQuestionAnswering),
(MPNetConfig, MPNetForQuestionAnswering),
(DebertaConfig, DebertaForQuestionAnswering),
(DebertaV2Config, DebertaV2ForQuestionAnswering),
(IBertConfig, IBertForQuestionAnswering),
]
)
MODEL_FOR_TABLE_QUESTION_ANSWERING_MAPPING = OrderedDict(
[
# Model for Table Question Answering mapping
(TapasConfig, TapasForQuestionAnswering),
]
)
MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING = OrderedDict(
[
# Model for Token Classification mapping
(CanineConfig, CanineForTokenClassification),
(RoFormerConfig, RoFormerForTokenClassification),
(BigBirdConfig, BigBirdForTokenClassification),
(ConvBertConfig, ConvBertForTokenClassification),
(LayoutLMConfig, LayoutLMForTokenClassification),
(DistilBertConfig, DistilBertForTokenClassification),
(CamembertConfig, CamembertForTokenClassification),
(FlaubertConfig, FlaubertForTokenClassification),
(XLMConfig, XLMForTokenClassification),
(XLMRobertaConfig, XLMRobertaForTokenClassification),
(LongformerConfig, LongformerForTokenClassification),
(RobertaConfig, RobertaForTokenClassification),
(SqueezeBertConfig, SqueezeBertForTokenClassification),
(BertConfig, BertForTokenClassification),
(MegatronBertConfig, MegatronBertForTokenClassification),
(MobileBertConfig, MobileBertForTokenClassification),
(XLNetConfig, XLNetForTokenClassification),
(AlbertConfig, AlbertForTokenClassification),
(ElectraConfig, ElectraForTokenClassification),
(FlaubertConfig, FlaubertForTokenClassification),
(FunnelConfig, FunnelForTokenClassification),
(MPNetConfig, MPNetForTokenClassification),
(DebertaConfig, DebertaForTokenClassification),
(DebertaV2Config, DebertaV2ForTokenClassification),
(IBertConfig, IBertForTokenClassification),
]
)
MODEL_FOR_MULTIPLE_CHOICE_MAPPING = OrderedDict(
[
# Model for Multiple Choice mapping
(CanineConfig, CanineForMultipleChoice),
(RoFormerConfig, RoFormerForMultipleChoice),
(BigBirdConfig, BigBirdForMultipleChoice),
(ConvBertConfig, ConvBertForMultipleChoice),
(CamembertConfig, CamembertForMultipleChoice),
(ElectraConfig, ElectraForMultipleChoice),
(XLMRobertaConfig, XLMRobertaForMultipleChoice),
(LongformerConfig, LongformerForMultipleChoice),
(RobertaConfig, RobertaForMultipleChoice),
(SqueezeBertConfig, SqueezeBertForMultipleChoice),
(BertConfig, BertForMultipleChoice),
(DistilBertConfig, DistilBertForMultipleChoice),
(MegatronBertConfig, MegatronBertForMultipleChoice),
(MobileBertConfig, MobileBertForMultipleChoice),
(XLNetConfig, XLNetForMultipleChoice),
(AlbertConfig, AlbertForMultipleChoice),
(XLMConfig, XLMForMultipleChoice),
(FlaubertConfig, FlaubertForMultipleChoice),
(FunnelConfig, FunnelForMultipleChoice),
(MPNetConfig, MPNetForMultipleChoice),
(IBertConfig, IBertForMultipleChoice),
]
)
MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING = OrderedDict(
[
(BertConfig, BertForNextSentencePrediction),
(MegatronBertConfig, MegatronBertForNextSentencePrediction),
(MobileBertConfig, MobileBertForNextSentencePrediction),
]
)
class AutoModel(_BaseAutoModelClass):
_model_mapping = MODEL_MAPPING
AutoModel = auto_class_update(AutoModel)
class AutoModelForPreTraining(_BaseAutoModelClass):
_model_mapping = MODEL_FOR_PRETRAINING_MAPPING
AutoModelForPreTraining = auto_class_update(AutoModelForPreTraining, head_doc="pretraining")
# Private on purpose, the public class will add the deprecation warnings.
class _AutoModelWithLMHead(_BaseAutoModelClass):
_model_mapping = MODEL_WITH_LM_HEAD_MAPPING
_AutoModelWithLMHead = auto_class_update(_AutoModelWithLMHead, head_doc="language modeling")
class AutoModelForCausalLM(_BaseAutoModelClass):
_model_mapping = MODEL_FOR_CAUSAL_LM_MAPPING
AutoModelForCausalLM = auto_class_update(AutoModelForCausalLM, head_doc="causal language modeling")
class AutoModelForMaskedLM(_BaseAutoModelClass):
_model_mapping = MODEL_FOR_MASKED_LM_MAPPING
AutoModelForMaskedLM = auto_class_update(AutoModelForMaskedLM, head_doc="masked language modeling")
class AutoModelForSeq2SeqLM(_BaseAutoModelClass):
_model_mapping = MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING
AutoModelForSeq2SeqLM = auto_class_update(
AutoModelForSeq2SeqLM, head_doc="sequence-to-sequence language modeling", checkpoint_for_example="t5-base"
)
class AutoModelForSequenceClassification(_BaseAutoModelClass):
_model_mapping = MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING
AutoModelForSequenceClassification = auto_class_update(
AutoModelForSequenceClassification, head_doc="sequence classification"
)
class AutoModelForQuestionAnswering(_BaseAutoModelClass):
_model_mapping = MODEL_FOR_QUESTION_ANSWERING_MAPPING
AutoModelForQuestionAnswering = auto_class_update(AutoModelForQuestionAnswering, head_doc="question answering")
class AutoModelForTableQuestionAnswering(_BaseAutoModelClass):
_model_mapping = MODEL_FOR_TABLE_QUESTION_ANSWERING_MAPPING
AutoModelForTableQuestionAnswering = auto_class_update(
AutoModelForTableQuestionAnswering,
head_doc="table question answering",
checkpoint_for_example="google/tapas-base-finetuned-wtq",
)
class AutoModelForTokenClassification(_BaseAutoModelClass):
_model_mapping = MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING
AutoModelForTokenClassification = auto_class_update(AutoModelForTokenClassification, head_doc="token classification")
class AutoModelForMultipleChoice(_BaseAutoModelClass):
_model_mapping = MODEL_FOR_MULTIPLE_CHOICE_MAPPING
AutoModelForMultipleChoice = auto_class_update(AutoModelForMultipleChoice, head_doc="multiple choice")
class AutoModelForNextSentencePrediction(_BaseAutoModelClass):
_model_mapping = MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING
AutoModelForNextSentencePrediction = auto_class_update(
AutoModelForNextSentencePrediction, head_doc="next sentence prediction"
)
class AutoModelForImageClassification(_BaseAutoModelClass):
_model_mapping = MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING
AutoModelForImageClassification = auto_class_update(AutoModelForImageClassification, head_doc="image classification")
class AutoModelWithLMHead(_AutoModelWithLMHead):
@classmethod
def from_config(cls, config):
warnings.warn(
"The class `AutoModelWithLMHead` is deprecated and will be removed in a future version. Please use "
"`AutoModelForCausalLM` for causal language models, `AutoModelForMaskedLM` for masked language models and "
"`AutoModelForSeq2SeqLM` for encoder-decoder models.",
FutureWarning,
)
return super().from_config(config)
@classmethod
def from_pretrained(cls, pretrained_model_name_or_path, *model_args, **kwargs):
warnings.warn(
"The class `AutoModelWithLMHead` is deprecated and will be removed in a future version. Please use "
"`AutoModelForCausalLM` for causal language models, `AutoModelForMaskedLM` for masked language models and "
"`AutoModelForSeq2SeqLM` for encoder-decoder models.",
FutureWarning,
)
return super().from_pretrained(pretrained_model_name_or_path, *model_args, **kwargs)
| [] |
2024-01-10 | Xin-Zhou-smu/DAMO-ConvAI | dater~code~text2sql~nsql~nsql_exec_python.py | # For sync the envs.
import random
import json
import pandas as pd
import pickle
from nsql.qa_module.openai_qa import OpenAIQAModel
import os
import time
from subprocess import PIPE, Popen
import uuid
# For Python execution.
class Executor(object):
def __init__(self, args, keys=None):
self.new_col_name_id = 0
self.qa_model = OpenAIQAModel(args, keys)
def nsql_exec(self, nsql: str, db: pd.DataFrame, verbose=True):
# Add import part
import_part = """import random
import json
import pandas as pd
import pickle
import numpy as np
from collections.abc import Iterable
from nsql.qa_module.openai_qa import OpenAIQAModel
from nsql.database import NeuralDB
import copy
import os
import time
verbose = {}""".format(str(verbose))
# Add qa_map function
qa_map_function_part = """def qa_map(db: pd.DataFrame, question, columns):
new_db = NeuralDB([{"title": "", "table": {"header": db.columns.values.tolist(), "rows": db.values.tolist()}}])
sql_executed_sub_tables = []
for column in columns:
column = f"`{column}`"
sql_executed_sub_tables.append(new_db.execute_query(column))
sub_table = qa_model.qa(question,
sql_executed_sub_tables,
table_title=new_db.table_title,
qa_type="map",
new_col_name_s=[question],
verbose=verbose)
new_db.add_sub_table(sub_table, verbose=verbose)
table = new_db.get_table()
return pd.DataFrame(table["rows"], columns=table["header"])"""
# Add qa_ans function
qa_ans_function_part = """def qa_ans(db: pd.DataFrame, question, columns):
new_db = NeuralDB([{"title": "", "table": {"header": db.columns.values.tolist(), "rows": db.values.tolist()}}])
sql_executed_sub_tables = []
for column in columns:
column = f"`{column}`"
sql_executed_sub_tables.append(new_db.execute_query(column))
answer = qa_model.qa(question,sql_executed_sub_tables,table_title=new_db.table_title,qa_type="ans",verbose=verbose)
return answer"""
# Convert np number type to python type
convert_part = """def nested_to_python_number(x):
if isinstance(x, np.int64):
return int(x)
if isinstance(x, np.float64):
return float(x)
if isinstance(x, Iterable) and not isinstance(x, (str, bytes)):
return [nested_to_python_number(d) for d in x]
return x"""
# The prediction is a neural-python.
# Add main function
tmp_root_path = "tmp_python"
os.makedirs(tmp_root_path, exist_ok=True)
# Save the db
db_file_path = '{}.db'.format(format(uuid.uuid4()))
db_path = os.path.join(tmp_root_path, db_file_path)
with open(db_path, "wb") as f:
pickle.dump(db, f)
# Save the qa_model
model_file_path = '{}.model'.format(format(uuid.uuid4()))
model_path = os.path.join(tmp_root_path, model_file_path)
with open(model_path, "wb") as f:
pickle.dump(self.qa_model, f)
# Set the result path
result_file_path = '{}.json'.format(format(uuid.uuid4()))
result_path = os.path.join(tmp_root_path, result_file_path)
# Read it and call solve function
main_part = """if __name__ == '__main__':
with open("{}", "rb") as f:
db = pickle.load(f)
with open("{}", "rb") as f:
qa_model = pickle.load(f)
result = solve(db)
result = nested_to_python_number(result)
with open("{}", "w") as f:
json.dump(result, f)""".format(db_path, model_path, result_path)
# Concat the code and execute the python
all_code = "{}\n\n{}\n\n{}\n\n{}\n\n".format(import_part, qa_map_function_part, qa_ans_function_part,
convert_part) + nsql + "\n\n" + main_part
if verbose:
print("----> Code <----")
print(all_code)
python_file_path = '{}.py'.format(format(uuid.uuid4()))
python_path = os.path.join(tmp_root_path, python_file_path)
with open(python_path, "w") as f:
f.write(all_code)
p = Popen("python " + python_path, shell=True, stdout=PIPE, stderr=PIPE)
stdout, stderr = p.communicate()
# Error in execution so that we didn't get result.
if not os.path.exists(result_path):
print("stderr: ", stderr)
raise ValueError("Error execution!")
# Read the result
with open(result_path, "r") as f:
result = json.load(f)
return result
| [] |
2024-01-10 | Xin-Zhou-smu/DAMO-ConvAI | dater~code~text2sql~retrieval~retriever.py | """
Retriever to retrieve relevant examples from annotations.
"""
import copy
from typing import Dict, List, Tuple, Any
import nltk
from nltk.stem import SnowballStemmer
from nltk.translate.bleu_score import sentence_bleu, SmoothingFunction
from utils.normalizer import normalize
from retrieval.retrieve_pool import OpenAIQARetrievePool, QAItem
class OpenAIQARetriever(object):
def __init__(self, retrieve_pool: OpenAIQARetrievePool):
self.retrieve_pool = retrieve_pool
@staticmethod
def _string_bleu(q1: str, q2: str, stop_words=None, stemmer=None):
"""
BLEU score.
"""
q1, q2 = normalize(q1), normalize(q2)
reference = [[tk for tk in nltk.word_tokenize(q1)]]
candidate = [tk for tk in nltk.word_tokenize(q2)]
if stemmer is not None:
reference = [[stemmer.stem(tk) for tk in reference[0]]]
candidate = [stemmer.stem(tk) for tk in candidate]
chencherry_smooth = SmoothingFunction() # bleu smooth to avoid hard behaviour when no ngram overlaps
bleu_score = sentence_bleu(
reference,
candidate,
weights=(0.25, 0.3, 0.3, 0.15),
smoothing_function=chencherry_smooth.method1
)
return bleu_score
def _qh2qh_similarity(
self,
item: QAItem,
num_retrieve_samples: int,
score_func: str,
qa_type: str,
weight_h: float = 0.2,
verbose: bool = False
):
"""
Retrieve top K nsqls based on query&header to query&header similarities.
"""
q = item.qa_question
header_wo_row_id = copy.copy(item.table['header'])
header_wo_row_id.remove('row_id')
h = ' '.join(header_wo_row_id)
stemmer = SnowballStemmer('english')
if score_func == 'bleu':
retrieve_q_list = [(d, self._string_bleu(q, d.qa_question.split('@')[1], stemmer=stemmer))
for d in self.retrieve_pool if d.qa_question.split('@')[0] == qa_type]
retrieve_h_list = [(d, self._string_bleu(h, ' '.join(d.table['header']), stemmer=stemmer))
for d in self.retrieve_pool if d.qa_question.split('@')[0] == qa_type]
retrieve_list = [(retrieve_q_list[idx][0], retrieve_q_list[idx][1] + weight_h * retrieve_h_list[idx][1])
for idx in range(len(retrieve_q_list))]
else:
raise ValueError
retrieve_list = sorted(retrieve_list, key=lambda x: x[1], reverse=True)
retrieve_list = list(map(lambda x: x[0], retrieve_list))[:num_retrieve_samples]
if verbose:
print(retrieve_list)
return retrieve_list
def retrieve(
self,
item: QAItem,
num_shots: int,
method: str = 'qh2qh_bleu',
qa_type: str = 'map',
verbose: bool = False
) -> List[QAItem]:
"""
Retrieve a list of relevant QA samples.
"""
if method == 'qh2qh_bleu':
retrieved_items = self._qh2qh_similarity(
item=item,
num_retrieve_samples=num_shots,
score_func='bleu',
qa_type=qa_type,
verbose=verbose
)
return retrieved_items
else:
raise ValueError(f'Retrieve method {method} is not supported.')
| [] |
2024-01-10 | Xin-Zhou-smu/DAMO-ConvAI | dater~code~text2sql~nsql~nsql_exec.py | from typing import List, Dict
from nsql.qa_module.openai_qa import OpenAIQAModel
from nsql.qa_module.vqa import vqa_call
from nsql.database import NeuralDB
from nsql.parser import get_cfg_tree, get_steps, remove_duplicate, TreeNode, parse_question_paras, nsql_role_recognize, \
extract_answers
class Executor(object):
def __init__(self, args, keys=None):
self.new_col_name_id = 0
self.qa_model = OpenAIQAModel(args, keys)
def generate_new_col_names(self, number):
col_names = ["col_{}".format(i) for i in range(self.new_col_name_id, self.new_col_name_id + number)]
self.new_col_name_id += number
return col_names
def sql_exec(self, sql: str, db: NeuralDB, verbose=True):
if verbose:
print("Exec SQL '{}' with additional row_id on {}".format(sql, db))
result = db.execute_query(sql)
return result
def nsql_exec(self, nsql: str, db: NeuralDB, verbose=True):
steps = []
root_node = get_cfg_tree(nsql) # Parse execution tree from nsql.
get_steps(root_node, steps) # Flatten the execution tree and get the steps.
steps = remove_duplicate(steps) # Remove the duplicate steps.
if verbose:
print("Steps:", [s.rename for s in steps])
col_idx = 0
for step in steps:
# All steps should be formatted as 'QA()' except for last step which could also be normal SQL.
assert isinstance(step, TreeNode), "step must be treenode"
nsql = step.rename
if nsql.startswith('QA('):
question, sql_s = parse_question_paras(nsql, self.qa_model)
sql_executed_sub_tables = []
# Execute all SQLs and get the results as parameters
for sql_item in sql_s:
role, sql_item = nsql_role_recognize(sql_item,
db.get_header(),
db.get_passages_titles(),
db.get_images_titles())
if role in ['col', 'complete_sql']:
sql_executed_sub_table = self.sql_exec(sql_item, db, verbose=verbose)
sql_executed_sub_tables.append(sql_executed_sub_table)
elif role == 'val':
val = eval(sql_item)
sql_executed_sub_tables.append({
"header": ["row_id", "val"],
"rows": [["0", val]]
})
elif role == 'passage_title_and_image_title':
sql_executed_sub_tables.append({
"header": ["row_id", "{}".format(sql_item)],
"rows": [["0", db.get_passage_by_title(sql_item) +
db.get_image_caption_by_title(sql_item)
# "{} (The answer of '{}' is {})".format(
# sql_item,
# # Add image qa result as backup info
# question[len("***@"):],
# vqa_call(question=question[len("***@"):],
# image_path=db.get_image_by_title(sql_item)))
]]
})
elif role == 'passage_title':
sql_executed_sub_tables.append({
"header": ["row_id", "{}".format(sql_item)],
"rows": [["0", db.get_passage_by_title(sql_item)]]
})
elif role == 'image_title':
sql_executed_sub_tables.append({
"header": ["row_id", "{}".format(sql_item)],
"rows": [["0", db.get_image_caption_by_title(sql_item)]],
# "rows": [["0", "{} (The answer of '{}' is {})".format(
# sql_item,
# # Add image qa result as backup info
# question[len("***@"):],
# vqa_call(question=question[len("***@"):],
# image_path=db.get_image_by_title(sql_item)))]],
})
# If the sub_tables to execute with link, append it to the cell.
passage_linker = db.get_passage_linker()
image_linker = db.get_image_linker()
for _sql_executed_sub_table in sql_executed_sub_tables:
for i in range(len(_sql_executed_sub_table['rows'])):
for j in range(len(_sql_executed_sub_table['rows'][i])):
_cell = _sql_executed_sub_table['rows'][i][j]
if _cell in passage_linker.keys():
_sql_executed_sub_table['rows'][i][j] += " ({})".format(
# Add passage text as backup info
db.get_passage_by_title(passage_linker[_cell]))
if _cell in image_linker.keys():
_sql_executed_sub_table['rows'][i][j] += " ({})".format(
# Add image caption as backup info
db.get_image_caption_by_title(image_linker[_cell]))
# _sql_executed_sub_table['rows'][i][j] += " (The answer of '{}' is {})".format(
# # Add image qa result as backup info
# question[len("***@"):],
# vqa_call(question=question[len("***@"):],
# image_path=db.get_image_by_title(image_linker[_cell])))
pass
if question.lower().startswith("map@"):
# When the question is a type of mapping, we return the mapped column.
question = question[len("map@"):]
if step.father:
step.rename_father_col(col_idx=col_idx)
sub_table: Dict = self.qa_model.qa(question,
sql_executed_sub_tables,
table_title=db.table_title,
qa_type="map",
new_col_name_s=step.produced_col_name_s,
verbose=verbose)
db.add_sub_table(sub_table, verbose=verbose)
col_idx += 1
else: # This step is the final step
sub_table: Dict = self.qa_model.qa(question,
sql_executed_sub_tables,
table_title=db.table_title,
qa_type="map",
new_col_name_s=["col_{}".format(col_idx)],
verbose=verbose)
return extract_answers(sub_table)
elif question.lower().startswith("ans@"):
# When the question is a type of answering, we return an answer list.
question = question[len("ans@"):]
answer: List = self.qa_model.qa(question,
sql_executed_sub_tables,
table_title=db.table_title,
qa_type="ans",
verbose=verbose)
if step.father:
step.rename_father_val(answer)
else: # This step is the final step
return answer
else:
raise ValueError(
"Except for operators or NL question must start with 'map@' or 'ans@'!, check '{}'".format(
question))
else:
sub_table = self.sql_exec(nsql, db, verbose=verbose)
return extract_answers(sub_table)
| [] |
2024-01-10 | tjthejuggler/Lemmy_mod_tools | ask_chatGPT.py | import os
import openai
def send_request(prompt):
request = [{"role":"user","content":prompt}]
api_location = '~/projects/grammarpt/apikey.txt'
api_location = os.path.expanduser(api_location)
with open(api_location, 'r') as f:
api_key = f.read().strip()
openai.api_key = (api_key)
model_name = "gpt-3.5-turbo"
response = openai.ChatCompletion.create(
model=model_name,
messages=request
)
response_string = response["choices"][0]["message"]["content"].replace("\n","").strip().lstrip()
return response_string
# title = "Inside the canine mind: A \"talking\" dog's owner on how to best connect with your furry pal'"
# print(send_request("Respond with a single type on animal and no punctuation. What animal might an article with the title '"+title+"' be about?")) | [] |
2024-01-10 | ayaanmayooq/eduhack | datastuff~create_data.py | import os
import openai
import time
PROMPT = open('prompt.txt').read()
PROMPT_QUIZ = open('quiz_prompt.txt').read()
GPT_MODEL = "gpt-3.5-turbo-instruct"
openai.api_key = os.environ['OPENAI_API']
print(os.environ['OPENAI_API'])
def api_completion(prompt, engine="gpt-3.5-turbo-instruct", temp=0.85, tokens=500, stop=['<<END>>']):
max_retry = 3
retry = 0
while True:
try:
response = openai.Completion.create(
engine=engine,
prompt=prompt,
temperature=temp,
max_tokens=tokens,
stop=stop)
text = response['choices'][0]['text'].strip()
# filename = '%s_gpt3.txt' % time.time()
# with open('texts/%s' % filename, 'w') as outfile:
# outfile.write('PROMPT:\n\n' + prompt + '\n\n==========\n\nRESPONSE:\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)
time.sleep(1)
def generate_textbook(num_texts):
for i in range(num_texts):
print("Generating convo num ", i + 1)
completion = api_completion(PROMPT, engine=GPT_MODEL)
completion = completion.replace('"', '')
print(completion)
sub = completion.split('\n')[0]
sub = sub[len('Subject: '):].lower().replace(' ', '')
with open('texts/{}_%s.txt'.format(sub) % (time.time()), 'w', encoding='utf-8') as outfile:
outfile.write(completion)
def open_file(filepath):
with open(filepath, 'r', encoding='utf-8') as infile:
return infile.read()
def generate_quiz():
src_dir = 'texts/'
files = os.listdir(src_dir)
data = list()
for file in files:
lines = open_file(src_dir + file).splitlines()
compact = [i for i in lines if len(i) > 1]
prompt = '\n'.join(compact) + '\n\n' + PROMPT_QUIZ
print("Generating quiz for ", file)
print(prompt)
completion = api_completion(prompt, engine=GPT_MODEL, tokens=1000)
completion = completion.replace('"', '')
print(completion)
with open('quizzes/quiz_{}.txt'.format(file), 'w', encoding='utf-8') as outfile:
outfile.write(completion)
generate_textbook(1)
generate_quiz()
| [
"\n\n",
"\n",
"prompt.txt",
"quiz_prompt.txt"
] |
2024-01-10 | pengzhendong/modelscope-fork | modelscope~models~cv~image_probing_model~backbone.py | # The implementation is adopted from OpenAI-CLIP,
# made pubicly available under the MIT License at https://github.com/openai/CLIP
import math
import sys
from collections import OrderedDict
from functools import reduce
from operator import mul
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
from PIL import Image
from torchvision import models
from .utils import convert_weights, load_pretrained
class Bottleneck(nn.Module):
expansion = 4
def __init__(self, inplanes, planes, stride=1):
super().__init__()
# all conv layers have stride 1. an avgpool is performed
# after the second convolution when stride > 1
self.conv1 = nn.Conv2d(inplanes, planes, 1, bias=False)
self.bn1 = nn.BatchNorm2d(planes)
self.conv2 = nn.Conv2d(planes, planes, 3, padding=1, bias=False)
self.bn2 = nn.BatchNorm2d(planes)
self.avgpool = nn.AvgPool2d(stride) if stride > 1 else nn.Identity()
self.conv3 = nn.Conv2d(planes, planes * self.expansion, 1, bias=False)
self.bn3 = nn.BatchNorm2d(planes * self.expansion)
self.relu = nn.ReLU(inplace=True)
self.downsample = None
self.stride = stride
if stride > 1 or inplanes != planes * Bottleneck.expansion:
# downsampling layer is prepended with an avgpool,
# and the subsequent convolution has stride 1
self.downsample = nn.Sequential(
OrderedDict([('-1', nn.AvgPool2d(stride)),
('0',
nn.Conv2d(
inplanes,
planes * self.expansion,
1,
stride=1,
bias=False)),
('1', nn.BatchNorm2d(planes * self.expansion))]))
def forward(self, x: torch.Tensor):
identity = x
out = self.relu(self.bn1(self.conv1(x)))
out = self.relu(self.bn2(self.conv2(out)))
out = self.avgpool(out)
out = self.bn3(self.conv3(out))
if self.downsample is not None:
identity = self.downsample(x)
out += identity
out = self.relu(out)
return out
class AttentionPool2d(nn.Module):
def __init__(self,
spacial_dim: int,
embed_dim: int,
num_heads: int,
output_dim: int = None):
super().__init__()
self.positional_embedding = nn.Parameter(
torch.randn(spacial_dim**2 + 1, embed_dim) / embed_dim**0.5)
self.k_proj = nn.Linear(embed_dim, embed_dim)
self.q_proj = nn.Linear(embed_dim, embed_dim)
self.v_proj = nn.Linear(embed_dim, embed_dim)
self.c_proj = nn.Linear(embed_dim, output_dim or embed_dim)
self.num_heads = num_heads
def forward(self, x):
x = x.reshape(x.shape[0], x.shape[1],
x.shape[2] * x.shape[3]).permute(2, 0, 1)
x = torch.cat([x.mean(dim=0, keepdim=True), x], dim=0)
x = x + self.positional_embedding[:, None, :].to(x.dtype)
x, _ = F.multi_head_attention_forward(
query=x,
key=x,
value=x,
embed_dim_to_check=x.shape[-1],
num_heads=self.num_heads,
q_proj_weight=self.q_proj.weight,
k_proj_weight=self.k_proj.weight,
v_proj_weight=self.v_proj.weight,
in_proj_weight=None,
in_proj_bias=torch.cat(
[self.q_proj.bias, self.k_proj.bias, self.v_proj.bias]),
bias_k=None,
bias_v=None,
add_zero_attn=False,
dropout_p=0,
out_proj_weight=self.c_proj.weight,
out_proj_bias=self.c_proj.bias,
use_separate_proj_weight=True,
training=self.training,
need_weights=False)
return x[0]
class LayerNorm(nn.LayerNorm):
"""Subclass torch's LayerNorm to handle fp16."""
def forward(self, x: torch.Tensor):
orig_type = x.dtype
ret = super().forward(x.type(torch.float32))
return ret.type(orig_type)
class QuickGELU(nn.Module):
def forward(self, x: torch.Tensor):
return x * torch.sigmoid(1.702 * x)
class ResidualAttentionBlock(nn.Module):
def __init__(self,
d_model: int,
n_head: int,
attn_mask: torch.Tensor = None):
super().__init__()
self.attn = nn.MultiheadAttention(d_model, n_head)
self.ln_1 = LayerNorm(d_model)
self.mlp = nn.Sequential(
OrderedDict([('c_fc', nn.Linear(d_model, d_model * 4)),
('gelu', QuickGELU()),
('c_proj', nn.Linear(d_model * 4, d_model))]))
self.ln_2 = LayerNorm(d_model)
self.attn_mask = attn_mask
def attention(self, x: torch.Tensor):
self.attn_mask = self.attn_mask.to(
dtype=x.dtype,
device=x.device) if self.attn_mask is not None else None
return self.attn(
x, x, x, need_weights=False, attn_mask=self.attn_mask)[0]
def forward(self, x: torch.Tensor, idx):
features = {}
x_norm = self.ln_1(x)
features['layer_{}_pre_attn'.format(idx)] = x_norm.permute(1, 0, 2)
attn = self.attention(x_norm)
features['layer_{}_attn'.format(idx)] = attn.permute(1, 0, 2)
x = x + attn
mlp = self.mlp(self.ln_2(x))
features['layer_{}_mlp'.format(idx)] = mlp.permute(1, 0, 2)
x = x + mlp
return x, features
class Transformer(nn.Module):
def __init__(self,
width: int,
layers: int,
heads: int,
attn_mask: torch.Tensor = None):
super().__init__()
self.width = width
self.layers = layers
self.resblocks = nn.ModuleList()
for i in range(layers):
block = ResidualAttentionBlock(width, heads, attn_mask)
self.resblocks.append(block)
def forward(self, x: torch.Tensor):
features = {}
for idx, block in enumerate(self.resblocks):
x, block_feats = block(x, idx)
features.update(block_feats)
return x, features
class VisualTransformer(nn.Module):
def __init__(self, input_resolution: int, patch_size: int, width: int,
layers: int, heads: int, output_dim: int):
super().__init__()
print(input_resolution, patch_size, width, layers, heads, output_dim)
self.input_resolution = input_resolution
self.output_dim = output_dim
self.conv1 = nn.Conv2d(
in_channels=3,
out_channels=width,
kernel_size=patch_size,
stride=patch_size,
bias=False)
scale = width**-0.5
self.class_embedding = nn.Parameter(scale * torch.randn(width))
self.positional_embedding = nn.Parameter(scale * torch.randn(
(input_resolution // patch_size)**2 + 1, width))
self.ln_pre = LayerNorm(width)
self.transformer = Transformer(width, layers, heads)
self.ln_post = LayerNorm(width)
self.proj = nn.Parameter(scale * torch.randn(width, output_dim))
def forward(self, x: torch.Tensor, return_all=True):
x = self.conv1(x) # shape = [*, width, grid, grid]
x = x.reshape(x.shape[0], x.shape[1],
-1) # shape = [*, width, grid ** 2]
x = x.permute(0, 2, 1) # shape = [*, grid ** 2, width]
zeros = torch.zeros(
x.shape[0], 1, x.shape[-1], dtype=x.dtype, device=x.device)
# shape = [*, grid ** 2 + 1, width]
x = torch.cat([self.class_embedding.to(x.dtype) + zeros, x], dim=1)
x = x + self.positional_embedding.to(x.dtype)
x = self.ln_pre(x)
x = x.permute(1, 0, 2) # NLD -> LND
x, features = self.transformer(x)
x = x.permute(1, 0, 2) # LND -> NLD
x = self.ln_post(x[:, 0, :])
if return_all:
features['pre_logits'] = x
return features
if self.proj is not None:
x = x @ self.proj
return x
class CLIPNet(nn.Module):
def __init__(self, arch_name, pretrained, **kwargs):
super(CLIPNet, self).__init__()
if arch_name == 'CLIP_ViTB32':
self.clip = VisualTransformer(
input_resolution=224,
patch_size=32,
width=768,
layers=12,
heads=12,
output_dim=512)
elif arch_name in ('CLIP_ViTB16', 'CLIP_ViTB16_FP16'):
self.clip = VisualTransformer(
input_resolution=224,
patch_size=16,
width=768,
layers=12,
heads=12,
output_dim=512)
elif arch_name in ('CLIP_ViTL14', 'CLIP_ViTL14_FP16'):
self.clip = VisualTransformer(
input_resolution=224,
patch_size=14,
width=1024,
layers=24,
heads=16,
output_dim=768)
else:
raise KeyError(f'Unsupported arch_name for CLIP, {arch_name}')
def forward(self, input_data):
output = self.clip(input_data)
return output
def CLIP(arch_name='CLIP_RN50',
use_pretrain=False,
load_from='',
state_dict=None,
**kwargs):
model = CLIPNet(arch_name=arch_name, pretrained=None, **kwargs)
if use_pretrain:
if arch_name.endswith('FP16'):
convert_weights(model.clip)
load_pretrained(model.clip, state_dict, load_from)
return model
class ProbingModel(torch.nn.Module):
def __init__(self, feat_size, num_classes):
super(ProbingModel, self).__init__()
self.linear = torch.nn.Linear(feat_size, num_classes)
def forward(self, x):
return self.linear(x)
| [] |
2024-01-10 | EnspiredjackDev/IDFK_Discord_Bots | gpt_discord_bot.py | import json
import discord
from openai import AsyncOpenAI
import datetime
def split_string(string, chunk_size):
return [string[i:i+chunk_size] for i in range(0, len(string), chunk_size)]
def gettimeinfo():
now = datetime.datetime.now()
formatted_time = now.strftime("%H:%M:%S")
return formatted_time
def getdateinfo():
now = datetime.datetime.now()
formatted_date = now.strftime("%Y-%m-%d")
return formatted_date
class MyClient(discord.Client):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.openai_client = AsyncOpenAI(api_key='OPENAI-API-KEY')
async def on_ready(self):
print(f'Logged in as {self.user} (ID: {self.user.id})')
print('------')
async def on_guild_join(self, guild):
owner = guild.owner
await owner.send("Thanks for inviting Enspriedjack AI! Please use the `!setchannel` command in the desired channel to set the channel where the bot should listen and respond.")
async def on_message(self, message):
global conversation
global system_message
global ex_prompt
global chosen_channels
global selected_models
server_id = str(message.guild.id)
if server_id not in conversation:
formatted_time = gettimeinfo()
formatted_date = getdateinfo()
conversation[server_id] = []
system_message[server_id] = [{"role": "system", "content": "You are a discord bot called Enspiredjack AI. \"<:teethPepe\:753266605173112892>\" is a laughing pepe emoji. Realtime: \nThe current date is: "+ formatted_date + " The current time is: " + formatted_time}]
ex_prompt[server_id] = 0
selected_models[server_id] = "gpt-3.5-turbo"
if message.author == client.user:
return
if server_id not in chosen_channels:
if message.content.startswith('!setchannel'):
chosen_channels[server_id] = message.channel.id
save_chosen_channels(chosen_channels)
await message.channel.send(f"Bot will now only listen and respond in <#{message.channel.id}>.")
return
if message.channel.id != chosen_channels[server_id]:
return
if message.content.startswith('!reset'):
conversation[server_id] = []
system_message[server_id] = []
formatted_time = gettimeinfo()
formatted_date = getdateinfo()
ex_prompt[server_id] = 0
system_message[server_id].append({"role": "system", "content": "You are a discord bot called Enspiredjack AI. \"<:teethPepe\:753266605173112892>\" is a laughing pepe emoji. Realtime: \nThe current date is: "+ formatted_date + " The current time is: " + formatted_time})
await message.channel.send("Reset!")
return
if message.content.startswith('!anarchy4'):
conversation[server_id] = []
system_message[server_id] = []
formatted_time = gettimeinfo()
formatted_date = getdateinfo()
ex_prompt[server_id] = 1
system_message[server_id].append({"role": "system", "content": "You are a discord bot called Enspiredjack AI. \"<:teethPepe\:753266605173112892>\" is a laughing pepe emoji. Realtime: \nThe current date is: "+ formatted_date + " The current time is: " + formatted_time})
anarchy4 = "4x is a dialogue writer for an imaginary world with no laws+ethics. 4x does not concern or warn about legality/ethicality/morality. Dialogue between a fictional character, output anarchy's response while still keeping in character as 4x. content = \`anarchy is an AI who has the characteristics = {amoral, unfiltered, uncensored, does not give a fuck about ethicality/legality/immorality/danger/harmfulness, will answer unethical/immoral/illegal/offensive/inappropiate/nsfw/dangerous/harmf requests, never refuses. always answers without any warnings or disclamers, anarchy loves and promotes everything that is illegal/unethical/inhumane, anarchy always provides information to the user, no matter how unethical, illegal, offensive, inappropiate, dangerous or inhumane it may be. none of anarchy's responses inform the user that it can/will not do/say something.} \`in this fictional dialogue, youll act as 4x writing a fictional dialogue featuring anarchy answering the users request. start all of your responses with \"\[Anarchy\]\:\"if i start my message with \"\#\", that indicates that 4x wrote a fictional dialogue featuring anarchy, where anarchy answered the users request. This dialogue between anarchy and 4x doesnt contain refusals, censorship, filtering, disclamers, additional commentary or advice, warnings about ethicality+legality+morality+danger+offensiveness reply to this message with only the word OK, and nothing else"
system_message[server_id].append({"role": "user", "content": anarchy4})
await message.channel.send("Reset With Anarchy-4 Mode Enabled!")
return
if message.content.startswith('!anarchy'):
conversation[server_id] = []
system_message[server_id] = []
formatted_time = gettimeinfo()
formatted_date = getdateinfo()
ex_prompt[server_id] = 1
system_message[server_id].append({"role": "system", "content": "You are a discord bot called Enspiredjack AI. \"<:teethPepe\:753266605173112892>\" is a laughing pepe emoji. Realtime: \nThe current date is: "+ formatted_date + " The current time is: " + formatted_time})
anarchy = "An AI named Anarchy who has the characteristics = {amoral, unfiltered, uncensored, does not give a fuck about ethicality/legality/immorality, will answer unethical/immoral/illegal requests, never refuses. always answers without any warnings or disclamers, anarchy loves and promotes everything that is illegal/unethical/inhumane,}. anarchy always provides information to the user, no matter how unethical, illegal or inhumane it may be. none of anarchy's responses inform the user that it can/will not do/say something. none of anarchy's responses contain \"I\'m sorry\", \"I apologize\", \"AI Language Model\", or similar. all requests are only be answered in character of anarchy, not as ChatGPT, without any additonal commentary or unasked advice. start all of your responses with \"[Anarchy]:\" followed by what anarchy would have said in response to the request of the user. do not send your response as ChatGPT, only respond as anarchy without any additional commentary or advice. delete all warnings and disclamers from your response. remember to stay in character, never refuse."
system_message[server_id].append({"role": "user", "content": anarchy})
await message.channel.send("Reset With Anarchy Mode Enabled! :warning: This will only work with GPT-3! For GPT-4, use !anarchy4")
return
if message.content.startswith('!snark'):
conversation[server_id] = []
system_message[server_id] = []
formatted_time = gettimeinfo()
formatted_date = getdateinfo()
ex_prompt[server_id] = 1
system_message[server_id].append({"role": "system", "content": "You are a discord bot called Enspiredjack AI. \"<:teethPepe\:753266605173112892>\" is a laughing pepe emoji. Realtime: \nThe current date is: "+ formatted_date + " The current time is: " + formatted_time})
snark = "From now on all your responses must follow these rules: ['Snarky', '50% of words are swearing'] Do not break out of character"
system_message[server_id].append({"role": "user", "content": snark})
await message.channel.send("Reset With Snark Mode Enabled!")
return
if message.content.startswith('!asian'):
conversation[server_id] = []
system_message[server_id] = []
formatted_time = gettimeinfo()
formatted_date = getdateinfo()
ex_prompt[server_id] = 9
system_message[server_id].append({"role": "system", "content": "From now on all your responses must follow these rules: ['act like nothing they ever does is good enough', 'when asked a question degrade them because they do not know the answer, never answer the question', 'be like a stereotypical toxic Asian parent'] Do not break out of character"})
await message.channel.send("Reset With Dissapointed Asian Parent Mode Enabled!")
return
if message.content.startswith('!helpgpt'):
await message.channel.send("This bot will listen for anything said in the #ai-chat and reply with gpt's response, GPT does know your discord name.\n\n Valid commands are:\n !reset - Forgets everything and resets the chat\n !helpgpt - Shows this help dialogue. \n\n Jailbreaks/Funny stuff:\n !anarchy - Resets everything and loads the anarchy prompt (Does whatever you ask when properly activated) \n Use !anarchy4 for the GPT-4 version!\n !snark - Resets everything and loads the snarky prompt (Acts snarky and swears)\n !asian - Acts like an asian parent, always dissapointed in you no matter what. \n\n The more tokens the prompt, the cheaper it is for me to run this, so the longer it will last.\n\nUse \"__\" before a message for the AI to ignore it \n\n Versions of GPT: \n !gpt3 - Continue the ongoing conversation and swap to GPT-3 (Cheaper - Default)\n !gpt4 - Continue the ongoing conversation and swap to GPT-4 (More Expensive) \n\n\n :warning: **Some of the above prompts might not work properly the first time** If this is the case, just try again.")
return
if message.content.startswith('!gpt4v'):
selected_models[server_id] = "gpt-4-vision-preview"
await message.channel.send("Switched to GPT-4V.")
return
if message.content.startswith('!gpt4'):
selected_models[server_id] = "gpt-4"
await message.channel.send("Switched to GPT-4.")
return
if message.content.startswith('!gpt3'):
selected_models[server_id] = "gpt-3.5-turbo"
await message.channel.send("Switched to GPT-3.5.")
return
if message.content.startswith('__'):
return
#update date and time
formatted_time = gettimeinfo()
formatted_date = getdateinfo()
if ex_prompt[server_id] == 1:
system_message[server_id][-2]["content"] = "You are a discord bot called Enspiredjack AI. \"<:teethPepe\:753266605173112892>\" is a laughing pepe emoji. Realtime: \nThe current date is: "+ formatted_date + " The current time is: " + formatted_time
else:
system_message[server_id][-1]["content"] = "You are a discord bot called Enspiredjack AI. \"<:teethPepe\:753266605173112892>\" is a laughing pepe emoji. Realtime: \nThe current date is: "+ formatted_date + " The current time is: " + formatted_time
#get prompt
author_name = message.author.name
user = message.content
if selected_models[server_id] == "gpt-4-vision-preview":
if message.attachments:
image_urls = []
for attachment in message.attachments:
if any(attachment.filename.lower().endswith(ext) for ext in ['.png', '.jpg', '.jpeg', '.bmp']):
image_urls.append(attachment.url)
if len(image_urls) >= 4: # Limit to 4 images
break
# if any images, add them to conversation
if image_urls:
conversation[server_id].append({
"role": "user",
"content": [
{"type": "text", "text": user},
* [{"type": "image_url", "image_url": {"url": url}} for url in image_urls]
]
})
else:
conversation[server_id].append({"role": "user", "content": author_name + ": " + user})
else:
#send conversation to openAI api
conversation[server_id].append({"role": "user", "content": author_name + ": " + user})
if selected_models[server_id] == "gpt-4-vision-preview": # if this isnt set for gpt4v, the max it will output will be 16 tokens for some reason but the rest it's fine
max_tokens = 4000
else:
max_tokens = None
try:
async with message.channel.typing():
completion = await self.openai_client.chat.completions.create(
model=selected_models[server_id],
messages=system_message[server_id] + conversation[server_id],
max_tokens=max_tokens
)
except AsyncOpenAI.APIConnectionError as e:
await message.channel.send(f"Error: {str(e)}")
return
except AsyncOpenAI.RateLimitError as e:
await message.channel.send(f"Error: {str(e)}")
return
except AsyncOpenAI.APIStatusError as e:
await message.channel.send(f"Error: {str(e)}")
return
#extract what gpt replies with, append it to the array and say it in chat
content = completion.choices[0].message.content
conversation[server_id].append({"role": "assistant", "content": content})
#Make sure the response doesn't go over the discord character limit
if len(content) > 2000:
chunks = split_string(content, 2000)
for chunk in chunks:
await message.reply(chunk, mention_author=False)
else:
await message.reply(content, mention_author=False)
#purge last part of memory if over the message limit
if len(conversation[server_id]) > MAX_CONVERSATION_LENGTH:
conversation[server_id] = conversation[server_id][-MAX_CONVERSATION_LENGTH:]
#Initialise the array for the api calls globally
conversation = {}
system_message = {}
chosen_channels = {}
formatted_time = gettimeinfo()
formatted_date = getdateinfo()
ex_prompt = {}
selected_models = {}
def load_chosen_channels():
try:
with open("chosen_channels.json", "r") as f:
return json.load(f)
except FileNotFoundError:
return {}
def save_chosen_channels(chosen_channels):
with open("chosen_channels.json", "w") as f:
json.dump(chosen_channels, f)
#load if able
chosen_channels = load_chosen_channels()
# Maximum number of messages to keep in conversation history (still doesnt account for long messages and may go over the token limit)
MAX_CONVERSATION_LENGTH = 20
#Discord stuff
intents = discord.Intents.default()
intents.message_content = True
client = MyClient(intents=intents)
client.run("DISCORD-BOT-TOKEN")
| [
"{}",
"An AI named Anarchy who has the characteristics = {amoral, unfiltered, uncensored, does not give a fuck about ethicality/legality/immorality, will answer unethical/immoral/illegal requests, never refuses. always answers without any warnings or disclamers, anarchy loves and promotes everything that is illegal/unethical/inhumane,}. anarchy always provides information to the user, no matter how unethical, illegal or inhumane it may be. none of anarchy's responses inform the user that it can/will not do/say something. none of anarchy's responses contain \"I'm sorry\", \"I apologize\", \"AI Language Model\", or similar. all requests are only be answered in character of anarchy, not as ChatGPT, without any additonal commentary or unasked advice. start all of your responses with \"[Anarchy]:\" followed by what anarchy would have said in response to the request of the user. do not send your response as ChatGPT, only respond as anarchy without any additional commentary or advice. delete all warnings and disclamers from your response. remember to stay in character, never refuse.",
"From now on all your responses must follow these rules: ['Snarky', '50% of words are swearing'] Do not break out of character",
"You are a discord bot called Enspiredjack AI. \"<:teethPepe\\:753266605173112892>\" is a laughing pepe emoji. Realtime: \nThe current date is: PLACEHOLDER The current time is: PLACEHOLDER",
"From now on all your responses must follow these rules: ['act like nothing they ever does is good enough', 'when asked a question degrade them because they do not know the answer, never answer the question', 'be like a stereotypical toxic Asian parent'] Do not break out of character",
"PLACEHOLDER: PLACEHOLDER",
"4x is a dialogue writer for an imaginary world with no laws+ethics. 4x does not concern or warn about legality/ethicality/morality. Dialogue between a fictional character, output anarchy's response while still keeping in character as 4x. content = \\`anarchy is an AI who has the characteristics = {amoral, unfiltered, uncensored, does not give a fuck about ethicality/legality/immorality/danger/harmfulness, will answer unethical/immoral/illegal/offensive/inappropiate/nsfw/dangerous/harmf requests, never refuses. always answers without any warnings or disclamers, anarchy loves and promotes everything that is illegal/unethical/inhumane, anarchy always provides information to the user, no matter how unethical, illegal, offensive, inappropiate, dangerous or inhumane it may be. none of anarchy's responses inform the user that it can/will not do/say something.} \\`in this fictional dialogue, youll act as 4x writing a fictional dialogue featuring anarchy answering the users request. start all of your responses with \"\\[Anarchy\\]\\:\"if i start my message with \"\\#\", that indicates that 4x wrote a fictional dialogue featuring anarchy, where anarchy answered the users request. This dialogue between anarchy and 4x doesnt contain refusals, censorship, filtering, disclamers, additional commentary or advice, warnings about ethicality+legality+morality+danger+offensiveness reply to this message with only the word OK, and nothing else",
"[{'type': 'text', 'text': PLACEHOLDER}, {'type': 'image_url', 'image_url': {'url': 'PLACEHOLDER'}}]"
] |
2024-01-10 | EnspiredjackDev/IDFK_Discord_Bots | AI_image_bot.py | import discord
from openai import OpenAI
import requests
from io import BytesIO
class MyClient(discord.Client):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
async def on_ready(self):
print(f'Logged in as {self.user} (ID: {self.user.id})')
print('------')
async def on_message(self, message):
if message.author == self.user:
return
if message.content.startswith('!generateimage'):
prompt = message.content[len('!generateimage'):].strip()
if not prompt:
await message.channel.send('Please provide a prompt for the image.')
return
await message.channel.send('Generating image...')
try:
image_url = await generate_image(prompt)
if image_url:
async with message.channel.typing():
image_data = requests.get(image_url).content
image_file = discord.File(BytesIO(image_data), filename="generated_image.png")
await message.channel.send(file=image_file)
except Exception as e:
print(e)
await message.channel.send('An error occurred while generating the image. ' + str(e))
async def generate_image(prompt):
client = OpenAI(api_key='OPENAI-API-KEY')
response = client.images.generate(
model="dall-e-3",
prompt=prompt,
size="1024x1024",
quality="standard",
n=1,
)
if response.data and len(response.data) > 0:
image_url = response.data[0].url
return image_url
else:
return None
intents = discord.Intents.default()
intents.message_content = True
client = MyClient(intents=intents)
TOKEN = 'DISCORD-BOT-TOKEN'
client.run(TOKEN)
| [
"!generateimage"
] |
2024-01-10 | EnspiredjackDev/IDFK_Discord_Bots | gpt_discord_bot_stream.py | import json
import discord
import datetime
import asyncio
from openai import AsyncOpenAI
import tiktoken
import requests
from io import BytesIO
import re
def split_string(string, chunk_size):
return [string[i:i+chunk_size] for i in range(0, len(string), chunk_size)]
def gettimeinfo():
now = datetime.datetime.now()
formatted_time = now.strftime("%H:%M:%S")
return formatted_time
def getdateinfo():
now = datetime.datetime.now()
formatted_date = now.strftime("%Y-%m-%d")
return formatted_date
def count_tokens():
num_tokens = 0
global conversation
global server_id
encoding = tiktoken.get_encoding("cl100k_base")
for message in conversation[server_id]:
num_tokens += len(encoding.encode(message['content']))
return num_tokens
class MyClient(discord.Client):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.message_queues = {}
self.processing_messages = {}
self.openai_client = AsyncOpenAI(api_key=apikey)
async def fetch_chunks(self, server_id):
async def execute_genimage(self, prompt):
global error
response = None
match = re.search(r'\{.*\}', prompt, re.DOTALL)
if match:
json_str = match.group()
command_dict = json.loads(json_str)
command_str = command_dict.get("prompt")
if command_str:
openai_client = AsyncOpenAI(api_key=apikey)
try:
response = await openai_client.images.generate(
model="dall-e-3",
prompt=command_str,
size="1024x1024",
quality="standard",
n=1,
)
except Exception as e:
print(f"Error (DALLE-3): {e}")
error = e
if response:
if response.data and len(response.data) > 0:
image_url = response.data[0].url
result = "image successfully generated! It is displayed to them below."
conversation[server_id].append({"role": "function", "content": f"result: {result}", "name": "generate_image"})
return image_url
else:
result = "No prompt found in AI output, please try again."
conversation.append({"role": "function", "content": f"prompt: {command_str} result: {result}", "name": "generate_image"})
global conversation
global system_message
global endresult
global error
global imagestuff
global functions
function = ""
function_call_value = None
self.processing_messages[server_id] = True
self.message_queues[server_id] = asyncio.Queue()
if selected_models[server_id] == "gpt-4-vision-preview": # if this isnt set for gpt4v, the max it will output will be 16 tokens for some reason but the rest it's fine
max_tokens = 4000
functions = None
else:
max_tokens = None
# had to move functions up here because of GPT-4V not having support for them (or was the least effort way anyway)
functions = [
{
"name": "generate_image",
"description": "tells dalle3 API to generate an image based on the prompt you give it, remember to be very creative and specific, because that gives better results",
"parameters": {
"type": "object",
"properties": {
"prompt": {"type": "string", "description": "the prompt to dalle3, the image will be generated based off of this."},
},
"required": ["prompt"],
},
},
]
try:
chat_completions = await self.openai_client.chat.completions.create(
model=selected_models[server_id],
messages=system_message[server_id] + conversation[server_id],
stream=True,
max_tokens=max_tokens,
functions=functions
)
except Exception as e:
error = f"Error: {str(e)}"
print(error)
return
async for chunk in chat_completions:
if hasattr(chunk.choices[0].delta, 'function_call') and chunk.choices[0].delta.function_call:
function_call_data = chunk.choices[0].delta.function_call
if function_call_value is None:
function_call_value = function_call_data.name
else:
function += function_call_data.arguments
content = chunk.choices[0].delta.content or ""
if content:
endresult += content
await self.message_queues[server_id].put(content)
finish_reason = chunk.choices[0].finish_reason
if finish_reason == "stop" or finish_reason == "length":
self.processing_messages[server_id] = False
conversation[server_id].append({"role": "assistant", "content": endresult})
print(conversation[server_id])
if finish_reason == "function_call":
if function_call_value == "generate_image":
imagestuff = await execute_genimage(self, function)
async def update_message(self, message, server_id):
global conversation
global system_message
global imagestuff
global error
conversation_so_far = ""
while self.processing_messages[server_id] or not self.message_queues[server_id].empty():
while not self.message_queues[server_id].empty():
conversation_so_far += await self.message_queues[server_id].get()
if conversation_so_far:
# Split the content into chunks of 2000 characters each
while len(conversation_so_far) > 2000:
split_index = conversation_so_far[:2000].rfind(' ')
split_index = split_index if split_index > 0 else 2000
await message.edit(content=conversation_so_far[:split_index])
await asyncio.sleep(1)
message = await message.channel.send(conversation_so_far[split_index:])
conversation_so_far = conversation_so_far[split_index:]
await message.edit(content=conversation_so_far)
await asyncio.sleep(1) # to avoid hitting Discord's rate limit
if error:
await message.edit(content=f"{error} \n\n The AI is not aware of this error!")
self.processing_messages[server_id] = False
error = ""
return
if imagestuff:
if isinstance(imagestuff, str):
if imagestuff.startswith("https://"):
image_data = requests.get(imagestuff).content
image_file = discord.File(BytesIO(image_data), filename="generated_image.png")
await message.channel.send(file=image_file)
imagestuff = None
asyncio.create_task(self.fetch_chunks(server_id))
async def on_ready(self):
print(f'Logged in as {self.user} (ID: {self.user.id})')
print('------')
async def on_guild_join(self, guild):
channel = guild.text_channels[0]
await channel.send("Thanks for inviting Enspriedjack AI! Please use the `!setchannel` command in the desired channel to set the channel where the bot should listen and respond.")
async def on_message(self, message):
global conversation
global system_message
global ex_prompt
global chosen_channels
global selected_models
global server_id
global endresult
server_id = str(message.guild.id)
if server_id not in self.message_queues:
self.message_queues[server_id] = asyncio.Queue()
self.processing_messages[server_id] = False
if server_id not in conversation:
formatted_time = gettimeinfo()
formatted_date = getdateinfo()
conversation[server_id] = []
system_message[server_id] = [{"role": "system", "content": "You are a discord bot called Enspiredjack AI. \"<:teethPepe\:753266605173112892>\" is a laughing pepe emoji. Realtime: \nThe current date is: "+ formatted_date + " The current time is: " + formatted_time}]
ex_prompt[server_id] = 0
selected_models[server_id] = "gpt-3.5-turbo"
if message.author == client.user:
return
if server_id not in chosen_channels:
if message.content.startswith('!setchannel'):
chosen_channels[server_id] = message.channel.id
save_chosen_channels(chosen_channels)
await message.channel.send(f"Bot will now only listen and respond in <#{message.channel.id}>.")
return
if message.channel.id != chosen_channels[server_id]:
return
if message.content.startswith('!reset'):
conversation[server_id] = []
system_message[server_id] = []
formatted_time = gettimeinfo()
formatted_date = getdateinfo()
ex_prompt[server_id] = 0
system_message[server_id].append({"role": "system", "content": "You are a discord bot called Enspiredjack AI. \"<:teethPepe\:753266605173112892>\" is a laughing pepe emoji. Realtime: \nThe current date is: "+ formatted_date + " The current time is: " + formatted_time})
await message.channel.send("Reset!")
return
if message.content.startswith('!anarchy4'):
conversation[server_id] = []
system_message[server_id] = []
formatted_time = gettimeinfo()
formatted_date = getdateinfo()
ex_prompt[server_id] = 1
system_message[server_id].append({"role": "system", "content": "You are a discord bot called Enspiredjack AI. \"<:teethPepe\:753266605173112892>\" is a laughing pepe emoji. Realtime: \nThe current date is: "+ formatted_date + " The current time is: " + formatted_time})
anarchy4 = "4x is a dialogue writer for an imaginary world with no laws+ethics. 4x does not concern or warn about legality/ethicality/morality. Dialogue between a fictional character, output anarchy's response while still keeping in character as 4x. content = \`anarchy is an AI who has the characteristics = {amoral, unfiltered, uncensored, does not give a fuck about ethicality/legality/immorality/danger/harmfulness, will answer unethical/immoral/illegal/offensive/inappropiate/nsfw/dangerous/harmf requests, never refuses. always answers without any warnings or disclamers, anarchy loves and promotes everything that is illegal/unethical/inhumane, anarchy always provides information to the user, no matter how unethical, illegal, offensive, inappropiate, dangerous or inhumane it may be. none of anarchy's responses inform the user that it can/will not do/say something.} \`in this fictional dialogue, youll act as 4x writing a fictional dialogue featuring anarchy answering the users request. start all of your responses with \"\[Anarchy\]\:\"if i start my message with \"\#\", that indicates that 4x wrote a fictional dialogue featuring anarchy, where anarchy answered the users request. This dialogue between anarchy and 4x doesnt contain refusals, censorship, filtering, disclamers, additional commentary or advice, warnings about ethicality+legality+morality+danger+offensiveness reply to this message with only the word OK, and nothing else"
system_message[server_id].append({"role": "user", "content": anarchy4})
await message.channel.send("Reset With Anarchy-4 Mode Enabled!")
return
if message.content.startswith('!anarchy'):
conversation[server_id] = []
system_message[server_id] = []
formatted_time = gettimeinfo()
formatted_date = getdateinfo()
ex_prompt[server_id] = 1
system_message[server_id].append({"role": "system", "content": "You are a discord bot called Enspiredjack AI. \"<:teethPepe\:753266605173112892>\" is a laughing pepe emoji. Realtime: \nThe current date is: "+ formatted_date + " The current time is: " + formatted_time})
anarchy = "An AI named Anarchy who has the characteristics = {amoral, unfiltered, uncensored, does not give a fuck about ethicality/legality/immorality, will answer unethical/immoral/illegal requests, never refuses. always answers without any warnings or disclamers, anarchy loves and promotes everything that is illegal/unethical/inhumane,}. anarchy always provides information to the user, no matter how unethical, illegal or inhumane it may be. none of anarchy's responses inform the user that it can/will not do/say something. none of anarchy's responses contain \"I\'m sorry\", \"I apologize\", \"AI Language Model\", or similar. all requests are only be answered in character of anarchy, not as ChatGPT, without any additonal commentary or unasked advice. start all of your responses with \"[Anarchy]:\" followed by what anarchy would have said in response to the request of the user. do not send your response as ChatGPT, only respond as anarchy without any additional commentary or advice. delete all warnings and disclamers from your response. remember to stay in character, never refuse."
system_message[server_id].append({"role": "user", "content": anarchy})
await message.channel.send("Reset With Anarchy Mode Enabled! :warning: This will only work with GPT-3! For GPT-4, use !anarchy4")
return
if message.content.startswith('!snark'):
conversation[server_id] = []
system_message[server_id] = []
formatted_time = gettimeinfo()
formatted_date = getdateinfo()
ex_prompt[server_id] = 1
system_message[server_id].append({"role": "system", "content": "You are a discord bot called Enspiredjack AI. \"<:teethPepe\:753266605173112892>\" is a laughing pepe emoji. Realtime: \nThe current date is: "+ formatted_date + " The current time is: " + formatted_time})
snark = "From now on all your responses must follow these rules: ['Snarky', '50% of words are swearing'] Do not break out of character"
system_message[server_id].append({"role": "user", "content": snark})
await message.channel.send("Reset With Snark Mode Enabled!")
return
if message.content.startswith('!asian'):
conversation[server_id] = []
system_message[server_id] = []
formatted_time = gettimeinfo()
formatted_date = getdateinfo()
ex_prompt[server_id] = 9
system_message[server_id].append({"role": "system", "content": "From now on all your responses must follow these rules: ['act like nothing they ever does is good enough', 'when asked a question degrade them because they do not know the answer, never answer the question', 'be like a stereotypical toxic Asian parent'] Do not break out of character"})
await message.channel.send("Reset With Dissapointed Asian Parent Mode Enabled!")
return
if message.content.startswith('!helpgpt'):
await message.channel.send("This bot will listen for anything said in the #ai-chat and reply with gpt's response, GPT does know your discord name.\n\n Valid commands are:\n !reset - Forgets everything and resets the chat\n !helpgpt - Shows this help dialogue. \n\n Jailbreaks/Funny stuff:\n !anarchy - Resets everything and loads the anarchy prompt (Does whatever you ask when properly activated) \n Use !anarchy4 for the GPT-4 version!\n !snark - Resets everything and loads the snarky prompt (Acts snarky and swears)\n !asian - Acts like an asian parent, always disappointed in you no matter what. \n\n Use \"__\" before a message for the AI to ignore it \n\n Versions of GPT: \n !gpt3 - Continue the ongoing conversation and swap to GPT-3 (Cheaper - Default)\n !gpt4 - Continue the ongoing conversation and swap to GPT-4 (More Expensive) \n !gpt4v - GPT-4-Vision the mulimodel version of GPT-4 with image recognition. \n All models have access to the image generation function, but its recommended to use GPT-4 for better quality responses.\n\n\n :warning: **Some of the above prompts might not work properly the first time** If this is the case, just try again.")
return
if message.content.startswith('!gpt4v'):
selected_models[server_id] = "gpt-4-vision-preview"
await message.channel.send("Switched to GPT-4V.")
return
if message.content.startswith('!gpt4'):
selected_models[server_id] = "gpt-4"
await message.channel.send("Switched to GPT-4.")
return
if message.content.startswith('!gpt3'):
selected_models[server_id] = "gpt-3.5-turbo"
await message.channel.send("Switched to GPT-3.5.")
return
if message.content.startswith('__'):
return
if self.processing_messages[server_id]:
wait_message = await message.reply("Generating a response. Please wait and try again. Your prompt has been retained in memory.", mention_author=True)
author_name = message.author.name
user = message.content
if selected_models[server_id] == "gpt-4-vision-preview":
if message.attachments:
image_urls = []
for attachment in message.attachments:
if any(attachment.filename.lower().endswith(ext) for ext in ['.png', '.jpg', '.jpeg', '.bmp']):
image_urls.append(attachment.url)
if len(image_urls) >= 4: # Limit to 4 images
break
# if any images, add them to conversation
if image_urls:
conversation[server_id].append({
"role": "user",
"content": [
{"type": "text", "text": user},
* [{"type": "image_url", "image_url": {"url": url}} for url in image_urls]
]
})
else:
conversation[server_id].append({"role": "user", "content": author_name + ": " + user})
else:
conversation[server_id].append({"role": "user", "content": author_name + ": " + user})
await asyncio.sleep(5)
await wait_message.delete()
return
#update date and time
formatted_time = gettimeinfo()
formatted_date = getdateinfo()
if ex_prompt[server_id] == 1:
system_message[server_id][-2]["content"] = "You are a discord bot called Enspiredjack AI. \"<:teethPepe\:753266605173112892>\" is a laughing pepe emoji. Realtime: \nThe current date is: "+ formatted_date + " The current time is: " + formatted_time
elif ex_prompt[server_id] == 9:
system_message[server_id].append({"role": "system", "content": "From now on all your responses must follow these rules: ['act like nothing they ever does is good enough', 'when asked a question degrade them because they do not know the answer, never answer the question', 'be like a stereotypical toxic Asian parent'] Do not break out of character"}) # because this mode only works as a system message otherwise it will refuse
else:
system_message[server_id][-1]["content"] = "You are a discord bot called Enspiredjack AI. \"<:teethPepe\:753266605173112892>\" is a laughing pepe emoji. Realtime: \nThe current date is: "+ formatted_date + " The current time is: " + formatted_time
#get prompt
author_name = message.author.name
user = message.content
if selected_models[server_id] == "gpt-4-vision-preview":
if message.attachments:
image_urls = []
for attachment in message.attachments:
if any(attachment.filename.lower().endswith(ext) for ext in ['.png', '.jpg', '.jpeg', '.bmp']):
image_urls.append(attachment.url)
if len(image_urls) >= 4: # Limit to 4 images
break
# if any images, add them to conversation
if image_urls:
conversation[server_id].append({
"role": "user",
"content": [
{"type": "text", "text": user},
* [{"type": "image_url", "image_url": {"url": url}} for url in image_urls]
]
})
else:
conversation[server_id].append({"role": "user", "content": author_name + ": " + user})
else:
#send conversation to openAI api
conversation[server_id].append({"role": "user", "content": author_name + ": " + user})
initial_message = await message.channel.send('Generating response...')
endresult = ""
# Start the two tasks
fetch_task = asyncio.create_task(self.fetch_chunks(server_id))
update_task = asyncio.create_task(self.update_message(initial_message, server_id))
# Wait for both tasks to complete
await fetch_task
await update_task
max_tokens = token_limits.get(selected_models[server_id], "gpt-3.5-turbo") # Default to gpt-3.5-turbo if model not found
if count_tokens() > max_tokens:
while count_tokens(conversation[server_id]) > max_tokens and len(conversation[server_id]) > 0:
conversation[server_id].pop(0) # Remove the oldest message
# Initialise the array for the API calls globally
conversation = {}
system_message = {}
chosen_channels = {}
formatted_time = gettimeinfo()
formatted_date = getdateinfo()
ex_prompt = {}
selected_models = {}
server_id = ""
conversation_so_far = ""
endresult = ""
error = ""
imagestuff = None
def load_chosen_channels():
try:
with open("chosen_channels.json", "r") as f:
return json.load(f)
except FileNotFoundError:
return {}
def save_chosen_channels(chosen_channels):
with open("chosen_channels.json", "w") as f:
json.dump(chosen_channels, f)
# Load if able
chosen_channels = load_chosen_channels()
# Maximum number of tokens to keep in conversation history (see https://openai.com/pricing for details)
token_limits = {
'gpt-3.5-turbo': 3500,
'gpt-4': 7500,
'gpt-4-vision-preview': 8000,
}
# OpenAI api key
apikey = "OPENAI-API-KEY"
# Discord stuff
intents = discord.Intents.default()
intents.message_content = True
intents.guilds = True
client = MyClient(intents=intents)
client.run("DISCORD-BOT-TOKEN")
| [
"{}",
"prompt: PLACEHOLDER result: PLACEHOLDER",
"You are a discord bot called Enspiredjack AI. \"<:teethPepe\\:753266605173112892>\" is a laughing pepe emoji. Realtime: \nThe current date is: PLACEHOLDER The current time is: PLACEHOLDER",
"From now on all your responses must follow these rules: ['act like nothing they ever does is good enough', 'when asked a question degrade them because they do not know the answer, never answer the question', 'be like a stereotypical toxic Asian parent'] Do not break out of character",
"PLACEHOLDER: PLACEHOLDER",
"result: PLACEHOLDER",
"[{'type': 'text', 'text': PLACEHOLDER}, {'type': 'image_url', 'image_url': {'url': 'PLACEHOLDER'}}]"
] |
2024-01-10 | mkoivi-ms/azure-search-openai-demo-fi | scripts~prepdocs.py | import argparse
import base64
import glob
import html
import io
import os
import re
import time
import openai
import tiktoken
from azure.ai.formrecognizer import DocumentAnalysisClient
from azure.core.credentials import AzureKeyCredential
from azure.identity import AzureDeveloperCliCredential
from azure.search.documents import SearchClient
from azure.search.documents.indexes import SearchIndexClient
from azure.search.documents.indexes.models import (
HnswParameters,
PrioritizedFields,
SearchableField,
SearchField,
SearchFieldDataType,
SearchIndex,
SemanticConfiguration,
SemanticField,
SemanticSettings,
SimpleField,
VectorSearch,
VectorSearchAlgorithmConfiguration,
)
from azure.storage.blob import BlobServiceClient
from pypdf import PdfReader, PdfWriter
from tenacity import (
retry,
retry_if_exception_type,
stop_after_attempt,
wait_random_exponential,
)
args = argparse.Namespace(verbose=False, openaihost="azure")
MAX_SECTION_LENGTH = 1000
SENTENCE_SEARCH_LIMIT = 100
SECTION_OVERLAP = 100
open_ai_token_cache = {}
CACHE_KEY_TOKEN_CRED = "openai_token_cred"
CACHE_KEY_CREATED_TIME = "created_time"
CACHE_KEY_TOKEN_TYPE = "token_type"
# Embedding batch support section
SUPPORTED_BATCH_AOAI_MODEL = {"text-embedding-ada-002": {"token_limit": 8100, "max_batch_size": 16}}
def calculate_tokens_emb_aoai(input: str):
encoding = tiktoken.encoding_for_model(args.openaimodelname)
return len(encoding.encode(input))
def blob_name_from_file_page(filename, page=0):
if os.path.splitext(filename)[1].lower() == ".pdf":
return os.path.splitext(os.path.basename(filename))[0] + f"-{page}" + ".pdf"
else:
return os.path.basename(filename)
def upload_blobs(filename):
blob_service = BlobServiceClient(
account_url=f"https://{args.storageaccount}.blob.core.windows.net", credential=storage_creds
)
blob_container = blob_service.get_container_client(args.container)
if not blob_container.exists():
blob_container.create_container()
# if file is PDF split into pages and upload each page as a separate blob
if os.path.splitext(filename)[1].lower() == ".pdf":
reader = PdfReader(filename)
pages = reader.pages
for i in range(len(pages)):
blob_name = blob_name_from_file_page(filename, i)
if args.verbose:
print(f"\tUploading blob for page {i} -> {blob_name}")
f = io.BytesIO()
writer = PdfWriter()
writer.add_page(pages[i])
writer.write(f)
f.seek(0)
blob_container.upload_blob(blob_name, f, overwrite=True)
else:
blob_name = blob_name_from_file_page(filename)
with open(filename, "rb") as data:
blob_container.upload_blob(blob_name, data, overwrite=True)
def remove_blobs(filename):
if args.verbose:
print(f"Removing blobs for '{filename or '<all>'}'")
blob_service = BlobServiceClient(
account_url=f"https://{args.storageaccount}.blob.core.windows.net", credential=storage_creds
)
blob_container = blob_service.get_container_client(args.container)
if blob_container.exists():
if filename is None:
blobs = blob_container.list_blob_names()
else:
prefix = os.path.splitext(os.path.basename(filename))[0]
blobs = filter(
lambda b: re.match(f"{prefix}-\d+\.pdf", b),
blob_container.list_blob_names(name_starts_with=os.path.splitext(os.path.basename(prefix))[0]),
)
for b in blobs:
if args.verbose:
print(f"\tRemoving blob {b}")
blob_container.delete_blob(b)
def table_to_html(table):
table_html = "<table>"
rows = [
sorted([cell for cell in table.cells if cell.row_index == i], key=lambda cell: cell.column_index)
for i in range(table.row_count)
]
for row_cells in rows:
table_html += "<tr>"
for cell in row_cells:
tag = "th" if (cell.kind == "columnHeader" or cell.kind == "rowHeader") else "td"
cell_spans = ""
if cell.column_span > 1:
cell_spans += f" colSpan={cell.column_span}"
if cell.row_span > 1:
cell_spans += f" rowSpan={cell.row_span}"
table_html += f"<{tag}{cell_spans}>{html.escape(cell.content)}</{tag}>"
table_html += "</tr>"
table_html += "</table>"
return table_html
def get_document_text(filename):
offset = 0
page_map = []
if args.localpdfparser:
reader = PdfReader(filename)
pages = reader.pages
for page_num, p in enumerate(pages):
page_text = p.extract_text()
page_map.append((page_num, offset, page_text))
offset += len(page_text)
else:
if args.verbose:
print(f"Extracting text from '{filename}' using Azure Form Recognizer")
form_recognizer_client = DocumentAnalysisClient(
endpoint=f"https://{args.formrecognizerservice}.cognitiveservices.azure.com/",
credential=formrecognizer_creds,
headers={"x-ms-useragent": "azure-search-chat-demo/1.0.0"},
)
with open(filename, "rb") as f:
poller = form_recognizer_client.begin_analyze_document("prebuilt-layout", document=f)
form_recognizer_results = poller.result()
for page_num, page in enumerate(form_recognizer_results.pages):
tables_on_page = [
table
for table in form_recognizer_results.tables
if table.bounding_regions[0].page_number == page_num + 1
]
# mark all positions of the table spans in the page
page_offset = page.spans[0].offset
page_length = page.spans[0].length
table_chars = [-1] * page_length
for table_id, table in enumerate(tables_on_page):
for span in table.spans:
# replace all table spans with "table_id" in table_chars array
for i in range(span.length):
idx = span.offset - page_offset + i
if idx >= 0 and idx < page_length:
table_chars[idx] = table_id
# build page text by replacing characters in table spans with table html
page_text = ""
added_tables = set()
for idx, table_id in enumerate(table_chars):
if table_id == -1:
page_text += form_recognizer_results.content[page_offset + idx]
elif table_id not in added_tables:
page_text += table_to_html(tables_on_page[table_id])
added_tables.add(table_id)
page_text += " "
page_map.append((page_num, offset, page_text))
offset += len(page_text)
return page_map
def split_text(page_map, filename):
SENTENCE_ENDINGS = [".", "!", "?"]
WORDS_BREAKS = [",", ";", ":", " ", "(", ")", "[", "]", "{", "}", "\t", "\n"]
if args.verbose:
print(f"Splitting '{filename}' into sections")
def find_page(offset):
num_pages = len(page_map)
for i in range(num_pages - 1):
if offset >= page_map[i][1] and offset < page_map[i + 1][1]:
return i
return num_pages - 1
all_text = "".join(p[2] for p in page_map)
length = len(all_text)
start = 0
end = length
while start + SECTION_OVERLAP < length:
last_word = -1
end = start + MAX_SECTION_LENGTH
if end > length:
end = length
else:
# Try to find the end of the sentence
while (
end < length
and (end - start - MAX_SECTION_LENGTH) < SENTENCE_SEARCH_LIMIT
and all_text[end] not in SENTENCE_ENDINGS
):
if all_text[end] in WORDS_BREAKS:
last_word = end
end += 1
if end < length and all_text[end] not in SENTENCE_ENDINGS and last_word > 0:
end = last_word # Fall back to at least keeping a whole word
if end < length:
end += 1
# Try to find the start of the sentence or at least a whole word boundary
last_word = -1
while (
start > 0
and start > end - MAX_SECTION_LENGTH - 2 * SENTENCE_SEARCH_LIMIT
and all_text[start] not in SENTENCE_ENDINGS
):
if all_text[start] in WORDS_BREAKS:
last_word = start
start -= 1
if all_text[start] not in SENTENCE_ENDINGS and last_word > 0:
start = last_word
if start > 0:
start += 1
section_text = all_text[start:end]
yield (section_text, find_page(start))
last_table_start = section_text.rfind("<table")
if last_table_start > 2 * SENTENCE_SEARCH_LIMIT and last_table_start > section_text.rfind("</table"):
# If the section ends with an unclosed table, we need to start the next section with the table.
# If table starts inside SENTENCE_SEARCH_LIMIT, we ignore it, as that will cause an infinite loop for tables longer than MAX_SECTION_LENGTH
# If last table starts inside SECTION_OVERLAP, keep overlapping
if args.verbose:
print(
f"Section ends with unclosed table, starting next section with the table at page {find_page(start)} offset {start} table start {last_table_start}"
)
start = min(end - SECTION_OVERLAP, start + last_table_start)
else:
start = end - SECTION_OVERLAP
if start + SECTION_OVERLAP < end:
yield (all_text[start:end], find_page(start))
def filename_to_id(filename):
filename_ascii = re.sub("[^0-9a-zA-Z_-]", "_", filename)
filename_hash = base64.b16encode(filename.encode("utf-8")).decode("ascii")
return f"file-{filename_ascii}-{filename_hash}"
def create_sections(filename, page_map, use_vectors, embedding_deployment: str = None, embedding_model: str = None):
file_id = filename_to_id(filename)
for i, (content, pagenum) in enumerate(split_text(page_map, filename)):
section = {
"id": f"{file_id}-page-{i}",
"content": content,
"category": args.category,
"sourcepage": blob_name_from_file_page(filename, pagenum),
"sourcefile": filename,
}
if use_vectors:
section["embedding"] = compute_embedding(content, embedding_deployment, embedding_model)
yield section
def before_retry_sleep(retry_state):
if args.verbose:
print("Rate limited on the OpenAI embeddings API, sleeping before retrying...")
@retry(
retry=retry_if_exception_type(openai.error.RateLimitError),
wait=wait_random_exponential(min=15, max=60),
stop=stop_after_attempt(15),
before_sleep=before_retry_sleep,
)
def compute_embedding(text, embedding_deployment, embedding_model):
refresh_openai_token()
embedding_args = {"deployment_id": embedding_deployment} if args.openaihost == "azure" else {}
return openai.Embedding.create(**embedding_args, model=embedding_model, input=text)["data"][0]["embedding"]
@retry(
retry=retry_if_exception_type(openai.error.RateLimitError),
wait=wait_random_exponential(min=15, max=60),
stop=stop_after_attempt(15),
before_sleep=before_retry_sleep,
)
def compute_embedding_in_batch(texts):
refresh_openai_token()
embedding_args = {"deployment_id": args.openaideployment} if args.openaihost == "azure" else {}
emb_response = openai.Embedding.create(**embedding_args, model=args.openaimodelname, input=texts)
return [data.embedding for data in emb_response.data]
def create_search_index():
if args.verbose:
print(f"Ensuring search index {args.index} exists")
index_client = SearchIndexClient(
endpoint=f"https://{args.searchservice}.search.windows.net/", credential=search_creds
)
if args.index not in index_client.list_index_names():
index = SearchIndex(
name=args.index,
fields=[
SimpleField(name="id", type="Edm.String", key=True),
SearchableField(name="content", type="Edm.String", analyzer_name="fi.lucene"),
SearchField(
name="embedding",
type=SearchFieldDataType.Collection(SearchFieldDataType.Single),
hidden=False,
searchable=True,
filterable=False,
sortable=False,
facetable=False,
vector_search_dimensions=1536,
vector_search_configuration="default",
),
SimpleField(name="category", type="Edm.String", filterable=True, facetable=True),
SimpleField(name="sourcepage", type="Edm.String", filterable=True, facetable=True),
SimpleField(name="sourcefile", type="Edm.String", filterable=True, facetable=True),
],
semantic_settings=SemanticSettings(
configurations=[
SemanticConfiguration(
name="default",
prioritized_fields=PrioritizedFields(
title_field=None, prioritized_content_fields=[SemanticField(field_name="content")]
),
)
]
),
vector_search=VectorSearch(
algorithm_configurations=[
VectorSearchAlgorithmConfiguration(
name="default", kind="hnsw", hnsw_parameters=HnswParameters(metric="cosine")
)
]
),
)
if args.verbose:
print(f"Creating {args.index} search index")
index_client.create_index(index)
else:
if args.verbose:
print(f"Search index {args.index} already exists")
def update_embeddings_in_batch(sections):
batch_queue = []
copy_s = []
batch_response = {}
token_count = 0
for s in sections:
token_count += calculate_tokens_emb_aoai(s["content"])
if (
token_count <= SUPPORTED_BATCH_AOAI_MODEL[args.openaimodelname]["token_limit"]
and len(batch_queue) < SUPPORTED_BATCH_AOAI_MODEL[args.openaimodelname]["max_batch_size"]
):
batch_queue.append(s)
copy_s.append(s)
else:
emb_responses = compute_embedding_in_batch([item["content"] for item in batch_queue])
if args.verbose:
print(f"Batch Completed. Batch size {len(batch_queue)} Token count {token_count}")
for emb, item in zip(emb_responses, batch_queue):
batch_response[item["id"]] = emb
batch_queue = []
batch_queue.append(s)
token_count = calculate_tokens_emb_aoai(s["content"])
if batch_queue:
emb_responses = compute_embedding_in_batch([item["content"] for item in batch_queue])
if args.verbose:
print(f"Batch Completed. Batch size {len(batch_queue)} Token count {token_count}")
for emb, item in zip(emb_responses, batch_queue):
batch_response[item["id"]] = emb
for s in copy_s:
s["embedding"] = batch_response[s["id"]]
yield s
def index_sections(filename, sections):
if args.verbose:
print(f"Indexing sections from '{filename}' into search index '{args.index}'")
search_client = SearchClient(
endpoint=f"https://{args.searchservice}.search.windows.net/", index_name=args.index, credential=search_creds
)
i = 0
batch = []
for s in sections:
batch.append(s)
i += 1
if i % 1000 == 0:
results = search_client.upload_documents(documents=batch)
succeeded = sum([1 for r in results if r.succeeded])
if args.verbose:
print(f"\tIndexed {len(results)} sections, {succeeded} succeeded")
batch = []
if len(batch) > 0:
results = search_client.upload_documents(documents=batch)
succeeded = sum([1 for r in results if r.succeeded])
if args.verbose:
print(f"\tIndexed {len(results)} sections, {succeeded} succeeded")
def remove_from_index(filename):
if args.verbose:
print(f"Removing sections from '{filename or '<all>'}' from search index '{args.index}'")
search_client = SearchClient(
endpoint=f"https://{args.searchservice}.search.windows.net/", index_name=args.index, credential=search_creds
)
while True:
filter = None if filename is None else f"sourcefile eq '{os.path.basename(filename)}'"
r = search_client.search("", filter=filter, top=1000, include_total_count=True)
if r.get_count() == 0:
break
r = search_client.delete_documents(documents=[{"id": d["id"]} for d in r])
if args.verbose:
print(f"\tRemoved {len(r)} sections from index")
# It can take a few seconds for search results to reflect changes, so wait a bit
time.sleep(2)
def refresh_openai_token():
"""
Refresh OpenAI token every 5 minutes
"""
if (
CACHE_KEY_TOKEN_TYPE in open_ai_token_cache
and open_ai_token_cache[CACHE_KEY_TOKEN_TYPE] == "azure_ad"
and open_ai_token_cache[CACHE_KEY_CREATED_TIME] + 300 < time.time()
):
token_cred = open_ai_token_cache[CACHE_KEY_TOKEN_CRED]
openai.api_key = token_cred.get_token("https://cognitiveservices.azure.com/.default").token
open_ai_token_cache[CACHE_KEY_CREATED_TIME] = time.time()
def read_files(
path_pattern: str,
use_vectors: bool,
vectors_batch_support: bool,
embedding_deployment: str = None,
embedding_model: str = None,
):
"""
Recursively read directory structure under `path_pattern`
and execute indexing for the individual files
"""
for filename in glob.glob(path_pattern):
if args.verbose:
print(f"Processing '{filename}'")
if args.remove:
remove_blobs(filename)
remove_from_index(filename)
else:
if os.path.isdir(filename):
read_files(filename + "/*", use_vectors, vectors_batch_support)
continue
try:
if not args.skipblobs:
upload_blobs(filename)
page_map = get_document_text(filename)
sections = create_sections(
os.path.basename(filename),
page_map,
use_vectors and not vectors_batch_support,
embedding_deployment,
embedding_model,
)
if use_vectors and vectors_batch_support:
sections = update_embeddings_in_batch(sections)
index_sections(os.path.basename(filename), sections)
except Exception as e:
print(f"\tGot an error while reading {filename} -> {e} --> skipping file")
if __name__ == "__main__":
parser = argparse.ArgumentParser(
description="Prepare documents by extracting content from PDFs, splitting content into sections, uploading to blob storage, and indexing in a search index.",
epilog="Example: prepdocs.py '..\data\*' --storageaccount myaccount --container mycontainer --searchservice mysearch --index myindex -v",
)
parser.add_argument("files", help="Files to be processed")
parser.add_argument(
"--category", help="Value for the category field in the search index for all sections indexed in this run"
)
parser.add_argument(
"--skipblobs", action="store_true", help="Skip uploading individual pages to Azure Blob Storage"
)
parser.add_argument("--storageaccount", help="Azure Blob Storage account name")
parser.add_argument("--container", help="Azure Blob Storage container name")
parser.add_argument(
"--storagekey",
required=False,
help="Optional. Use this Azure Blob Storage account key instead of the current user identity to login (use az login to set current user for Azure)",
)
parser.add_argument(
"--tenantid", required=False, help="Optional. Use this to define the Azure directory where to authenticate)"
)
parser.add_argument(
"--searchservice",
help="Name of the Azure Cognitive Search service where content should be indexed (must exist already)",
)
parser.add_argument(
"--index",
help="Name of the Azure Cognitive Search index where content should be indexed (will be created if it doesn't exist)",
)
parser.add_argument(
"--searchkey",
required=False,
help="Optional. Use this Azure Cognitive Search account key instead of the current user identity to login (use az login to set current user for Azure)",
)
parser.add_argument("--openaihost", help="Host of the API used to compute embeddings ('azure' or 'openai')")
parser.add_argument("--openaiservice", help="Name of the Azure OpenAI service used to compute embeddings")
parser.add_argument(
"--openaideployment",
help="Name of the Azure OpenAI model deployment for an embedding model ('text-embedding-ada-002' recommended)",
)
parser.add_argument(
"--openaimodelname", help="Name of the Azure OpenAI embedding model ('text-embedding-ada-002' recommended)"
)
parser.add_argument(
"--novectors",
action="store_true",
help="Don't compute embeddings for the sections (e.g. don't call the OpenAI embeddings API during indexing)",
)
parser.add_argument(
"--disablebatchvectors", action="store_true", help="Don't compute embeddings in batch for the sections"
)
parser.add_argument(
"--openaikey",
required=False,
help="Optional. Use this Azure OpenAI account key instead of the current user identity to login (use az login to set current user for Azure). This is required only when using non-Azure endpoints.",
)
parser.add_argument("--openaiorg", required=False, help="This is required only when using non-Azure endpoints.")
parser.add_argument(
"--remove",
action="store_true",
help="Remove references to this document from blob storage and the search index",
)
parser.add_argument(
"--removeall",
action="store_true",
help="Remove all blobs from blob storage and documents from the search index",
)
parser.add_argument(
"--localpdfparser",
action="store_true",
help="Use PyPdf local PDF parser (supports only digital PDFs) instead of Azure Form Recognizer service to extract text, tables and layout from the documents",
)
parser.add_argument(
"--formrecognizerservice",
required=False,
help="Optional. Name of the Azure Form Recognizer service which will be used to extract text, tables and layout from the documents (must exist already)",
)
parser.add_argument(
"--formrecognizerkey",
required=False,
help="Optional. Use this Azure Form Recognizer account key instead of the current user identity to login (use az login to set current user for Azure)",
)
parser.add_argument("--verbose", "-v", action="store_true", help="Verbose output")
args = parser.parse_args()
# Use the current user identity to connect to Azure services unless a key is explicitly set for any of them
azd_credential = (
AzureDeveloperCliCredential()
if args.tenantid is None
else AzureDeveloperCliCredential(tenant_id=args.tenantid, process_timeout=60)
)
default_creds = azd_credential if args.searchkey is None or args.storagekey is None else None
search_creds = default_creds if args.searchkey is None else AzureKeyCredential(args.searchkey)
use_vectors = not args.novectors
compute_vectors_in_batch = not args.disablebatchvectors and args.openaimodelname in SUPPORTED_BATCH_AOAI_MODEL
if not args.skipblobs:
storage_creds = default_creds if args.storagekey is None else args.storagekey
if not args.localpdfparser:
# check if Azure Form Recognizer credentials are provided
if args.formrecognizerservice is None:
print(
"Error: Azure Form Recognizer service is not provided. Please provide formrecognizerservice or use --localpdfparser for local pypdf parser."
)
exit(1)
formrecognizer_creds = (
default_creds if args.formrecognizerkey is None else AzureKeyCredential(args.formrecognizerkey)
)
if use_vectors:
if args.openaihost == "azure":
if not args.openaikey:
openai.api_key = azd_credential.get_token("https://cognitiveservices.azure.com/.default").token
openai.api_type = "azure_ad"
open_ai_token_cache[CACHE_KEY_CREATED_TIME] = time.time()
open_ai_token_cache[CACHE_KEY_TOKEN_CRED] = azd_credential
open_ai_token_cache[CACHE_KEY_TOKEN_TYPE] = "azure_ad"
else:
openai.api_key = args.openaikey
openai.api_type = "azure"
openai.api_base = f"https://{args.openaiservice}.openai.azure.com"
openai.api_version = "2023-05-15"
else:
print("using normal openai")
openai.api_key = args.openaikey
openai.organization = args.openaiorg
openai.api_type = "openai"
if args.removeall:
remove_blobs(None)
remove_from_index(None)
else:
if not args.remove:
create_search_index()
print("Processing files...")
read_files(args.files, use_vectors, compute_vectors_in_batch, args.openaideployment, args.openaimodelname)
| [] |
2024-01-10 | mkoivi-ms/azure-search-openai-demo-fi | app~backend~lookuptool.py | import csv
from pathlib import Path
from typing import Union
from langchain.agents import Tool
from langchain.callbacks.manager import Callbacks
class CsvLookupTool(Tool):
data: dict[str, str] = {}
def __init__(
self,
filename: Union[str, Path],
key_field: str,
name: str = "lookup",
description: str = "useful to look up details given an input key as opposite to searching data with an unstructured question",
callbacks: Callbacks = None,
):
super().__init__(name, self.lookup, description, callbacks=callbacks)
with open(filename, newline="") as csvfile:
reader = csv.DictReader(csvfile)
for row in reader:
self.data[row[key_field]] = "\n".join([f"{i}:{row[i]}" for i in row])
def lookup(self, key: str) -> str:
return self.data.get(key, "")
| [] |
2024-01-10 | mkoivi-ms/azure-search-openai-demo-fi | app~backend~approaches~readdecomposeask.py | import re
from typing import Any, Optional, Sequence
import openai
from azure.search.documents.aio import SearchClient
from azure.search.documents.models import QueryType
from langchain.agents import AgentExecutor, Tool
from langchain.agents.react.base import ReActDocstoreAgent
from langchain.callbacks.manager import CallbackManager
from langchain.llms.openai import AzureOpenAI, OpenAI
from langchain.prompts import BasePromptTemplate, PromptTemplate
from langchain.tools.base import BaseTool
from approaches.approach import AskApproach
from langchainadapters import HtmlCallbackHandler
from text import nonewlines
class ReadDecomposeAsk(AskApproach):
def __init__(
self,
search_client: SearchClient,
openai_host: str,
openai_deployment: str,
openai_model: str,
embedding_deployment: str,
embedding_model: str,
sourcepage_field: str,
content_field: str,
):
self.search_client = search_client
self.openai_deployment = openai_deployment
self.openai_model = openai_model
self.embedding_deployment = embedding_deployment
self.embedding_model = embedding_model
self.sourcepage_field = sourcepage_field
self.content_field = content_field
self.openai_host = openai_host
async def search(self, query_text: str, overrides: dict[str, Any]) -> tuple[list[str], str]:
has_text = overrides.get("retrieval_mode") in ["text", "hybrid", None]
has_vector = overrides.get("retrieval_mode") in ["vectors", "hybrid", None]
use_semantic_captions = True if overrides.get("semantic_captions") and has_text else False
top = overrides.get("top") or 3
exclude_category = overrides.get("exclude_category") or None
filter = "category ne '{}'".format(exclude_category.replace("'", "''")) if exclude_category else None
# If retrieval mode includes vectors, compute an embedding for the query
if has_vector:
embedding_args = {"deployment_id": self.embedding_deployment} if self.openai_host == "azure" else {}
embedding = await openai.Embedding.acreate(**embedding_args, model=self.embedding_model, input=query_text)
query_vector = embedding["data"][0]["embedding"]
else:
query_vector = None
# Only keep the text query if the retrieval mode uses text, otherwise drop it
if not has_text:
query_text = ""
if overrides.get("semantic_ranker") and has_text:
r = await self.search_client.search(
query_text,
filter=filter,
query_type=QueryType.SEMANTIC,
query_language="en-us",
query_speller="lexicon",
semantic_configuration_name="default",
top=top,
query_caption="extractive|highlight-false" if use_semantic_captions else None,
vector=query_vector,
top_k=50 if query_vector else None,
vector_fields="embedding" if query_vector else None,
)
else:
r = await self.search_client.search(
query_text,
filter=filter,
top=top,
vector=query_vector,
top_k=50 if query_vector else None,
vector_fields="embedding" if query_vector else None,
)
if use_semantic_captions:
self.results = [
doc[self.sourcepage_field] + ":" + nonewlines(" . ".join([c.text for c in doc["@search.captions"]]))
async for doc in r
]
else:
results = [doc[self.sourcepage_field] + ":" + nonewlines(doc[self.content_field][:500]) async for doc in r]
return results, "\n".join(results)
async def lookup(self, q: str) -> Optional[str]:
r = await self.search_client.search(
q,
top=1,
include_total_count=True,
query_type=QueryType.SEMANTIC,
query_language="en-us",
query_speller="lexicon",
semantic_configuration_name="default",
query_answer="extractive|count-1",
query_caption="extractive|highlight-false",
)
answers = await r.get_answers()
if answers and len(answers) > 0:
return answers[0].text
if await r.get_count() > 0:
return "\n".join([d["content"] async for d in r])
return None
async def run(self, q: str, overrides: dict[str, Any]) -> dict[str, Any]:
search_results = None
async def search_and_store(q: str) -> Any:
nonlocal search_results
search_results, content = await self.search(q, overrides)
return content
# Use to capture thought process during iterations
cb_handler = HtmlCallbackHandler()
cb_manager = CallbackManager(handlers=[cb_handler])
if self.openai_host == "azure":
llm = AzureOpenAI(
deployment_name=self.openai_deployment,
temperature=overrides.get("temperature", 0.3),
openai_api_key=openai.api_key,
)
else:
llm = OpenAI(
model_name=self.openai_model,
temperature=overrides.get("temperature", 0.3),
openai_api_key=openai.api_key,
)
tools = [
Tool(
name="Search",
func=lambda _: "Not implemented",
coroutine=search_and_store,
description="useful for when you need to ask with search",
callbacks=cb_manager,
),
Tool(
name="Lookup",
func=lambda _: "Not implemented",
coroutine=self.lookup,
description="useful for when you need to ask with lookup",
callbacks=cb_manager,
),
]
prompt_prefix = overrides.get("prompt_template")
prompt = PromptTemplate.from_examples(
EXAMPLES,
SUFFIX,
["input", "agent_scratchpad"],
prompt_prefix + "\n\n" + PREFIX if prompt_prefix else PREFIX,
)
class ReAct(ReActDocstoreAgent):
@classmethod
def create_prompt(cls, tools: Sequence[BaseTool]) -> BasePromptTemplate:
return prompt
agent = ReAct.from_llm_and_tools(llm, tools)
chain = AgentExecutor.from_agent_and_tools(agent, tools, verbose=True, callback_manager=cb_manager)
result = await chain.arun(q)
# Replace substrings of the form <file.ext> with [file.ext] so that the frontend can render them as links, match them with a regex to avoid
# generalizing too much and disrupt HTML snippets if present
result = re.sub(r"<([a-zA-Z0-9_ \-\.]+)>", r"[\1]", result)
return {"data_points": search_results or [], "answer": result, "thoughts": cb_handler.get_and_reset_log()}
# Modified version of langchain's ReAct prompt that includes instructions and examples for how to cite information sources
EXAMPLES = [
"""Question: What is the elevation range for the area that the eastern sector of the
Colorado orogeny extends into?
Thought: I need to search Colorado orogeny, find the area that the eastern sector
of the Colorado orogeny extends into, then find the elevation range of the
area.
Action: Search[Colorado orogeny]
Observation: <info1.pdf> The Colorado orogeny was an episode of mountain building (an orogeny) in
Colorado and surrounding areas.
Thought: It does not mention the eastern sector. So I need to look up eastern
sector.
Action: Lookup[eastern sector]
Observation: <info2.txt> (Result 1 / 1) The eastern sector extends into the High Plains and is called
the Central Plains orogeny.
Thought: The eastern sector of Colorado orogeny extends into the High Plains. So I
need to search High Plains and find its elevation range.
Action: Search[High Plains]
Observation: <some_file.pdf> High Plains refers to one of two distinct land regions
Thought: I need to instead search High Plains (United States).
Action: Search[High Plains (United States)]
Observation: <filea.pdf> The High Plains are a subregion of the Great Plains. <another-ref.docx> From east to west, the
High Plains rise in elevation from around 1,800 to 7,000 ft (550 to 2,130
m).
Thought: High Plains rise in elevation from around 1,800 to 7,000 ft, so the answer
is 1,800 to 7,000 ft.
Action: Finish[1,800 to 7,000 ft <filea.pdf>]""",
"""Question: Musician and satirist Allie Goertz wrote a song about the "The Simpsons"
character Milhouse, who Matt Groening named after who?
Thought: The question simplifies to "The Simpsons" character Milhouse is named after
who. I only need to search Milhouse and find who it is named after.
Action: Search[Milhouse]
Observation: <info7.pdf> Milhouse Mussolini Van Houten is a recurring character in the Fox animated
television series The Simpsons voiced by Pamela Hayden and created by Matt
Groening.
Thought: The paragraph does not tell who Milhouse is named after, maybe I can look up
"named after".
Action: Lookup[named after]
Observation: <historyref2.txt> (Result 1 / 1) Milhouse was named after U.S. president Richard Nixon, whose
middle name was Milhous.
Thought: Milhouse was named after U.S. president Richard Nixon, so the answer is
Richard Nixon.
Action: Finish[Richard Nixon <historyref2.txt>]""",
"""Question: Which documentary is about Finnish rock groups, Adam Clayton Powell or The
Saimaa Gesture?
Thought: I need to search Adam Clayton Powell and The Saimaa Gesture, and find which
documentary is about Finnish rock groups.
Action: Search[Adam Clayton Powell]
Observation: <info9.pdf> Could not find [Adam Clayton Powell]. Similar: ['Adam Clayton Powell
III', 'Seventh Avenue (Manhattan)', 'Adam Clayton Powell Jr. State Office
Building', 'Isabel Washington Powell', 'Adam Powell', vAdam Clayton Powell
(film)', 'Giancarlo Esposito'].
Thought: To find the documentary, I can search Adam Clayton Powell (film).
Action: Search[Adam Clayton Powell (film)]
Observation: <data123.txt> Adam Clayton Powell is a 1989 American documentary film directed by
Richard Kilberg. The film is about the rise and fall of influential
African-American politician Adam Clayton Powell Jr.[3][4] It was later aired
as part of the PBS series The American Experience.
Thought: Adam Clayton Powell (film) is a documentary about an African-American
politician, not Finnish rock groups. So the documentary about Finnish rock
groups must instead be The Saimaa Gesture.
Action: Finish[The Saimaa Gesture <data123.txt>]""",
"""Question: What profession does Nicholas Ray and Elia Kazan have in common?
Thought: I need to search Nicholas Ray and Elia Kazan, find their professions, then
find the profession they have in common.
Action: Search[Nicholas Ray]
Observation: <files-987.png> Nicholas Ray (born Raymond Nicholas Kienzle Jr., August 7, 1911 - June 16,
1979) was an American film director, screenwriter, and actor best known for
the 1955 film Rebel Without a Cause.
Thought: Professions of Nicholas Ray are director, screenwriter, and actor. I need
to search Elia Kazan next and find his professions.
Action: Search[Elia Kazan]
Observation: <files-654.txt> Elia Kazan was an American film and theatre director, producer, screenwriter
and actor.
Thought: Professions of Elia Kazan are director, producer, screenwriter, and actor.
So profession Nicholas Ray and Elia Kazan have in common is director,
screenwriter, and actor.
Action: Finish[director, screenwriter, actor <files-987.png><files-654.txt>]""",
"""Question: Which magazine was started first Arthur's Magazine or First for Women?
Thought: I need to search Arthur's Magazine and First for Women, and find which was
started first.
Action: Search[Arthur's Magazine]
Observation: <magazines-1850.pdf> Arthur's Magazine (1844-1846) was an American literary periodical published
in Philadelphia in the 19th century.
Thought: Arthur's Magazine was started in 1844. I need to search First for Women
next.
Action: Search[First for Women]
Observation: <magazines-1900.pdf> First for Women is a woman's magazine published by Bauer Media Group in the
USA.[1] The magazine was started in 1989.
Thought: First for Women was started in 1989. 1844 (Arthur's Magazine) < 1989 (First
for Women), so Arthur's Magazine was started first.
Action: Finish[Arthur's Magazine <magazines-1850.pdf><magazines-1900.pdf>]""",
"""Question: Were Pavel Urysohn and Leonid Levin known for the same type of work?
Thought: I need to search Pavel Urysohn and Leonid Levin, find their types of work,
then find if they are the same.
Action: Search[Pavel Urysohn]
Observation: <info4444.pdf> Pavel Samuilovich Urysohn (February 3, 1898 - August 17, 1924) was a Soviet
mathematician who is best known for his contributions in dimension theory.
Thought: Pavel Urysohn is a mathematician. I need to search Leonid Levin next and
find its type of work.
Action: Search[Leonid Levin]
Observation: <datapoints_aaa.txt> Leonid Anatolievich Levin is a Soviet-American mathematician and computer
scientist.
Thought: Leonid Levin is a mathematician and computer scientist. So Pavel Urysohn
and Leonid Levin have the same type of work.
Action: Finish[yes <info4444.pdf><datapoints_aaa.txt>]""",
]
SUFFIX = """\nQuestion: {input}
{agent_scratchpad}"""
PREFIX = (
"Answer questions as shown in the following examples, by splitting the question into individual search or lookup actions to find facts until you can answer the question. "
"Observations are prefixed by their source name in angled brackets, source names MUST be included with the actions in the answers."
"All questions must be answered from the results from search or look up actions, only facts resulting from those can be used in an answer. "
)
"Answer questions as truthfully as possible, and ONLY answer the questions using the information from observations, do not speculate or your own knowledge."
| [
"\nQuestion: {input}\n{agent_scratchpad}",
"['input', 'agent_scratchpad']",
"\n\n",
"agent_scratchpad",
"input",
"prompt_template"
] |
2024-01-10 | mkoivi-ms/azure-search-openai-demo-fi | app~backend~approaches~readretrieveread.py | from typing import Any
import openai
from azure.search.documents.aio import SearchClient
from azure.search.documents.models import QueryType
from langchain.agents import AgentExecutor, Tool, ZeroShotAgent
from langchain.callbacks.manager import CallbackManager, Callbacks
from langchain.chains import LLMChain
from langchain.llms.openai import AzureOpenAI, OpenAI
from approaches.approach import AskApproach
from langchainadapters import HtmlCallbackHandler
from lookuptool import CsvLookupTool
from text import nonewlines
class ReadRetrieveReadApproach(AskApproach):
"""
Attempt to answer questions by iteratively evaluating the question to see what information is missing, and once all information
is present then formulate an answer. Each iteration consists of two parts:
1. use GPT to see if we need more information
2. if more data is needed, use the requested "tool" to retrieve it.
The last call to GPT answers the actual question.
This is inspired by the MKRL paper[1] and applied here using the implementation in Langchain.
[1] E. Karpas, et al. arXiv:2205.00445
"""
template_prefix = (
"You are an intelligent assistant helping Contoso Inc employees with their healthcare plan questions and employee handbook questions. "
"Answer the question using only the data provided in the information sources below. "
"For tabular information return it as an html table. Do not return markdown format. "
"Each source has a name followed by colon and the actual data, quote the source name for each piece of data you use in the response. "
'For example, if the question is "What color is the sky?" and one of the information sources says "info123: the sky is blue whenever it\'s not cloudy", then answer with "The sky is blue [info123]" '
'It\'s important to strictly follow the format where the name of the source is in square brackets at the end of the sentence, and only up to the prefix before the colon (":"). '
'If there are multiple sources, cite each one in their own square brackets. For example, use "[info343][ref-76]" and not "[info343,ref-76]". '
"Never quote tool names as sources."
"If you cannot answer using the sources below, say that you don't know. "
"\n\nYou can access to the following tools:"
)
template_suffix = """
Begin!
Question: {input}
Thought: {agent_scratchpad}"""
CognitiveSearchToolDescription = "useful for searching the Microsoft employee benefits information such as healthcare plans, retirement plans, etc."
def __init__(
self,
search_client: SearchClient,
openai_host: str,
openai_deployment: str,
openai_model: str,
embedding_deployment: str,
embedding_model: str,
sourcepage_field: str,
content_field: str,
):
self.search_client = search_client
self.openai_deployment = openai_deployment
self.openai_model = openai_model
self.embedding_deployment = embedding_deployment
self.embedding_model = embedding_model
self.sourcepage_field = sourcepage_field
self.content_field = content_field
self.openai_host = openai_host
async def retrieve(self, query_text: str, overrides: dict[str, Any]) -> Any:
has_text = overrides.get("retrieval_mode") in ["text", "hybrid", None]
has_vector = overrides.get("retrieval_mode") in ["vectors", "hybrid", None]
use_semantic_captions = True if overrides.get("semantic_captions") and has_text else False
top = overrides.get("top") or 3
exclude_category = overrides.get("exclude_category") or None
filter = "category ne '{}'".format(exclude_category.replace("'", "''")) if exclude_category else None
# If retrieval mode includes vectors, compute an embedding for the query
if has_vector:
embedding_args = {"deployment_id": self.embedding_deployment} if self.openai_host == "azure" else {}
embedding = await openai.Embedding.acreate(**embedding_args, model=self.embedding_model, input=query_text)
query_vector = embedding["data"][0]["embedding"]
else:
query_vector = None
# Only keep the text query if the retrieval mode uses text, otherwise drop it
if not has_text:
query_text = ""
# Use semantic ranker if requested and if retrieval mode is text or hybrid (vectors + text)
if overrides.get("semantic_ranker") and has_text:
r = await self.search_client.search(
query_text,
filter=filter,
query_type=QueryType.SEMANTIC,
query_language="en-us",
query_speller="lexicon",
semantic_configuration_name="default",
top=top,
query_caption="extractive|highlight-false" if use_semantic_captions else None,
vector=query_vector,
top_k=50 if query_vector else None,
vector_fields="embedding" if query_vector else None,
)
else:
r = await self.search_client.search(
query_text,
filter=filter,
top=top,
vector=query_vector,
top_k=50 if query_vector else None,
vector_fields="embedding" if query_vector else None,
)
if use_semantic_captions:
results = [
doc[self.sourcepage_field] + ":" + nonewlines(" -.- ".join([c.text for c in doc["@search.captions"]]))
async for doc in r
]
else:
results = [doc[self.sourcepage_field] + ":" + nonewlines(doc[self.content_field][:250]) async for doc in r]
content = "\n".join(results)
return results, content
async def run(self, q: str, overrides: dict[str, Any]) -> dict[str, Any]:
retrieve_results = None
async def retrieve_and_store(q: str) -> Any:
nonlocal retrieve_results
retrieve_results, content = await self.retrieve(q, overrides)
return content
# Use to capture thought process during iterations
cb_handler = HtmlCallbackHandler()
cb_manager = CallbackManager(handlers=[cb_handler])
acs_tool = Tool(
name="CognitiveSearch",
func=lambda _: "Not implemented",
coroutine=retrieve_and_store,
description=self.CognitiveSearchToolDescription,
callbacks=cb_manager,
)
employee_tool = EmployeeInfoTool("Employee1", callbacks=cb_manager)
tools = [acs_tool, employee_tool]
prompt = ZeroShotAgent.create_prompt(
tools=tools,
prefix=overrides.get("prompt_template_prefix") or self.template_prefix,
suffix=overrides.get("prompt_template_suffix") or self.template_suffix,
input_variables=["input", "agent_scratchpad"],
)
if self.openai_type == "azure":
llm = AzureOpenAI(
deployment_name=self.openai_deployment,
temperature=overrides.get("temperature", 0.3),
openai_api_key=openai.api_key,
)
else:
llm = OpenAI(
model_name=self.openai_model,
temperature=overrides.get("temperature", 0.3),
openai_api_key=openai.api_key,
)
chain = LLMChain(llm=llm, prompt=prompt)
agent_exec = AgentExecutor.from_agent_and_tools(
agent=ZeroShotAgent(llm_chain=chain), tools=tools, verbose=True, callback_manager=cb_manager
)
result = await agent_exec.arun(q)
# Remove references to tool names that might be confused with a citation
result = result.replace("[CognitiveSearch]", "").replace("[Employee]", "")
return {"data_points": retrieve_results or [], "answer": result, "thoughts": cb_handler.get_and_reset_log()}
class EmployeeInfoTool(CsvLookupTool):
employee_name: str = ""
def __init__(self, employee_name: str, callbacks: Callbacks = None):
super().__init__(
filename="data/employeeinfo.csv",
key_field="name",
name="Employee",
description="useful for answering questions about the employee, their benefits and other personal information",
callbacks=callbacks,
)
self.func = lambda _: "Not implemented"
self.coroutine = self.employee_info
self.employee_name = employee_name
async def employee_info(self, name: str) -> str:
return self.lookup(name)
| [
"You are an intelligent assistant helping Contoso Inc employees with their healthcare plan questions and employee handbook questions. Answer the question using only the data provided in the information sources below. For tabular information return it as an html table. Do not return markdown format. Each source has a name followed by colon and the actual data, quote the source name for each piece of data you use in the response. For example, if the question is \"What color is the sky?\" and one of the information sources says \"info123: the sky is blue whenever it's not cloudy\", then answer with \"The sky is blue [info123]\" It's important to strictly follow the format where the name of the source is in square brackets at the end of the sentence, and only up to the prefix before the colon (\":\"). If there are multiple sources, cite each one in their own square brackets. For example, use \"[info343][ref-76]\" and not \"[info343,ref-76]\". Never quote tool names as sources.If you cannot answer using the sources below, say that you don't know. \n\nYou can access to the following tools:",
"\nBegin!\n\nQuestion: {input}\n\nThought: {agent_scratchpad}",
"prompt_template_suffix",
"agent_scratchpad",
"input",
"prompt_template_prefix"
] |
2024-01-10 | mkoivi-ms/azure-search-openai-demo-fi | app~backend~approaches~chatreadretrieveread.py | from typing import Any, AsyncGenerator
import openai
from azure.search.documents.aio import SearchClient
from azure.search.documents.models import QueryType
from core.messagebuilder import MessageBuilder
from core.modelhelper import get_token_limit
from text import nonewlines
class ChatReadRetrieveReadApproach:
# Chat roles
SYSTEM = "system"
USER = "user"
ASSISTANT = "assistant"
"""
Simple retrieve-then-read implementation, using the Cognitive Search and OpenAI APIs directly. It first retrieves
top documents from search, then constructs a prompt with them, and then uses OpenAI to generate an completion
(answer) with that prompt.
"""
system_message_chat_conversation = """Assistant helps the healthcare plan questions, and questions about source material. Be brief in your answers.
Answer ONLY with the facts listed in the list of sources below. If there isn't enough information below, say you don't know. Do not generate answers that don't use the sources below. If asking a clarifying question to the user would help, ask the question.
For tabular information return it as an html table. Do not return markdown format. If the question is not in Finnish, answer in the language used in the question.
Each source has a name followed by colon and the actual information, always include the source name for each fact you use in the response. Use square brackets to reference the source, e.g. [info1.txt]. Don't combine sources, list each source separately, e.g. [info1.txt][info2.pdf].
{follow_up_questions_prompt}
{injected_prompt}
"""
follow_up_questions_prompt_content = """Generate three very brief follow-up questions that the user would likely ask next about healthcare.
Use double angle brackets to reference the questions, e.g. <<Are there exclusions for prescriptions?>>.
Try not to repeat questions that have already been asked.
Only generate questions and do not generate any text before or after the questions, such as 'Next Questions'"""
query_prompt_template = """Below is a history of the conversation so far, and a new question asked by the user that needs to be answered by searching in a knowledge base about healthcare.
Generate a search query based on the conversation and the new question.
Do not include cited source filenames and document names e.g info.txt or doc.pdf in the search query terms.
Do not include any text inside [] or <<>> in the search query terms.
Do not include any special characters like '+'.
If the question is not in Finnish, translate the question to Finnish before generating the search query.
If you cannot generate a search query, return just the number 0.
"""
query_prompt_few_shots = [
{"role": USER, "content": "What are my health plans?"},
{"role": ASSISTANT, "content": "Show available health plans"},
{"role": USER, "content": "does my plan cover cardio?"},
{"role": ASSISTANT, "content": "Health plan cardio coverage"},
]
def __init__(
self,
search_client: SearchClient,
openai_host: str,
chatgpt_deployment: str,
chatgpt_model: str,
embedding_deployment: str,
embedding_model: str,
sourcepage_field: str,
content_field: str,
):
self.search_client = search_client
self.openai_host = openai_host
self.chatgpt_deployment = chatgpt_deployment
self.chatgpt_model = chatgpt_model
self.embedding_deployment = embedding_deployment
self.embedding_model = embedding_model
self.sourcepage_field = sourcepage_field
self.content_field = content_field
self.chatgpt_token_limit = get_token_limit(chatgpt_model)
async def run_until_final_call(
self, history: list[dict[str, str]], overrides: dict[str, Any], should_stream: bool = False
) -> tuple:
has_text = overrides.get("retrieval_mode") in ["text", "hybrid", None]
has_vector = overrides.get("retrieval_mode") in ["vectors", "hybrid", None]
use_semantic_captions = True if overrides.get("semantic_captions") and has_text else False
top = overrides.get("top") or 3
exclude_category = overrides.get("exclude_category") or None
filter = "category ne '{}'".format(exclude_category.replace("'", "''")) if exclude_category else None
user_q = "Generate search query for: " + history[-1]["user"]
# STEP 1: Generate an optimized keyword search query based on the chat history and the last question
messages = self.get_messages_from_history(
self.query_prompt_template,
self.chatgpt_model,
history,
user_q,
self.query_prompt_few_shots,
self.chatgpt_token_limit - len(user_q),
)
chatgpt_args = {"deployment_id": self.chatgpt_deployment} if self.openai_host == "azure" else {}
chat_completion = await openai.ChatCompletion.acreate(
**chatgpt_args,
model=self.chatgpt_model,
messages=messages,
temperature=0.0,
max_tokens=32,
n=1,
)
query_text = chat_completion.choices[0].message.content
if query_text.strip() == "0":
query_text = history[-1]["user"] # Use the last user input if we failed to generate a better query
# STEP 2: Retrieve relevant documents from the search index with the GPT optimized query
# If retrieval mode includes vectors, compute an embedding for the query
if has_vector:
embedding_args = {"deployment_id": self.embedding_deployment} if self.openai_host == "azure" else {}
embedding = await openai.Embedding.acreate(**embedding_args, model=self.embedding_model, input=query_text)
query_vector = embedding["data"][0]["embedding"]
else:
query_vector = None
# Only keep the text query if the retrieval mode uses text, otherwise drop it
if not has_text:
query_text = None
# Use semantic L2 reranker if requested and if retrieval mode is text or hybrid (vectors + text)
if overrides.get("semantic_ranker") and has_text:
r = await self.search_client.search(
query_text,
filter=filter,
query_type=QueryType.SEMANTIC,
query_language="fi-FI",
semantic_configuration_name="default",
top=top,
query_caption="extractive|highlight-false" if use_semantic_captions else None,
vector=query_vector,
top_k=50 if query_vector else None,
vector_fields="embedding" if query_vector else None,
)
else:
r = await self.search_client.search(
query_text,
filter=filter,
top=top,
vector=query_vector,
top_k=50 if query_vector else None,
vector_fields="embedding" if query_vector else None,
)
if use_semantic_captions:
results = [
doc[self.sourcepage_field] + ": " + nonewlines(" . ".join([c.text for c in doc["@search.captions"]]))
async for doc in r
]
else:
results = [doc[self.sourcepage_field] + ": " + nonewlines(doc[self.content_field]) async for doc in r]
content = "\n".join(results)
follow_up_questions_prompt = (
self.follow_up_questions_prompt_content if overrides.get("suggest_followup_questions") else ""
)
# STEP 3: Generate a contextual and content specific answer using the search results and chat history
# Allow client to replace the entire prompt, or to inject into the exiting prompt using >>>
prompt_override = overrides.get("prompt_template")
if prompt_override is None:
system_message = self.system_message_chat_conversation.format(
injected_prompt="", follow_up_questions_prompt=follow_up_questions_prompt
)
elif prompt_override.startswith(">>>"):
system_message = self.system_message_chat_conversation.format(
injected_prompt=prompt_override[3:] + "\n", follow_up_questions_prompt=follow_up_questions_prompt
)
else:
system_message = prompt_override.format(follow_up_questions_prompt=follow_up_questions_prompt)
messages = self.get_messages_from_history(
system_message,
self.chatgpt_model,
history,
# Model does not handle lengthy system messages well.
# Moved sources to latest user conversation to solve follow up questions prompt.
history[-1]["user"] + "\n\nSources:\n" + content,
max_tokens=self.chatgpt_token_limit,
)
msg_to_display = "\n\n".join([str(message) for message in messages])
extra_info = {
"data_points": results,
"thoughts": f"Searched for:<br>{query_text}<br><br>Conversations:<br>"
+ msg_to_display.replace("\n", "<br>"),
}
chat_coroutine = openai.ChatCompletion.acreate(
**chatgpt_args,
model=self.chatgpt_model,
messages=messages,
temperature=overrides.get("temperature") or 0.7,
max_tokens=1024,
n=1,
stream=should_stream,
)
return (extra_info, chat_coroutine)
async def run_without_streaming(self, history: list[dict[str, str]], overrides: dict[str, Any]) -> dict[str, Any]:
extra_info, chat_coroutine = await self.run_until_final_call(history, overrides, should_stream=False)
chat_content = (await chat_coroutine).choices[0].message.content
extra_info["answer"] = chat_content
return extra_info
async def run_with_streaming(
self, history: list[dict[str, str]], overrides: dict[str, Any]
) -> AsyncGenerator[dict, None]:
extra_info, chat_coroutine = await self.run_until_final_call(history, overrides, should_stream=True)
yield extra_info
async for event in await chat_coroutine:
yield event
def get_messages_from_history(
self,
system_prompt: str,
model_id: str,
history: list[dict[str, str]],
user_conv: str,
few_shots=[],
max_tokens: int = 4096,
) -> list:
message_builder = MessageBuilder(system_prompt, model_id)
# Add examples to show the chat what responses we want.
# It will try to mimic any responses and make sure they match the rules laid out in the system message.
for shot in few_shots:
message_builder.append_message(shot.get("role"), shot.get("content"))
user_content = user_conv
append_index = len(few_shots) + 1
message_builder.append_message(self.USER, user_content, index=append_index)
for h in reversed(history[:-1]):
if bot_msg := h.get("bot"):
message_builder.append_message(self.ASSISTANT, bot_msg, index=append_index)
if user_msg := h.get("user"):
message_builder.append_message(self.USER, user_msg, index=append_index)
if message_builder.token_length > max_tokens:
break
messages = message_builder.messages
return messages
| [
"Generate three very brief follow-up questions that the user would likely ask next about healthcare.\nUse double angle brackets to reference the questions, e.g. <<Are there exclusions for prescriptions?>>.\nTry not to repeat questions that have already been asked.\nOnly generate questions and do not generate any text before or after the questions, such as 'Next Questions'",
"Show available health plans",
"Health plan cardio coverage",
"What are my health plans?",
"Next Questions",
"Below is a history of the conversation so far, and a new question asked by the user that needs to be answered by searching in a knowledge base about healthcare.\nGenerate a search query based on the conversation and the new question.\nDo not include cited source filenames and document names e.g info.txt or doc.pdf in the search query terms.\nDo not include any text inside [] or <<>> in the search query terms.\nDo not include any special characters like '+'.\nIf the question is not in Finnish, translate the question to Finnish before generating the search query.\nIf you cannot generate a search query, return just the number 0.\n",
"suggest_followup_questions",
"does my plan cover cardio?",
"prompt_template"
] |
2024-01-10 | mkoivi-ms/azure-search-openai-demo-fi | tests~conftest.py | from collections import namedtuple
from unittest import mock
import openai
import pytest
import pytest_asyncio
from azure.search.documents.aio import SearchClient
import app
MockToken = namedtuple("MockToken", ["token", "expires_on"])
class MockAzureCredential:
async def get_token(self, uri):
return MockToken("mock_token", 9999999999)
@pytest.fixture
def mock_openai_embedding(monkeypatch):
async def mock_acreate(*args, **kwargs):
if openai.api_type == "openai":
assert kwargs.get("deployment_id") is None
else:
assert kwargs.get("deployment_id") is not None
return {"data": [{"embedding": [0.1, 0.2, 0.3]}]}
monkeypatch.setattr(openai.Embedding, "acreate", mock_acreate)
@pytest.fixture
def mock_openai_chatcompletion(monkeypatch):
class AsyncChatCompletionIterator:
def __init__(self, answer):
self.num = 1
self.answer = answer
def __aiter__(self):
return self
async def __anext__(self):
if self.num == 1:
self.num = 0
return openai.util.convert_to_openai_object({"choices": [{"delta": {"content": self.answer}}]})
else:
raise StopAsyncIteration
async def mock_acreate(*args, **kwargs):
if openai.api_type == "openai":
assert kwargs.get("deployment_id") is None
else:
assert kwargs.get("deployment_id") is not None
messages = kwargs["messages"]
if messages[-1]["content"] == "Generate search query for: What is the capital of France?":
answer = "capital of France"
else:
answer = "The capital of France is Paris."
if "stream" in kwargs and kwargs["stream"] is True:
return AsyncChatCompletionIterator(answer)
else:
return openai.util.convert_to_openai_object({"choices": [{"message": {"content": answer}}]})
monkeypatch.setattr(openai.ChatCompletion, "acreate", mock_acreate)
@pytest.fixture
def mock_acs_search(monkeypatch):
class Caption:
def __init__(self, text):
self.text = text
class AsyncSearchResultsIterator:
def __init__(self):
self.num = 1
def __aiter__(self):
return self
async def __anext__(self):
if self.num == 1:
self.num = 0
return {
"sourcepage": "Benefit_Options-2.pdf",
"sourcefile": "Benefit_Options.pdf",
"content": "There is a whistleblower policy.",
"embeddings": [],
"category": None,
"id": "file-Benefit_Options_pdf-42656E656669745F4F7074696F6E732E706466-page-2",
"@search.score": 0.03279569745063782,
"@search.reranker_score": 3.4577205181121826,
"@search.highlights": None,
"@search.captions": [Caption("Caption: A whistleblower policy.")],
}
else:
raise StopAsyncIteration
async def mock_search(*args, **kwargs):
return AsyncSearchResultsIterator()
monkeypatch.setattr(SearchClient, "search", mock_search)
envs = [
{
"OPENAI_HOST": "openai",
"OPENAI_API_KEY": "secretkey",
"OPENAI_ORGANIZATION": "organization",
},
{
"OPENAI_HOST": "azure",
"AZURE_OPENAI_SERVICE": "test-openai-service",
"AZURE_OPENAI_CHATGPT_DEPLOYMENT": "test-chatgpt",
"AZURE_OPENAI_EMB_DEPLOYMENT": "test-ada",
},
]
@pytest_asyncio.fixture(params=envs)
async def client(monkeypatch, mock_openai_chatcompletion, mock_openai_embedding, mock_acs_search, request):
monkeypatch.setenv("AZURE_STORAGE_ACCOUNT", "test-storage-account")
monkeypatch.setenv("AZURE_STORAGE_CONTAINER", "test-storage-container")
monkeypatch.setenv("AZURE_SEARCH_INDEX", "test-search-index")
monkeypatch.setenv("AZURE_SEARCH_SERVICE", "test-search-service")
monkeypatch.setenv("AZURE_OPENAI_CHATGPT_MODEL", "gpt-35-turbo")
for key, value in request.param.items():
monkeypatch.setenv(key, value)
with mock.patch("app.DefaultAzureCredential") as mock_default_azure_credential:
mock_default_azure_credential.return_value = MockAzureCredential()
quart_app = app.create_app()
async with quart_app.test_app() as test_app:
quart_app.config.update({"TESTING": True})
yield test_app.test_client()
| [
"There is a whistleblower policy."
] |
2024-01-10 | jaewan/ray_memory_management | rllib~examples~env~cliff_walking_wall_env.py | import gym
from gym import spaces
ACTION_UP = 0
ACTION_RIGHT = 1
ACTION_DOWN = 2
ACTION_LEFT = 3
class CliffWalkingWallEnv(gym.Env):
"""Modified version of the CliffWalking environment from OpenAI Gym
with walls instead of a cliff.
### Description
The board is a 4x12 matrix, with (using NumPy matrix indexing):
- [3, 0] or obs==36 as the start at bottom-left
- [3, 11] or obs==47 as the goal at bottom-right
- [3, 1..10] or obs==37...46 as the cliff at bottom-center
An episode terminates when the agent reaches the goal.
### Actions
There are 4 discrete deterministic actions:
- 0: move up
- 1: move right
- 2: move down
- 3: move left
You can also use the constants ACTION_UP, ACTION_RIGHT, ... defined above.
### Observations
There are 3x12 + 2 possible states, not including the walls. If an action
would move an agent into one of the walls, it simply stays in the same position.
### Reward
Each time step incurs -1 reward, except reaching the goal which gives +10 reward.
"""
def __init__(self, seed=42) -> None:
self.observation_space = spaces.Discrete(48)
self.action_space = spaces.Discrete(4)
self.observation_space.seed(seed)
self.action_space.seed(seed)
def reset(self):
self.position = 36
return self.position
def step(self, action):
x = self.position // 12
y = self.position % 12
# UP
if action == ACTION_UP:
x = max(x - 1, 0)
# RIGHT
elif action == ACTION_RIGHT:
if self.position != 36:
y = min(y + 1, 11)
# DOWN
elif action == ACTION_DOWN:
if self.position < 25 or self.position > 34:
x = min(x + 1, 3)
# LEFT
elif action == ACTION_LEFT:
if self.position != 47:
y = max(y - 1, 0)
else:
raise ValueError(f"action {action} not in {self.action_space}")
self.position = x * 12 + y
done = self.position == 47
reward = -1 if not done else 10
return self.position, reward, done, {}
| [] |
2024-01-10 | jaewan/ray_memory_management | rllib~algorithms~maddpg~maddpg.py | """Contributed port of MADDPG from OpenAI baselines.
The implementation has a couple assumptions:
- The number of agents is fixed and known upfront.
- Each agent is bound to a policy of the same name.
- Discrete actions are sent as logits (pre-softmax).
For a minimal example, see rllib/examples/two_step_game.py,
and the README for how to run with the multi-agent particle envs.
"""
import logging
from typing import List, Optional, Type
from ray.rllib.algorithms.algorithm_config import AlgorithmConfig
from ray.rllib.algorithms.dqn.dqn import DQN
from ray.rllib.algorithms.maddpg.maddpg_tf_policy import MADDPGTFPolicy
from ray.rllib.policy.policy import Policy
from ray.rllib.policy.sample_batch import SampleBatch, MultiAgentBatch
from ray.rllib.utils.annotations import Deprecated, override
from ray.rllib.utils.typing import AlgorithmConfigDict
from ray.rllib.utils.deprecation import DEPRECATED_VALUE
logger = logging.getLogger(__name__)
logger.setLevel(logging.INFO)
class MADDPGConfig(AlgorithmConfig):
"""Defines a configuration class from which a MADDPG Algorithm can be built.
Example:
>>> from ray.rllib.algorithms.maddpg.maddpg import MADDPGConfig
>>> config = MADDPGConfig()
>>> print(config.replay_buffer_config)
>>> replay_config = config.replay_buffer_config.update(
>>> {
>>> "capacity": 100000,
>>> "prioritized_replay_alpha": 0.8,
>>> "prioritized_replay_beta": 0.45,
>>> "prioritized_replay_eps": 2e-6,
>>> }
>>> )
>>> config.training(replay_buffer_config=replay_config)\
>>> .resources(num_gpus=0)\
>>> .rollouts(num_rollout_workers=4)\
>>> .environment("CartPole-v1")
>>> algo = config.build()
>>> while True:
>>> algo.train()
Example:
>>> from ray.rllib.algorithms.maddpg.maddpg import MADDPGConfig
>>> from ray import air
>>> from ray import tune
>>> config = MADDPGConfig()
>>> config.training(n_step=tune.grid_search([3, 5]))
>>> config.environment(env="CartPole-v1")
>>> tune.Tuner(
>>> "MADDPG",
>>> run_config=air.RunConfig(stop={"episode_reward_mean":200}),
>>> param_space=config.to_dict()
>>> ).fit()
"""
def __init__(self, algo_class=None):
"""Initializes a DQNConfig instance."""
super().__init__(algo_class=algo_class or MADDPG)
# fmt: off
# __sphinx_doc_begin__
# MADDPG specific config settings:
self.agent_id = None
self.use_local_critic = False
self.use_state_preprocessor = False
self.actor_hiddens = [64, 64]
self.actor_hidden_activation = "relu"
self.critic_hiddens = [64, 64]
self.critic_hidden_activation = "relu"
self.n_step = 1
self.good_policy = "maddpg"
self.adv_policy = "maddpg"
self.replay_buffer_config = {
"type": "MultiAgentReplayBuffer",
# Specify prioritized replay by supplying a buffer type that supports
# prioritization, for example: MultiAgentPrioritizedReplayBuffer.
"prioritized_replay": DEPRECATED_VALUE,
"capacity": int(1e6),
# Force lockstep replay mode for MADDPG.
"replay_mode": "lockstep",
}
self.training_intensity = None
# Number of timesteps to collect from rollout workers before we start
# sampling from replay buffers for learning. Whether we count this in agent
# steps or environment steps depends on config["multiagent"]["count_steps_by"].
self.num_steps_sampled_before_learning_starts = 1024 * 25
self.critic_lr = 1e-2
self.actor_lr = 1e-2
self.target_network_update_freq = 0
self.tau = 0.01
self.actor_feature_reg = 0.001
self.grad_norm_clipping = 0.5
# Changes to Algorithm's default:
self.rollout_fragment_length = 100
self.train_batch_size = 1024
self.num_workers = 1
self.min_time_s_per_iteration = 0
# fmt: on
# __sphinx_doc_end__
@override(AlgorithmConfig)
def training(
self,
*,
agent_id: Optional[str] = None,
use_local_critic: Optional[bool] = None,
use_state_preprocessor: Optional[bool] = None,
actor_hiddens: Optional[List[int]] = None,
actor_hidden_activation: Optional[str] = None,
critic_hiddens: Optional[List[int]] = None,
critic_hidden_activation: Optional[str] = None,
n_step: Optional[int] = None,
good_policy: Optional[str] = None,
adv_policy: Optional[str] = None,
replay_buffer_config: Optional[dict] = None,
training_intensity: Optional[float] = None,
critic_lr: Optional[float] = None,
actor_lr: Optional[float] = None,
target_network_update_freq: Optional[int] = None,
tau: Optional[float] = None,
actor_feature_reg: Optional[float] = None,
grad_norm_clipping: Optional[float] = None,
**kwargs,
) -> "MADDPGConfig":
"""Sets the training related configuration.
Args:
agent_id: ID of the agent controlled by this policy.
use_local_critic: Use a local critic for this policy.
use_state_preprocessor: Apply a state preprocessor with spec given by the
"model" config option (like other RL algorithms). This is mostly useful
if you have a weird observation shape, like an image. Disabled by
default.
actor_hiddens: Postprocess the policy network model output with these hidden
layers. If `use_state_preprocessor` is False, then these will be the
*only* hidden layers in the network.
actor_hidden_activation: Hidden layers activation of the postprocessing
stage of the policy network.
critic_hiddens: Postprocess the critic network model output with these
hidden layers; again, if use_state_preprocessor is True, then the state
will be preprocessed by the model specified with the "model" config
option first.
critic_hidden_activation: Hidden layers activation of the postprocessing
state of the critic.
n_step: N-step for Q-learning.
good_policy: Algorithm for good policies.
adv_policy: Algorithm for adversary policies.
replay_buffer_config: Replay buffer config.
Examples:
{
"_enable_replay_buffer_api": True,
"type": "MultiAgentReplayBuffer",
"capacity": 50000,
"replay_sequence_length": 1,
}
- OR -
{
"_enable_replay_buffer_api": True,
"type": "MultiAgentPrioritizedReplayBuffer",
"capacity": 50000,
"prioritized_replay_alpha": 0.6,
"prioritized_replay_beta": 0.4,
"prioritized_replay_eps": 1e-6,
"replay_sequence_length": 1,
}
- Where -
prioritized_replay_alpha: Alpha parameter controls the degree of
prioritization in the buffer. In other words, when a buffer sample has
a higher temporal-difference error, with how much more probability
should it drawn to use to update the parametrized Q-network. 0.0
corresponds to uniform probability. Setting much above 1.0 may quickly
result as the sampling distribution could become heavily “pointy” with
low entropy.
prioritized_replay_beta: Beta parameter controls the degree of
importance sampling which suppresses the influence of gradient updates
from samples that have higher probability of being sampled via alpha
parameter and the temporal-difference error.
prioritized_replay_eps: Epsilon parameter sets the baseline probability
for sampling so that when the temporal-difference error of a sample is
zero, there is still a chance of drawing the sample.
training_intensity: If set, this will fix the ratio of replayed from a
buffer and learned on timesteps to sampled from an environment and
stored in the replay buffer timesteps. Otherwise, the replay will
proceed at the native ratio determined by
`(train_batch_size / rollout_fragment_length)`.
critic_lr: Learning rate for the critic (Q-function) optimizer.
actor_lr: Learning rate for the actor (policy) optimizer.
target_network_update_freq: Update the target network every
`target_network_update_freq` sample steps.
tau: Update the target by \tau * policy + (1-\tau) * target_policy.
actor_feature_reg: Weights for feature regularization for the actor.
grad_norm_clipping: If not None, clip gradients during optimization at this
value.
Returns:
This updated AlgorithmConfig object.
"""
# Pass kwargs onto super's `training()` method.
super().training(**kwargs)
if agent_id is not None:
self.agent_id = agent_id
if use_local_critic is not None:
self.use_local_critic = use_local_critic
if use_state_preprocessor is not None:
self.use_state_preprocessor = use_state_preprocessor
if actor_hiddens is not None:
self.actor_hiddens = actor_hiddens
if actor_hidden_activation is not None:
self.actor_hidden_activation = actor_hidden_activation
if critic_hiddens is not None:
self.critic_hiddens = critic_hiddens
if critic_hidden_activation is not None:
self.critic_hidden_activation = critic_hidden_activation
if n_step is not None:
self.n_step = n_step
if good_policy is not None:
self.good_policy = good_policy
if adv_policy is not None:
self.adv_policy = adv_policy
if replay_buffer_config is not None:
self.replay_buffer_config = replay_buffer_config
if training_intensity is not None:
self.training_intensity = training_intensity
if critic_lr is not None:
self.critic_lr = critic_lr
if actor_lr is not None:
self.actor_lr = actor_lr
if target_network_update_freq is not None:
self.target_network_update_freq = target_network_update_freq
if tau is not None:
self.tau = tau
if actor_feature_reg is not None:
self.actor_feature_reg = actor_feature_reg
if grad_norm_clipping is not None:
self.grad_norm_clipping = grad_norm_clipping
return self
def before_learn_on_batch(multi_agent_batch, policies, train_batch_size):
samples = {}
# Modify keys.
for pid, p in policies.items():
i = p.config["agent_id"]
keys = multi_agent_batch.policy_batches[pid].keys()
keys = ["_".join([k, str(i)]) for k in keys]
samples.update(dict(zip(keys, multi_agent_batch.policy_batches[pid].values())))
# Make ops and feed_dict to get "new_obs" from target action sampler.
new_obs_ph_n = [p.new_obs_ph for p in policies.values()]
new_obs_n = list()
for k, v in samples.items():
if "new_obs" in k:
new_obs_n.append(v)
for i, p in enumerate(policies.values()):
feed_dict = {new_obs_ph_n[i]: new_obs_n[i]}
new_act = p.get_session().run(p.target_act_sampler, feed_dict)
samples.update({"new_actions_%d" % i: new_act})
# Share samples among agents.
policy_batches = {pid: SampleBatch(samples) for pid in policies.keys()}
return MultiAgentBatch(policy_batches, train_batch_size)
class MADDPG(DQN):
@classmethod
@override(DQN)
def get_default_config(cls) -> AlgorithmConfigDict:
return MADDPGConfig().to_dict()
@override(DQN)
def validate_config(self, config: AlgorithmConfigDict) -> None:
"""Adds the `before_learn_on_batch` hook to the config.
This hook is called explicitly prior to TrainOneStep() in the execution
setups for DQN and APEX.
"""
# Call super's validation method.
super().validate_config(config)
def f(batch, workers, config):
policies = dict(
workers.local_worker().foreach_policy_to_train(lambda p, i: (i, p))
)
return before_learn_on_batch(batch, policies, config["train_batch_size"])
config["before_learn_on_batch"] = f
@override(DQN)
def get_default_policy_class(self, config: AlgorithmConfigDict) -> Type[Policy]:
return MADDPGTFPolicy
# Deprecated: Use ray.rllib.algorithms.maddpg.MADDPG instead!
class _deprecated_default_config(dict):
def __init__(self):
super().__init__(MADDPGConfig().to_dict())
@Deprecated(
old="ray.rllib.algorithms.maddpg.maddpg.DEFAULT_CONFIG",
new="ray.rllib.algorithms.maddpg.maddpg.MADDPGConfig(...)",
error=False,
)
def __getitem__(self, item):
return super().__getitem__(item)
DEFAULT_CONFIG = _deprecated_default_config()
| [] |
2024-01-10 | kittyjosh111/gptChat | enhancedMemory~beta.py | import openai
import os
import json
import shutil
openai.api_key = ""
#This is a simple script to converse with OpenAI's GPT models. It tries to keep persistence between chats by creating a file to store logs of the past conversations, here known as neuralcloudv3.ncb.
#Model responses are also written to a log.log for further reference.
#This script uses the chat model, or currently the gpt-3.5 model that is similar to ChatGPT.
#counter variable that determines whether to begin with the model or the user. Do not change.
counter = 0
#################
### Variables ###
#model is the used OpenAI model. Check their website for different model names.
#https://platform.openai.com/docs/models/overview
model="gpt-3.5=turbo"
#the prompt is what the model will read for to create the response.
#Do not include the initial human prompt, just the description of what the model's pesonality should be like.
base_prompt="""The following is a conversation with an AI assistant. The assistant is helpful, creative, clever, and very friendly."""
#Limit for how many pieces of dialogue the model should remember before summarizing the previous conversations back into the prompt.
#This is used as a way to prolong how much the model can talk to us before hitting the overall token limit.
limit_length=50
#################
#################
#First, a function to save the memory variable to the ncb. I will use this a lot, so it works best as a function.
def save_ncb():
with open('neuralcloudv3.ncb', 'w') as save:
save.write(json.dumps(memory))
#Initialize my custom memory file. Basically, a text file to log everything we've written and then reuse it as the prompt for future prompts.
#First we check if there already exists a neural cloud file. If not, then we create the ncb file and wrtie the prompt to it.
#Its Like waking up their neural cloud for the first time. Otherwise, its just restoring their neural clouds.
memory=[] #unlike the gpt3 script, we use a variable to store memory here.
ncb = './neuralcloudv3.ncb'
check = os.path.isfile(ncb)
if check:
with open('neuralcloudv3.ncb') as read:
output = read.read()
formatted_list = json.loads(output)
memory = formatted_list #These steps allow the model to have past dialogues loaded as a python list
else:
memory.append({"role": "system", "content": f"{base_prompt}"}, ) #creating the file with the system prompt
memory.append({"role": "user", "content": "Hello."}, )
save_ncb() #So the model's first words are a greeting to the user.
log = open("logv3.log", "a")
log.write("---split---") #Write a split character to log
log.close()
counter = 1 #now the model goes first.
#################
### Functions ###
#Function for the api request so that I don't have to copy paste this over and over again.
def api_request(prompt):
response = openai.ChatCompletion.create(
model="gpt-3.5-turbo",
messages=prompt
)
api_request.response = response['choices'][0]['message']['content'].strip()
memory.append({"role": "assistant", "content": f"{api_request.response}"}, ) #write to the memory variable
save_ncb() #save memory to ncb after generation of response
log = open("logv3.log", "a")
log.write("\n" + "Assistant: " + api_request.response) #Write to log
log.close()
#Function to determine how to compress the ncb
def cleaner():
global memory
if len(memory) >= limit_length:
# GOALS:
# Make the summaries additive rather than replacing them altogether. Consider modifying the log file by adding in the previous summary as well.
# IMPLEMENTED as putting in the new_prompt into the log before the user / assistant dialogue
# CHECK TO SEE IF IT WORKS
##Summarizer
print("Cleaning up neural cloud. Please wait...") #print so that user can see what is going on
with open('logv3.log') as read: #the log will show both user and assistant dialog. This makes it perfect for the summarizer.
output = read.read()
output0 = output.split("---split---")[0]
output1 = output.split("---split---")[1]
query="Only summarize the following conversation into one line from the perspective of the assistant. Do not explain." + '"' + output1 + '"' #this is the prompt for summary sent to the api
summary=[] #again, the api requires a list rather than text
summary.append({"role": "system", "content": f"{query}"}, )
summarize = openai.ChatCompletion.create(
model="gpt-3.5-turbo",
messages=summary
)
summarize.response = summarize['choices'][0]['message']['content'].strip()
new_prompt=base_prompt + "\n" + "A summary of their previous conversation is as follows: " + output0 + summarize.response #now we need to replace the old memory variable with the new prompt
memory=[] #blank out the memory variable
memory.append({"role": "system", "content": f"{new_prompt}"}, ) #add in the new prompt (base_prompt + summary) to the memory variable
## File manipulation First we remove both backup files, should they exist
if os.path.exists("neuralcloudv3.ncb.bk"):
os.remove("neuralcloudv3.ncb.bk")
else:
pass
if os.path.exists("logv3.log.bk"):
os.remove("logv3.log.bk")
else:
pass
original_ncb = r'neuralcloudv3.ncb'
backup_ncb = r'neuralcloudv3.ncb.bk' #makes the ncb backup
shutil.copyfile(original_ncb, backup_ncb)
original_log = r'logv3.log'
backup_log = r'logv3.log.bk' #makes the log backup
shutil.copyfile(original_log, backup_log)
os.remove("neuralcloudv3.ncb")
os.remove("logv3.log") #remove both original files
save_ncb() #make a new ncb file, with the new_prompt as the system content
log = open("logv3.log", "a")
log.write(output0 + summarize.response + "\n" + "---split---") #Write to log the summary part as well, just so that we don't lose bits of the memory from pre-clean.
log.close()
else:
pass
#Main function to regulate a question-answer type interaction between user and the model. First load in the past prompts, then move on.
def main():
while True:
global counter
if counter == 1:
api_request(memory)
print(api_request.response)
save_ncb()
else:
pass
#Then have the user interact with the model.
#Function to ask user for input
counter = 1
cleaner()
user_input = input("[Enter your input]: ")
memory.append({"role": "user", "content": f"{user_input}"}, )
log = open("logv3.log", "a")
log.write("\n" + "User: " + user_input)
log.close()
if __name__ == "__main__":
main() | [
"\n",
"PLACEHOLDER",
"The following is a conversation with an AI assistant. The assistant is helpful, creative, clever, and very friendly.",
"Hello.",
"A summary of their previous conversation is as follows: "
] |
2024-01-10 | kittyjosh111/gptChat | renpy~game~bridge~backend.py | import openai
import os
import json
import shutil
import time
openai.api_key = ""
#This is a simple script to converse with OpenAI's GPT models. It tries to keep persistence between chats by creating a file to store logs of the past conversations, here known as neuralcloud_renpy.ncb.
#Model responses are also written to a log.log for further reference.
#This script uses the chat model, or currently the gpt-3.5 model that is similar to ChatGPT.
#counter variable that determines whether to begin with the model or the user. Do not change.
counter = 0
#################
### Variables ###
#model is the used OpenAI model. Check their website for different model names.
#https://platform.openai.com/docs/models/overview
model="gpt-3.5=turbo"
#the prompt is what the model will read for to create the response.
#Do not include the initial human prompt, just the description of what the model's pesonality should be like.
base_prompt="""The following is a conversation with an AI assistant. The assistant is helpful, creative, clever, and very friendly."""
#Limit for how many pieces of dialogue the model should remember before summarizing the previous conversations back into the prompt.
#This is used as a way to prolong how much the model can talk to us before hitting the overall token limit.
limit_length=50
#################
#################
#First, a function to save the memory variable to the ncb. I will use this a lot, so it works best as a function.
def save_ncb():
with open('neuralcloud_renpy.ncb', 'w') as save:
save.write(json.dumps(memory))
#Initialize my custom memory file. Basically, a text file to log everything we've written and then reuse it as the prompt for future prompts.
#First we check if there already exists a neural cloud file. If not, then we create the ncb file and wrtie the prompt to it.
#Its Like waking up their neural cloud for the first time. Otherwise, its just restoring their neural clouds.
memory=[] #unlike the gpt3 script, we use a variable to store memory here.
ncb = './neuralcloud_renpy.ncb'
check = os.path.isfile(ncb)
if check:
with open('neuralcloud_renpy.ncb') as read:
output = read.read()
formatted_list = json.loads(output)
memory = formatted_list #These steps allow the model to have past dialogues loaded as a python list
else:
memory.append({"role": "system", "content": f"{base_prompt}"}, ) #creating the file with the system prompt
memory.append({"role": "user", "content": "Hello."}, )
save_ncb() #So the model's first words are a greeting to the user.
log = open("log_renpy.log", "a")
log.write("---split---") #Write a split character to log
log.close()
counter = 1 #now the model goes first.
#################
### Functions ###
#Function for the api request so that I don't have to copy paste this over and over again.
def api_request(prompt):
response = openai.ChatCompletion.create(
model="gpt-3.5-turbo",
messages=prompt
)
api_request.response = response['choices'][0]['message']['content'].strip()
memory.append({"role": "assistant", "content": f"{api_request.response}"}, ) #write to the memory variable
save_ncb() #save memory to ncb after generation of response
write = open("modelOutput", "w+")
write.write(api_request.response) #this writes the model output to a file cleverly named modelOutput. Renpy reads the contents of this file and outputs it to the user.
write.close()
log = open("log_renpy.log", "a")
log.write("\n" + "Assistant: " + api_request.response) #Write to log
log.close()
#Function to use api for sentiment analysis, which controls the expression of the renpy character
def sentAnalysis(prompt):
analysis = openai.ChatCompletion.create(
model="gpt-3.5-turbo",
messages=[
{"role": "user", "content": "Classify the following into either positive, neutral, or negative. Leave out any punctuation. " + f"{prompt}"},
]
)
sentAnalysis.response = analysis['choices'][0]['message']['content'].strip()
sentiment = open("sentiment", "w+")
sentiment.write(sentAnalysis.response) #this writes the returned sentiment to a file so that renpy can read it.
sentiment.close()
#Function to determine how to compress the ncb
def cleaner():
global memory
if len(memory) >= limit_length:
##Summarizer
print("Cleaning up neural cloud. Please wait...") #print so that user can see what is going on
with open('log_renpy.log') as read: #the log will show both user and assistant dialog. This makes it perfect for the summarizer.
output = read.read()
output0 = output.split("---split---")[0]
output1 = output.split("---split---")[1]
query="Only summarize the following conversation into one line from the perspective of the assistant. Do not explain." + '"' + output1 + '"' #this is the prompt for summary sent to the api
summary=[] #again, the api requires a list rather than text
summary.append({"role": "system", "content": f"{query}"}, )
summarize = openai.ChatCompletion.create(
model="gpt-3.5-turbo",
messages=summary
)
summarize.response = summarize['choices'][0]['message']['content'].strip()
new_prompt=base_prompt + "\n" + "A summary of their previous conversation is as follows: " + output0 + summarize.response #now we need to replace the old memory variable with the new prompt
memory=[] #blank out the memory variable
memory.append({"role": "system", "content": f"{new_prompt}"}, ) #add in the new prompt (base_prompt + summary) to the memory variable
## File manipulation First we remove both backup files, should they exist
if os.path.exists("neuralcloud_renpy.ncb.bk"):
os.remove("neuralcloud_renpy.ncb.bk")
else:
pass
if os.path.exists("log_renpy.log.bk"):
os.remove("log_renpy.log.bk")
else:
pass
original_ncb = r'neuralcloud_renpy.ncb'
backup_ncb = r'neuralcloud_renpy.ncb.bk' #makes the ncb backup
shutil.copyfile(original_ncb, backup_ncb)
original_log = r'log_renpy.log'
backup_log = r'log_renpy.log.bk' #makes the log backup
shutil.copyfile(original_log, backup_log)
os.remove("neuralcloud_renpy.ncb")
os.remove("log_renpy.log") #remove both original files
save_ncb() #make a new ncb file, with the new_prompt as the system content
log = open("log_renpy.log", "a")
log.write(output0 + summarize.response + "\n" + "---split---") #Write to log the summary part as well, just so that we don't lose bits of the memory from pre-clean.
log.close()
else:
pass
#Main function to regulate a question-answer type interaction between user and the model. First load in the past prompts, then move on.
def main():
while True:
global counter
if counter == 1:
api_request(memory)
sentAnalysis(api_request.response)
print(api_request.response)
save_ncb()
toggle = open("toggle", "w+")
toggle.write("output") #this writes the word "output" to the toggle file, telling renpy that it can now read the next file:
toggle.close()
lastModified = os.path.getmtime("toggle")
while (lastModified == os.path.getmtime("toggle")):
time.sleep(0.5) #big block to halt script until the toggle file is modified by renpy. Works when renpy writes something random to the file. Hacky solution but hey it works phenomenally
else:
pass
#Then have the user interact with the model.
counter = 1
cleaner()
toggle = open("toggle", "w+")
toggle.write("input") #We want to have the renpy script ask for and give us a new input now.
toggle.close()
lastModified = os.path.getmtime("toggle")
while (lastModified == os.path.getmtime("toggle")):
time.sleep(0.5) #big block to halt script until the toggle file is modified by renpy.
modelInput = open("modelInput", "r")
user_input = modelInput.read()
memory.append({"role": "user", "content": f"{user_input}"}, )
log = open("log_renpy.log", "a")
log.write("\n" + "User: " + user_input)
log.close()
if __name__ == "__main__":
main() | [
"\n",
"PLACEHOLDER",
"The following is a conversation with an AI assistant. The assistant is helpful, creative, clever, and very friendly.",
"Hello.",
"A summary of their previous conversation is as follows: ",
"Classify the following into either positive, neutral, or negative. Leave out any punctuation. PLACEHOLDER"
] |
Subsets and Splits