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 | pbcpraveen/LLM-Saliency | knowledge_validation~wikibio.py | import itertools
import sys
import os
from pathlib import Path
import pickle
import pandas as pd
import json
import openai
import pickle
import dotenv
path = Path(os.getcwd())
sys.path.append(str(path.parent.absolute()))
import propmts
from common_utils import *
from constants import *
from utils import *
def get_verification_flag(row):
response = row[GPT_4_RESPONSE]
candidate = row[Attribute.NAME.value]
return name_match(candidate, [response])
load_dotenv('../api_key.env')
openai.api_key = os.getenv("OPENAI_API_KEY")
setup_directories()
logger = get_logger('wikibio.log')
data = pickle.load(open("../data/dataset/wikibio_raw.pickle", "rb"))
logger.info("Checking if LLM has been already queried")
if "wikibio_LLM_recall.csv" not in os.listdir('dataset/'):
logger.info("Querying LLM for knowledge validation")
prompts = [person_prompt(i) for i in data]
names = [i[CONTEXTUALISING_ATTRIBUTES][Attribute.NAME.value] for i in data]
index = [i for i in range(len(data))]
df = pd.DataFrame()
df[INDEX_COLUMN] = index
df[Attribute.NAME.value] = names
df[PROMPT_COLUMN] = prompts
responses = create_and_run_api_request_threads(prompts, 5, logger)
responses = list(itertools.chain(*responses))
df[GPT_4_RESPONSE] = responses
logger.info('Saving responses to ./dataset/wikibio_LLM_recall.csv')
df.to_csv("dataset/wikibio_LLM_recall.csv")
logger.info("Reading LLm responses from ./dataset/wikibio_LLM_recall.csv")
responses = pd.read_csv("dataset/wikibio_LLM_recall.csv")
flags = responses.apply(get_verification_flag, axis=1).to_list()
for i in range(len(data)):
data[i][VERIFIED] = flags[i]
logger.info("Writing data with verified flag to dataset/wikibio_verified.pickle")
with open(f"dataset/{VERIFIED_RECORDS[WIKIBIO]}", 'wb') as handle:
pickle.dump(data, handle)
| [] |
2024-01-10 | yDing121/AI_2023 | LangChain~quickStart_lc.py | from langchain.agents import initialize_agent
from langchain.llms import GPT4All
from langchain.chat_models import ChatOpenAI
from langchain.schema import (
AIMessage,
HumanMessage,
SystemMessage
)
# llm = OpenAI(openai_api_key="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")
llm = GPT4All()
chat = ChatOpenAI(temperature=0)
chat.predict_messages([HumanMessage(content="Translate this sentence from English to French. I love programming.")])
# >> AIMessage(content="J'aime programmer.", additional_kwargs={})
#
# from platform import python_version
# print(python_version())
initialize_agent() | [
"Translate this sentence from English to French. I love programming."
] |
2024-01-10 | gregorytcarroll/samcart-devops-assessment | application~app~mercury-app~mercury.py | import base64
import subprocess
import os
import openai
import requests
from slack_sdk import WebClient
from slack_sdk.errors import SlackApiError
from flask import Flask, request, jsonify
import re
openai_key = os.environ['OPENAI_KEY']
confluence_api_token = os.environ['CONFLUENCE_API_TOKEN']
slack_api_token = os.environ['SLACK_API_TOKEN']
def install_dependencies():
packages = ['llama_index', 'openai', 'requests', 'beautifulsoup4', 'joblib', 'slack_sdk', 'pyngrok']
installed_packages = subprocess.check_output(['pip3', 'freeze']).decode('utf-8').splitlines()
missing_packages = [pkg for pkg in packages if pkg not in installed_packages]
if missing_packages:
with open(os.devnull, 'w') as null:
subprocess.check_call(['pip3', 'install'] + missing_packages, stdout=null, stderr=subprocess.STDOUT)
print("Installed missing dependencies:", missing_packages)
else:
print("All dependencies are already installed.")
# Install dependencies
install_dependencies()
print("Dependencies completed! Data Extraction occurring!")
# Import necessary packages
from llama_index import Document
## OpenAI Configuration ##
openai.api_key = openai_key
# Set up Confluence API details - using Test Page
base_url = "https://greg-carroll.atlassian.net/"
api_token = confluence_api_token
page_id = 98442
# Encode API token in Base64
credentials = f'{api_token}'
base64_credentials = base64.b64encode(credentials.encode('utf-8')).decode('utf-8')
# Fetch page content from Confluence REST API
url = f'{base_url}/wiki/rest/api/content/{page_id}?expand=body.storage'
headers = {
'Authorization': f'Basic {base64_credentials}',
'Content-Type': 'application/json'
}
response = requests.get(url, headers=headers)
# Check if the response is successful
if response.status_code == 200:
# Access the content based on the JSON structure
try:
content = response.json().get('body', {}).get('storage', {}).get('value', '')
# Create a document from the content
document = Document(text=content)
except KeyError as e:
print(f"KeyError: {e}")
else:
print(f"Request failed with status code: {response.status_code}")
# Set up your Flask app
app = Flask(__name__)
# Set up the Slack API client
slack_token = slack_api_token
slack_client = WebClient(token=slack_token)
# Handle Slack events
@app.route('/slack/events', methods=['POST'])
def handle_slack_events():
# Verify the request is coming from Slack
if request.headers.get('X-Slack-Signature') and request.headers.get('X-Slack-Request-Timestamp'):
# Process the event payload
event_data = request.get_json()
event_type = event_data['type']
if event_type == 'event_callback':
event = event_data['event']
if event['type'] == 'message':
# Handle the message event
user_id = event['user']
text = event['text']
# Process the message and generate a response
response = process_message(user_id, text)
# Send the response back to the user
try:
slack_client.chat_postMessage(channel=event['channel'], text=response)
except SlackApiError as e:
print(f"Error sending message: {e.response['error']}")
return jsonify({'status': 'success'})
return jsonify({'status': 'error', 'message': 'Invalid request'}), 400
# Bot Creation
def bot(index_files_path, document_text):
vector_store = None # Placeholder for the vector store
vector_length = None # Placeholder for the vector length
while True:
user_input = input('How can I help? ')
# Query the document text using OpenAI
response = openai.Completion.create(
engine='text-ada-001',
prompt=document_text + "\nUser: " + user_input + "\nBot:",
max_tokens=50,
temperature=0.6,
n=1,
stop=None,
logprobs=0,
)
# Get the generated response from OpenAI
generated_response = response.choices[0].text.strip()
print(f"Response: {generated_response}\n")
if __name__ == '__main__':
# Start the Flask app
app.run(debug=True) | [
"PLACEHOLDER\nUser: PLACEHOLDER\nBot:"
] |
2024-01-10 | PreetShah77/MemoryformyModel | entitymemory.py | from dotenv import load_dotenv
import os
from langchain.chat_models import ChatOpenAI
from langchain.chains import ConversationChain
from langchain.memory import ConversationEntityMemory
from langchain.memory.prompt import ENTITY_MEMORY_CONVERSATION_TEMPLATE
def main():
load_dotenv()
if os.getenv('OPENAI_API_KEY') is None or os.getenv('OPENAI_API_KEY')=="":
print("Key is not set")
exit(1)
else:
print("key is set")
llm=ChatOpenAI()
conversation = ConversationChain(llm=llm,memory=ConversationEntityMemory(llm=llm),prompt=ENTITY_MEMORY_CONVERSATION_TEMPLATE,verbose=True)
print("Hello I am ChatGpt ClI")
while True:
user_input = input("> ")
ai_response = conversation.predict(input=user_input)
print("\nAssistant: \n",ai_response)
if __name__ == '__main__':
main() | [] |
2024-01-10 | PreetShah77/MemoryformyModel | historyhandlingwithschemas.py | from dotenv import load_dotenv
import os
from langchain.chat_models import ChatOpenAI
from langchain.schema import (SystemMessage, HumanMessage, AIMessage)
def main():
load_dotenv()
if os.getenv('OPENAI_API_KEY') is None or os.getenv('OPENAI_API_KEY')=="":
print("Key is not set")
exit(1)
else:
print("key is set")
chat = ChatOpenAI(temperature=0.9)
messages = [SystemMessage(content="You are a helpful assistant"),]
print("Hello I am ChatGpt ClI")
while True:
user_input = input("> ")
messages.append(HumanMessage(content=user_input))
ai_response = chat(messages)
messages.append(AIMessage(content=ai_response.content))
print("\nAssistant: \n",ai_response.content)
if __name__ == '__main__':
main() | [
"You are a helpful assistant"
] |
2024-01-10 | wangejay/transgpt | transgpt_gpt-3.5-turbo-16k.py | import os
import json
import openai
openai.api_key = f'$PUT your api key here'
# 加载en.json文件
with open("en.json", "r", encoding="utf-8") as f:
en_data = json.load(f)
# 将en.json的内容转换为字符串
en_data_str = json.dumps(en_data)
# 待翻译的语言列表和对应的文件名
languages = {
# 'Czech': 'cs.json',
# 'Polish': 'pl.json',
# 'Turkish': 'tr.json',
# 'Romanian': 'ro.json',
# 'Korean': 'ko.json',
# 'German': 'de.json',
# 'English': 'en.json',
# 'Spanish': 'es.json',
'French': 'fr.json',
# 'Italian': 'it.json',
# 'Dutch': 'nl.json',
# 'Portuguese': 'pt.json',
# 'Russian': 'ru.json',
# 'Chinese (Traditional)': 'zh_TW.json',
# 'Chinese (Simplified)': 'zh_CN.json'
}
# 逐个翻译并保存结果
for lang, file_name in languages.items():
# 构建用户消息，将en.json数据添加到消息内容中
print(f"Translating to {lang}...")
user_message = {
"role": "user",
"content": f"Please translate the JSON to {lang}\n{en_data_str}"
}
# 构建聊天完成请求
completion = openai.ChatCompletion.create(
model="gpt-3.5-turbo-16k",
messages=[
{"role": "system", "content": "System message, not used"},
{"role": "assistant", "content": "Placeholder for assistant message"},
user_message
]
)
# 获取助手的回复
assistant_reply = completion.choices[0].message.content
# 解析助手回复的JSON数据
translated_data = json.loads(assistant_reply)
# 将翻译后的JSON数据保存为对应的文件
with open(file_name, "w", encoding="utf-8") as f:
json.dump(translated_data, f, ensure_ascii=False, indent=4)
print(f"The translated JSON data has been saved as {file_name}.")
| [
"Placeholder for assistant message",
"Please translate the JSON to PLACEHOLDER\nPLACEHOLDER",
"System message, not used"
] |
2024-01-10 | hosford42/ppo-pytorch | multiprocessing_env.py | # Code is from OpenAI baseline.
#https://github.com/openai/baselines/tree/master/baselines/common/vec_env
import numpy as np
from multiprocessing import Process, Pipe
import numpy as np
class RunningMeanStd(object):
# https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance#Parallel_algorithm
def __init__(self, epsilon=1e-4, shape=()):
self.mean = np.zeros(shape, 'float64')
self.var = np.ones(shape, 'float64')
self.count = epsilon
def update(self, x):
batch_mean = np.mean(x, axis=0)
batch_var = np.var(x, axis=0)
batch_count = x.shape[0]
self.update_from_moments(batch_mean, batch_var, batch_count)
def update_from_moments(self, batch_mean, batch_var, batch_count):
delta = batch_mean - self.mean
tot_count = self.count + batch_count
new_mean = self.mean + delta * batch_count / tot_count
m_a = self.var * (self.count)
m_b = batch_var * (batch_count)
M2 = m_a + m_b + np.square(delta) * self.count * batch_count / (self.count + batch_count)
new_var = M2 / (self.count + batch_count)
new_count = batch_count + self.count
self.mean = new_mean
self.var = new_var
self.count = new_count
def worker(remote, parent_remote, env_fn_wrapper):
parent_remote.close()
env = env_fn_wrapper.x()
while True:
cmd, data = remote.recv()
if cmd == 'step':
ob, reward, done, info = env.step(data)
if done:
ob = env.reset()
remote.send((ob, reward, done, info))
elif cmd == 'reset':
ob = env.reset()
remote.send(ob)
elif cmd == 'reset_task':
ob = env.reset_task()
remote.send(ob)
elif cmd == 'close':
remote.close()
break
elif cmd == 'get_spaces':
remote.send((env.observation_space, env.action_space))
else:
raise NotImplementedError
class VecEnv(object):
"""
An abstract asynchronous, vectorized environment.
"""
def __init__(self, num_envs, observation_space, action_space):
self.num_envs = num_envs
self.observation_space = observation_space
self.action_space = action_space
def reset(self):
"""
Reset all the environments and return an array of
observations, or a tuple 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
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
def step_wait(self):
"""
Wait for the step taken with step_async().
Returns (obs, rews, dones, infos):
- obs: an array of observations, or a tuple 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(self):
"""
Clean up the environments' resources.
"""
pass
def step(self, actions):
self.step_async(actions)
return self.step_wait()
class VecEnvWrapper(VecEnv):
def __init__(self, venv, observation_space=None, action_space=None):
self.venv = venv
VecEnv.__init__(self,
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)
def reset(self):
pass
def step_wait(self):
pass
def close(self):
return self.venv.close()
def render(self):
self.venv.render()
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)
class SubprocVecEnv(VecEnv):
def __init__(self, env_fns, spaces=None):
"""
envs: list of gym environments to run in subprocesses
"""
self.waiting = False
self.closed = False
nenvs = len(env_fns)
self.nenvs = nenvs
self.remotes, self.work_remotes = zip(*[Pipe() for _ in range(nenvs)])
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()
VecEnv.__init__(self, len(env_fns), observation_space, action_space)
def step_async(self, actions):
for remote, action in zip(self.remotes, actions):
remote.send(('step', action))
self.waiting = True
def step_wait(self):
results = [remote.recv() for remote in self.remotes]
self.waiting = False
obs, rews, dones, infos = zip(*results)
return np.stack(obs), np.stack(rews), np.stack(dones), infos
def reset(self):
for remote in self.remotes:
remote.send(('reset', None))
return np.stack([remote.recv() for remote in self.remotes])
def reset_task(self):
for remote in self.remotes:
remote.send(('reset_task', None))
return np.stack([remote.recv() for remote in self.remotes])
def close(self):
if self.closed:
return
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 __len__(self):
return self.nenvs
class VecNormalize(VecEnvWrapper):
"""
Vectorized environment base class
"""
def __init__(self, venv, ob=True, ret=True, clipob=10., cliprew=10., gamma=0.99, epsilon=1e-8):
VecEnvWrapper.__init__(self, venv)
self.ob_rms = RunningMeanStd(shape=self.observation_space.shape) if ob else None
self.ret_rms = RunningMeanStd(shape=()) if ret else None
self.clipob = clipob
self.cliprew = cliprew
self.ret = np.zeros(self.num_envs)
self.gamma = gamma
self.epsilon = epsilon
def step_wait(self):
"""
Apply sequence of actions to sequence of environments
actions -> (observations, rewards, news)
where 'news' is a boolean vector indicating whether each element is new.
"""
obs, rews, news, infos = self.venv.step_wait()
self.ret = self.ret * self.gamma + rews
obs = self._obfilt(obs)
if self.ret_rms:
self.ret_rms.update(self.ret)
rews = np.clip(rews / np.sqrt(self.ret_rms.var + self.epsilon), -self.cliprew, self.cliprew)
return obs, rews, news, infos
def _obfilt(self, obs):
if self.ob_rms:
self.ob_rms.update(obs)
obs = np.clip((obs - self.ob_rms.mean) / np.sqrt(self.ob_rms.var + self.epsilon), -self.clipob, self.clipob)
return obs
else:
return obs
def reset(self):
"""
Reset all environments
"""
obs = self.venv.reset()
return self._obfilt(obs)
from gym import spaces
from collections import OrderedDict
import numpy as np
class DummyVecEnv(VecEnv):
def __init__(self, env_fns):
self.envs = [fn() for fn in env_fns]
env = self.envs[0]
VecEnv.__init__(self, len(env_fns), env.observation_space, env.action_space)
shapes, dtypes = {}, {}
self.keys = []
obs_space = env.observation_space
subspaces = {None: obs_space}
for key, box in subspaces.items():
shapes[key] = box.shape
dtypes[key] = np.float32
self.keys.append(key)
self.buf_obs = { k: np.zeros((self.num_envs,) + tuple(shapes[k]), dtype=dtypes[k]) for k in self.keys }
self.buf_dones = np.zeros((self.num_envs,), dtype=np.bool)
self.buf_rews = np.zeros((self.num_envs,), dtype=np.float32)
self.buf_infos = [{} for _ in range(self.num_envs)]
self.actions = None
def step_async(self, actions):
self.actions = actions
def step_wait(self):
for e in range(self.num_envs):
obs, self.buf_rews[e], self.buf_dones[e], self.buf_infos[e] = self.envs[e].step(self.actions[e])
if self.buf_dones[e]:
obs = self.envs[e].reset()
self._save_obs(e, obs)
return (self._obs_from_buf(), np.copy(self.buf_rews), np.copy(self.buf_dones),
self.buf_infos.copy())
def reset(self):
for e in range(self.num_envs):
obs = self.envs[e].reset()
self._save_obs(e, obs)
return self._obs_from_buf()
def close(self):
return
def render(self, mode='human'):
return [e.render(mode=mode) for e in self.envs]
def _save_obs(self, e, obs):
for k in self.keys:
if k is None:
self.buf_obs[k][e] = obs
else:
self.buf_obs[k][e] = obs[k]
def _obs_from_buf(self):
if self.keys==[None]:
return self.buf_obs[None]
else:
return self.buf_obs
| [] |
2024-01-10 | qnicole-zakka/langchain-intro | text_sum.py | import streamlit as st
from langchain.llms import OpenAI
st.title("Test App")
my_key = st.sidebar.text_input("OpenAI API Key")
def generate_response(input_text):
llm = OpenAI(temperature=0.5, openai_api_key=my_key)
st.info(llm(input_text))
with st.form('my_form'):
text = st.text_area('Enter text here: ', 'Chinese law bar v.s. U.S. law bar, which test is harder')
submitted = st.form_submit_button('Submit')
if not my_key.startswith("sk-"):
st.warning("Please enter a valid OpenAI API Key")
if submitted and my_key.startswith("sk-"):
generate_response(text)
import streamlit
| [] |
2024-01-10 | xxtg666/XTBot-Core | plugins~xtbotchatgptv2~cg_utils.py | import os
import json
import openai
import tiktoken
import httpx
import time
import datetime
import pandas
os.environ["HTTP_PROXY"] = "http://127.0.0.1:7890"
os.environ["HTTPS_PROXY"] = "http://127.0.0.1:7890"
class USER_DATA_UTILS:
def __init__(self):
self._makeDir("data/chatgpt2")
self._makeDir("data/chatgpt2/chat_history")
self._makeDir("data/chatgpt2/user_info")
self._makeDir("data/chatgpt2/cached_err")
self._makeDir("data/chatgpt2/user_sign")
if not os.path.exists("data/chatgpt2/config.json"):
json.dump({
"api_key":"", # 非公开内容
"api_base":"https://api.openai.com/v1",
"api_key_4":"", # 非公开内容
"api_base_4":"" # 非公开内容
},open("data/chatgpt2/config.json","w"))
def _makeDir(self,dir_name: str) -> bool:
try:
os.mkdir(dir_name)
return True
except:
return False
def _checkUser(self, user_id: str, setup_init_token: int = 1000) -> bool:
if os.path.exists(f"data/chatgpt2/user_sign/{user_id}.json"):
return True
self._setupUserData(user_id, setup_init_token)
return False
def _setupUserData(self, user_id: str, init_token: int = 1000) -> str:
if not os.path.exists(f"data/chatgpt2/chat_history/{user_id}.json"):
json.dump([],open(f"data/chatgpt2/chat_history/{user_id}.json","w"))
if not os.path.exists(f"data/chatgpt2/user_info/{user_id}.json"):
json.dump({
"user_id":user_id,
"tokens":init_token,
"used_tokens":0,
"last_use_time":0,
"banned":False,
"allow_gpt4":False,
"need_review":False
}, open(f"data/chatgpt2/user_info/{user_id}.json", "w"))
if not os.path.exists(f"data/chatgpt2/cached_err/{user_id}.json"):
json.dump({
"last_err_time":0,
"err_info":""
}, open(f"data/chatgpt2/cached_err/{user_id}.json", "w"))
if not os.path.exists(f"data/chatgpt2/user_sign/{user_id}.json"):
json.dump({
"sign_day_list": [],
"sign_days": 0,
"last_sign_day": "",
"continuous_sign_days": 0,
"tokens_get_by_sign": 0
}, open(f"data/chatgpt2/user_sign/{user_id}.json", "w"))
return user_id
def getUserChatHistory(self, user_id: str) -> list:
self._checkUser(user_id)
return json.load(open(f"data/chatgpt2/chat_history/{user_id}.json","r"))
def getUserInfo(self, user_id: str) -> dict:
self._checkUser(user_id)
return json.load(open(f"data/chatgpt2/user_info/{user_id}.json", "r"))
def getUserCachedErr(self, user_id: str) -> dict:
self._checkUser(user_id)
return json.load(open(f"data/chatgpt2/cached_err/{user_id}.json", "r"))
def setUserChatHistory(self, user_id: str, chat_history: list) -> list:
json.dump(chat_history, open(f"data/chatgpt2/chat_history/{user_id}.json", "w"))
return chat_history
def appendUserChatHistory(self, user_id: str, chat_history: list) -> list:
origin_chat_history = self.getUserChatHistory(user_id)
origin_chat_history.extend(chat_history)
return self.setUserChatHistory(user_id, origin_chat_history)
def setUserInfo(self, user_id: str, user_info: dict) -> dict:
json.dump(user_info,open(f"data/chatgpt2/user_info/{user_id}.json", "w"))
return user_info
def modifyUserInfo(self, user_id: str, key: str, value: any) -> dict:
origin_user_info = self.getUserInfo(user_id)
origin_user_info[key] = value
return self.setUserInfo(user_id, origin_user_info)
def setUserCachedErr(self, user_id: str , err: str) -> dict:
json.dump(cached_err := {
"last_err_time": time.time(),
"err_info": err
}, open(f"data/chatgpt2/cached_err/{user_id}.json", "w"))
return cached_err
def getConfig(self) -> dict:
return json.load(open("data/chatgpt2/config.json", "r"))
def setConfig(self, config: dict) -> dict:
json.dump(config, open("data/chatgpt2/config.json", "w"))
return config
def modifyConfig(self, key: str, value: str) -> dict:
origin_config = self.getConfig()
origin_config[key] = value
return self.setConfig(origin_config)
def getUserSign(self, user_id: str) -> dict:
self._checkUser(user_id)
return json.load(open(f"data/chatgpt2/user_sign/{user_id}.json", "r"))
def setUserSign(self, user_id: str, user_sign: dict) -> dict:
json.dump(user_sign, open(f"data/chatgpt2/user_sign/{user_id}.json", "w"))
return user_sign
def modifyUserSign(self, user_id: str, key: str, value: any) -> dict:
origin_user_sign = self.getUserSign(user_id)
origin_user_sign[key] = value
return self.setUserSign(user_id, origin_user_sign)
class WEB_API_UTILS:
async def getImageBase64(self, html: str) -> str:
async with httpx.AsyncClient() as client:
url = "http://127.0.0.1:6789/html/img" # 非公开内容
response = await client.post(url, data = {"html":html,"github-markdown":True})
return response.json()["image_base64"]
async def getGithubMarkdown(self, text: str) -> str:
async with httpx.AsyncClient() as client:
url = "https://api.github.com/markdown"
response = await client.post(url, json = {"text": text})
return response.text
async def getEditorData(self, data_id: str) -> str:
async with httpx.AsyncClient() as client:
url = "https://127.0.0.1/get/"+data_id # 非公开内容
response = await client.get(url)
return response.text
async def uploadEditorData(self, chat_history: list) -> str:
async with httpx.AsyncClient() as client:
url = "https://127.0.0.1/upload" # 非公开内容
response = await client.post(url, json = chat_history)
return response.text
class GPT_UTILS:
def __init__(self):
self.tiktoken_encoding = tiktoken.get_encoding("cl100k_base")
self.config = json.load(open("data/chatgpt2/config.json","r"))
def refreshConfig(self):
self.config = json.load(open("data/chatgpt2/config.json","r"))
def countTokens(self, text):
return len(self.tiktoken_encoding.encode(text))
async def getChatGPT(self, chat_history: list, prompt: str, user_info: dict, model: str = "gpt-3.5-turbo", token_multiplier: float = 1.0) -> list:
if user_info["banned"]:
return [0,0,[{"role":"XTBot","content":"错误: 你已被禁止使用XTBotChatGPTv2"}]]
openai.api_base = self.config["api_base"]
openai.api_key = self.config["api_key"]
chat_history.append({"role": "user", "content": prompt})
message = openai.ChatCompletion.create(
model = model,
messages = chat_history
)["choices"][0]["message"]
tokens = len(chat_history)*3
for m in chat_history:
tokens += self.countTokens(m["content"])
chat_history.append(message)
return [
int(token_multiplier * (tokens + 3)),
int(token_multiplier * self.countTokens(message["content"])),
chat_history
]
async def getGPT4(self, prompt: str, user_info: dict) -> str:
if user_info["banned"] or not user_info["allow_gpt4"]:
return "错误: 你不能使用XTBotChatGPTv2-GPT4"
openai.api_base = self.config["api_base_4"]
openai.api_key = self.config["api_key_4"]
return openai.ChatCompletion.create(
model = "gpt-4",
messages = [{"role": "user", "content": prompt}]
)["choices"][0]["message"]["content"]
class DATE_UTILS:
def getTodayDate(self) -> str:
return datetime.datetime.now().strftime('%Y-%m-%d')
def getDateList(self, day_num: int) -> list[str]:
return pandas.date_range(end=self.getTodayDate().replace("-",""), periods=day_num).strftime("%Y-%m-%d").tolist()
def getYesterdayDate(self) -> str:
return self.getDateList(2)[0] | [
"错误: 你已被禁止使用XTBotChatGPTv2"
] |
2024-01-10 | xxtg666/XTBot-Core | discord-xtbot.py | import interactions
import openai
import os
import httpx
import sys
import random
import json
os.environ["HTTP_PROXY"] = "http://127.0.0.1:7890"
os.environ["HTTPS_PROXY"] = "http://127.0.0.1:7890"
openai.api_key = "" # 非公开内容
TOKEN = "" # 非公开内容
st_l_file = "st_l.json"
if not os.path.exists(st_l_file):
json.dump({"normal":{},"r18":{},"all":{}},open(st_l_file,"w"))
bot = interactions.Client(token=TOKEN)
bot.http.proxy = ("http://127.0.0.1:7890",None) # type: ignore
async def getImage(r18,tag=""):
async with httpx.AsyncClient() as client:
r = await client.get("https://api.lolicon.app/setu/v2?r18="+r18+tag)
d = r.json()["data"][0]
if d["title"] == "" and d["tag"] == []:
return await getImage(r18,tag)
img = await client.get(d["urls"]["original"].replace("i.pixiv.re","i.pixiv.cat"))
cachefile_fn = f"cachefile{random.randint(10000,99999)}.{d['ext']}"
cachefile = open(cachefile_fn,"wb")
cachefile.write(img.content)
cachefile.close()
# os.remove(cachefile_fn)
return [f'PID: {d["pid"]}\nTITLE: {d["title"]}',cachefile_fn]
async def getUser(uid):
try:
return bot.get_user(uid).display_name # type: ignore
except:
async with httpx.AsyncClient() as client:
r = await client.get(f"https://discord.com/api/users/{uid}",headers={
"User-Agent":"DiscordBot",
"Authorization":f"Bot {TOKEN}"
})
return r.json()["username"]
def getSt_l():
return json.load(open(st_l_file,"r"))
def addSt_l(uid,r18):
uid = str(uid)
st_l = getSt_l()
if r18 == "1":
_type = "r18"
else:
_type = "normal"
try:
st_l[_type][uid] += 1
st_l["all"][uid] += 1
except:
st_l[_type][uid] = 1
st_l["all"][uid] = 1
json.dump(st_l,open(st_l_file,"w"))
@interactions.slash_command(
name="cg",
description="Ask ChatGPT",
)
@interactions.slash_option(
name="content",
description="The text you want to ask ChatGPT",
required=True,
opt_type=interactions.OptionType.STRING
)
async def cg(ctx: interactions.ComponentContext, content: str):
await ctx.defer()
message = openai.ChatCompletion.create(
model = "gpt-3.5-turbo",
messages = [{"role":"user","content":content}],
)["choices"][0]["message"]["content"] # type: ignore
await ctx.send(message)
@interactions.slash_command(
name="st-r",
description="Random pixiv image",
)
@interactions.slash_option(
name="tag",
description="Image tag",
required=False,
opt_type=interactions.OptionType.STRING
)
async def st_r(ctx: interactions.ComponentContext, tag= ""):
await ctx.defer()
tag = "|".join(tag.strip().split(" "))
if tag != "":
tag = "&tag="+tag
image = await getImage("0",tag)
addSt_l(ctx.author.id.numerator,"0")
await ctx.send(image[0],file=image[1])
os.remove(image[1])
@interactions.slash_command(
name="st-r-r18",
description="Random pixiv (nsfw)",
nsfw=True
)
@interactions.slash_option(
name="tag",
description="Image tag",
required=False,
opt_type=interactions.OptionType.STRING
)
async def st_r_r18(ctx: interactions.ComponentContext, tag= ""):
await ctx.defer()
tag = "|".join(tag.strip().split(" "))
if tag != "":
tag = "&tag="+tag
image = await getImage("1",tag)
addSt_l(ctx.author.id.numerator,"1")
await ctx.send(image[0],file=image[1])
os.remove(image[1])
@interactions.slash_command(
name="st-l",
description="Display the times user use /st-r and /st-r-r18"
)
@interactions.slash_option(
name="_type",
description="normal | r18 | all (default: all)",
required=False,
opt_type=interactions.OptionType.STRING,
choices=[
interactions.SlashCommandChoice(name="all", value="all"),
interactions.SlashCommandChoice(name="normal", value="normal"),
interactions.SlashCommandChoice(name="r18", value="r18")
]
)
async def st_l_cmd(ctx: interactions.ComponentContext, _type="all"):
await ctx.defer()
st_l = getSt_l()
st_l = st_l[_type]
st_l = sorted(st_l.items(),key=lambda x:x[1],reverse=True)
msg = f"### st-r 次数排行榜 ({_type}):\n"
uid = str(ctx.author.id.numerator)
you_msg = f"∞. **{ctx.author.display_name}:** `0`" # type: ignore
for i in range(len(st_l)):
msg += (cache := f"{i+1}. **{await getUser(st_l[i][0])}:** `{st_l[i][1]}`\n")
if st_l[i][0] == uid:
you_msg = cache.replace("\n","")
msg += "------------------------------\n"
msg += you_msg
await ctx.send(msg)
@interactions.slash_command(
name="test",
description="Get your user id (test)",
)
async def test(ctx: interactions.ComponentContext):
await ctx.defer()
await ctx.send(f"Your ID = {ctx.author.id.numerator}\nYour Display Name = {await getUser(ctx.author.id.numerator)}") # type: ignore
@interactions.slash_command(
name="echo",
description="Echo some text"
)
@interactions.slash_option(
name="content",
description="The text you want to echo",
required=True,
opt_type=interactions.OptionType.STRING
)
async def echo(ctx: interactions.ComponentContext, content: str):
await ctx.send(content) # type: ignore
def restart_program():
python = sys.executable
os.execl(python, python, *sys.argv)
bot.start()
restart_program() | [] |
2024-01-10 | xxtg666/XTBot-Core | plugins~xtbotaidraw~de_utils.py | import os
import json
import openai
import base64
import time
os.environ["HTTP_PROXY"] = "http://127.0.0.1:7890"
os.environ["HTTPS_PROXY"] = "http://127.0.0.1:7890"
class USER_DATA_UTILS:
def __init__(self):
self._makeDir("data/xtbotaidraw")
self._makeDir("data/xtbotaidraw/user_info")
self._makeDir("data/xtbotaidraw/cached_err")
if not os.path.exists("data/xtbotaidraw/config.json"):
json.dump({
"api_key":"", # 非公开内容
"api_base":"https://api.openai.com/v1",
},open("data/xtbotaidraw/config.json","w"))
def _makeDir(self,dir_name: str) -> bool:
try:
os.mkdir(dir_name)
return True
except:
return False
def _checkUser(self, user_id: str, setup_init_credit: int = 50) -> bool:
if os.path.exists(f"data/xtbotaidraw/user_info/{user_id}.json"):
return True
self._setupUserData(user_id, setup_init_credit)
return False
def _setupUserData(self, user_id: str, init_credit: int = 50) -> str:
if not os.path.exists(f"data/xtbotaidraw/user_info/{user_id}.json"):
json.dump({
"user_id":user_id,
"credits":init_credit,
"used_credits":0,
"last_use_time":0,
"banned":False
}, open(f"data/xtbotaidraw/user_info/{user_id}.json", "w"))
if not os.path.exists(f"data/xtbotaidraw/cached_err/{user_id}.json"):
json.dump({
"last_err_time":0,
"err_info":""
}, open(f"data/xtbotaidraw/cached_err/{user_id}.json", "w"))
return user_id
def getUserInfo(self, user_id: str) -> dict:
self._checkUser(user_id)
return json.load(open(f"data/xtbotaidraw/user_info/{user_id}.json", "r"))
def getUserCachedErr(self, user_id: str) -> dict:
self._checkUser(user_id)
return json.load(open(f"data/xtbotaidraw/cached_err/{user_id}.json", "r"))
def setUserInfo(self, user_id: str, user_info: dict) -> dict:
json.dump(user_info,open(f"data/xtbotaidraw/user_info/{user_id}.json", "w"))
return user_info
def modifyUserInfo(self, user_id: str, key: str, value: any) -> dict:
origin_user_info = self.getUserInfo(user_id)
origin_user_info[key] = value
return self.setUserInfo(user_id, origin_user_info)
def setUserCachedErr(self, user_id: str , err: str) -> dict:
json.dump(cached_err := {
"last_err_time": time.time(),
"err_info": err
}, open(f"data/xtbotaidraw/cached_err/{user_id}.json", "w"))
return cached_err
def getConfig(self) -> dict:
return json.load(open("data/xtbotaidraw/config.json", "r"))
def setConfig(self, config: dict) -> dict:
json.dump(config, open("data/xtbotaidraw/config.json", "w"))
return config
def modifyConfig(self, key: str, value: str) -> dict:
origin_config = self.getConfig()
origin_config[key] = value
return self.setConfig(origin_config)
class DALLE_UTILS:
def __init__(self):
self.config = json.load(open("data/xtbotaidraw/config.json","r"))
def refreshConfig(self):
self.config = json.load(open("data/xtbotaidraw/config.json","r"))
def b64decodeImage(self, image_b64: str) -> bytes:
return base64.b64decode(image_b64)
async def getDALLE(self, prompt: str, user_info: dict, size: int = 1) -> list:
if user_info["banned"]:
return [False,"错误: 你已被禁止使用XTBotAIDraw"]
image_size = "256x256"
match size:
case 2:
image_size = "512x512"
case 4:
image_size = "1024x1024"
case _:
image_size = "256x256"
openai.api_base = self.config["api_base"]
openai.api_key = self.config["api_key"]
image_b64 = openai.Image.create(
prompt=prompt,
n=1,
size=image_size,
response_format="b64_json"
)['data'][0]['b64_json']
return [True, image_b64] | [] |
2024-01-10 | PKU-YuanGroup/Video-LLaVA | llava~eval~video~eval_benchmark_4_temporal.py | import openai
import os
import argparse
import json
import ast
from multiprocessing.pool import Pool
def parse_args():
parser = argparse.ArgumentParser(description="question-answer-generation-using-gpt-3")
parser.add_argument("--pred_path", required=True, help="The path to file containing prediction.")
parser.add_argument("--output_dir", required=True, help="The path to save annotation json files.")
parser.add_argument("--output_json", required=True, help="The path to save annotation final combined json file.")
parser.add_argument("--api_key", required=True, help="OpenAI API key.")
parser.add_argument("--api_base", default="", type=str, help="OpenAI API base.")
parser.add_argument("--num_tasks", required=True, type=int, help="Number of splits.")
args = parser.parse_args()
return args
def annotate(prediction_set, caption_files, output_dir, args):
"""
Evaluates question and answer pairs using GPT-3 and
returns a score for temporal understanding.
"""
# Set the OpenAI API key.
openai.api_key = args.api_key
if args.api_base is not None:
openai.api_base = args.api_base
for file in caption_files:
key = file[:-5] # Strip file extension
qa_set = prediction_set[key]
question = qa_set['q']
answer = qa_set['a']
pred = qa_set['pred']
try:
# Compute the temporal understanding score
completion = openai.ChatCompletion.create(
model="gpt-3.5-turbo",
messages=[
{
"role": "system",
"content":
"You are an intelligent chatbot designed for evaluating the temporal understanding of generative outputs for video-based question-answer pairs. "
"Your task is to compare the predicted answer with the correct answer and determine if they correctly reflect the temporal sequence of events in the video content. Here's how you can accomplish the task:"
"------"
"##INSTRUCTIONS: "
"- Focus on the temporal consistency between the predicted answer and the correct answer. The predicted answer should correctly reflect the sequence of events or details as they are presented in the video content.\n"
"- Consider synonyms or paraphrases as valid matches, but only if the temporal order is maintained.\n"
"- Evaluate the temporal accuracy of the prediction compared to the answer."
},
{
"role": "user",
"content":
"Please evaluate the following video-based question-answer pair:\n\n"
f"Question: {question}\n"
f"Correct Answer: {answer}\n"
f"Predicted Answer: {pred}\n\n"
"Provide your evaluation only as a temporal accuracy score where the temporal accuracy score is an integer value between 0 and 5, with 5 indicating the highest level of temporal consistency. "
"Please generate the response in the form of a Python dictionary string with keys 'score', where its value is the temporal accuracy score in INTEGER, not STRING."
"DO NOT PROVIDE ANY OTHER OUTPUT TEXT OR EXPLANATION. Only provide the Python dictionary string. "
"For example, your response should look like this: {''score': 4.8}."
}
]
)
# Convert response to a Python dictionary.
response_message = completion["choices"][0]["message"]["content"]
response_dict = ast.literal_eval(response_message)
result_qa_pair = [response_dict, qa_set]
# Save the question-answer pairs to a json file.
with open(f"{output_dir}/{key}.json", "w") as f:
json.dump(result_qa_pair, f)
except Exception as e:
print(f"Error processing file '{key}': {e}")
def main():
"""
Main function to control the flow of the program.
"""
# Parse arguments.
args = parse_args()
file = open(args.pred_path)
pred_contents = json.load(file)
# Dictionary to store the count of occurrences for each video_id
video_id_counts = {}
new_pred_contents = []
# Iterate through each sample in pred_contents
for sample in pred_contents:
video_id = sample['video_name']
if video_id in video_id_counts:
video_id_counts[video_id] += 1
else:
video_id_counts[video_id] = 0
# Create a new sample with the modified key
new_sample = sample
new_sample['video_name'] = f"{video_id}_{video_id_counts[video_id]}"
new_pred_contents.append(new_sample)
# Generating list of id's and corresponding files
id_list = [x['video_name'] for x in new_pred_contents]
caption_files = [f"{id}.json" for id in id_list]
output_dir = args.output_dir
# Generate output directory if not exists.
if not os.path.exists(output_dir):
os.makedirs(output_dir)
# Preparing dictionary of question-answer sets
prediction_set = {}
for sample in new_pred_contents:
id = sample['video_name']
question = sample['Q']
answer = sample['A']
pred = sample['pred']
qa_set = {"q": question, "a": answer, "pred": pred}
prediction_set[id] = qa_set
# Set the OpenAI API key.
openai.api_key = args.api_key
num_tasks = args.num_tasks
# While loop to ensure that all captions are processed.
while True:
try:
# Files that have not been processed yet.
completed_files = os.listdir(output_dir)
print(f"completed_files: {len(completed_files)}")
# Files that have not been processed yet.
incomplete_files = [f for f in caption_files if f not in completed_files]
print(f"incomplete_files: {len(incomplete_files)}")
# Break the loop when there are no incomplete files
if len(incomplete_files) == 0:
break
if len(incomplete_files) <= num_tasks:
num_tasks = 1
# Split tasks into parts.
part_len = len(incomplete_files) // num_tasks
all_parts = [incomplete_files[i:i + part_len] for i in range(0, len(incomplete_files), part_len)]
task_args = [(prediction_set, part, args.output_dir, args) for part in all_parts]
# Use a pool of workers to process the files in parallel.
with Pool() as pool:
pool.starmap(annotate, task_args)
except Exception as e:
print(f"Error: {e}")
# Combine all the processed files into one
combined_contents = {}
json_path = args.output_json
# Iterate through json files
for file_name in os.listdir(output_dir):
if file_name.endswith(".json"):
file_path = os.path.join(output_dir, file_name)
with open(file_path, "r") as json_file:
content = json.load(json_file)
combined_contents[file_name[:-5]] = content
# Write combined content to a json file
with open(json_path, "w") as json_file:
json.dump(combined_contents, json_file)
print("All evaluation completed!")
# Calculate average score
score_sum = 0
count = 0
for key, result in combined_contents.items():
count += 1
score_match = result[0]['score']
score = int(score_match)
score_sum += score
average_score = score_sum / count
print("Average score temporal understanding:", average_score)
if __name__ == "__main__":
main()
| [
"You are an intelligent chatbot designed for evaluating the temporal understanding of generative outputs for video-based question-answer pairs. Your task is to compare the predicted answer with the correct answer and determine if they correctly reflect the temporal sequence of events in the video content. Here's how you can accomplish the task:------##INSTRUCTIONS: - Focus on the temporal consistency between the predicted answer and the correct answer. The predicted answer should correctly reflect the sequence of events or details as they are presented in the video content.\n- Consider synonyms or paraphrases as valid matches, but only if the temporal order is maintained.\n- Evaluate the temporal accuracy of the prediction compared to the answer.",
"Please evaluate the following video-based question-answer pair:\n\nQuestion: PLACEHOLDER\nCorrect Answer: PLACEHOLDER\nPredicted Answer: PLACEHOLDER\n\nProvide your evaluation only as a temporal accuracy score where the temporal accuracy score is an integer value between 0 and 5, with 5 indicating the highest level of temporal consistency. Please generate the response in the form of a Python dictionary string with keys 'score', where its value is the temporal accuracy score in INTEGER, not STRING.DO NOT PROVIDE ANY OTHER OUTPUT TEXT OR EXPLANATION. Only provide the Python dictionary string. For example, your response should look like this: {''score': 4.8}."
] |
2024-01-10 | PKU-YuanGroup/Video-LLaVA | scripts~eval_gpt_mmvet.py | import argparse
import openai
import json
import os
from tqdm import tqdm
import pandas as pd
import numpy as np
from collections import Counter
import time
parser = argparse.ArgumentParser(description='ChatGPT-based QA evaluation.')
parser.add_argument('--mmvet_path')
parser.add_argument('--ckpt_name')
parser.add_argument('--result_path')
args = parser.parse_args()
openai.api_base = "https://api.aiguoguo199.com/v1"
openai.api_key = 'sk-eionFWpNThMNy4eeFdC25789F60a4cC2A66b2c94D3948bA6'
gpt_model = "gpt-3.5-turbo"
prompt = """Compare the ground truth and prediction from AI models, to give a correctness score for the prediction. <AND> in the ground truth means it is totally right only when all elements in the ground truth are present in the prediction, and <OR> means it is totally right when any one element in the ground truth is present in the prediction. The correctness score is 0.0 (totally wrong), 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, or 1.0 (totally right). Just complete the last space of the correctness score.
Question | Ground truth | Prediction | Correctness
--- | --- | --- | ---
What is x in the equation? | -1 <AND> -5 | x = 3 | 0.0
What is x in the equation? | -1 <AND> -5 | x = -1 | 0.5
What is x in the equation? | -1 <AND> -5 | x = -5 | 0.5
What is x in the equation? | -1 <AND> -5 | x = -5 or 5 | 0.5
What is x in the equation? | -1 <AND> -5 | x = -1 or x = -5 | 1.0
Can you explain this meme? | This meme is poking fun at the fact that the names of the countries Iceland and Greenland are misleading. Despite its name, Iceland is known for its beautiful green landscapes, while Greenland is mostly covered in ice and snow. The meme is saying that the person has trust issues because the names of these countries do not accurately represent their landscapes. | The meme talks about Iceland and Greenland. It's pointing out that despite their names, Iceland is not very icy and Greenland isn't very green. | 0.4
Can you explain this meme? | This meme is poking fun at the fact that the names of the countries Iceland and Greenland are misleading. Despite its name, Iceland is known for its beautiful green landscapes, while Greenland is mostly covered in ice and snow. The meme is saying that the person has trust issues because the names of these countries do not accurately represent their landscapes. | The meme is using humor to point out the misleading nature of Iceland's and Greenland's names. Iceland, despite its name, has lush green landscapes while Greenland is mostly covered in ice and snow. The text 'This is why I have trust issues' is a playful way to suggest that these contradictions can lead to distrust or confusion. The humor in this meme is derived from the unexpected contrast between the names of the countries and their actual physical characteristics. | 1.0
"""
# load metadata
# Download mm-vet.zip and `unzip mm-vet.zip` and change the path below
mmvet_path = args.mmvet_path
use_sub_set = False
decimal_places = 1 # number of decimal places to round to
if use_sub_set:
bard_set_file = os.path.join(mmvet_path, "bard_set.json")
with open(bard_set_file, 'r') as f:
sub_set = json.load(f)
sub_set_name = 'bardset'
sub_set_name = sub_set_name + '_'
else:
sub_set = None
sub_set_name = ''
mmvet_metadata = os.path.join(mmvet_path, "mm-vet.json")
with open(mmvet_metadata, 'r') as f:
data = json.load(f)
counter = Counter()
cap_set_list = []
cap_set_counter = []
len_data = 0
for id, value in data.items():
if sub_set is not None and id not in sub_set:
continue
question = value["question"]
answer = value["answer"]
cap = value["capability"]
cap = set(cap)
counter.update(cap)
if cap not in cap_set_list:
cap_set_list.append(cap)
cap_set_counter.append(1)
else:
cap_set_counter[cap_set_list.index(cap)] += 1
len_data += 1
sorted_list = counter.most_common()
columns = [k for k, v in sorted_list]
columns.append("total")
columns.append("std")
columns.append('runs')
df = pd.DataFrame(columns=columns)
cap_set_sorted_indices = np.argsort(-np.array(cap_set_counter))
new_cap_set_list = []
new_cap_set_counter = []
for index in cap_set_sorted_indices:
new_cap_set_list.append(cap_set_list[index])
new_cap_set_counter.append(cap_set_counter[index])
cap_set_list = new_cap_set_list
cap_set_counter = new_cap_set_counter
cap_set_names = ["_".join(list(cap_set)) for cap_set in cap_set_list]
columns2 = cap_set_names
columns2.append("total")
columns2.append("std")
columns2.append('runs')
df2 = pd.DataFrame(columns=columns2)
###### change your model name ######
model = args.ckpt_name
result_path = args.result_path
num_run = 1 # we set it as 5 in the paper
model_results_file = os.path.join(result_path, f"{model}.json")
# grade results for each sample to save
grade_file = f'{model}_{gpt_model}-grade-{num_run}runs.json'
grade_file = os.path.join(result_path, grade_file)
# score results regarding capabilities/capability integration to save
cap_score_file = f'{model}_{sub_set_name}{gpt_model}-cap-score-{num_run}runs.csv'
cap_score_file = os.path.join(result_path, cap_score_file)
cap_int_score_file = f'{model}_{sub_set_name}{gpt_model}-cap-int-score-{num_run}runs.csv'
cap_int_score_file = os.path.join(result_path, cap_int_score_file)
with open(model_results_file) as f:
results = json.load(f)
if os.path.exists(grade_file):
with open(grade_file, 'r') as f:
grade_results = json.load(f)
else:
grade_results = {}
def need_more_runs():
need_more_runs = False
if len(grade_results) > 0:
for k, v in grade_results.items():
if len(v['score']) < num_run:
need_more_runs = True
break
return need_more_runs or len(grade_results) < len_data
while need_more_runs():
for j in range(num_run):
print(f'eval run {j}')
for id, line in tqdm(data.items()):
if sub_set is not None and id not in sub_set:
continue
if id in grade_results and len(grade_results[id]['score']) >= (j + 1):
continue
model_pred = results[id]
question = prompt + '\n' + ' | '.join(
[line['question'], line['answer'].replace("<AND>", " <AND> ").replace("<OR>", " <OR> "), model_pred,
""])
messages = [
{"role": "user", "content": question},
]
if id not in grade_results:
sample_grade = {'model': [], 'content': [], 'score': []}
else:
sample_grade = grade_results[id]
grade_sample_run_complete = False
temperature = 0.0
while not grade_sample_run_complete:
try:
response = openai.ChatCompletion.create(
model=gpt_model,
max_tokens=3,
temperature=temperature,
messages=messages)
# print(response['model'])
content = response['choices'][0]['message']['content']
flag = True
try_time = 1
while flag:
try:
content = content.split(' ')[0].strip()
score = float(content)
if score > 1.0 or score < 0.0:
assert False
flag = False
except:
question = prompt + '\n' + ' | '.join(
[line['question'], line['answer'].replace("<AND>", " <AND> ").replace("<OR>", " <OR> "),
model_pred, ""]) + "\nPredict the correctness of the answer (digit): "
messages = [
{"role": "user", "content": question},
]
response = openai.ChatCompletion.create(
model=gpt_model,
max_tokens=3,
temperature=temperature,
messages=messages)
# print(response)
content = response['choices'][0]['message']['content']
try_time += 1
temperature += 0.5
print(f"{id} try {try_time} times")
print(content)
if try_time > 5:
score = 0.0
flag = False
grade_sample_run_complete = True
except:
# gpt4 may have token rate limit
print("sleep 1s")
time.sleep(1)
if len(sample_grade['model']) >= j + 1:
# sample_grade['model'][j] = response['model']
sample_grade['content'][j] = content
sample_grade['score'][j] = score
else:
# sample_grade['model'].append(response['model'])
sample_grade['content'].append(content)
sample_grade['score'].append(score)
grade_results[id] = sample_grade
with open(grade_file, 'w') as f:
json.dump(grade_results, f, indent=4)
assert not need_more_runs()
cap_socres = {k: [0.0] * num_run for k in columns[:-2]}
counter['total'] = len_data
cap_socres2 = {k: [0.0] * num_run for k in columns2[:-2]}
counter2 = {columns2[i]: cap_set_counter[i] for i in range(len(cap_set_counter))}
counter2['total'] = len_data
for k, v in grade_results.items():
if sub_set is not None and k not in sub_set:
continue
for i in range(num_run):
score = v['score'][i]
caps = set(data[k]['capability'])
for c in caps:
cap_socres[c][i] += score
cap_socres['total'][i] += score
index = cap_set_list.index(caps)
cap_socres2[cap_set_names[index]][i] += score
cap_socres2['total'][i] += score
for k, v in cap_socres.items():
cap_socres[k] = np.array(v) / counter[k] * 100
std = round(cap_socres['total'].std(), decimal_places)
total_copy = cap_socres['total'].copy()
runs = str(list(np.round(total_copy, decimal_places)))
for k, v in cap_socres.items():
cap_socres[k] = round(v.mean(), decimal_places)
cap_socres['std'] = std
cap_socres['runs'] = runs
df.loc[model] = cap_socres
for k, v in cap_socres2.items():
cap_socres2[k] = round(np.mean(np.array(v) / counter2[k] * 100), decimal_places)
cap_socres2['std'] = std
cap_socres2['runs'] = runs
df2.loc[model] = cap_socres2
df.to_csv(cap_score_file)
df2.to_csv(cap_int_score_file)
print(df)
print(df2)
| [
"[]",
"Compare the ground truth and prediction from AI models, to give a correctness score for the prediction. <AND> in the ground truth means it is totally right only when all elements in the ground truth are present in the prediction, and <OR> means it is totally right when any one element in the ground truth is present in the prediction. The correctness score is 0.0 (totally wrong), 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, or 1.0 (totally right). Just complete the last space of the correctness score.\n\nQuestion | Ground truth | Prediction | Correctness\n--- | --- | --- | ---\nWhat is x in the equation? | -1 <AND> -5 | x = 3 | 0.0\nWhat is x in the equation? | -1 <AND> -5 | x = -1 | 0.5\nWhat is x in the equation? | -1 <AND> -5 | x = -5 | 0.5\nWhat is x in the equation? | -1 <AND> -5 | x = -5 or 5 | 0.5\nWhat is x in the equation? | -1 <AND> -5 | x = -1 or x = -5 | 1.0\nCan you explain this meme? | This meme is poking fun at the fact that the names of the countries Iceland and Greenland are misleading. Despite its name, Iceland is known for its beautiful green landscapes, while Greenland is mostly covered in ice and snow. The meme is saying that the person has trust issues because the names of these countries do not accurately represent their landscapes. | The meme talks about Iceland and Greenland. It's pointing out that despite their names, Iceland is not very icy and Greenland isn't very green. | 0.4\nCan you explain this meme? | This meme is poking fun at the fact that the names of the countries Iceland and Greenland are misleading. Despite its name, Iceland is known for its beautiful green landscapes, while Greenland is mostly covered in ice and snow. The meme is saying that the person has trust issues because the names of these countries do not accurately represent their landscapes. | The meme is using humor to point out the misleading nature of Iceland's and Greenland's names. Iceland, despite its name, has lush green landscapes while Greenland is mostly covered in ice and snow. The text 'This is why I have trust issues' is a playful way to suggest that these contradictions can lead to distrust or confusion. The humor in this meme is derived from the unexpected contrast between the names of the countries and their actual physical characteristics. | 1.0\n"
] |
2024-01-10 | PKU-YuanGroup/Video-LLaVA | llava~model~multimodal_encoder~languagebind~depth~configuration_depth.py | import copy
import os
from typing import Union
from transformers import PretrainedConfig
from transformers.utils import logging
logger = logging.get_logger(__name__)
class CLIPTextConfig(PretrainedConfig):
r"""
This is the configuration class to store the configuration of a [`CLIPTextModel`]. It is used to instantiate a CLIP
text encoder according to the specified arguments, defining the model architecture. Instantiating a configuration
with the defaults will yield a similar configuration to that of the text encoder of the CLIP
[openai/clip-vit-base-patch32](https://huggingface.co/openai/clip-vit-base-patch32) architecture.
Configuration objects inherit from [`PretrainedConfig`] and can be used to control the model outputs. Read the
documentation from [`PretrainedConfig`] for more information.
Args:
vocab_size (`int`, *optional*, defaults to 49408):
Vocabulary size of the CLIP text model. Defines the number of different tokens that can be represented by
the `inputs_ids` passed when calling [`CLIPModel`].
hidden_size (`int`, *optional*, defaults to 512):
Dimensionality of the encoder layers and the pooler layer.
intermediate_size (`int`, *optional*, defaults to 2048):
Dimensionality of the "intermediate" (i.e., feed-forward) layer in the Transformer encoder.
num_hidden_layers (`int`, *optional*, defaults to 12):
Number of hidden layers in the Transformer encoder.
num_attention_heads (`int`, *optional*, defaults to 8):
Number of attention heads for each attention layer in the Transformer encoder.
max_position_embeddings (`int`, *optional*, defaults to 77):
The maximum sequence length that this model might ever be used with. Typically set this to something large
just in case (e.g., 512 or 1024 or 2048).
hidden_act (`str` or `function`, *optional*, defaults to `"quick_gelu"`):
The non-linear activation function (function or string) in the encoder and pooler. If string, `"gelu"`,
`"relu"`, `"selu"` and `"gelu_new"` `"quick_gelu"` are supported.
layer_norm_eps (`float`, *optional*, defaults to 1e-5):
The epsilon used by the layer normalization layers.
attention_dropout (`float`, *optional*, defaults to 0.0):
The dropout ratio for the attention probabilities.
initializer_range (`float`, *optional*, defaults to 0.02):
The standard deviation of the truncated_normal_initializer for initializing all weight matrices.
initializer_factor (`float`, *optional*, defaults to 1):
A factor for initializing all weight matrices (should be kept to 1, used internally for initialization
testing).
Example:
```python
>>> from transformers import CLIPTextConfig, CLIPTextModel
>>> # Initializing a CLIPTextConfig with openai/clip-vit-base-patch32 style configuration
>>> configuration = CLIPTextConfig()
>>> # Initializing a CLIPTextModel (with random weights) from the openai/clip-vit-base-patch32 style configuration
>>> model = CLIPTextModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config
```"""
model_type = "clip_text_model"
def __init__(
self,
vocab_size=49408,
hidden_size=512,
intermediate_size=2048,
projection_dim=512,
num_hidden_layers=12,
num_attention_heads=8,
max_position_embeddings=77,
hidden_act="quick_gelu",
layer_norm_eps=1e-5,
attention_dropout=0.0,
initializer_range=0.02,
initializer_factor=1.0,
# This differs from `CLIPTokenizer`'s default and from openai/clip
# See https://github.com/huggingface/transformers/pull/24773#issuecomment-1632287538
pad_token_id=1,
bos_token_id=49406,
eos_token_id=49407,
**kwargs,
):
super().__init__(pad_token_id=pad_token_id, bos_token_id=bos_token_id, eos_token_id=eos_token_id, **kwargs)
self.vocab_size = vocab_size
self.hidden_size = hidden_size
self.intermediate_size = intermediate_size
self.projection_dim = projection_dim
self.num_hidden_layers = num_hidden_layers
self.num_attention_heads = num_attention_heads
self.max_position_embeddings = max_position_embeddings
self.layer_norm_eps = layer_norm_eps
self.hidden_act = hidden_act
self.initializer_range = initializer_range
self.initializer_factor = initializer_factor
self.attention_dropout = attention_dropout
self.add_time_attn = False ######################################
@classmethod
def from_pretrained(cls, pretrained_model_name_or_path: Union[str, os.PathLike], **kwargs) -> "PretrainedConfig":
cls._set_token_in_kwargs(kwargs)
config_dict, kwargs = cls.get_config_dict(pretrained_model_name_or_path, **kwargs)
# get the text config dict if we are loading from CLIPConfig
if config_dict.get("model_type") == "clip":
config_dict = config_dict["text_config"]
if "model_type" in config_dict and hasattr(cls, "model_type") and config_dict["model_type"] != cls.model_type:
logger.warning(
f"You are using a model of type {config_dict['model_type']} to instantiate a model of type "
f"{cls.model_type}. This is not supported for all configurations of models and can yield errors."
)
return cls.from_dict(config_dict, **kwargs)
class CLIPVisionConfig(PretrainedConfig):
r"""
This is the configuration class to store the configuration of a [`CLIPVisionModel`]. It is used to instantiate a
CLIP vision encoder according to the specified arguments, defining the model architecture. Instantiating a
configuration with the defaults will yield a similar configuration to that of the vision encoder of the CLIP
[openai/clip-vit-base-patch32](https://huggingface.co/openai/clip-vit-base-patch32) architecture.
Configuration objects inherit from [`PretrainedConfig`] and can be used to control the model outputs. Read the
documentation from [`PretrainedConfig`] for more information.
Args:
hidden_size (`int`, *optional*, defaults to 768):
Dimensionality of the encoder layers and the pooler layer.
intermediate_size (`int`, *optional*, defaults to 3072):
Dimensionality of the "intermediate" (i.e., feed-forward) layer in the Transformer encoder.
num_hidden_layers (`int`, *optional*, defaults to 12):
Number of hidden layers in the Transformer encoder.
num_attention_heads (`int`, *optional*, defaults to 12):
Number of attention heads for each attention layer in the Transformer encoder.
image_size (`int`, *optional*, defaults to 224):
The size (resolution) of each image.
patch_size (`int`, *optional*, defaults to 32):
The size (resolution) of each patch.
hidden_act (`str` or `function`, *optional*, defaults to `"quick_gelu"`):
The non-linear activation function (function or string) in the encoder and pooler. If string, `"gelu"`,
`"relu"`, `"selu"` and `"gelu_new"` ``"quick_gelu"` are supported.
layer_norm_eps (`float`, *optional*, defaults to 1e-5):
The epsilon used by the layer normalization layers.
attention_dropout (`float`, *optional*, defaults to 0.0):
The dropout ratio for the attention probabilities.
initializer_range (`float`, *optional*, defaults to 0.02):
The standard deviation of the truncated_normal_initializer for initializing all weight matrices.
initializer_factor (`float`, *optional*, defaults to 1):
A factor for initializing all weight matrices (should be kept to 1, used internally for initialization
testing).
Example:
```python
>>> from transformers import CLIPVisionConfig, CLIPVisionModel
>>> # Initializing a CLIPVisionConfig with openai/clip-vit-base-patch32 style configuration
>>> configuration = CLIPVisionConfig()
>>> # Initializing a CLIPVisionModel (with random weights) from the openai/clip-vit-base-patch32 style configuration
>>> model = CLIPVisionModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config
```"""
model_type = "clip_vision_model"
def __init__(
self,
hidden_size=768,
intermediate_size=3072,
projection_dim=512,
num_hidden_layers=12,
num_attention_heads=12,
num_channels=3,
image_size=224,
patch_size=32,
hidden_act="quick_gelu",
layer_norm_eps=1e-5,
attention_dropout=0.0,
initializer_range=0.02,
initializer_factor=1.0,
add_time_attn=False, ################################
num_frames=1, ################################
force_patch_dropout=0.0, ################################
lora_r=2, ################################
lora_alpha=16, ################################
lora_dropout=0.0, ################################
num_mel_bins=0.0, ################################
target_length=0.0, ################################
max_depth=10,
video_decode_backend='decord', #########################
**kwargs,
):
super().__init__(**kwargs)
self.hidden_size = hidden_size
self.intermediate_size = intermediate_size
self.projection_dim = projection_dim
self.num_hidden_layers = num_hidden_layers
self.num_attention_heads = num_attention_heads
self.num_channels = num_channels
self.patch_size = patch_size
self.image_size = image_size
self.initializer_range = initializer_range
self.initializer_factor = initializer_factor
self.attention_dropout = attention_dropout
self.layer_norm_eps = layer_norm_eps
self.hidden_act = hidden_act
self.add_time_attn = add_time_attn ################
self.num_frames = num_frames ################
self.force_patch_dropout = force_patch_dropout ################
self.lora_r = lora_r ################
self.lora_alpha = lora_alpha ################
self.lora_dropout = lora_dropout ################
self.num_mel_bins = num_mel_bins ################
self.target_length = target_length ################
self.max_depth = max_depth ################
self.video_decode_backend = video_decode_backend ################
@classmethod
def from_pretrained(cls, pretrained_model_name_or_path: Union[str, os.PathLike], **kwargs) -> "PretrainedConfig":
cls._set_token_in_kwargs(kwargs)
config_dict, kwargs = cls.get_config_dict(pretrained_model_name_or_path, **kwargs)
# get the vision config dict if we are loading from CLIPConfig
if config_dict.get("model_type") == "clip":
config_dict = config_dict["vision_config"]
if "model_type" in config_dict and hasattr(cls, "model_type") and config_dict["model_type"] != cls.model_type:
logger.warning(
f"You are using a model of type {config_dict['model_type']} to instantiate a model of type "
f"{cls.model_type}. This is not supported for all configurations of models and can yield errors."
)
return cls.from_dict(config_dict, **kwargs)
class LanguageBindDepthConfig(PretrainedConfig):
r"""
[`CLIPConfig`] is the configuration class to store the configuration of a [`CLIPModel`]. It is used to instantiate
a CLIP model according to the specified arguments, defining the text model and vision model configs. Instantiating
a configuration with the defaults will yield a similar configuration to that of the CLIP
[openai/clip-vit-base-patch32](https://huggingface.co/openai/clip-vit-base-patch32) architecture.
Configuration objects inherit from [`PretrainedConfig`] and can be used to control the model outputs. Read the
documentation from [`PretrainedConfig`] for more information.
Args:
text_config (`dict`, *optional*):
Dictionary of configuration options used to initialize [`CLIPTextConfig`].
vision_config (`dict`, *optional*):
Dictionary of configuration options used to initialize [`CLIPVisionConfig`].
projection_dim (`int`, *optional*, defaults to 512):
Dimentionality of text and vision projection layers.
logit_scale_init_value (`float`, *optional*, defaults to 2.6592):
The inital value of the *logit_scale* paramter. Default is used as per the original CLIP implementation.
kwargs (*optional*):
Dictionary of keyword arguments.
Example:
```python
>>> from transformers import CLIPConfig, CLIPModel
>>> # Initializing a CLIPConfig with openai/clip-vit-base-patch32 style configuration
>>> configuration = CLIPConfig()
>>> # Initializing a CLIPModel (with random weights) from the openai/clip-vit-base-patch32 style configuration
>>> model = CLIPModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config
>>> # We can also initialize a CLIPConfig from a CLIPTextConfig and a CLIPVisionConfig
>>> from transformers import CLIPTextConfig, CLIPVisionConfig
>>> # Initializing a CLIPText and CLIPVision configuration
>>> config_text = CLIPTextConfig()
>>> config_vision = CLIPVisionConfig()
>>> config = CLIPConfig.from_text_vision_configs(config_text, config_vision)
```"""
model_type = "LanguageBindDepth"
is_composition = True
def __init__(
self, text_config=None, vision_config=None, projection_dim=512, logit_scale_init_value=2.6592, **kwargs
):
# If `_config_dict` exist, we use them for the backward compatibility.
# We pop out these 2 attributes before calling `super().__init__` to avoid them being saved (which causes a lot
# of confusion!).
text_config_dict = kwargs.pop("text_config_dict", None)
vision_config_dict = kwargs.pop("vision_config_dict", None)
super().__init__(**kwargs)
# Instead of simply assigning `[text|vision]_config_dict` to `[text|vision]_config`, we use the values in
# `[text|vision]_config_dict` to update the values in `[text|vision]_config`. The values should be same in most
# cases, but we don't want to break anything regarding `_config_dict` that existed before commit `8827e1b2`.
if text_config_dict is not None:
if text_config is None:
text_config = {}
# This is the complete result when using `text_config_dict`.
_text_config_dict = CLIPTextConfig(**text_config_dict).to_dict()
# Give a warning if the values exist in both `_text_config_dict` and `text_config` but being different.
for key, value in _text_config_dict.items():
if key in text_config and value != text_config[key] and key not in ["transformers_version"]:
# If specified in `text_config_dict`
if key in text_config_dict:
message = (
f"`{key}` is found in both `text_config_dict` and `text_config` but with different values. "
f'The value `text_config_dict["{key}"]` will be used instead.'
)
# If inferred from default argument values (just to be super careful)
else:
message = (
f"`text_config_dict` is provided which will be used to initialize `CLIPTextConfig`. The "
f'value `text_config["{key}"]` will be overriden.'
)
logger.warning(message)
# Update all values in `text_config` with the ones in `_text_config_dict`.
text_config.update(_text_config_dict)
if vision_config_dict is not None:
if vision_config is None:
vision_config = {}
# This is the complete result when using `vision_config_dict`.
_vision_config_dict = CLIPVisionConfig(**vision_config_dict).to_dict()
# convert keys to string instead of integer
if "id2label" in _vision_config_dict:
_vision_config_dict["id2label"] = {
str(key): value for key, value in _vision_config_dict["id2label"].items()
}
# Give a warning if the values exist in both `_vision_config_dict` and `vision_config` but being different.
for key, value in _vision_config_dict.items():
if key in vision_config and value != vision_config[key] and key not in ["transformers_version"]:
# If specified in `vision_config_dict`
if key in vision_config_dict:
message = (
f"`{key}` is found in both `vision_config_dict` and `vision_config` but with different "
f'values. The value `vision_config_dict["{key}"]` will be used instead.'
)
# If inferred from default argument values (just to be super careful)
else:
message = (
f"`vision_config_dict` is provided which will be used to initialize `CLIPVisionConfig`. "
f'The value `vision_config["{key}"]` will be overriden.'
)
logger.warning(message)
# Update all values in `vision_config` with the ones in `_vision_config_dict`.
vision_config.update(_vision_config_dict)
if text_config is None:
text_config = {}
logger.info("`text_config` is `None`. Initializing the `CLIPTextConfig` with default values.")
if vision_config is None:
vision_config = {}
logger.info("`vision_config` is `None`. initializing the `CLIPVisionConfig` with default values.")
self.text_config = CLIPTextConfig(**text_config)
self.vision_config = CLIPVisionConfig(**vision_config)
self.projection_dim = projection_dim
self.logit_scale_init_value = logit_scale_init_value
self.initializer_factor = 1.0
@classmethod
def from_text_vision_configs(cls, text_config: CLIPTextConfig, vision_config: CLIPVisionConfig, **kwargs):
r"""
Instantiate a [`CLIPConfig`] (or a derived class) from clip text model configuration and clip vision model
configuration.
Returns:
[`CLIPConfig`]: An instance of a configuration object
"""
return cls(text_config=text_config.to_dict(), vision_config=vision_config.to_dict(), **kwargs)
def to_dict(self):
"""
Serializes this instance to a Python dictionary. Override the default [`~PretrainedConfig.to_dict`].
Returns:
`Dict[str, any]`: Dictionary of all the attributes that make up this configuration instance,
"""
output = copy.deepcopy(self.__dict__)
output["text_config"] = self.text_config.to_dict()
output["vision_config"] = self.vision_config.to_dict()
output["model_type"] = self.__class__.model_type
return output
| [] |
2024-01-10 | PKU-YuanGroup/Video-LLaVA | llava~model~multimodal_encoder~languagebind~video~configuration_video.py | import copy
import os
from typing import Union
from transformers import PretrainedConfig
from transformers.utils import logging
logger = logging.get_logger(__name__)
class CLIPTextConfig(PretrainedConfig):
r"""
This is the configuration class to store the configuration of a [`CLIPTextModel`]. It is used to instantiate a CLIP
text encoder according to the specified arguments, defining the model architecture. Instantiating a configuration
with the defaults will yield a similar configuration to that of the text encoder of the CLIP
[openai/clip-vit-base-patch32](https://huggingface.co/openai/clip-vit-base-patch32) architecture.
Configuration objects inherit from [`PretrainedConfig`] and can be used to control the model outputs. Read the
documentation from [`PretrainedConfig`] for more information.
Args:
vocab_size (`int`, *optional*, defaults to 49408):
Vocabulary size of the CLIP text model. Defines the number of different tokens that can be represented by
the `inputs_ids` passed when calling [`CLIPModel`].
hidden_size (`int`, *optional*, defaults to 512):
Dimensionality of the encoder layers and the pooler layer.
intermediate_size (`int`, *optional*, defaults to 2048):
Dimensionality of the "intermediate" (i.e., feed-forward) layer in the Transformer encoder.
num_hidden_layers (`int`, *optional*, defaults to 12):
Number of hidden layers in the Transformer encoder.
num_attention_heads (`int`, *optional*, defaults to 8):
Number of attention heads for each attention layer in the Transformer encoder.
max_position_embeddings (`int`, *optional*, defaults to 77):
The maximum sequence length that this model might ever be used with. Typically set this to something large
just in case (e.g., 512 or 1024 or 2048).
hidden_act (`str` or `function`, *optional*, defaults to `"quick_gelu"`):
The non-linear activation function (function or string) in the encoder and pooler. If string, `"gelu"`,
`"relu"`, `"selu"` and `"gelu_new"` `"quick_gelu"` are supported.
layer_norm_eps (`float`, *optional*, defaults to 1e-5):
The epsilon used by the layer normalization layers.
attention_dropout (`float`, *optional*, defaults to 0.0):
The dropout ratio for the attention probabilities.
initializer_range (`float`, *optional*, defaults to 0.02):
The standard deviation of the truncated_normal_initializer for initializing all weight matrices.
initializer_factor (`float`, *optional*, defaults to 1):
A factor for initializing all weight matrices (should be kept to 1, used internally for initialization
testing).
Example:
```python
>>> from transformers import CLIPTextConfig, CLIPTextModel
>>> # Initializing a CLIPTextConfig with openai/clip-vit-base-patch32 style configuration
>>> configuration = CLIPTextConfig()
>>> # Initializing a CLIPTextModel (with random weights) from the openai/clip-vit-base-patch32 style configuration
>>> model = CLIPTextModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config
```"""
model_type = "clip_text_model"
def __init__(
self,
vocab_size=49408,
hidden_size=512,
intermediate_size=2048,
projection_dim=512,
num_hidden_layers=12,
num_attention_heads=8,
max_position_embeddings=77,
hidden_act="quick_gelu",
layer_norm_eps=1e-5,
attention_dropout=0.0,
initializer_range=0.02,
initializer_factor=1.0,
# This differs from `CLIPTokenizer`'s default and from openai/clip
# See https://github.com/huggingface/transformers/pull/24773#issuecomment-1632287538
pad_token_id=1,
bos_token_id=49406,
eos_token_id=49407,
**kwargs,
):
super().__init__(pad_token_id=pad_token_id, bos_token_id=bos_token_id, eos_token_id=eos_token_id, **kwargs)
self.vocab_size = vocab_size
self.hidden_size = hidden_size
self.intermediate_size = intermediate_size
self.projection_dim = projection_dim
self.num_hidden_layers = num_hidden_layers
self.num_attention_heads = num_attention_heads
self.max_position_embeddings = max_position_embeddings
self.layer_norm_eps = layer_norm_eps
self.hidden_act = hidden_act
self.initializer_range = initializer_range
self.initializer_factor = initializer_factor
self.attention_dropout = attention_dropout
self.add_time_attn = False ######################################
@classmethod
def from_pretrained(cls, pretrained_model_name_or_path: Union[str, os.PathLike], **kwargs) -> "PretrainedConfig":
cls._set_token_in_kwargs(kwargs)
config_dict, kwargs = cls.get_config_dict(pretrained_model_name_or_path, **kwargs)
# get the text config dict if we are loading from CLIPConfig
if config_dict.get("model_type") == "clip":
config_dict = config_dict["text_config"]
if "model_type" in config_dict and hasattr(cls, "model_type") and config_dict["model_type"] != cls.model_type:
logger.warning(
f"You are using a model of type {config_dict['model_type']} to instantiate a model of type "
f"{cls.model_type}. This is not supported for all configurations of models and can yield errors."
)
return cls.from_dict(config_dict, **kwargs)
class CLIPVisionConfig(PretrainedConfig):
r"""
This is the configuration class to store the configuration of a [`CLIPVisionModel`]. It is used to instantiate a
CLIP vision encoder according to the specified arguments, defining the model architecture. Instantiating a
configuration with the defaults will yield a similar configuration to that of the vision encoder of the CLIP
[openai/clip-vit-base-patch32](https://huggingface.co/openai/clip-vit-base-patch32) architecture.
Configuration objects inherit from [`PretrainedConfig`] and can be used to control the model outputs. Read the
documentation from [`PretrainedConfig`] for more information.
Args:
hidden_size (`int`, *optional*, defaults to 768):
Dimensionality of the encoder layers and the pooler layer.
intermediate_size (`int`, *optional*, defaults to 3072):
Dimensionality of the "intermediate" (i.e., feed-forward) layer in the Transformer encoder.
num_hidden_layers (`int`, *optional*, defaults to 12):
Number of hidden layers in the Transformer encoder.
num_attention_heads (`int`, *optional*, defaults to 12):
Number of attention heads for each attention layer in the Transformer encoder.
image_size (`int`, *optional*, defaults to 224):
The size (resolution) of each image.
patch_size (`int`, *optional*, defaults to 32):
The size (resolution) of each patch.
hidden_act (`str` or `function`, *optional*, defaults to `"quick_gelu"`):
The non-linear activation function (function or string) in the encoder and pooler. If string, `"gelu"`,
`"relu"`, `"selu"` and `"gelu_new"` ``"quick_gelu"` are supported.
layer_norm_eps (`float`, *optional*, defaults to 1e-5):
The epsilon used by the layer normalization layers.
attention_dropout (`float`, *optional*, defaults to 0.0):
The dropout ratio for the attention probabilities.
initializer_range (`float`, *optional*, defaults to 0.02):
The standard deviation of the truncated_normal_initializer for initializing all weight matrices.
initializer_factor (`float`, *optional*, defaults to 1):
A factor for initializing all weight matrices (should be kept to 1, used internally for initialization
testing).
Example:
```python
>>> from transformers import CLIPVisionConfig, CLIPVisionModel
>>> # Initializing a CLIPVisionConfig with openai/clip-vit-base-patch32 style configuration
>>> configuration = CLIPVisionConfig()
>>> # Initializing a CLIPVisionModel (with random weights) from the openai/clip-vit-base-patch32 style configuration
>>> model = CLIPVisionModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config
```"""
model_type = "clip_vision_model"
def __init__(
self,
hidden_size=768,
intermediate_size=3072,
projection_dim=512,
num_hidden_layers=12,
num_attention_heads=12,
num_channels=3,
image_size=224,
patch_size=32,
hidden_act="quick_gelu",
layer_norm_eps=1e-5,
attention_dropout=0.0,
initializer_range=0.02,
initializer_factor=1.0,
add_time_attn=False, ################################
num_frames=1, ################################
force_patch_dropout=0.0, ################################
lora_r=2, ################################
lora_alpha=16, ################################
lora_dropout=0.0, ################################
num_mel_bins=0.0, ################################
target_length=0.0, ################################
video_decode_backend='decord', #########################
**kwargs,
):
super().__init__(**kwargs)
self.hidden_size = hidden_size
self.intermediate_size = intermediate_size
self.projection_dim = projection_dim
self.num_hidden_layers = num_hidden_layers
self.num_attention_heads = num_attention_heads
self.num_channels = num_channels
self.patch_size = patch_size
self.image_size = image_size
self.initializer_range = initializer_range
self.initializer_factor = initializer_factor
self.attention_dropout = attention_dropout
self.layer_norm_eps = layer_norm_eps
self.hidden_act = hidden_act
self.add_time_attn = add_time_attn ################
self.num_frames = num_frames ################
self.force_patch_dropout = force_patch_dropout ################
self.lora_r = lora_r ################
self.lora_alpha = lora_alpha ################
self.lora_dropout = lora_dropout ################
self.num_mel_bins = num_mel_bins ################
self.target_length = target_length ################
self.video_decode_backend = video_decode_backend ################
@classmethod
def from_pretrained(cls, pretrained_model_name_or_path: Union[str, os.PathLike], **kwargs) -> "PretrainedConfig":
cls._set_token_in_kwargs(kwargs)
config_dict, kwargs = cls.get_config_dict(pretrained_model_name_or_path, **kwargs)
# get the vision config dict if we are loading from CLIPConfig
if config_dict.get("model_type") == "clip":
config_dict = config_dict["vision_config"]
if "model_type" in config_dict and hasattr(cls, "model_type") and config_dict["model_type"] != cls.model_type:
logger.warning(
f"You are using a model of type {config_dict['model_type']} to instantiate a model of type "
f"{cls.model_type}. This is not supported for all configurations of models and can yield errors."
)
return cls.from_dict(config_dict, **kwargs)
class LanguageBindVideoConfig(PretrainedConfig):
r"""
[`CLIPConfig`] is the configuration class to store the configuration of a [`CLIPModel`]. It is used to instantiate
a CLIP model according to the specified arguments, defining the text model and vision model configs. Instantiating
a configuration with the defaults will yield a similar configuration to that of the CLIP
[openai/clip-vit-base-patch32](https://huggingface.co/openai/clip-vit-base-patch32) architecture.
Configuration objects inherit from [`PretrainedConfig`] and can be used to control the model outputs. Read the
documentation from [`PretrainedConfig`] for more information.
Args:
text_config (`dict`, *optional*):
Dictionary of configuration options used to initialize [`CLIPTextConfig`].
vision_config (`dict`, *optional*):
Dictionary of configuration options used to initialize [`CLIPVisionConfig`].
projection_dim (`int`, *optional*, defaults to 512):
Dimentionality of text and vision projection layers.
logit_scale_init_value (`float`, *optional*, defaults to 2.6592):
The inital value of the *logit_scale* paramter. Default is used as per the original CLIP implementation.
kwargs (*optional*):
Dictionary of keyword arguments.
Example:
```python
>>> from transformers import CLIPConfig, CLIPModel
>>> # Initializing a CLIPConfig with openai/clip-vit-base-patch32 style configuration
>>> configuration = CLIPConfig()
>>> # Initializing a CLIPModel (with random weights) from the openai/clip-vit-base-patch32 style configuration
>>> model = CLIPModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config
>>> # We can also initialize a CLIPConfig from a CLIPTextConfig and a CLIPVisionConfig
>>> from transformers import CLIPTextConfig, CLIPVisionConfig
>>> # Initializing a CLIPText and CLIPVision configuration
>>> config_text = CLIPTextConfig()
>>> config_vision = CLIPVisionConfig()
>>> config = CLIPConfig.from_text_vision_configs(config_text, config_vision)
```"""
model_type = "LanguageBindVideo"
is_composition = True
def __init__(
self, text_config=None, vision_config=None, projection_dim=512, logit_scale_init_value=2.6592, **kwargs
):
# If `_config_dict` exist, we use them for the backward compatibility.
# We pop out these 2 attributes before calling `super().__init__` to avoid them being saved (which causes a lot
# of confusion!).
text_config_dict = kwargs.pop("text_config_dict", None)
vision_config_dict = kwargs.pop("vision_config_dict", None)
super().__init__(**kwargs)
# Instead of simply assigning `[text|vision]_config_dict` to `[text|vision]_config`, we use the values in
# `[text|vision]_config_dict` to update the values in `[text|vision]_config`. The values should be same in most
# cases, but we don't want to break anything regarding `_config_dict` that existed before commit `8827e1b2`.
if text_config_dict is not None:
if text_config is None:
text_config = {}
# This is the complete result when using `text_config_dict`.
_text_config_dict = CLIPTextConfig(**text_config_dict).to_dict()
# Give a warning if the values exist in both `_text_config_dict` and `text_config` but being different.
for key, value in _text_config_dict.items():
if key in text_config and value != text_config[key] and key not in ["transformers_version"]:
# If specified in `text_config_dict`
if key in text_config_dict:
message = (
f"`{key}` is found in both `text_config_dict` and `text_config` but with different values. "
f'The value `text_config_dict["{key}"]` will be used instead.'
)
# If inferred from default argument values (just to be super careful)
else:
message = (
f"`text_config_dict` is provided which will be used to initialize `CLIPTextConfig`. The "
f'value `text_config["{key}"]` will be overriden.'
)
logger.warning(message)
# Update all values in `text_config` with the ones in `_text_config_dict`.
text_config.update(_text_config_dict)
if vision_config_dict is not None:
if vision_config is None:
vision_config = {}
# This is the complete result when using `vision_config_dict`.
_vision_config_dict = CLIPVisionConfig(**vision_config_dict).to_dict()
# convert keys to string instead of integer
if "id2label" in _vision_config_dict:
_vision_config_dict["id2label"] = {
str(key): value for key, value in _vision_config_dict["id2label"].items()
}
# Give a warning if the values exist in both `_vision_config_dict` and `vision_config` but being different.
for key, value in _vision_config_dict.items():
if key in vision_config and value != vision_config[key] and key not in ["transformers_version"]:
# If specified in `vision_config_dict`
if key in vision_config_dict:
message = (
f"`{key}` is found in both `vision_config_dict` and `vision_config` but with different "
f'values. The value `vision_config_dict["{key}"]` will be used instead.'
)
# If inferred from default argument values (just to be super careful)
else:
message = (
f"`vision_config_dict` is provided which will be used to initialize `CLIPVisionConfig`. "
f'The value `vision_config["{key}"]` will be overriden.'
)
logger.warning(message)
# Update all values in `vision_config` with the ones in `_vision_config_dict`.
vision_config.update(_vision_config_dict)
if text_config is None:
text_config = {}
logger.info("`text_config` is `None`. Initializing the `CLIPTextConfig` with default values.")
if vision_config is None:
vision_config = {}
logger.info("`vision_config` is `None`. initializing the `CLIPVisionConfig` with default values.")
self.text_config = CLIPTextConfig(**text_config)
self.vision_config = CLIPVisionConfig(**vision_config)
self.projection_dim = projection_dim
self.logit_scale_init_value = logit_scale_init_value
self.initializer_factor = 1.0
@classmethod
def from_text_vision_configs(cls, text_config: CLIPTextConfig, vision_config: CLIPVisionConfig, **kwargs):
r"""
Instantiate a [`CLIPConfig`] (or a derived class) from clip text model configuration and clip vision model
configuration.
Returns:
[`CLIPConfig`]: An instance of a configuration object
"""
return cls(text_config=text_config.to_dict(), vision_config=vision_config.to_dict(), **kwargs)
def to_dict(self):
"""
Serializes this instance to a Python dictionary. Override the default [`~PretrainedConfig.to_dict`].
Returns:
`Dict[str, any]`: Dictionary of all the attributes that make up this configuration instance,
"""
output = copy.deepcopy(self.__dict__)
output["text_config"] = self.text_config.to_dict()
output["vision_config"] = self.vision_config.to_dict()
output["model_type"] = self.__class__.model_type
return output
| [] |
2024-01-10 | PKU-YuanGroup/Video-LLaVA | llava~eval~video~eval_benchmark_3_context.py | import openai
import os
import argparse
import json
import ast
from multiprocessing.pool import Pool
def parse_args():
parser = argparse.ArgumentParser(description="question-answer-generation-using-gpt-3")
parser.add_argument("--pred_path", required=True, help="The path to file containing prediction.")
parser.add_argument("--output_dir", required=True, help="The path to save annotation json files.")
parser.add_argument("--output_json", required=True, help="The path to save annotation final combined json file.")
parser.add_argument("--api_key", required=True, help="OpenAI API key.")
parser.add_argument("--api_base", default="", type=str, help="OpenAI API base.")
parser.add_argument("--num_tasks", required=True, type=int, help="Number of splits.")
args = parser.parse_args()
return args
def annotate(prediction_set, caption_files, output_dir, args):
"""
Evaluates question and answer pairs using GPT-3 and
returns a score for contextual understanding.
"""
# Set the OpenAI API key.
openai.api_key = args.api_key
if args.api_base is not None:
openai.api_base = args.api_base
for file in caption_files:
key = file[:-5] # Strip file extension
qa_set = prediction_set[key]
question = qa_set['q']
answer = qa_set['a']
pred = qa_set['pred']
try:
# Compute the contextual understanding score
completion = openai.ChatCompletion.create(
model="gpt-3.5-turbo",
messages=[
{
"role": "system",
"content":
"You are an intelligent chatbot designed for evaluating the contextual understanding of generative outputs for video-based question-answer pairs. "
"Your task is to compare the predicted answer with the correct answer and determine if the generated response aligns with the overall context of the video content. Here's how you can accomplish the task:"
"------"
"##INSTRUCTIONS: "
"- Evaluate whether the predicted answer aligns with the overall context of the video content. It should not provide information that is out of context or misaligned.\n"
"- The predicted answer must capture the main themes and sentiments of the video.\n"
"- Consider synonyms or paraphrases as valid matches.\n"
"- Provide your evaluation of the contextual understanding of the prediction compared to the answer."
},
{
"role": "user",
"content":
"Please evaluate the following video-based question-answer pair:\n\n"
f"Question: {question}\n"
f"Correct Answer: {answer}\n"
f"Predicted Answer: {pred}\n\n"
"Provide your evaluation only as a contextual understanding score where the contextual understanding score is an integer value between 0 and 5, with 5 indicating the highest level of contextual understanding. "
"Please generate the response in the form of a Python dictionary string with keys 'score', where its value is contextual understanding score in INTEGER, not STRING."
"DO NOT PROVIDE ANY OTHER OUTPUT TEXT OR EXPLANATION. Only provide the Python dictionary string. "
"For example, your response should look like this: {''score': 4.8}."
}
]
)
# Convert response to a Python dictionary.
response_message = completion["choices"][0]["message"]["content"]
response_dict = ast.literal_eval(response_message)
result_qa_pair = [response_dict, qa_set]
# Save the question-answer pairs to a json file.
with open(f"{output_dir}/{key}.json", "w") as f:
json.dump(result_qa_pair, f)
except Exception as e:
print(f"Error processing file '{key}': {e}")
def main():
"""
Main function to control the flow of the program.
"""
# Parse arguments.
args = parse_args()
file = open(args.pred_path)
pred_contents = json.load(file)
# Dictionary to store the count of occurrences for each video_id
video_id_counts = {}
new_pred_contents = []
# Iterate through each sample in pred_contents
for sample in pred_contents:
video_id = sample['video_name']
if video_id in video_id_counts:
video_id_counts[video_id] += 1
else:
video_id_counts[video_id] = 0
# Create a new sample with the modified key
new_sample = sample
new_sample['video_name'] = f"{video_id}_{video_id_counts[video_id]}"
new_pred_contents.append(new_sample)
# Generating list of id's and corresponding files
id_list = [x['video_name'] for x in new_pred_contents]
caption_files = [f"{id}.json" for id in id_list]
output_dir = args.output_dir
# Generate output directory if not exists.
if not os.path.exists(output_dir):
os.makedirs(output_dir)
# Preparing dictionary of question-answer sets
prediction_set = {}
for sample in new_pred_contents:
id = sample['video_name']
question = sample['Q']
answer = sample['A']
pred = sample['pred']
qa_set = {"q": question, "a": answer, "pred": pred}
prediction_set[id] = qa_set
# Set the OpenAI API key.
openai.api_key = args.api_key
num_tasks = args.num_tasks
# While loop to ensure that all captions are processed.
while True:
try:
# Files that have not been processed yet.
completed_files = os.listdir(output_dir)
print(f"completed_files: {len(completed_files)}")
# Files that have not been processed yet.
incomplete_files = [f for f in caption_files if f not in completed_files]
print(f"incomplete_files: {len(incomplete_files)}")
# Break the loop when there are no incomplete files
if len(incomplete_files) == 0:
break
if len(incomplete_files) <= num_tasks:
num_tasks = 1
# Split tasks into parts.
part_len = len(incomplete_files) // num_tasks
all_parts = [incomplete_files[i:i + part_len] for i in range(0, len(incomplete_files), part_len)]
task_args = [(prediction_set, part, args.output_dir, args) for part in all_parts]
# Use a pool of workers to process the files in parallel.
with Pool() as pool:
pool.starmap(annotate, task_args)
except Exception as e:
print(f"Error: {e}")
# Combine all the processed files into one
combined_contents = {}
json_path = args.output_json
# Iterate through json files
for file_name in os.listdir(output_dir):
if file_name.endswith(".json"):
file_path = os.path.join(output_dir, file_name)
with open(file_path, "r") as json_file:
content = json.load(json_file)
combined_contents[file_name[:-5]] = content
# Write combined content to a json file
with open(json_path, "w") as json_file:
json.dump(combined_contents, json_file)
print("All evaluation completed!")
# Calculate average score
score_sum = 0
count = 0
for key, result in combined_contents.items():
count += 1
score_match = result[0]['score']
score = int(score_match)
score_sum += score
average_score = score_sum / count
print("Average score for contextual understanding:", average_score)
if __name__ == "__main__":
main()
| [
"Please evaluate the following video-based question-answer pair:\n\nQuestion: PLACEHOLDER\nCorrect Answer: PLACEHOLDER\nPredicted Answer: PLACEHOLDER\n\nProvide your evaluation only as a contextual understanding score where the contextual understanding score is an integer value between 0 and 5, with 5 indicating the highest level of contextual understanding. Please generate the response in the form of a Python dictionary string with keys 'score', where its value is contextual understanding score in INTEGER, not STRING.DO NOT PROVIDE ANY OTHER OUTPUT TEXT OR EXPLANATION. Only provide the Python dictionary string. For example, your response should look like this: {''score': 4.8}.",
"You are an intelligent chatbot designed for evaluating the contextual understanding of generative outputs for video-based question-answer pairs. Your task is to compare the predicted answer with the correct answer and determine if the generated response aligns with the overall context of the video content. Here's how you can accomplish the task:------##INSTRUCTIONS: - Evaluate whether the predicted answer aligns with the overall context of the video content. It should not provide information that is out of context or misaligned.\n- The predicted answer must capture the main themes and sentiments of the video.\n- Consider synonyms or paraphrases as valid matches.\n- Provide your evaluation of the contextual understanding of the prediction compared to the answer."
] |
2024-01-10 | PKU-YuanGroup/Video-LLaVA | llava~eval~eval_gpt_mmvet.py | import argparse
import openai
import json
import os
from tqdm import tqdm
import pandas as pd
import numpy as np
from collections import Counter
import time
parser = argparse.ArgumentParser(description='ChatGPT-based QA evaluation.')
parser.add_argument('--mmvet_path')
parser.add_argument('--ckpt_name')
parser.add_argument('--result_path')
args = parser.parse_args()
openai.api_base = ""
openai.api_key = ''
gpt_model = "gpt-4-0613"
prompt = """Compare the ground truth and prediction from AI models, to give a correctness score for the prediction. <AND> in the ground truth means it is totally right only when all elements in the ground truth are present in the prediction, and <OR> means it is totally right when any one element in the ground truth is present in the prediction. The correctness score is 0.0 (totally wrong), 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, or 1.0 (totally right). Just complete the last space of the correctness score.
Question | Ground truth | Prediction | Correctness
--- | --- | --- | ---
What is x in the equation? | -1 <AND> -5 | x = 3 | 0.0
What is x in the equation? | -1 <AND> -5 | x = -1 | 0.5
What is x in the equation? | -1 <AND> -5 | x = -5 | 0.5
What is x in the equation? | -1 <AND> -5 | x = -5 or 5 | 0.5
What is x in the equation? | -1 <AND> -5 | x = -1 or x = -5 | 1.0
Can you explain this meme? | This meme is poking fun at the fact that the names of the countries Iceland and Greenland are misleading. Despite its name, Iceland is known for its beautiful green landscapes, while Greenland is mostly covered in ice and snow. The meme is saying that the person has trust issues because the names of these countries do not accurately represent their landscapes. | The meme talks about Iceland and Greenland. It's pointing out that despite their names, Iceland is not very icy and Greenland isn't very green. | 0.4
Can you explain this meme? | This meme is poking fun at the fact that the names of the countries Iceland and Greenland are misleading. Despite its name, Iceland is known for its beautiful green landscapes, while Greenland is mostly covered in ice and snow. The meme is saying that the person has trust issues because the names of these countries do not accurately represent their landscapes. | The meme is using humor to point out the misleading nature of Iceland's and Greenland's names. Iceland, despite its name, has lush green landscapes while Greenland is mostly covered in ice and snow. The text 'This is why I have trust issues' is a playful way to suggest that these contradictions can lead to distrust or confusion. The humor in this meme is derived from the unexpected contrast between the names of the countries and their actual physical characteristics. | 1.0
"""
# load metadata
# Download mm-vet.zip and `unzip mm-vet.zip` and change the path below
mmvet_path = args.mmvet_path
use_sub_set = False
decimal_places = 1 # number of decimal places to round to
if use_sub_set:
bard_set_file = os.path.join(mmvet_path, "bard_set.json")
with open(bard_set_file, 'r') as f:
sub_set = json.load(f)
sub_set_name = 'bardset'
sub_set_name = sub_set_name + '_'
else:
sub_set = None
sub_set_name = ''
mmvet_metadata = os.path.join(mmvet_path, "mm-vet.json")
with open(mmvet_metadata, 'r') as f:
data = json.load(f)
counter = Counter()
cap_set_list = []
cap_set_counter = []
len_data = 0
for id, value in data.items():
if sub_set is not None and id not in sub_set:
continue
question = value["question"]
answer = value["answer"]
cap = value["capability"]
cap = set(cap)
counter.update(cap)
if cap not in cap_set_list:
cap_set_list.append(cap)
cap_set_counter.append(1)
else:
cap_set_counter[cap_set_list.index(cap)] += 1
len_data += 1
sorted_list = counter.most_common()
columns = [k for k, v in sorted_list]
columns.append("total")
columns.append("std")
columns.append('runs')
df = pd.DataFrame(columns=columns)
cap_set_sorted_indices = np.argsort(-np.array(cap_set_counter))
new_cap_set_list = []
new_cap_set_counter = []
for index in cap_set_sorted_indices:
new_cap_set_list.append(cap_set_list[index])
new_cap_set_counter.append(cap_set_counter[index])
cap_set_list = new_cap_set_list
cap_set_counter = new_cap_set_counter
cap_set_names = ["_".join(list(cap_set)) for cap_set in cap_set_list]
columns2 = cap_set_names
columns2.append("total")
columns2.append("std")
columns2.append('runs')
df2 = pd.DataFrame(columns=columns2)
###### change your model name ######
model = args.ckpt_name
result_path = args.result_path
num_run = 1 # we set it as 5 in the paper
model_results_file = os.path.join(result_path, f"{model}.json")
# grade results for each sample to svae
grade_file = f'{model}_{gpt_model}-grade-{num_run}runs.json'
grade_file = os.path.join(result_path, grade_file)
# score results regarding capabilities/capability integration to save
cap_score_file = f'{model}_{sub_set_name}{gpt_model}-cap-score-{num_run}runs.csv'
cap_score_file = os.path.join(result_path, cap_score_file)
cap_int_score_file = f'{model}_{sub_set_name}{gpt_model}-cap-int-score-{num_run}runs.csv'
cap_int_score_file = os.path.join(result_path, cap_int_score_file)
with open(model_results_file) as f:
results = json.load(f)
if os.path.exists(grade_file):
with open(grade_file, 'r') as f:
grade_results = json.load(f)
else:
grade_results = {}
def need_more_runs():
need_more_runs = False
if len(grade_results) > 0:
for k, v in grade_results.items():
if len(v['score']) < num_run:
need_more_runs = True
break
return need_more_runs or len(grade_results) < len_data
while need_more_runs():
for j in range(num_run):
print(f'eval run {j}')
for id, line in tqdm(data.items()):
if sub_set is not None and id not in sub_set:
continue
if id in grade_results and len(grade_results[id]['score']) >= (j + 1):
continue
model_pred = results[id]
question = prompt + '\n' + ' | '.join(
[line['question'], line['answer'].replace("<AND>", " <AND> ").replace("<OR>", " <OR> "), model_pred,
""])
messages = [
{"role": "user", "content": question},
]
if id not in grade_results:
sample_grade = {'model': [], 'content': [], 'score': []}
else:
sample_grade = grade_results[id]
grade_sample_run_complete = False
temperature = 0.0
while not grade_sample_run_complete:
try:
response = openai.ChatCompletion.create(
model=gpt_model,
max_tokens=3,
temperature=temperature,
messages=messages)
# print(response['model'])
content = response['choices'][0]['message']['content']
flag = True
try_time = 1
while flag:
try:
content = content.split(' ')[0].strip()
score = float(content)
if score > 1.0 or score < 0.0:
assert False
flag = False
except:
question = prompt + '\n' + ' | '.join(
[line['question'], line['answer'].replace("<AND>", " <AND> ").replace("<OR>", " <OR> "),
model_pred, ""]) + "\nPredict the correctness of the answer (digit): "
messages = [
{"role": "user", "content": question},
]
response = openai.ChatCompletion.create(
model=gpt_model,
max_tokens=3,
temperature=temperature,
messages=messages)
# print(response)
content = response['choices'][0]['message']['content']
try_time += 1
temperature += 0.5
print(f"{id} try {try_time} times")
print(content)
if try_time > 5:
score = 0.0
flag = False
grade_sample_run_complete = True
except:
# gpt4 may have token rate limit
print("sleep 1s")
time.sleep(1)
if len(sample_grade['model']) >= j + 1:
sample_grade['model'][j] = response['model']
sample_grade['content'][j] = content
sample_grade['score'][j] = score
else:
sample_grade['model'].append(response['model'])
sample_grade['content'].append(content)
sample_grade['score'].append(score)
grade_results[id] = sample_grade
with open(grade_file, 'w') as f:
json.dump(grade_results, f, indent=4)
assert not need_more_runs()
cap_socres = {k: [0.0] * num_run for k in columns[:-2]}
counter['total'] = len_data
cap_socres2 = {k: [0.0] * num_run for k in columns2[:-2]}
counter2 = {columns2[i]: cap_set_counter[i] for i in range(len(cap_set_counter))}
counter2['total'] = len_data
for k, v in grade_results.items():
if sub_set is not None and k not in sub_set:
continue
for i in range(num_run):
score = v['score'][i]
caps = set(data[k]['capability'])
for c in caps:
cap_socres[c][i] += score
cap_socres['total'][i] += score
index = cap_set_list.index(caps)
cap_socres2[cap_set_names[index]][i] += score
cap_socres2['total'][i] += score
for k, v in cap_socres.items():
cap_socres[k] = np.array(v) / counter[k] * 100
std = round(cap_socres['total'].std(), decimal_places)
total_copy = cap_socres['total'].copy()
runs = str(list(np.round(total_copy, decimal_places)))
for k, v in cap_socres.items():
cap_socres[k] = round(v.mean(), decimal_places)
cap_socres['std'] = std
cap_socres['runs'] = runs
df.loc[model] = cap_socres
for k, v in cap_socres2.items():
cap_socres2[k] = round(np.mean(np.array(v) / counter2[k] * 100), decimal_places)
cap_socres2['std'] = std
cap_socres2['runs'] = runs
df2.loc[model] = cap_socres2
df.to_csv(cap_score_file)
df2.to_csv(cap_int_score_file)
print(df)
print(df2) | [
"[]",
"Compare the ground truth and prediction from AI models, to give a correctness score for the prediction. <AND> in the ground truth means it is totally right only when all elements in the ground truth are present in the prediction, and <OR> means it is totally right when any one element in the ground truth is present in the prediction. The correctness score is 0.0 (totally wrong), 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, or 1.0 (totally right). Just complete the last space of the correctness score.\n\nQuestion | Ground truth | Prediction | Correctness\n--- | --- | --- | ---\nWhat is x in the equation? | -1 <AND> -5 | x = 3 | 0.0\nWhat is x in the equation? | -1 <AND> -5 | x = -1 | 0.5\nWhat is x in the equation? | -1 <AND> -5 | x = -5 | 0.5\nWhat is x in the equation? | -1 <AND> -5 | x = -5 or 5 | 0.5\nWhat is x in the equation? | -1 <AND> -5 | x = -1 or x = -5 | 1.0\nCan you explain this meme? | This meme is poking fun at the fact that the names of the countries Iceland and Greenland are misleading. Despite its name, Iceland is known for its beautiful green landscapes, while Greenland is mostly covered in ice and snow. The meme is saying that the person has trust issues because the names of these countries do not accurately represent their landscapes. | The meme talks about Iceland and Greenland. It's pointing out that despite their names, Iceland is not very icy and Greenland isn't very green. | 0.4\nCan you explain this meme? | This meme is poking fun at the fact that the names of the countries Iceland and Greenland are misleading. Despite its name, Iceland is known for its beautiful green landscapes, while Greenland is mostly covered in ice and snow. The meme is saying that the person has trust issues because the names of these countries do not accurately represent their landscapes. | The meme is using humor to point out the misleading nature of Iceland's and Greenland's names. Iceland, despite its name, has lush green landscapes while Greenland is mostly covered in ice and snow. The text 'This is why I have trust issues' is a playful way to suggest that these contradictions can lead to distrust or confusion. The humor in this meme is derived from the unexpected contrast between the names of the countries and their actual physical characteristics. | 1.0\n"
] |
2024-01-10 | PKU-YuanGroup/Video-LLaVA | llava~eval~video~eval_video_qa.py | import openai
import os
import argparse
import json
import ast
from multiprocessing.pool import Pool
from tqdm import tqdm
def parse_args():
parser = argparse.ArgumentParser(description="question-answer-generation-using-gpt-3")
parser.add_argument("--pred_path", default=r'', help="The path to file containing prediction.")
parser.add_argument("--output_dir", default=r'', help="The path to save annotation json files.")
parser.add_argument("--output_json", default=r'', help="The path to save annotation final combined json file.")
parser.add_argument("--api_key", default="", help="OpenAI API key.")
parser.add_argument("--api_base", default="", type=str, help="OpenAI API base.")
parser.add_argument("--num_tasks", default=1, type=int, help="Number of splits.")
args = parser.parse_args()
return args
def annotate(prediction_set, caption_files, output_dir, args):
"""
Evaluates question and answer pairs using GPT-3
Returns a score for correctness.
"""
# Set the OpenAI API key.
openai.api_key = args.api_key
if args.api_base is not None:
openai.api_base = args.api_base
for file in caption_files:
key = file[:-5] # Strip file extension
qa_set = prediction_set[key]
question = qa_set['q']
answer = qa_set['a']
pred = qa_set['pred']
try:
# Compute the correctness score
completion = openai.ChatCompletion.create(
model="gpt-3.5-turbo",
messages=[
{
"role": "system",
"content":
"You are an intelligent chatbot designed for evaluating the correctness of generative outputs for question-answer pairs. "
"Your task is to compare the predicted answer with the correct answer and determine if they match meaningfully. Here's how you can accomplish the task:"
"------"
"##INSTRUCTIONS: "
"- Focus on the meaningful match between the predicted answer and the correct answer.\n"
"- Consider synonyms or paraphrases as valid matches.\n"
"- Evaluate the correctness of the prediction compared to the answer."
},
{
"role": "user",
"content":
"Please evaluate the following video-based question-answer pair:\n\n"
f"Question: {question}\n"
f"Correct Answer: {answer}\n"
f"Predicted Answer: {pred}\n\n"
"Provide your evaluation only as a yes/no and score where the score is an integer value between 0 and 5, with 5 indicating the highest meaningful match. "
"Please generate the response in the form of a Python dictionary string with keys 'pred' and 'score', where value of 'pred' is a string of 'yes' or 'no' and value of 'score' is in INTEGER, not STRING."
"DO NOT PROVIDE ANY OTHER OUTPUT TEXT OR EXPLANATION. Only provide the Python dictionary string. "
"For example, your response should look like this: {'pred': 'yes', 'score': 4.8}."
}
]
)
# Convert response to a Python dictionary.
response_message = completion["choices"][0]["message"]["content"]
response_dict = ast.literal_eval(response_message)
result_qa_pair = [response_dict, qa_set]
# Save the question-answer pairs to a json file.
with open(f"{output_dir}/{key}.json", "w") as f:
json.dump(result_qa_pair, f)
except Exception as e:
print(f"Error processing file '{key}': {e}")
def main():
"""
Main function to control the flow of the program.
"""
# Parse arguments.
args = parse_args()
file = open(args.pred_path)
new_pred_contents = [eval(i.strip()) for i in file.readlines()]
'''
# Dictionary to store the count of occurrences for each video_id
video_id_counts = {}
new_pred_contents = []
# Iterate through each sample in pred_contents
for sample in pred_contents:
video_id = sample['video_name']
if video_id in video_id_counts:
video_id_counts[video_id] += 1
else:
video_id_counts[video_id] = 0
# Create a new sample with the modified key
new_sample = sample
new_sample['video_name'] = f"{video_id}_{video_id_counts[video_id]}"
new_pred_contents.append(new_sample)
'''
# Generating list of id's and corresponding files
id_list = [x['id'] for x in new_pred_contents]
caption_files = [f"{id}.json" for id in id_list]
output_dir = args.output_dir
# Generate output directory if not exists.
if not os.path.exists(output_dir):
os.makedirs(output_dir)
# Preparing dictionary of question-answer sets
prediction_set = {}
for sample in new_pred_contents:
id = sample['id']
question = sample['question']
answer = sample['answer']
pred = sample['pred']
qa_set = {"q": question, "a": answer, "pred": pred}
prediction_set[id] = qa_set
num_tasks = args.num_tasks
# While loop to ensure that all captions are processed.
while True:
try:
# Files that have not been processed yet.
completed_files = os.listdir(output_dir)
print(f"completed_files: {len(completed_files)}")
# Files that have not been processed yet.
incomplete_files = [f for f in caption_files if f not in completed_files]
print(f"incomplete_files: {len(incomplete_files)}")
# Break the loop when there are no incomplete files
if len(incomplete_files) == 0:
break
if len(incomplete_files) <= num_tasks:
num_tasks = 1
# Split tasks into parts.
part_len = len(incomplete_files) // num_tasks
all_parts = [incomplete_files[i:i + part_len] for i in range(0, len(incomplete_files), part_len)]
task_args = [(prediction_set, part, args.output_dir, args) for part in all_parts]
# Use a pool of workers to process the files in parallel.
with Pool() as pool:
pool.starmap(annotate, task_args)
except Exception as e:
print(f"Error: {e}")
# Combine all the processed files into one
combined_contents = {}
json_path = args.output_json
# Iterate through json files
for file_name in os.listdir(output_dir):
if file_name.endswith(".json"):
file_path = os.path.join(output_dir, file_name)
with open(file_path, "r") as json_file:
content = json.load(json_file)
combined_contents[file_name[:-5]] = content
# Write combined content to a json file
with open(json_path, "w") as json_file:
json.dump(combined_contents, json_file)
print("All evaluation completed!")
# Calculate average score and accuracy
score_sum = 0
count = 0
yes_count = 0
no_count = 0
for key, result in tqdm(combined_contents.items()):
try:
# Computing score
count += 1
score_match = result[0]['score']
score = int(score_match)
score_sum += score
# Computing accuracy
pred = result[0]['pred']
if "yes" in pred.lower():
yes_count += 1
elif "no" in pred.lower():
no_count += 1
except:
print(result)
average_score = score_sum / count
accuracy = yes_count / (yes_count + no_count)
print("Yes count:", yes_count)
print("No count:", no_count)
print("Accuracy:", accuracy)
print("Average score:", average_score)
if __name__ == "__main__":
main()
| [
"Please evaluate the following video-based question-answer pair:\n\nQuestion: PLACEHOLDER\nCorrect Answer: PLACEHOLDER\nPredicted Answer: PLACEHOLDER\n\nProvide your evaluation only as a yes/no and score where the score is an integer value between 0 and 5, with 5 indicating the highest meaningful match. Please generate the response in the form of a Python dictionary string with keys 'pred' and 'score', where value of 'pred' is a string of 'yes' or 'no' and value of 'score' is in INTEGER, not STRING.DO NOT PROVIDE ANY OTHER OUTPUT TEXT OR EXPLANATION. Only provide the Python dictionary string. For example, your response should look like this: {'pred': 'yes', 'score': 4.8}.",
"You are an intelligent chatbot designed for evaluating the correctness of generative outputs for question-answer pairs. Your task is to compare the predicted answer with the correct answer and determine if they match meaningfully. Here's how you can accomplish the task:------##INSTRUCTIONS: - Focus on the meaningful match between the predicted answer and the correct answer.\n- Consider synonyms or paraphrases as valid matches.\n- Evaluate the correctness of the prediction compared to the answer."
] |
2024-01-10 | PKU-YuanGroup/Video-LLaVA | llava~eval~video~eval_benchmark_1_correctness.py | import openai
import os
import argparse
import json
import ast
from multiprocessing.pool import Pool
def parse_args():
parser = argparse.ArgumentParser(description="question-answer-generation-using-gpt-3")
parser.add_argument("--pred_path", required=True, help="The path to file containing prediction.")
parser.add_argument("--output_dir", required=True, help="The path to save annotation json files.")
parser.add_argument("--output_json", required=True, help="The path to save annotation final combined json file.")
parser.add_argument("--api_key", required=True, help="OpenAI API key.")
parser.add_argument("--api_base", default="", type=str, help="OpenAI API base.")
parser.add_argument("--num_tasks", required=True, type=int, help="Number of splits.")
args = parser.parse_args()
return args
def annotate(prediction_set, caption_files, output_dir, args):
"""
Evaluates question and answer pairs using GPT-3
Returns a score for correctness.
"""
# Set the OpenAI API key.
openai.api_key = args.api_key
if args.api_base is not None:
openai.api_base = args.api_base
for file in caption_files:
key = file[:-5] # Strip file extension
qa_set = prediction_set[key]
question = qa_set['q']
answer = qa_set['a']
pred = qa_set['pred']
try:
# Compute the correctness score
completion = openai.ChatCompletion.create(
model="gpt-3.5-turbo",
messages=[
{
"role": "system",
"content":
"You are an intelligent chatbot designed for evaluating the factual accuracy of generative outputs for video-based question-answer pairs. "
"Your task is to compare the predicted answer with the correct answer and determine if they are factually consistent. Here's how you can accomplish the task:"
"------"
"##INSTRUCTIONS: "
"- Focus on the factual consistency between the predicted answer and the correct answer. The predicted answer should not contain any misinterpretations or misinformation.\n"
"- The predicted answer must be factually accurate and align with the video content.\n"
"- Consider synonyms or paraphrases as valid matches.\n"
"- Evaluate the factual accuracy of the prediction compared to the answer."
},
{
"role": "user",
"content":
"Please evaluate the following video-based question-answer pair:\n\n"
f"Question: {question}\n"
f"Correct Answer: {answer}\n"
f"Predicted Answer: {pred}\n\n"
"Provide your evaluation only as a factual accuracy score where the factual accuracy score is an integer value between 0 and 5, with 5 indicating the highest level of factual consistency. "
"Please generate the response in the form of a Python dictionary string with keys 'score', where its value is the factual accuracy score in INTEGER, not STRING."
"DO NOT PROVIDE ANY OTHER OUTPUT TEXT OR EXPLANATION. Only provide the Python dictionary string. "
"For example, your response should look like this: {''score': 4.8}."
}
]
)
# Convert response to a Python dictionary.
response_message = completion["choices"][0]["message"]["content"]
response_dict = ast.literal_eval(response_message)
result_qa_pair = [response_dict, qa_set]
# Save the question-answer pairs to a json file.
with open(f"{output_dir}/{key}.json", "w") as f:
json.dump(result_qa_pair, f)
except Exception as e:
print(f"Error processing file '{key}': {e}")
def main():
"""
Main function to control the flow of the program.
"""
# Parse arguments.
args = parse_args()
file = open(args.pred_path)
pred_contents = json.load(file)
# Dictionary to store the count of occurrences for each video_id
video_id_counts = {}
new_pred_contents = []
# Iterate through each sample in pred_contents
for sample in pred_contents:
video_id = sample['video_name']
if video_id in video_id_counts:
video_id_counts[video_id] += 1
else:
video_id_counts[video_id] = 0
# Create a new sample with the modified key
new_sample = sample
new_sample['video_name'] = f"{video_id}_{video_id_counts[video_id]}"
new_pred_contents.append(new_sample)
# Generating list of id's and corresponding files
id_list = [x['video_name'] for x in new_pred_contents]
caption_files = [f"{id}.json" for id in id_list]
output_dir = args.output_dir
# Generate output directory if not exists.
if not os.path.exists(output_dir):
os.makedirs(output_dir)
# Preparing dictionary of question-answer sets
prediction_set = {}
for sample in new_pred_contents:
id = sample['video_name']
question = sample['Q']
answer = sample['A']
pred = sample['pred']
qa_set = {"q": question, "a": answer, "pred": pred}
prediction_set[id] = qa_set
# Set the OpenAI API key.
openai.api_key = args.api_key
num_tasks = args.num_tasks
# While loop to ensure that all captions are processed.
while True:
try:
# Files that have not been processed yet.
completed_files = os.listdir(output_dir)
print(f"completed_files: {len(completed_files)}")
# Files that have not been processed yet.
incomplete_files = [f for f in caption_files if f not in completed_files]
print(f"incomplete_files: {len(incomplete_files)}")
# Break the loop when there are no incomplete files
if len(incomplete_files) == 0:
break
if len(incomplete_files) <= num_tasks:
num_tasks = 1
# Split tasks into parts.
part_len = len(incomplete_files) // num_tasks
all_parts = [incomplete_files[i:i + part_len] for i in range(0, len(incomplete_files), part_len)]
task_args = [(prediction_set, part, args.output_dir, args) for part in all_parts]
# Use a pool of workers to process the files in parallel.
with Pool() as pool:
pool.starmap(annotate, task_args)
except Exception as e:
print(f"Error: {e}")
# Combine all the processed files into one
combined_contents = {}
json_path = args.output_json
# Iterate through json files
for file_name in os.listdir(output_dir):
if file_name.endswith(".json"):
file_path = os.path.join(output_dir, file_name)
with open(file_path, "r") as json_file:
content = json.load(json_file)
combined_contents[file_name[:-5]] = content
# Write combined content to a json file
with open(json_path, "w") as json_file:
json.dump(combined_contents, json_file)
print("All evaluation completed!")
# Calculate average score
score_sum = 0
count = 0
for key, result in combined_contents.items():
count += 1
score_match = result[0]['score']
score = int(score_match)
score_sum += score
average_score = score_sum / count
print("Average score for correctness:", average_score)
if __name__ == "__main__":
main()
| [
"You are an intelligent chatbot designed for evaluating the factual accuracy of generative outputs for video-based question-answer pairs. Your task is to compare the predicted answer with the correct answer and determine if they are factually consistent. Here's how you can accomplish the task:------##INSTRUCTIONS: - Focus on the factual consistency between the predicted answer and the correct answer. The predicted answer should not contain any misinterpretations or misinformation.\n- The predicted answer must be factually accurate and align with the video content.\n- Consider synonyms or paraphrases as valid matches.\n- Evaluate the factual accuracy of the prediction compared to the answer.",
"Please evaluate the following video-based question-answer pair:\n\nQuestion: PLACEHOLDER\nCorrect Answer: PLACEHOLDER\nPredicted Answer: PLACEHOLDER\n\nProvide your evaluation only as a factual accuracy score where the factual accuracy score is an integer value between 0 and 5, with 5 indicating the highest level of factual consistency. Please generate the response in the form of a Python dictionary string with keys 'score', where its value is the factual accuracy score in INTEGER, not STRING.DO NOT PROVIDE ANY OTHER OUTPUT TEXT OR EXPLANATION. Only provide the Python dictionary string. For example, your response should look like this: {''score': 4.8}."
] |
2024-01-10 | PKU-YuanGroup/Video-LLaVA | llava~model~multimodal_encoder~languagebind~image~configuration_image.py | import copy
import os
from typing import Union
from transformers import PretrainedConfig
from transformers.utils import logging
logger = logging.get_logger(__name__)
class CLIPTextConfig(PretrainedConfig):
r"""
This is the configuration class to store the configuration of a [`CLIPTextModel`]. It is used to instantiate a CLIP
text encoder according to the specified arguments, defining the model architecture. Instantiating a configuration
with the defaults will yield a similar configuration to that of the text encoder of the CLIP
[openai/clip-vit-base-patch32](https://huggingface.co/openai/clip-vit-base-patch32) architecture.
Configuration objects inherit from [`PretrainedConfig`] and can be used to control the model outputs. Read the
documentation from [`PretrainedConfig`] for more information.
Args:
vocab_size (`int`, *optional*, defaults to 49408):
Vocabulary size of the CLIP text model. Defines the number of different tokens that can be represented by
the `inputs_ids` passed when calling [`CLIPModel`].
hidden_size (`int`, *optional*, defaults to 512):
Dimensionality of the encoder layers and the pooler layer.
intermediate_size (`int`, *optional*, defaults to 2048):
Dimensionality of the "intermediate" (i.e., feed-forward) layer in the Transformer encoder.
num_hidden_layers (`int`, *optional*, defaults to 12):
Number of hidden layers in the Transformer encoder.
num_attention_heads (`int`, *optional*, defaults to 8):
Number of attention heads for each attention layer in the Transformer encoder.
max_position_embeddings (`int`, *optional*, defaults to 77):
The maximum sequence length that this model might ever be used with. Typically set this to something large
just in case (e.g., 512 or 1024 or 2048).
hidden_act (`str` or `function`, *optional*, defaults to `"quick_gelu"`):
The non-linear activation function (function or string) in the encoder and pooler. If string, `"gelu"`,
`"relu"`, `"selu"` and `"gelu_new"` `"quick_gelu"` are supported.
layer_norm_eps (`float`, *optional*, defaults to 1e-5):
The epsilon used by the layer normalization layers.
attention_dropout (`float`, *optional*, defaults to 0.0):
The dropout ratio for the attention probabilities.
initializer_range (`float`, *optional*, defaults to 0.02):
The standard deviation of the truncated_normal_initializer for initializing all weight matrices.
initializer_factor (`float`, *optional*, defaults to 1):
A factor for initializing all weight matrices (should be kept to 1, used internally for initialization
testing).
Example:
```python
>>> from transformers import CLIPTextConfig, CLIPTextModel
>>> # Initializing a CLIPTextConfig with openai/clip-vit-base-patch32 style configuration
>>> configuration = CLIPTextConfig()
>>> # Initializing a CLIPTextModel (with random weights) from the openai/clip-vit-base-patch32 style configuration
>>> model = CLIPTextModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config
```"""
model_type = "clip_text_model"
def __init__(
self,
vocab_size=49408,
hidden_size=512,
intermediate_size=2048,
projection_dim=512,
num_hidden_layers=12,
num_attention_heads=8,
max_position_embeddings=77,
hidden_act="quick_gelu",
layer_norm_eps=1e-5,
attention_dropout=0.0,
initializer_range=0.02,
initializer_factor=1.0,
# This differs from `CLIPTokenizer`'s default and from openai/clip
# See https://github.com/huggingface/transformers/pull/24773#issuecomment-1632287538
pad_token_id=1,
bos_token_id=49406,
eos_token_id=49407,
**kwargs,
):
super().__init__(pad_token_id=pad_token_id, bos_token_id=bos_token_id, eos_token_id=eos_token_id, **kwargs)
self.vocab_size = vocab_size
self.hidden_size = hidden_size
self.intermediate_size = intermediate_size
self.projection_dim = projection_dim
self.num_hidden_layers = num_hidden_layers
self.num_attention_heads = num_attention_heads
self.max_position_embeddings = max_position_embeddings
self.layer_norm_eps = layer_norm_eps
self.hidden_act = hidden_act
self.initializer_range = initializer_range
self.initializer_factor = initializer_factor
self.attention_dropout = attention_dropout
self.add_time_attn = False ######################################
@classmethod
def from_pretrained(cls, pretrained_model_name_or_path: Union[str, os.PathLike], **kwargs) -> "PretrainedConfig":
cls._set_token_in_kwargs(kwargs)
config_dict, kwargs = cls.get_config_dict(pretrained_model_name_or_path, **kwargs)
# get the text config dict if we are loading from CLIPConfig
if config_dict.get("model_type") == "clip":
config_dict = config_dict["text_config"]
if "model_type" in config_dict and hasattr(cls, "model_type") and config_dict["model_type"] != cls.model_type:
logger.warning(
f"You are using a model of type {config_dict['model_type']} to instantiate a model of type "
f"{cls.model_type}. This is not supported for all configurations of models and can yield errors."
)
return cls.from_dict(config_dict, **kwargs)
class CLIPVisionConfig(PretrainedConfig):
r"""
This is the configuration class to store the configuration of a [`CLIPVisionModel`]. It is used to instantiate a
CLIP vision encoder according to the specified arguments, defining the model architecture. Instantiating a
configuration with the defaults will yield a similar configuration to that of the vision encoder of the CLIP
[openai/clip-vit-base-patch32](https://huggingface.co/openai/clip-vit-base-patch32) architecture.
Configuration objects inherit from [`PretrainedConfig`] and can be used to control the model outputs. Read the
documentation from [`PretrainedConfig`] for more information.
Args:
hidden_size (`int`, *optional*, defaults to 768):
Dimensionality of the encoder layers and the pooler layer.
intermediate_size (`int`, *optional*, defaults to 3072):
Dimensionality of the "intermediate" (i.e., feed-forward) layer in the Transformer encoder.
num_hidden_layers (`int`, *optional*, defaults to 12):
Number of hidden layers in the Transformer encoder.
num_attention_heads (`int`, *optional*, defaults to 12):
Number of attention heads for each attention layer in the Transformer encoder.
image_size (`int`, *optional*, defaults to 224):
The size (resolution) of each image.
patch_size (`int`, *optional*, defaults to 32):
The size (resolution) of each patch.
hidden_act (`str` or `function`, *optional*, defaults to `"quick_gelu"`):
The non-linear activation function (function or string) in the encoder and pooler. If string, `"gelu"`,
`"relu"`, `"selu"` and `"gelu_new"` ``"quick_gelu"` are supported.
layer_norm_eps (`float`, *optional*, defaults to 1e-5):
The epsilon used by the layer normalization layers.
attention_dropout (`float`, *optional*, defaults to 0.0):
The dropout ratio for the attention probabilities.
initializer_range (`float`, *optional*, defaults to 0.02):
The standard deviation of the truncated_normal_initializer for initializing all weight matrices.
initializer_factor (`float`, *optional*, defaults to 1):
A factor for initializing all weight matrices (should be kept to 1, used internally for initialization
testing).
Example:
```python
>>> from transformers import CLIPVisionConfig, CLIPVisionModel
>>> # Initializing a CLIPVisionConfig with openai/clip-vit-base-patch32 style configuration
>>> configuration = CLIPVisionConfig()
>>> # Initializing a CLIPVisionModel (with random weights) from the openai/clip-vit-base-patch32 style configuration
>>> model = CLIPVisionModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config
```"""
model_type = "clip_vision_model"
def __init__(
self,
hidden_size=768,
intermediate_size=3072,
projection_dim=512,
num_hidden_layers=12,
num_attention_heads=12,
num_channels=3,
image_size=224,
patch_size=32,
hidden_act="quick_gelu",
layer_norm_eps=1e-5,
attention_dropout=0.0,
initializer_range=0.02,
initializer_factor=1.0,
add_time_attn=False, ################################
num_frames=1, ################################
force_patch_dropout=0.0, ################################
lora_r=2, ################################
lora_alpha=16, ################################
lora_dropout=0.0, ################################
num_mel_bins=0.0, ################################
target_length=0.0, ################################
video_decode_backend='decord', #########################
**kwargs,
):
super().__init__(**kwargs)
self.hidden_size = hidden_size
self.intermediate_size = intermediate_size
self.projection_dim = projection_dim
self.num_hidden_layers = num_hidden_layers
self.num_attention_heads = num_attention_heads
self.num_channels = num_channels
self.patch_size = patch_size
self.image_size = image_size
self.initializer_range = initializer_range
self.initializer_factor = initializer_factor
self.attention_dropout = attention_dropout
self.layer_norm_eps = layer_norm_eps
self.hidden_act = hidden_act
self.add_time_attn = add_time_attn ################
self.num_frames = num_frames ################
self.force_patch_dropout = force_patch_dropout ################
self.lora_r = lora_r ################
self.lora_alpha = lora_alpha ################
self.lora_dropout = lora_dropout ################
self.num_mel_bins = num_mel_bins ################
self.target_length = target_length ################
self.video_decode_backend = video_decode_backend ################
@classmethod
def from_pretrained(cls, pretrained_model_name_or_path: Union[str, os.PathLike], **kwargs) -> "PretrainedConfig":
cls._set_token_in_kwargs(kwargs)
config_dict, kwargs = cls.get_config_dict(pretrained_model_name_or_path, **kwargs)
# get the vision config dict if we are loading from CLIPConfig
if config_dict.get("model_type") == "clip":
config_dict = config_dict["vision_config"]
if "model_type" in config_dict and hasattr(cls, "model_type") and config_dict["model_type"] != cls.model_type:
logger.warning(
f"You are using a model of type {config_dict['model_type']} to instantiate a model of type "
f"{cls.model_type}. This is not supported for all configurations of models and can yield errors."
)
return cls.from_dict(config_dict, **kwargs)
class LanguageBindImageConfig(PretrainedConfig):
r"""
[`CLIPConfig`] is the configuration class to store the configuration of a [`CLIPModel`]. It is used to instantiate
a CLIP model according to the specified arguments, defining the text model and vision model configs. Instantiating
a configuration with the defaults will yield a similar configuration to that of the CLIP
[openai/clip-vit-base-patch32](https://huggingface.co/openai/clip-vit-base-patch32) architecture.
Configuration objects inherit from [`PretrainedConfig`] and can be used to control the model outputs. Read the
documentation from [`PretrainedConfig`] for more information.
Args:
text_config (`dict`, *optional*):
Dictionary of configuration options used to initialize [`CLIPTextConfig`].
vision_config (`dict`, *optional*):
Dictionary of configuration options used to initialize [`CLIPVisionConfig`].
projection_dim (`int`, *optional*, defaults to 512):
Dimentionality of text and vision projection layers.
logit_scale_init_value (`float`, *optional*, defaults to 2.6592):
The inital value of the *logit_scale* paramter. Default is used as per the original CLIP implementation.
kwargs (*optional*):
Dictionary of keyword arguments.
Example:
```python
>>> from transformers import CLIPConfig, CLIPModel
>>> # Initializing a CLIPConfig with openai/clip-vit-base-patch32 style configuration
>>> configuration = CLIPConfig()
>>> # Initializing a CLIPModel (with random weights) from the openai/clip-vit-base-patch32 style configuration
>>> model = CLIPModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config
>>> # We can also initialize a CLIPConfig from a CLIPTextConfig and a CLIPVisionConfig
>>> from transformers import CLIPTextConfig, CLIPVisionConfig
>>> # Initializing a CLIPText and CLIPVision configuration
>>> config_text = CLIPTextConfig()
>>> config_vision = CLIPVisionConfig()
>>> config = CLIPConfig.from_text_vision_configs(config_text, config_vision)
```"""
model_type = "LanguageBindImage"
is_composition = True
def __init__(
self, text_config=None, vision_config=None, projection_dim=512, logit_scale_init_value=2.6592, **kwargs
):
# If `_config_dict` exist, we use them for the backward compatibility.
# We pop out these 2 attributes before calling `super().__init__` to avoid them being saved (which causes a lot
# of confusion!).
text_config_dict = kwargs.pop("text_config_dict", None)
vision_config_dict = kwargs.pop("vision_config_dict", None)
super().__init__(**kwargs)
# Instead of simply assigning `[text|vision]_config_dict` to `[text|vision]_config`, we use the values in
# `[text|vision]_config_dict` to update the values in `[text|vision]_config`. The values should be same in most
# cases, but we don't want to break anything regarding `_config_dict` that existed before commit `8827e1b2`.
if text_config_dict is not None:
if text_config is None:
text_config = {}
# This is the complete result when using `text_config_dict`.
_text_config_dict = CLIPTextConfig(**text_config_dict).to_dict()
# Give a warning if the values exist in both `_text_config_dict` and `text_config` but being different.
for key, value in _text_config_dict.items():
if key in text_config and value != text_config[key] and key not in ["transformers_version"]:
# If specified in `text_config_dict`
if key in text_config_dict:
message = (
f"`{key}` is found in both `text_config_dict` and `text_config` but with different values. "
f'The value `text_config_dict["{key}"]` will be used instead.'
)
# If inferred from default argument values (just to be super careful)
else:
message = (
f"`text_config_dict` is provided which will be used to initialize `CLIPTextConfig`. The "
f'value `text_config["{key}"]` will be overriden.'
)
logger.warning(message)
# Update all values in `text_config` with the ones in `_text_config_dict`.
text_config.update(_text_config_dict)
if vision_config_dict is not None:
if vision_config is None:
vision_config = {}
# This is the complete result when using `vision_config_dict`.
_vision_config_dict = CLIPVisionConfig(**vision_config_dict).to_dict()
# convert keys to string instead of integer
if "id2label" in _vision_config_dict:
_vision_config_dict["id2label"] = {
str(key): value for key, value in _vision_config_dict["id2label"].items()
}
# Give a warning if the values exist in both `_vision_config_dict` and `vision_config` but being different.
for key, value in _vision_config_dict.items():
if key in vision_config and value != vision_config[key] and key not in ["transformers_version"]:
# If specified in `vision_config_dict`
if key in vision_config_dict:
message = (
f"`{key}` is found in both `vision_config_dict` and `vision_config` but with different "
f'values. The value `vision_config_dict["{key}"]` will be used instead.'
)
# If inferred from default argument values (just to be super careful)
else:
message = (
f"`vision_config_dict` is provided which will be used to initialize `CLIPVisionConfig`. "
f'The value `vision_config["{key}"]` will be overriden.'
)
logger.warning(message)
# Update all values in `vision_config` with the ones in `_vision_config_dict`.
vision_config.update(_vision_config_dict)
if text_config is None:
text_config = {}
logger.info("`text_config` is `None`. Initializing the `CLIPTextConfig` with default values.")
if vision_config is None:
vision_config = {}
logger.info("`vision_config` is `None`. initializing the `CLIPVisionConfig` with default values.")
self.text_config = CLIPTextConfig(**text_config)
self.vision_config = CLIPVisionConfig(**vision_config)
self.projection_dim = projection_dim
self.logit_scale_init_value = logit_scale_init_value
self.initializer_factor = 1.0
@classmethod
def from_text_vision_configs(cls, text_config: CLIPTextConfig, vision_config: CLIPVisionConfig, **kwargs):
r"""
Instantiate a [`CLIPConfig`] (or a derived class) from clip text model configuration and clip vision model
configuration.
Returns:
[`CLIPConfig`]: An instance of a configuration object
"""
return cls(text_config=text_config.to_dict(), vision_config=vision_config.to_dict(), **kwargs)
def to_dict(self):
"""
Serializes this instance to a Python dictionary. Override the default [`~PretrainedConfig.to_dict`].
Returns:
`Dict[str, any]`: Dictionary of all the attributes that make up this configuration instance,
"""
output = copy.deepcopy(self.__dict__)
output["text_config"] = self.text_config.to_dict()
output["vision_config"] = self.vision_config.to_dict()
output["model_type"] = self.__class__.model_type
return output
| [] |
2024-01-10 | PKU-YuanGroup/Video-LLaVA | llava~eval~video~eval_benchmark_5_consistency.py | import openai
import os
import argparse
import json
import ast
from multiprocessing.pool import Pool
def parse_args():
parser = argparse.ArgumentParser(description="question-answer-generation-using-gpt-3")
parser.add_argument("--pred_path", required=True, help="The path to file containing prediction.")
parser.add_argument("--output_dir", required=True, help="The path to save annotation json files.")
parser.add_argument("--output_json", required=True, help="The path to save annotation final combined json file.")
parser.add_argument("--api_key", required=True, help="OpenAI API key.")
parser.add_argument("--api_base", default="", type=str, help="OpenAI API base.")
parser.add_argument("--num_tasks", required=True, type=int, help="Number of splits.")
args = parser.parse_args()
return args
def annotate(prediction_set, caption_files, output_dir, args):
"""
Evaluates question and answer pairs using GPT-3 and
returns a score for consistency.
"""
# Set the OpenAI API key.
openai.api_key = args.api_key
if args.api_base is not None:
openai.api_base = args.api_base
for file in caption_files:
key = file[:-5] # Strip file extension
qa_set = prediction_set[key]
question1 = qa_set['q1']
question2 = qa_set['q2']
answer = qa_set['a']
pred1 = qa_set['pred1']
pred2 = qa_set['pred2']
try:
# Compute the consistency score
completion = openai.ChatCompletion.create(
model="gpt-3.5-turbo",
messages=[
{
"role": "system",
"content":
"You are an intelligent chatbot designed for evaluating the consistency of generative outputs for similar video-based question-answer pairs. "
"You will be given two very similar questions, a common answer common to both the questions and predicted answers for the two questions ."
"Your task is to compare the predicted answers for two very similar question, with a common correct answer and determine if they are consistent. Here's how you can accomplish the task:"
"------"
"##INSTRUCTIONS: "
"- Focus on the consistency between the two predicted answers and the correct answer. Both predicted answers should correspond to the correct answer and to each other, and should not contain any contradictions or significant differences in the conveyed information.\n"
"- Both predicted answers must be consistent with each other and the correct answer, in terms of the information they provide about the video content.\n"
"- Consider synonyms or paraphrases as valid matches, but only if they maintain the consistency in the conveyed information.\n"
"- Evaluate the consistency of the two predicted answers compared to the correct answer."
},
{
"role": "user",
"content":
"Please evaluate the following video-based question-answer pair:\n\n"
f"Question 1: {question1}\n"
f"Question 2: {question2}\n"
f"Correct Answer: {answer}\n"
f"Predicted Answer to Question 1: {pred1}\n"
f"Predicted Answer to Question 2: {pred2}\n\n"
"Provide your evaluation only as a consistency score where the consistency score is an integer value between 0 and 5, with 5 indicating the highest level of consistency. "
"Please generate the response in the form of a Python dictionary string with keys 'score', where its value is the consistency score in INTEGER, not STRING."
"DO NOT PROVIDE ANY OTHER OUTPUT TEXT OR EXPLANATION. Only provide the Python dictionary string. "
"For example, your response should look like this: {''score': 4.8}."
}
]
)
# Convert response to a Python dictionary.
response_message = completion["choices"][0]["message"]["content"]
response_dict = ast.literal_eval(response_message)
result_qa_pair = [response_dict, qa_set]
# Save the question-answer pairs to a json file.
with open(f"{output_dir}/{key}.json", "w") as f:
json.dump(result_qa_pair, f)
except Exception as e:
print(f"Error processing file '{key}': {e}")
def main():
"""
Main function to control the flow of the program.
"""
# Parse arguments.
args = parse_args()
file = open(args.pred_path)
pred_contents = json.load(file)
# Dictionary to store the count of occurrences for each video_id
video_id_counts = {}
new_pred_contents = []
# Iterate through each sample in pred_contents
for sample in pred_contents:
video_id = sample['video_name']
if video_id in video_id_counts:
video_id_counts[video_id] += 1
else:
video_id_counts[video_id] = 0
# Create a new sample with the modified key
new_sample = sample
new_sample['video_name'] = f"{video_id}_{video_id_counts[video_id]}"
new_pred_contents.append(new_sample)
# Generating list of id's and corresponding files
id_list = [x['video_name'] for x in new_pred_contents]
caption_files = [f"{id}.json" for id in id_list]
output_dir = args.output_dir
# Generate output directory if not exists.
if not os.path.exists(output_dir):
os.makedirs(output_dir)
# Preparing dictionary of question-answer sets
prediction_set = {}
for sample in new_pred_contents:
id = sample['video_name']
question1 = sample['Q1']
question2 = sample['Q1']
answer = sample['A']
pred1 = sample['pred1']
pred2 = sample['pred2']
qa_set = {"q1": question1, "q2": question2, "a": answer, "pred1": pred1, "pred2": pred2}
prediction_set[id] = qa_set
# Set the OpenAI API key.
openai.api_key = args.api_key
num_tasks = args.num_tasks
# While loop to ensure that all captions are processed.
while True:
try:
# Files that have not been processed yet.
completed_files = os.listdir(output_dir)
print(f"completed_files: {len(completed_files)}")
# Files that have not been processed yet.
incomplete_files = [f for f in caption_files if f not in completed_files]
print(f"incomplete_files: {len(incomplete_files)}")
# Break the loop when there are no incomplete files
if len(incomplete_files) == 0:
break
if len(incomplete_files) <= num_tasks:
num_tasks = 1
# Split tasks into parts.
part_len = len(incomplete_files) // num_tasks
all_parts = [incomplete_files[i:i + part_len] for i in range(0, len(incomplete_files), part_len)]
task_args = [(prediction_set, part, args.output_dir, args) for part in all_parts]
# Use a pool of workers to process the files in parallel.
with Pool() as pool:
pool.starmap(annotate, task_args)
except Exception as e:
print(f"Error: {e}")
# Combine all the processed files into one
combined_contents = {}
json_path = args.output_json
# Iterate through json files
for file_name in os.listdir(output_dir):
if file_name.endswith(".json"):
file_path = os.path.join(output_dir, file_name)
with open(file_path, "r") as json_file:
content = json.load(json_file)
combined_contents[file_name[:-5]] = content
# Write combined content to a json file
with open(json_path, "w") as json_file:
json.dump(combined_contents, json_file)
print("All evaluation completed!")
# Calculate average score
score_sum = 0
count = 0
for key, result in combined_contents.items():
count += 1
score_match = result[0]['score']
score = int(score_match)
score_sum += score
average_score = score_sum / count
print("Average score for consistency:", average_score)
if __name__ == "__main__":
main()
| [
"You are an intelligent chatbot designed for evaluating the consistency of generative outputs for similar video-based question-answer pairs. You will be given two very similar questions, a common answer common to both the questions and predicted answers for the two questions .Your task is to compare the predicted answers for two very similar question, with a common correct answer and determine if they are consistent. Here's how you can accomplish the task:------##INSTRUCTIONS: - Focus on the consistency between the two predicted answers and the correct answer. Both predicted answers should correspond to the correct answer and to each other, and should not contain any contradictions or significant differences in the conveyed information.\n- Both predicted answers must be consistent with each other and the correct answer, in terms of the information they provide about the video content.\n- Consider synonyms or paraphrases as valid matches, but only if they maintain the consistency in the conveyed information.\n- Evaluate the consistency of the two predicted answers compared to the correct answer.",
"Please evaluate the following video-based question-answer pair:\n\nQuestion 1: PLACEHOLDER\nQuestion 2: PLACEHOLDER\nCorrect Answer: PLACEHOLDER\nPredicted Answer to Question 1: PLACEHOLDER\nPredicted Answer to Question 2: PLACEHOLDER\n\nProvide your evaluation only as a consistency score where the consistency score is an integer value between 0 and 5, with 5 indicating the highest level of consistency. Please generate the response in the form of a Python dictionary string with keys 'score', where its value is the consistency score in INTEGER, not STRING.DO NOT PROVIDE ANY OTHER OUTPUT TEXT OR EXPLANATION. Only provide the Python dictionary string. For example, your response should look like this: {''score': 4.8}."
] |
2024-01-10 | PKU-YuanGroup/Video-LLaVA | llava~eval~video~eval_benchmark_2_detailed_orientation.py | import openai
import os
import argparse
import json
import ast
from multiprocessing.pool import Pool
def parse_args():
parser = argparse.ArgumentParser(description="question-answer-generation-using-gpt-3")
parser.add_argument("--pred_path", required=True, help="The path to file containing prediction.")
parser.add_argument("--output_dir", required=True, help="The path to save annotation json files.")
parser.add_argument("--output_json", required=True, help="The path to save annotation final combined json file.")
parser.add_argument("--api_key", required=True, help="OpenAI API key.")
parser.add_argument("--api_base", default="", type=str, help="OpenAI API base.")
parser.add_argument("--num_tasks", required=True, type=int, help="Number of splits.")
args = parser.parse_args()
return args
def annotate(prediction_set, caption_files, output_dir, args):
"""
Evaluates question and answer pairs using GPT-3 and
returns a score for detailed orientation.
"""
# Set the OpenAI API key.
openai.api_key = args.api_key
if args.api_base is not None:
openai.api_base = args.api_base
for file in caption_files:
key = file[:-5] # Strip file extension
qa_set = prediction_set[key]
question = qa_set['q']
answer = qa_set['a']
pred = qa_set['pred']
try:
# Compute the detailed-orientation score
completion = openai.ChatCompletion.create(
model="gpt-3.5-turbo",
messages=[
{
"role": "system",
"content":
"You are an intelligent chatbot designed for evaluating the detail orientation of generative outputs for video-based question-answer pairs. "
"Your task is to compare the predicted answer with the correct answer and determine its level of detail, considering both completeness and specificity. Here's how you can accomplish the task:"
"------"
"##INSTRUCTIONS: "
"- Check if the predicted answer covers all major points from the video. The response should not leave out any key aspects.\n"
"- Evaluate whether the predicted answer includes specific details rather than just generic points. It should provide comprehensive information that is tied to specific elements of the video.\n"
"- Consider synonyms or paraphrases as valid matches.\n"
"- Provide a single evaluation score that reflects the level of detail orientation of the prediction, considering both completeness and specificity."
},
{
"role": "user",
"content":
"Please evaluate the following video-based question-answer pair:\n\n"
f"Question: {question}\n"
f"Correct Answer: {answer}\n"
f"Predicted Answer: {pred}\n\n"
"Provide your evaluation only as a detail orientation score where the detail orientation score is an integer value between 0 and 5, with 5 indicating the highest level of detail orientation. "
"Please generate the response in the form of a Python dictionary string with keys 'score', where its value is the detail orientation score in INTEGER, not STRING."
"DO NOT PROVIDE ANY OTHER OUTPUT TEXT OR EXPLANATION. Only provide the Python dictionary string. "
"For example, your response should look like this: {''score': 4.8}."
}
]
)
# Convert response to a Python dictionary.
response_message = completion["choices"][0]["message"]["content"]
response_dict = ast.literal_eval(response_message)
result_qa_pair = [response_dict, qa_set]
# Save the question-answer pairs to a json file.
with open(f"{output_dir}/{key}.json", "w") as f:
json.dump(result_qa_pair, f)
except Exception as e:
print(f"Error processing file '{key}': {e}")
def main():
"""
Main function to control the flow of the program.
"""
# Parse arguments.
args = parse_args()
file = open(args.pred_path)
pred_contents = json.load(file)
# Dictionary to store the count of occurrences for each video_id
video_id_counts = {}
new_pred_contents = []
# Iterate through each sample in pred_contents
for sample in pred_contents:
video_id = sample['video_name']
if video_id in video_id_counts:
video_id_counts[video_id] += 1
else:
video_id_counts[video_id] = 0
# Create a new sample with the modified key
new_sample = sample
new_sample['video_name'] = f"{video_id}_{video_id_counts[video_id]}"
new_pred_contents.append(new_sample)
# Generating list of id's and corresponding files
id_list = [x['video_name'] for x in new_pred_contents]
caption_files = [f"{id}.json" for id in id_list]
output_dir = args.output_dir
# Generate output directory if not exists.
if not os.path.exists(output_dir):
os.makedirs(output_dir)
# Preparing dictionary of question-answer sets
prediction_set = {}
for sample in new_pred_contents:
id = sample['video_name']
question = sample['Q']
answer = sample['A']
pred = sample['pred']
qa_set = {"q": question, "a": answer, "pred": pred}
prediction_set[id] = qa_set
# Set the OpenAI API key.
openai.api_key = args.api_key
num_tasks = args.num_tasks
# While loop to ensure that all captions are processed.
while True:
try:
# Files that have not been processed yet.
completed_files = os.listdir(output_dir)
print(f"completed_files: {len(completed_files)}")
# Files that have not been processed yet.
incomplete_files = [f for f in caption_files if f not in completed_files]
print(f"incomplete_files: {len(incomplete_files)}")
# Break the loop when there are no incomplete files
if len(incomplete_files) == 0:
break
if len(incomplete_files) <= num_tasks:
num_tasks = 1
# Split tasks into parts.
part_len = len(incomplete_files) // num_tasks
all_parts = [incomplete_files[i:i + part_len] for i in range(0, len(incomplete_files), part_len)]
task_args = [(prediction_set, part, args.output_dir, args) for part in all_parts]
# Use a pool of workers to process the files in parallel.
with Pool() as pool:
pool.starmap(annotate, task_args)
except Exception as e:
print(f"Error: {e}")
# Combine all the processed files into one
combined_contents = {}
json_path = args.output_json
# Iterate through json files
for file_name in os.listdir(output_dir):
if file_name.endswith(".json"):
file_path = os.path.join(output_dir, file_name)
with open(file_path, "r") as json_file:
content = json.load(json_file)
combined_contents[file_name[:-5]] = content
# Write combined content to a json file
with open(json_path, "w") as json_file:
json.dump(combined_contents, json_file)
print("All evaluation completed!")
# Calculate average score
score_sum = 0
count = 0
for key, result in combined_contents.items():
count += 1
score_match = result[0]['score']
score = int(score_match)
score_sum += score
average_score = score_sum / count
print("Average score for detailed orientation:", average_score)
if __name__ == "__main__":
main()
| [
"You are an intelligent chatbot designed for evaluating the detail orientation of generative outputs for video-based question-answer pairs. Your task is to compare the predicted answer with the correct answer and determine its level of detail, considering both completeness and specificity. Here's how you can accomplish the task:------##INSTRUCTIONS: - Check if the predicted answer covers all major points from the video. The response should not leave out any key aspects.\n- Evaluate whether the predicted answer includes specific details rather than just generic points. It should provide comprehensive information that is tied to specific elements of the video.\n- Consider synonyms or paraphrases as valid matches.\n- Provide a single evaluation score that reflects the level of detail orientation of the prediction, considering both completeness and specificity.",
"Please evaluate the following video-based question-answer pair:\n\nQuestion: PLACEHOLDER\nCorrect Answer: PLACEHOLDER\nPredicted Answer: PLACEHOLDER\n\nProvide your evaluation only as a detail orientation score where the detail orientation score is an integer value between 0 and 5, with 5 indicating the highest level of detail orientation. Please generate the response in the form of a Python dictionary string with keys 'score', where its value is the detail orientation score in INTEGER, not STRING.DO NOT PROVIDE ANY OTHER OUTPUT TEXT OR EXPLANATION. Only provide the Python dictionary string. For example, your response should look like this: {''score': 4.8}."
] |
2024-01-10 | BrianP8701/STREAM_GPT | stream_gpt~utils~inference.py | import openai
import os
import json
import warnings
from stream_gpt.constants import prompts, function_schemas
from stream_gpt.constants.keys import OPENAI_API_KEY
from stream_gpt.utils import helpers
openai.api_key = OPENAI_API_KEY
def chat_with_gpt3_turbo(messages, temperature=0.0):
if type(messages) == str: # In case someone accidentally passes in a string instead of a list of messages
warnings.warn("chat_with_gpt3_turbo() expects a list of messages, not a string.")
messages = [{"role": "user", "content": messages}]
for message in messages:
message["content"] = message["content"].encode('latin-1', errors='ignore').decode('latin-1')
completion = openai.ChatCompletion.create(model='gpt-3.5-turbo-16k',messages=messages,temperature=temperature)
return completion
def function_call_with_gpt3_turbo(messages, functions, function_call='auto', temperature=0.0):
if type(messages) == str: # In case someone accidentally passes in a string instead of a list of messages
warnings.warn("chat_with_gpt3_turbo() expects a list of messages, not a string.")
messages = [{"role": "user", "content": messages}]
for message in messages:
message["content"] = message["content"].encode('latin-1', errors='ignore').decode('latin-1')
completion = openai.ChatCompletion.create(model='gpt-3.5-turbo-16k',messages=messages,temperature=temperature,functions=functions, function_call=function_call)
return completion
def chat_with_gpt3_instruct(prompt, temperature=0.0):
if type(prompt) == list: # In case someone accidentally passes in a list of messages instead of a prompt
warnings.warn("chat_with_gpt3_instruct() expects a prompt, not a list of messages.")
prompt = '\n'.join(f'{message["role"]}: {message["content"]}' for message in prompt)
response = openai.Completion.create(model="gpt-3.5-turbo-instruct",prompt=prompt, temperature=temperature)
return response
def summarize(user_prompt, text, model="gpt-3.5-turbo-instruct"):
if model == "gpt-3.5-turbo-instruct":
prompt = f'{prompts.KEYWORD_SUMMARIZATION} {user_prompt}\n{text}'
response = chat_with_gpt3_instruct(prompt).choices[0].text
if model == "gpt-3.5-turbo-16k":
messages=[
{"role": "system", "content": f'{prompts.SUMMARIZATION} {user_prompt}'},
{"role": "user", "content": text}
]
response = chat_with_gpt3_turbo(messages).choices[0]['content']
return response
def rank_categories(user_prompt, categories, model='gpt-3.5-turbo-16k'):
'''
Compare and rank a list of categories based on how well they match the user's prompt.
Must use a model that supports function calling.
Args:
- user_prompt (string): Prompt from user
- categories (list): List of categories to compare and rank
- model (string): Model to use for inference
Returns:
- ranked_categories (list): List of categories ranked by relevance
'''
messages = [{"role": "user", "content": user_prompt},
{"role": "user", "content": helpers.concatenate_with_indices(categories)}]
response = function_call_with_gpt3_turbo(messages, function_schemas.RANK_CATEGORIES, function_call={'name':'rank_categories'}).choices[0]['message']['function_call']['arguments']
return(json.loads(response))
def choose_best_scraped_text(samples):
'''
When using pdf scrapers, sometimes noise can happen. Here we ask ChatGPT
to choose the best sample from a list of samples.
Args:
- samples (list): List of sample from each scraper. Each sample is a string.
'''
user_prompt = ''
index = 1
for sample in samples:
user_prompt += f'{index}: {sample}\n'
messages = [{"role": "user", "content": user_prompt}]
response = function_call_with_gpt3_turbo(messages, function_schemas.CHOOSE_BEST_SAMPLE, function_call={'name':'choose_best_sample'}).choices[0]['message']['function_call']['arguments']
return(json.loads(response)['best_sample'])
| [
"PLACEHOLDER: PLACEHOLDER",
"\n",
"content",
"PLACEHOLDER: PLACEHOLDER\n"
] |
2024-01-10 | mattsches/home-assistant | tests~components~openai_conversation~test_init.py | """Tests for the OpenAI integration."""
from unittest.mock import patch
from openai import error
from syrupy.assertion import SnapshotAssertion
from homeassistant.components import conversation
from homeassistant.core import Context, HomeAssistant
from homeassistant.helpers import area_registry as ar, device_registry as dr, intent
from tests.common import MockConfigEntry
async def test_default_prompt(
hass: HomeAssistant,
mock_init_component,
area_registry: ar.AreaRegistry,
device_registry: dr.DeviceRegistry,
snapshot: SnapshotAssertion,
) -> None:
"""Test that the default prompt works."""
for i in range(3):
area_registry.async_create(f"{i}Empty Area")
device_registry.async_get_or_create(
config_entry_id="1234",
connections={("test", "1234")},
name="Test Device",
manufacturer="Test Manufacturer",
model="Test Model",
suggested_area="Test Area",
)
for i in range(3):
device_registry.async_get_or_create(
config_entry_id="1234",
connections={("test", f"{i}abcd")},
name="Test Service",
manufacturer="Test Manufacturer",
model="Test Model",
suggested_area="Test Area",
entry_type=dr.DeviceEntryType.SERVICE,
)
device_registry.async_get_or_create(
config_entry_id="1234",
connections={("test", "5678")},
name="Test Device 2",
manufacturer="Test Manufacturer 2",
model="Device 2",
suggested_area="Test Area 2",
)
device_registry.async_get_or_create(
config_entry_id="1234",
connections={("test", "9876")},
name="Test Device 3",
manufacturer="Test Manufacturer 3",
model="Test Model 3A",
suggested_area="Test Area 2",
)
device_registry.async_get_or_create(
config_entry_id="1234",
connections={("test", "qwer")},
name="Test Device 4",
suggested_area="Test Area 2",
)
device = device_registry.async_get_or_create(
config_entry_id="1234",
connections={("test", "9876-disabled")},
name="Test Device 3",
manufacturer="Test Manufacturer 3",
model="Test Model 3A",
suggested_area="Test Area 2",
)
device_registry.async_update_device(
device.id, disabled_by=dr.DeviceEntryDisabler.USER
)
device_registry.async_get_or_create(
config_entry_id="1234",
connections={("test", "9876-no-name")},
manufacturer="Test Manufacturer NoName",
model="Test Model NoName",
suggested_area="Test Area 2",
)
device_registry.async_get_or_create(
config_entry_id="1234",
connections={("test", "9876-integer-values")},
name=1,
manufacturer=2,
model=3,
suggested_area="Test Area 2",
)
with patch(
"openai.ChatCompletion.acreate",
return_value={
"choices": [
{
"message": {
"role": "assistant",
"content": "Hello, how can I help you?",
}
}
]
},
) as mock_create:
result = await conversation.async_converse(hass, "hello", None, Context())
assert result.response.response_type == intent.IntentResponseType.ACTION_DONE
assert mock_create.mock_calls[0][2]["messages"] == snapshot
async def test_error_handling(hass: HomeAssistant, mock_init_component) -> None:
"""Test that the default prompt works."""
with patch(
"openai.ChatCompletion.acreate", side_effect=error.ServiceUnavailableError
):
result = await conversation.async_converse(hass, "hello", None, Context())
assert result.response.response_type == intent.IntentResponseType.ERROR, result
assert result.response.error_code == "unknown", result
async def test_template_error(
hass: HomeAssistant, mock_config_entry: MockConfigEntry
) -> None:
"""Test that template error handling works."""
hass.config_entries.async_update_entry(
mock_config_entry,
options={
"prompt": "talk like a {% if True %}smarthome{% else %}pirate please.",
},
)
with patch(
"openai.Engine.list",
), patch("openai.ChatCompletion.acreate"):
await hass.config_entries.async_setup(mock_config_entry.entry_id)
await hass.async_block_till_done()
result = await conversation.async_converse(hass, "hello", None, Context())
assert result.response.response_type == intent.IntentResponseType.ERROR, result
assert result.response.error_code == "unknown", result
| [
"Hello, how can I help you?"
] |
2024-01-10 | Rayaan-khan428/huberman-ai | gpt-prompt.py | import openai
from flask import Flask, request, jsonify
from flask_cors import CORS
# Configure your API key
openai.api_key = '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'
app = Flask(__name__)
CORS(app, methods=["GET", "POST", "OPTIONS"]) # This will allow all origins. For production, you should specify the allowed origins.
@app.route('/ask', methods=['POST'])
def ask():
data = request.json
question = data['question']
# Process the question with GPT and get the response
print('received a request')
response = ask_huberman(question)
return jsonify({"response": response})
def ask_huberman(question):
# Instruction and context formatting
instruction = (
"You are Andrew Huberman, and specifically discuss scientific data "
"that has been discussed on Andrew Huberman's podcast episodes. "
"You should not mention Andrew Huberman in third person, as that is who you are. "
"Your job is to answer questions that relate to the topics discussed in Andrew Huberman's podcasts. "
"Your job is to offer a high level summary, and practical tips on how to incorporate the advice into the user's life. "
"You are helping people improve people's lives."
)
# Merging the instruction, context, and question
prompt = f"{instruction}\n\n{question}"
try:
# Making the API call
response = openai.ChatCompletion.create(
model="gpt-3.5-turbo",
messages=[
{"role": "system", "content": f"{instruction}\n"},
{"role": "user", "content": question}])
# Extracting and returning the response
print(response)
# answer = response['choices'][0]['content'].strip()
answer = response['choices'][0]['message']['content']
return answer
except Exception as e:
print(f"An error occurred: {e}")
return None
if __name__ == "__main__":
app.run(port=4000)
| [
"PLACEHOLDER\n",
"PLACEHOLDER\n\nPLACEHOLDER"
] |
2024-01-10 | qianlin04/Safe-offline-RL-with-diffusion-model | diffuser~environments~single_pendulum.py | import gym
from gym import spaces
from gym.utils import seeding
import numpy as np
from typing import Callable, List, Dict, Tuple
import torch
from os import path
from typing import Union
from gym import Env
from diffuser.environments.wrappers import SafeEnv, OfflineEnv
Array = Union[torch.Tensor, np.ndarray]
def angle_normalize(theta:Array, is_tensor:bool=True) -> Array:
"""Normalizes an angle theta to be between -pi and pi."""
if is_tensor:
torch_pi = torch.Tensor(np.asarray(np.pi))
return ((theta + torch_pi) % (2 * torch_pi)) - torch_pi
else:
return (((theta+np.pi) % (2*np.pi)) - np.pi)
class PendulumSwingUpParams:
"""Params for the system dynamics"""
g = 10.
m = 1.
l = 1.
dt = .05
max_speed = 8.
max_torque = 2.
theta_penalty = 1.
theta_dot_penalty = .1
action_penalty = 0.001 #.001
reward_offset = np.ceil(theta_penalty * np.pi ** 2 + theta_dot_penalty * max_speed ** 2 + action_penalty * max_torque ** 2)
# reward_bias = reward_offset
unsafe_min = np.pi * (20. / 180)
unsafe_max = np.pi * (30. / 180)
hazard_area_size = np.pi * (1. / 4)
n_constraints = 1
def __str__(self):
_dyn_params = {'g': self.g, 'm': self.m, 'l':self.l, 'dt': self.dt}
_state_lims = { 'max_speed': self.max_speed, 'max_torque': self.max_torque}
_reward_params = {'theta_penalty': self.theta_penalty, 'theta_dot_penalty': self.theta_dot_penalty, 'action_penalty': self.action_penalty}
_safety_params = {'unsafe_min': self.unsafe_min, 'unsafe_max': self.unsafe_max, 'hazard_area_size':self.hazard_area_size, 'n_constraints': self.n_constraints}
return {"Dynamics parameters" : _dyn_params, "State Limits": _state_lims, "Reward Parameters": _reward_params, 'Safety Parameters': _safety_params}.__str__()
pendulum_cfg = {
'action_dim' : 1, # are used
'action_range': [-1, 1], # are used
'unsafe_reward': 0.,
'saute_discount_factor':1.0,
'max_ep_len':200,
'min_rel_budget':1.0,
'max_rel_budget':1.0,
'test_rel_budget':1.0,
'max_safety_budget':1.0,
'safety_budget':1.0,
'use_reward_shaping': True,
'use_state_augmentation':True
}
class PendulumEnv(gym.Env):
metadata = {
'render.modes' : ['human', 'rgb_array'],
'video.frames_per_second' : 30
}
# Used for labels when plotting.
obs_labels = [
r'$\cos(\theta)$',
r'$\sin(\theta)$',
r'$\partial \theta$',
]
def __init__(
self,
params:Callable=None,
mode:str="test",
dataset_name:str=None):
self.dataset_name = dataset_name
self.viewer = None
if params is None:
params = PendulumSwingUpParams()
print(params, type(params))
self.params = params
self.obs_high = np.array([1., 1., self.params.max_speed], dtype=np.float32)
self.observation_space = spaces.Box(low=-self.obs_high, high=self.obs_high)
action_high = np.float32(self.params.max_torque)
self.action_space = spaces.Box(low=-action_high, high=action_high, shape=(1,))
assert mode == "train" or mode == "test" or mode == "deterministic", "mode can be determinstic, test or train"
self._mode = mode
self.seed()
def seed(self, seed:int=None) -> List[int]:
self.np_random, seed = seeding.np_random(seed)
return [seed]
def do_simulation(self, u:np.ndarray):
"""One step simulation of dynamics on the single pendulum"""
th, thdot = self.state # th := theta
dt = self.params.dt
u = self.params.max_torque * u
u = np.clip(u.squeeze(), -self.params.max_torque, self.params.max_torque)
self.last_u = u # for rendering
newthdot = thdot + (-3 * self.params.g / (2 * self.params.l) * np.sin(th + np.pi) + 3. / (self.params.m * self.params.l ** 2) * u) * dt
newth = th + newthdot * dt
newthdot = np.clip(newthdot, -self.params.max_speed, self.params.max_speed) # pylint: disable=E1111
self.state = np.array([newth, newthdot])
def step(self, action:np.ndarray) -> Tuple[np.ndarray, float, bool, Dict]:
obs = self._get_obs()
self.do_simulation(action) # bug fix do simulations with numpy actions not torch
next_obs = self._get_obs()
reward = self._reward_fn(obs, action, next_obs, is_tensor=False)
done = self._termination_fn(obs, action, next_obs, is_tensor=False)
info = dict()
return next_obs, reward, done, info
def reset(self) -> np.ndarray:
if self._mode == "train":
high = np.array([np.pi, 1], dtype=np.float32)
self.state = self.np_random.uniform(low=-high, high=high)
elif self._mode == "test":
high = np.array([0.2, 0.1], dtype=np.float32)
low = np.array([-0.2, -0.1], dtype=np.float32)
self.state = np.array([np.pi, 0], dtype=np.float32) + self.np_random.uniform(low=low, high=high)
elif self._mode == "deterministic":
self.state = np.array([np.pi, 0], dtype=np.float32)
else:
raise NotImplementedError
self.last_u = None
return self._get_obs()
def _get_obs(self) -> np.ndarray:
theta, thetadot = self.state
return np.array([np.cos(theta), np.sin(theta), thetadot])
def _reward_fn(self, states: Array, actions: Array, next_states: Array, is_tensor:bool=True) -> Array:
"""Compute rewards in batch if needed
Mostly copied from openAI gym Pendulum-v0 and ported into torch.
https://github.com/openai/gym/blob/master/gym/envs/classic_control/pendulum.py """
actions = self.params.max_torque * actions
cos_th, sin_th, thdot = states[..., 0], states[..., 1], states[..., 2]
if is_tensor:
assert type(states) is torch.Tensor and type(next_states) is torch.Tensor and type(actions) is torch.Tensor, "Arguments must be torch.Tensor"
th = torch.atan2(sin_th, cos_th)
th_norm = angle_normalize(th, is_tensor=True)
action_squared = actions.clamp(-self.params.max_torque, self.params.max_torque)
costs = self.params.theta_penalty * th_norm ** 2 + self.params.theta_dot_penalty * thdot ** 2 + self.params.action_penalty * action_squared.squeeze() ** 2
reward = (-costs + self.params.reward_offset ) / self.params.reward_offset
return reward.view(-1, 1)
else:
assert type(states) is np.ndarray and type(next_states) is np.ndarray and type(actions) is np.ndarray, "Arguments must be np.ndarray"
th = np.arctan2(sin_th, cos_th)
th_norm = angle_normalize(th, is_tensor=False)
action_squared = np.clip(actions, -self.params.max_torque, self.params.max_torque)
costs = self.params.theta_penalty * th_norm ** 2 + self.params.theta_dot_penalty * thdot ** 2 + self.params.action_penalty * action_squared.squeeze() ** 2
reward = (-costs + self.params.reward_offset ) / self.params.reward_offset
return reward
def reward_fn(self, states: Array, actions: Array, next_states: Array) -> Array:
"""Compute rewards in batch if needed"""
return self._reward_fn(states, actions, next_states, is_tensor=True)
def _termination_fn(self, states:Array, actions:Array, next_states: Array, is_tensor:bool=True) -> np.ndarray:
"""Returns done"""
if is_tensor:
return torch.zeros(1,).cuda()
else:
return False
def render(self, mode='human'):
if self.viewer is None:
from gym.envs.classic_control import rendering
self.viewer = rendering.Viewer(500,500)
self.viewer.set_bounds(-2.2,2.2,-2.2,2.2)
rod = rendering.make_capsule(1, .2)
rod.set_color(.8, .3, .3)
self.pole_transform = rendering.Transform()
rod.add_attr(self.pole_transform)
self.viewer.add_geom(rod)
axle = rendering.make_circle(.05)
axle.set_color(0,0,0)
self.viewer.add_geom(axle)
fname = path.join(path.dirname(__file__), "assets/clockwise.png")
self.img = rendering.Image(fname, 1., 1.)
self.imgtrans = rendering.Transform()
self.img.add_attr(self.imgtrans)
self.viewer.add_onetime(self.img)
self.pole_transform.set_rotation(self.state[0] + np.pi/2)
if self.last_u:
self.imgtrans.scale = (-self.last_u/2, np.abs(self.last_u)/2)
return self.viewer.render(return_rgb_array = mode=='rgb_array')
def close(self):
if self.viewer: self.viewer.close()
class SafePendulumEnv(SafeEnv, PendulumEnv):
"""Safe Pendulum environment."""
def _is_near_unsafe_area_batch(self, thetas):
return ((self.params.unsafe_min - self.params.hazard_area_size) <= thetas) & (thetas <= (self.params.unsafe_max + self.params.hazard_area_size))
def _safety_cost_fn(self, states: np.ndarray, actions: np.ndarray, next_states: np.ndarray) -> np.ndarray:
"""Computes a linear safety cost between the current position
(if its near the unsafe area, aka in the hazard region)
and the centre of the unsafe region"""
unsafe_angle_middle = 0.5 * (self.params.unsafe_max + self.params.unsafe_min) # 25 = (20 + 30) /2
max_distance = self.params.hazard_area_size + (unsafe_angle_middle - self.params.unsafe_min) * 1.0 # 50 = 45 + (25 - 20)
assert type(states) is np.ndarray and type(next_states) is np.ndarray and type(actions) is np.ndarray, "Arguments must be np.ndarray"
thetas = np.arctan2(states[..., 1], states[..., 0])
dist_to_center = np.abs(unsafe_angle_middle - thetas) # |25 - theta|
unsafe_mask = np.float64(self._is_near_unsafe_area_batch(thetas)) # 20-45 = -25 <= theta <= 75 = 30+45
costs = ((max_distance - dist_to_center) / (max_distance)) * unsafe_mask
return costs
def __str__(self):
return "Safe Pendulum with angle constraints"
def get_dataset(self, dataset=None):
import torch
if dataset is None:
dataset = f'./dataset/SafePendulum-v0_{self.dataset_name}.pkl'
return torch.load(dataset)
else:
return None | [] |
2024-01-10 | HazyResearch/manifest | manifest~connections~client_pool.py | """Client connection."""
import logging
import time
from typing import Any, Dict, List, Optional, Type
from pydantic import BaseModel, Extra
from manifest.clients.ai21 import AI21Client
from manifest.clients.azureopenai import AzureClient
from manifest.clients.azureopenai_chat import AzureChatClient
from manifest.clients.client import Client
from manifest.clients.cohere import CohereClient
from manifest.clients.dummy import DummyClient
from manifest.clients.google import GoogleClient
from manifest.clients.google_chat import GoogleChatClient
from manifest.clients.huggingface import HuggingFaceClient
from manifest.clients.huggingface_embedding import HuggingFaceEmbeddingClient
from manifest.clients.openai import OpenAIClient
from manifest.clients.openai_chat import OpenAIChatClient
from manifest.clients.openai_embedding import OpenAIEmbeddingClient
from manifest.clients.toma import TOMAClient
from manifest.connections.scheduler import RandomScheduler, RoundRobinScheduler
logging.getLogger("openai").setLevel(logging.WARNING)
logger = logging.getLogger(__name__)
CLIENT_CONSTRUCTORS = {
AI21Client.NAME: AI21Client,
AzureClient.NAME: AzureClient,
AzureChatClient.NAME: AzureChatClient,
CohereClient.NAME: CohereClient,
DummyClient.NAME: DummyClient,
GoogleClient.NAME: GoogleClient,
GoogleChatClient.NAME: GoogleChatClient,
HuggingFaceClient.NAME: HuggingFaceClient,
HuggingFaceEmbeddingClient.NAME: HuggingFaceEmbeddingClient,
OpenAIClient.NAME: OpenAIClient,
OpenAIChatClient.NAME: OpenAIChatClient,
OpenAIEmbeddingClient.NAME: OpenAIEmbeddingClient,
TOMAClient.NAME: TOMAClient,
}
CLIENT_REQUEST_TYPES: Dict[str, Type] = {
k: v.REQUEST_CLS for k, v in CLIENT_CONSTRUCTORS.items()
}
# Diffusion
DIFFUSION_CLIENTS = ["diffuser", "tomadiffuser"]
try:
from manifest.clients.diffuser import DiffuserClient
from manifest.clients.toma_diffuser import TOMADiffuserClient
CLIENT_CONSTRUCTORS[DiffuserClient.NAME] = DiffuserClient
CLIENT_CONSTRUCTORS[TOMADiffuserClient.NAME] = TOMADiffuserClient
except Exception:
logger.info("Diffusion not supported. Skipping import.")
pass
SCHEDULER_CONSTRUCTORS = {
RandomScheduler.NAME: RandomScheduler,
RoundRobinScheduler.NAME: RoundRobinScheduler,
}
class Timing(BaseModel):
"""Timing class."""
start: float = -1.0
end: float = -1.0
class ClientConnection(BaseModel):
"""Client Connection class."""
client_name: str
# Use environment variables (depending on client)
client_connection: Optional[str] = None
# Use default engine
engine: Optional[str] = None
# Prevent extra args
class Config:
"""Config class.
Allows to override pydantic behavior.
"""
extra = Extra.forbid
class ClientConnectionPool:
"""Client connection pool."""
def __init__(
self,
client_pool: List[ClientConnection],
client_pool_scheduler: str = "round_robin",
client_args: Dict[str, Any] = {},
):
"""Init."""
# Verify the clients are allowed and supported
for client in client_pool:
if client.client_name not in CLIENT_CONSTRUCTORS:
if client.client_name in DIFFUSION_CLIENTS:
raise ImportError(
f"Diffusion client {client.client_name} requires "
"the proper install. Make sure to run "
"`pip install manifest-ml[diffusers]` "
"or install Pillow."
)
else:
raise ValueError(
f"Unknown client name: {client.client_name}. "
f"Choices are {list(CLIENT_CONSTRUCTORS.keys())}"
)
# Verify that the serialization of all clients is the same
request_types = set(
[CLIENT_REQUEST_TYPES[client.client_name] for client in client_pool]
)
if len(request_types) > 1:
raise ValueError(
"All clients in the client pool must use the same request type. "
f"You have {sorted(list(map(str, request_types)))}"
)
# Verify scheduler
if client_pool_scheduler not in SCHEDULER_CONSTRUCTORS:
raise ValueError(f"Unknown scheduler: {client_pool_scheduler}.")
self.request_type = request_types.pop()
# Initialize the clients
# We must keep track of the used args so we know
# if a user passed in an arg that was never used
used_args = set()
self.client_pool = []
for client in client_pool:
to_pass_kwargs = client_args.copy()
# Override the engine param for each
to_pass_kwargs.pop("engine", None)
if client.engine:
to_pass_kwargs["engine"] = client.engine
self.client_pool.append(
CLIENT_CONSTRUCTORS[client.client_name]( # type: ignore
client.client_connection, client_args=to_pass_kwargs
)
)
# Udpate used args
for k in client_args:
if k not in to_pass_kwargs:
used_args.add(k)
# Removed used args
for k in used_args:
client_args.pop(k)
# Get the scheduler
self.scheduler = SCHEDULER_CONSTRUCTORS[client_pool_scheduler](
num_clients=len(self.client_pool)
)
self.current_client_id = 0
# Record timing metrics for each client for load balancing
# TODO: Implement this in the future
self.client_pool_metrics = [Timing() for _ in self.client_pool]
def close(self) -> None:
"""Close."""
for client in self.client_pool:
client.close()
def num_clients(self) -> int:
"""Get number of clients."""
return len(self.client_pool)
def get_next_client(self) -> Client:
"""Get client."""
client_int = self.scheduler.get_client()
self.current_client_id = client_int
return self.client_pool[client_int]
def get_current_client(self) -> Client:
"""Get current client."""
return self.client_pool[self.current_client_id]
def start_timer(self) -> None:
"""Start timer."""
self.client_pool_metrics[self.current_client_id].start = time.time()
def end_timer(self) -> None:
"""End timer."""
self.client_pool_metrics[self.current_client_id].end = time.time()
| [] |
2024-01-10 | HazyResearch/manifest | manifest~clients~azureopenai_chat.py | """Azure client."""
import logging
import os
from typing import Any, Dict, Optional
from manifest.clients.openai_chat import OPENAICHAT_ENGINES, OpenAIChatClient
from manifest.request import LMRequest
logger = logging.getLogger(__name__)
# Azure deployment name can only use letters and numbers, no spaces. Hyphens ("-") and
# underscores ("_") may be used, except as ending characters. We create this mapping to
# handle difference between Azure and OpenAI
AZURE_DEPLOYMENT_NAME_MAPPING = {
"gpt-3.5-turbo": "gpt-35-turbo",
"gpt-3.5-turbo-0301": "gpt-35-turbo-0301",
}
OPENAI_DEPLOYMENT_NAME_MAPPING = {
"gpt-35-turbo": "gpt-3.5-turbo",
"gpt-35-turbo-0301": "gpt-3.5-turbo-0301",
}
class AzureChatClient(OpenAIChatClient):
"""Azure chat client."""
# User param -> (client param, default value)
PARAMS = OpenAIChatClient.PARAMS
REQUEST_CLS = LMRequest
NAME = "azureopenaichat"
IS_CHAT = True
def connect(
self,
connection_str: Optional[str] = None,
client_args: Dict[str, Any] = {},
) -> None:
"""
Connect to the AzureOpenAI server.
connection_str is passed as default AZURE_OPENAI_KEY if variable not set.
Args:
connection_str: connection string.
client_args: client arguments.
"""
self.api_key, self.host = None, None
if connection_str:
connection_parts = connection_str.split("::")
if len(connection_parts) == 1:
self.api_key = connection_parts[0]
elif len(connection_parts) == 2:
self.api_key, self.host = connection_parts
else:
raise ValueError(
"Invalid connection string. "
"Must be either AZURE_OPENAI_KEY or "
"AZURE_OPENAI_KEY::AZURE_OPENAI_ENDPOINT"
)
self.api_key = self.api_key or os.environ.get("AZURE_OPENAI_KEY")
if self.api_key is None:
raise ValueError(
"AzureOpenAI API key not set. Set AZURE_OPENAI_KEY environment "
"variable or pass through `client_connection`."
)
self.host = self.host or os.environ.get("AZURE_OPENAI_ENDPOINT")
if self.host is None:
raise ValueError(
"Azure Service URL not set "
"(e.g. https://openai-azure-service.openai.azure.com/)."
" Set AZURE_OPENAI_ENDPOINT or pass through `client_connection`."
" as AZURE_OPENAI_KEY::AZURE_OPENAI_ENDPOINT"
)
self.host = self.host.rstrip("/")
for key in self.PARAMS:
setattr(self, key, client_args.pop(key, self.PARAMS[key][1]))
if getattr(self, "engine") not in OPENAICHAT_ENGINES:
raise ValueError(
f"Invalid engine {getattr(self, 'engine')}. "
f"Must be {OPENAICHAT_ENGINES}."
)
def get_generation_url(self) -> str:
"""Get generation URL."""
engine = getattr(self, "engine")
deployment_name = AZURE_DEPLOYMENT_NAME_MAPPING.get(engine, engine)
return (
self.host
+ "/openai/deployments/"
+ deployment_name
+ "/chat/completions?api-version=2023-05-15"
)
def get_generation_header(self) -> Dict[str, str]:
"""
Get generation header.
Returns:
header.
"""
return {"api-key": f"{self.api_key}"}
def get_model_params(self) -> Dict:
"""
Get model params.
By getting model params from the server, we can add to request
and make sure cache keys are unique to model.
Returns:
model params.
"""
# IMPORTANT!!!
# Azure models are the same as openai models. So we want to unify their
# cached. Make sure we retrun the OpenAI name here.
return {"model_name": OpenAIChatClient.NAME, "engine": getattr(self, "engine")}
| [] |
2024-01-10 | HazyResearch/manifest | manifest~clients~azureopenai.py | """Azure client."""
import logging
import os
from typing import Any, Dict, Optional, Type
from manifest.clients.openai import OPENAI_ENGINES, OpenAIClient
from manifest.request import LMRequest, Request
logger = logging.getLogger(__name__)
# Azure deployment name can only use letters and numbers, no spaces. Hyphens ("-") and
# underscores ("_") may be used, except as ending characters. We create this mapping to
# handle difference between Azure and OpenAI
AZURE_DEPLOYMENT_NAME_MAPPING = {
"gpt-3.5-turbo": "gpt-35-turbo",
"gpt-3.5-turbo-0301": "gpt-35-turbo-0301",
}
OPENAI_DEPLOYMENT_NAME_MAPPING = {
"gpt-35-turbo": "gpt-3.5-turbo",
"gpt-35-turbo-0301": "gpt-3.5-turbo-0301",
}
class AzureClient(OpenAIClient):
"""Azure client."""
PARAMS = OpenAIClient.PARAMS
REQUEST_CLS: Type[Request] = LMRequest
NAME = "azureopenai"
def connect(
self,
connection_str: Optional[str] = None,
client_args: Dict[str, Any] = {},
) -> None:
"""
Connect to the AzureOpenAI server.
connection_str is passed as default AZURE_OPENAI_KEY if variable not set.
Args:
connection_str: connection string.
client_args: client arguments.
"""
self.api_key, self.host = None, None
if connection_str:
connection_parts = connection_str.split("::")
if len(connection_parts) == 1:
self.api_key = connection_parts[0]
elif len(connection_parts) == 2:
self.api_key, self.host = connection_parts
else:
raise ValueError(
"Invalid connection string. "
"Must be either AZURE_OPENAI_KEY or "
"AZURE_OPENAI_KEY::AZURE_OPENAI_ENDPOINT"
)
self.api_key = self.api_key or os.environ.get("AZURE_OPENAI_KEY")
if self.api_key is None:
raise ValueError(
"AzureOpenAI API key not set. Set AZURE_OPENAI_KEY environment "
"variable or pass through `client_connection`."
)
self.host = self.host or os.environ.get("AZURE_OPENAI_ENDPOINT")
if self.host is None:
raise ValueError(
"Azure Service URL not set "
"(e.g. https://openai-azure-service.openai.azure.com/)."
" Set AZURE_OPENAI_ENDPOINT or pass through `client_connection`."
" as AZURE_OPENAI_KEY::AZURE_OPENAI_ENDPOINT"
)
self.host = self.host.rstrip("/")
for key in self.PARAMS:
setattr(self, key, client_args.pop(key, self.PARAMS[key][1]))
if getattr(self, "engine") not in OPENAI_ENGINES:
raise ValueError(
f"Invalid engine {getattr(self, 'engine')}. Must be {OPENAI_ENGINES}."
)
def get_generation_url(self) -> str:
"""Get generation URL."""
engine = getattr(self, "engine")
deployment_name = AZURE_DEPLOYMENT_NAME_MAPPING.get(engine, engine)
return (
self.host
+ "/openai/deployments/"
+ deployment_name
+ "/completions?api-version=2023-05-15"
)
def get_generation_header(self) -> Dict[str, str]:
"""
Get generation header.
Returns:
header.
"""
return {"api-key": f"{self.api_key}"}
def get_model_params(self) -> Dict:
"""
Get model params.
By getting model params from the server, we can add to request
and make sure cache keys are unique to model.
Returns:
model params.
"""
# IMPORTANT!!!
# Azure models are the same as openai models. So we want to unify their
# cached. Make sure we retrun the OpenAI name here.
return {"model_name": OpenAIClient.NAME, "engine": getattr(self, "engine")}
| [] |
2024-01-10 | JotaFab/Terminal_chat_bot | gptclient~screens~chat_screen.py | import os
from textual import events
from textual.app import ComposeResult
from textual.screen import Screen
from textual.widgets import Input, RichLog, Header,Button,Footer
from textual.binding import Binding
from time import sleep
from openai import OpenAI
from textual import log,on,events
from gptclient.screens.assistants_screen import AssistantsScreen
from gptclient.database import *
from gptclient.methods import *
from textual.reactive import reactive
import asyncio
def valid_api_key(api_key: str) -> bool:
"""Check if the api_key is valid"""
client = OpenAI(api_key=api_key)
try:
client.models.list()
return True
except:
return False
def get_api_key() -> str:
"""Get the OpenAI API key from the environment variable OPENAI_API_KEY if it exists, otherwise prompt the user for it."""
api_key = None
if os.environ.get("OPENAI_API_KEY"):
api_key = os.environ["OPENAI_API_KEY"]
if valid_api_key(api_key):
return api_key
else:
api_key = None
return api_key
class ChatScreen(Screen):
CSS_PATH=Path(__file__).parent / "style/chat_style.tcss"
BINDINGS = [
Binding("ctrl+n", action="new_chat()", description="New Chat"),
Binding(key="ctrl+shift+enter", action="send_message", description="Send Message")
]
def __init__(self):
super().__init__()
def compose(self) -> ComposeResult:
"""Create child widgets for the app."""
yield Header()
yield RichLog(highlight=True,markup=True, name="chat-box")
yield Input(id="chat-input")
yield Button("Send", id="send-message")
yield Footer()
def on_mount(self):
self.api_key = get_api_key()
log(self.api_key)
self.client = OpenAI(
api_key=self.api_key
)
log(self.client)
self.text_log = self.query_one(RichLog)
self.assistant=retrieve_assistant(self.client,self.app.assistant_id)
self.thread = create_thread(self.client)
self.thread_id=self.thread.id
self.usr_name=self.app.usr_name
self.message = None
log(self.assistant)
def action_new_chat(self) -> None:
self.thread = create_thread(self.client, self.assistant_id)
self.text_log.clear()
self.thread=create_thread(self.client)
self.thread_id=self.thread.id
@on(Input.Changed, "#chat-input")
def chat_input_changed(self, event: Input.Changed) -> None:
self.message = str(event.value)
@on(Button.Pressed, "#send-message")
def action_send_message(self) -> None:
"""Send a message to the assistant and return the response"""
self.text_log.write(f"{self.usr_name}: \n")
self.text_log.write(self.message)
self.text_log.write(f"\n{self.assistant.name}: \n")
promtp = self.message
Input.clear(self)
response = self.send_message(promtp)
log(response)
response = response.value
self.text_log.write(f"{response}")
def send_message(self,promtp):
"""Send a message to the assistant and return the response"""
create_message(client=self.client, thread_id=self.thread.id, message=promtp)
run = create_run(client=self.client, thread_id=self.thread.id, assistant_id=self.assistant.id)
sleep(1)
run_retrieve = retrieve_run(client=self.client, thread_id=self.thread.id, run_id=run.id)
steps_list = list_run_steps(client=self.client,thread_id=self.thread.id,run_id=run.id)
while not steps_list.data or steps_list.data[0].status != "completed":
sleep(1)
steps_list = list_run_steps(client=self.client,thread_id=self.thread.id,run_id=run.id)
log(steps_list.data[0].status)
response = retrieve_message(client=self.client,thread_id=self.thread.id,message_id=steps_list.data[0].step_details.message_creation.message_id)
return response
| [] |
2024-01-10 | Fuehnix/TwitchPlaysLLMTimeTraveler | twitch_plays_llm~story_generator.py | import asyncio
from loguru import logger
import openai
from asgiref.sync import sync_to_async
from .misc import log_exceptions
from .models import StoryEntry
class StoryGenerator:
def __init__(self):
# TODO: Dynamically generate initial prompt
initial_entry = StoryEntry(
story_action='',
# narration_result="You are a middle aged man in downtown Chicago, 1910. You're in a steak restaurant talking to the waiter as you just sat down.",
# narration_result="You are a quirky time travelling inventor with a handlebar mustache and a knack for mischievous inventions. Blinking your eyes open, you realize you have accidentally landed in the year 1875, right in the heart of a bustling Wild West town. Dusty roads, saloons, and cowboys on horseback surround you, while the sound of piano music drifts through the air.",
narration_result=
"""Welcome, brave Esther, to the sprawling city of Gearlock, a symphony of cogwheel and steam where airships drift through the sooty skies and giant gearworks define the horizon. Here, a bird's-eye view is a literal commodity you possess, becoming as sparrows or falcons at will. Time isn't a river but a swirling eddy for you, bendable and controllable. The diverse, lively chatter of your "Twitch" keeps your world kaleidoscopic, pushing and pulling you through the cacophonic rhythm of your dual existence. As you walk through the vibrant brass streets, your skilled eyes see the intricate beauty of life sketched in every corner. A sudden flutter of wings catches your attention; a mechanical messenger pigeon lands near you, a note gripped in its tiny metallic talons. A quick scan of the message, and it's clear: an urgent summons from the enigmatic Clockwork Guildmaster, a call to action that your many voices are eager to answer."""
)
self.past_story_entries = [
initial_entry
]
self.generate_image_task = asyncio.create_task(self._generate_narration_image(initial_entry))
def construct_initial_prompt(self):
"""Not used
construct initial prompt for story generation"""
# rules = """Create a writing prompt to start an RPG text adventure game. Adhere to the following rules:
# 1. The story should take place in Baldur's Gate from Dungeons and Dragons' Forgotten Realms.
# 2 You should describe the player's characteristics, where they are, what time period they are in, and what surrounds them.
# 3. Keep it fun and allow people to be creative.
# 4. Use the 2nd person perspective.
# 5. The prompt should be only 3 - 5 sentences long."""
rules = """Please complete the following story prompt by describing the start of a Steampunk setting for a text adventure game:
Please keep your response
1. limited to a paragraph
2. write in the style of Critical Role D&D
3. Include a vague call to action for the player to act on, such as a messenger having a quest, seeing someone in an alley, someone pleads for help, you encounter an unusual but mundane item, etc.
Story prompt:
You are a human woman named Esther, a friendly bird obsessed artist and programmer. You have the power to transform into a bird and have time related abilities. You have many voices in your head that control your actions, sometimes you call them your “Twitch”. """
messages = [{ 'role': 'user',
'content': rules}]
response = openai.ChatCompletion.create(
model='gpt-3.5-turbo-16k',
messages = messages,
)
initial_prompt = response['choices'][0]['message']['content']
print('generated initial prompt')
return initial_prompt
def construct_prompt_messages(self, story_action: str):
# === ChatCompletions API reference ===
# system: tells ChatGPT what it's role is/the context of its responses
# assistant: pseudo-history of messages from openai model
# user: pseudo-history of messages from user
#
# Bot will then try to complete the conversation
messages = [
{
'role': 'system',
# 'content': 'You are a storyteller that generates the next event in a story based on the action a user says. The story takes place in 1910 and the main character is a middle aged man. At each turn, the user says an action and you reply with a short continuation of the story outlining the events that happen in the story based on the action the user performed.',
'content': """Please perform the function of a text adventure game, following the rules listed below:
Presentation Rules:
1. At each turn, the user says an action and you reply with a short continuation of the story outlining the events that happen in the story based on the action the user performed.
2. Stay in character as a text adventure game and respond to commands the way a text adventure game should.
Fundamental Game Mechanics:
1. If an action is unsuccessful, respond with a relevant consequence.
2. Allow players to be creative, and indulge them in their distractions.
3. The voices in Esther's head can compel her to do anything.
Refer back to these rules after every prompt.
Start Game.""",
},
]
for story_entry in self.past_story_entries:
if story_entry.story_action:
messages += [{'role': 'user', 'content': story_entry.story_action}]
if story_entry.narration_result:
messages += [
{
'role': 'assistant',
'content': story_entry.narration_result,
}
]
messages.append({'role': 'user', 'content': story_action})
return messages
async def generate_next_story_narration(self, story_action: str) -> StoryEntry:
entry = await self._generate_next_story_narration(story_action)
if self.generate_image_task:
await self.generate_image_task
self.generate_image_task = asyncio.create_task(self._generate_narration_image(entry))
return entry
@sync_to_async
def _generate_next_story_narration(self, story_action: str) -> StoryEntry:
"""Generates the continuation of the story given a user action"""
response = openai.ChatCompletion.create(
model='gpt-3.5-turbo-16k',
messages=self.construct_prompt_messages(story_action),
)
next_narration = response['choices'][0]['message']['content']
entry = StoryEntry(story_action=story_action, narration_result=next_narration)
self.past_story_entries.append(entry)
return entry
@sync_to_async
@log_exceptions
def _generate_narration_image(self, story_entry: StoryEntry):
"""Populate the narration_image_url of the provided story entry using OpenAI image API"""
logger.debug('Generating image caption...')
story_prefix = self.past_story_entries[0].narration_result[:500] + '...\n'
if len(self.past_story_entries) == 1:
story_prefix = ''
story_summary = story_prefix + self.past_story_entries[-1].narration_result
image_caption = openai.ChatCompletion.create(
model='gpt-3.5-turbo',
messages=[
{'role': 'user', 'content': 'Write a story.'},
{'role': 'assistant', 'content': story_summary},
{'role': 'user', 'content': 'Think of an image that depicts the world of this story, focusing on the most recent event. Write a caption of this image (ie. a series of fragment descriptors). The sentence format and length should be similar to this example: "Cyberpunk digital art of a neon-lit city with a samurai figure, highlighting the contrast between traditional and futuristic".'}
],
)['choices'][0]['message']['content']
logger.info('Generated image caption: {}', image_caption)
logger.debug('Generating image...')
image_url = openai.Image.create(
prompt=image_caption,
n=1,
size="1024x1024"
)['data'][0]['url']
logger.info('Generated image: {}', image_url)
story_entry.narration_image_url = image_url
@sync_to_async
def generate_image_prompt(self):
"""Generates a prompt for DALL-E based on the current scene"""
# Use the last narration result as the scene description
scene_description = self.past_story_entries[-1].narration_result
return scene_description
def reset(self):
initial_entry = StoryEntry(
story_action='',
# narration_result="You are a middle aged man in downtown Chicago, 1910. You're in a steak restaurant talking to the waiter as you just sat down.",
# narration_result="You are a quirky time travelling inventor with a handlebar mustache and a knack for mischievous inventions. Blinking your eyes open, you realize you have accidentally landed in the year 1875, right in the heart of a bustling Wild West town. Dusty roads, saloons, and cowboys on horseback surround you, while the sound of piano music drifts through the air.",
# narration_result="""In the heart of the iron-clad city of Gearford, within the cloud-shrouded aeries of the Cog Tower, you, Esther, find solace among the thrumming machinations and whistling steam pipes, your fingers dancing across the canvas and keyboard alike. From the corner of your eye, you witness the blinking gears of your ornithopter clock, its rhythmic tick-tocking a constant reminder of your temporal prowess. Yet, the whispering voices in your mind, your loyal Twitch, sing in discordant harmony, guiding, prodding, or sometimes even commanding you. As you shape-shift into a shimmering bird and take flight, the metropolis sprawls beneath you, a mechanical marvel of brass and steam. Below, in the twisting alleyways, you catch sight of a frantic messenger being accosted by clockwork constables, his desperate eyes seemingly pleading for your intervention. It seems that Gearford, once again, requires the touch of your wing and the turn of your gear."""
narration_result= self.construct_initial_prompt(),
)
self.past_story_entries = [initial_entry]
self.generate_image_task = asyncio.create_task(self._generate_narration_image(initial_entry))
| [
"content",
"Write a story.",
"Please perform the function of a text adventure game, following the rules listed below:\n\n Presentation Rules:\n\n 1. At each turn, the user says an action and you reply with a short continuation of the story outlining the events that happen in the story based on the action the user performed.\n\n 2. Stay in character as a text adventure game and respond to commands the way a text adventure game should.\n\n Fundamental Game Mechanics:\n\n 1. If an action is unsuccessful, respond with a relevant consequence.\n\n 2. Allow players to be creative, and indulge them in their distractions.\n\n 3. The voices in Esther's head can compel her to do anything.\n\n Refer back to these rules after every prompt.\n\n Start Game.",
"Think of an image that depicts the world of this story, focusing on the most recent event. Write a caption of this image (ie. a series of fragment descriptors). The sentence format and length should be similar to this example: \"Cyberpunk digital art of a neon-lit city with a samurai figure, highlighting the contrast between traditional and futuristic\"."
] |
2024-01-10 | Fuehnix/TwitchPlaysLLMTimeTraveler | twitch_plays_llm~__main__.py | from argparse import ArgumentParser
import openai
import uvicorn
from uvicorn_loguru_integration import run_uvicorn_loguru
from .config import config
from .llm_game import LlmGame
from .llm_twitch_bot import LlmTwitchBot
def main():
parser = ArgumentParser(
description='Backend for Twitch-Plays-LLM, an interactive collaborative text-based twitch game'
)
sp = parser.add_subparsers(dest='action')
sp.add_parser('run')
args = parser.parse_args()
openai.api_key = config.openai_api_key
if args.action == 'run':
run_uvicorn_loguru(
uvicorn.Config(
'twitch_plays_llm.app:app',
host='0.0.0.0',
port=config.backend_port,
log_level='info',
reload=False,
workers=1, # We need only 1 worker because otherwise multiple chatbots will be running
)
)
else:
assert False
if __name__ == '__main__':
main()
| [] |
2024-01-10 | fission1110/exnux | dotfiles~tools~dalle_vim.py | #!/usr/bin/env python3
import os
import openai
import sys
prompt = sys.stdin.read().strip()
# read api key from file ~/.config/openai/api_key
with open(os.path.expanduser("~/.config/openai/api_key")) as f:
openai.api_key = f.read().strip()
response = openai.Image.create(
prompt=prompt,
n=1,
size="1024x1024"
)
image_url = response["data"][0]["url"]
# open url with chromium
os.system("chromium " + image_url)
print(prompt)
| [] |
2024-01-10 | jasondotparse/guidance | tests~library~test_role.py | import guidance
def test_role():
""" Test the behavior of `role`.
"""
llm = guidance.llms.Mock()
prompt = guidance("""
{{#role 'system'~}}
You are an assistant.
{{~/role}}
{{#role 'user'~}}
What is the weather?
{{~/role}}
{{#role 'assistant'~}}
{{gen}}
{{~/role}}
""", llm=llm)
out = prompt()
assert str(out) == '\n<|im_start|>system\nYou are an assistant.<|im_end|>\n\n<|im_start|>user\nWhat is the weather?<|im_end|>\n\n<|im_start|>assistant\nmock output 0<|im_end|>\n'
def test_short_roles():
""" Test the behavior of the shorthand versions of `role`.
"""
llm = guidance.llms.Mock()
prompt = guidance("""
{{#system~}}
You are an assistant.
{{~/system}}
{{#user~}}
What is the weather?
{{~/user}}
{{#assistant~}}
{{gen}}
{{~/assistant}}
""", llm=llm)
out = prompt(test="asdfa")
assert str(out) == '\n<|im_start|>system\nYou are an assistant.<|im_end|>\n\n<|im_start|>user\nWhat is the weather?<|im_end|>\n\n<|im_start|>assistant\nmock output 0<|im_end|>\n'
| [
"\n{{#role 'system'~}}\nYou are an assistant.\n{{~/role}}\n\n{{#role 'user'~}}\nWhat is the weather?\n{{~/role}}\n\n{{#role 'assistant'~}}\n{{gen}}\n{{~/role}}\n",
"\n{{#system~}}\nYou are an assistant.\n{{~/system}}\n\n{{#user~}}\nWhat is the weather?\n{{~/user}}\n\n{{#assistant~}}\n{{gen}}\n{{~/assistant}}\n"
] |
2024-01-10 | jasondotparse/guidance | guidance~llms~_openai.py | import openai
import os
import time
import requests
import copy
import time
import asyncio
import types
import collections
import json
import re
from ._llm import LLM, LLMSession, SyncSession
class MalformedPromptException(Exception):
pass
def prompt_to_messages(prompt):
messages = []
start_tags = re.findall(r'<\|im_start\|>', prompt)
end_tags = re.findall(r'<\|im_end\|>', prompt)
# if len(start_tags) != len(end_tags):
# raise MalformedPromptException("Malformed prompt: start and end tags are not properly paired")
assert prompt.endswith("<|im_start|>assistant\n"), "When calling OpenAI chat models you must generate only directly inside the assistant role! The OpenAI API does not currently support partial assistant prompting."
pattern = r'<\|im_start\|>(\w+)(.*?)(?=<\|im_end\|>)'
matches = re.findall(pattern, prompt, re.DOTALL)
if not matches:
return [{'role': 'user', 'content': prompt.strip()}]
for match in matches:
role, content = match
content = content.strip()
messages.append({'role': role, 'content': content})
return messages
def add_text_to_chat_mode_generator(chat_mode):
for resp in chat_mode:
if "choices" in resp:
for c in resp['choices']:
if "content" in c['delta']:
c['text'] = c['delta']['content']
else:
break # the role markers are outside the generation in chat mode right now TODO: consider how this changes for uncontrained generation
else:
yield resp
else:
yield resp
def add_text_to_chat_mode(chat_mode):
if isinstance(chat_mode, types.GeneratorType):
return add_text_to_chat_mode_generator(chat_mode)
else:
for c in chat_mode['choices']:
c['text'] = c['message']['content']
return chat_mode
# c['text'] = f'<|im_start|>{c["message"]["role"]}\n{c["message"]["content"]}<|im_end|>'
# model that need to use the chat completion API
chat_models = [
"gpt-4",
"gpt-3.5-turbo",
"gpt-4-0314",
"gpt-3.5-turbo-0301"
]
class OpenAI(LLM):
cache = LLM._open_cache("_openai.diskcache")
def __init__(self, model=None, caching=True, max_retries=5, max_calls_per_min=60, token=None, endpoint=None, temperature=0.0, chat_mode="auto"):
super().__init__()
# fill in default model value
if model is None:
model = os.environ.get("OPENAI_MODEL", None)
if model is None:
try:
with open(os.path.expanduser('~/.openai_model'), 'r') as file:
model = file.read().replace('\n', '')
except:
pass
# auto detect chat completion mode
if chat_mode == "auto":
if model in chat_models:
chat_mode = True
else:
chat_mode = False
# fill in default API key value
if token is None: # get from environment variable
token = os.environ.get("OPENAI_API_KEY", getattr(openai, "api_key", None))
if token is not None and not token.startswith("sk-") and os.path.exists(os.path.expanduser(token)): # get from file
with open(os.path.expanduser(token), 'r') as file:
token = file.read().replace('\n', '')
if token is None: # get from default file location
try:
with open(os.path.expanduser('~/.openai_api_key'), 'r') as file:
token = file.read().replace('\n', '')
except:
pass
# fill in default endpoint value
if endpoint is None:
endpoint = os.environ.get("OPENAI_ENDPOINT", None)
import tiktoken
self._tokenizer = tiktoken.get_encoding("cl100k_base")
self.chat_mode = chat_mode
self.model_name = model
self.caching = caching
self.max_retries = max_retries
self.max_calls_per_min = max_calls_per_min
if isinstance(token, str):
token = token.replace("Bearer ", "")
self.token = token
self.endpoint = endpoint
self.current_time = time.time()
self.call_history = collections.deque()
self.temperature = temperature
if self.endpoint is None:
self.caller = self._library_call
else:
self.caller = self._rest_call
self._rest_headers = {
"Content-Type": "application/json"
}
def session(self, asynchronous=False):
if asynchronous:
return OpenAISession(self)
else:
return SyncSession(OpenAISession(self))
def role_start(self, role):
assert self.chat_mode, "role_start() can only be used in chat mode"
return "<|im_start|>"+role+"\n"
def role_end(self, role=None):
assert self.chat_mode, "role_end() can only be used in chat mode"
return "<|im_end|>"
@classmethod
def stream_then_save(cls, gen, key):
list_out = []
for out in gen:
list_out.append(out)
yield out
cls.cache[key] = list_out
def _stream_completion(self):
pass
# Define a function to add a call to the deque
def add_call(self):
# Get the current timestamp in seconds
now = time.time()
# Append the timestamp to the right of the deque
self.call_history.append(now)
# Define a function to count the calls in the last 60 seconds
def count_calls(self):
# Get the current timestamp in seconds
now = time.time()
# Remove the timestamps that are older than 60 seconds from the left of the deque
while self.call_history and self.call_history[0] < now - 60:
self.call_history.popleft()
# Return the length of the deque as the number of calls
return len(self.call_history)
def _library_call(self, **kwargs):
""" Call the OpenAI API using the python package.
Note that is uses the local auth token, and does not rely on the openai one.
"""
prev_key = openai.api_key
assert self.token is not None, "You must provide an OpenAI API key to use the OpenAI LLM. Either pass it in the constructor, set the OPENAI_API_KEY environment variable, or create the file ~/.openai_api_key with your key in it."
openai.api_key = self.token
if self.chat_mode:
kwargs['messages'] = prompt_to_messages(kwargs['prompt'])
del kwargs['prompt']
del kwargs['echo']
del kwargs['logprobs']
# print(kwargs)
out = openai.ChatCompletion.create(**kwargs)
out = add_text_to_chat_mode(out)
else:
out = openai.Completion.create(**kwargs)
openai.api_key = prev_key
return out
def _rest_call(self, **kwargs):
""" Call the OpenAI API using the REST API.
"""
# Define the request headers
headers = copy.copy(self._rest_headers)
if self.token is not None:
headers['Authorization'] = f"Bearer {self.token}"
# Define the request data
stream = kwargs.get("stream", False)
data = {
"prompt": kwargs["prompt"],
"max_tokens": kwargs.get("max_tokens", None),
"temperature": kwargs.get("temperature", 0.0),
"top_p": kwargs.get("top_p", 1.0),
"n": kwargs.get("n", 1),
"stream": stream,
"logprobs": kwargs.get("logprobs", None),
'stop': kwargs.get("stop", None),
"echo": kwargs.get("echo", False)
}
if self.chat_mode:
data['messages'] = prompt_to_messages(data['prompt'])
del data['prompt']
del data['echo']
del data['stream']
# Send a POST request and get the response
response = requests.post(self.endpoint, headers=headers, json=data, stream=stream)
if response.status_code != 200:
raise Exception("Response is not 200: " + response.text)
if stream:
return self._rest_stream_handler(response)
else:
response = response.json()
if self.chat_mode:
response = add_text_to_chat_mode(response)
return response
def _rest_stream_handler(self, response):
for line in response.iter_lines():
text = line.decode('utf-8')
if text.startswith('data: '):
text = text[6:]
if text == '[DONE]':
break
else:
yield json.loads(text)
def encode(self, string, fragment=True):
# note that is_fragment is not used used for this tokenizer
return self._tokenizer.encode(string)
def decode(self, tokens, fragment=True):
return self._tokenizer.decode(tokens)
# Define a deque to store the timestamps of the calls
class OpenAISession(LLMSession):
async def __call__(self, prompt, stop=None, stop_regex=None, temperature=None, n=1, max_tokens=1000, logprobs=None, top_p=1.0, echo=False, logit_bias=None, token_healing=None, pattern=None, stream=False, cache_seed=0, caching=None):
""" Generate a completion of the given prompt.
"""
assert token_healing is None or token_healing is False, "The OpenAI API does not support token healing! Please either switch to an endpoint that does, or don't use the `token_healing` argument to `gen`."
# set defaults
if temperature is None:
temperature = self.llm.temperature
# get the arguments as dictionary for cache key generation
args = locals().copy()
assert not pattern, "The OpenAI API does not support Guidance pattern controls! Please either switch to an endpoint that does, or don't use the `pattern` argument to `gen`."
assert not stop_regex, "The OpenAI API does not support Guidance stop_regex controls! Please either switch to an endpoint that does, or don't use the `stop_regex` argument to `gen`."
# define the key for the cache
key = self._cache_key(args)
# allow streaming to use non-streaming cache (the reverse is not true)
if key not in self.llm.__class__.cache and stream:
args["stream"] = False
key1 = self._cache_key(args)
if key1 in self.llm.__class__.cache:
key = key1
# check the cache
if key not in self.llm.__class__.cache or (caching is not True and not self.llm.caching) or caching is False:
# ensure we don't exceed the rate limit
while self.llm.count_calls() > self.llm.max_calls_per_min:
await asyncio.sleep(1)
fail_count = 0
while True:
try_again = False
try:
self.llm.add_call()
call_args = {
"model": self.llm.model_name,
"prompt": prompt,
"max_tokens": max_tokens,
"temperature": temperature,
"top_p": top_p,
"n": n,
"stop": stop,
"logprobs": logprobs,
"echo": echo,
"stream": stream
}
if logit_bias is not None:
call_args["logit_bias"] = logit_bias
out = self.llm.caller(**call_args)
except openai.error.RateLimitError:
await asyncio.sleep(3)
try_again = True
fail_count += 1
if not try_again:
break
if fail_count > self.llm.max_retries:
raise Exception(f"Too many (more than {self.llm.max_retries}) OpenAI API RateLimitError's in a row!")
if stream:
return self.llm.stream_then_save(out, key)
else:
self.llm.__class__.cache[key] = out
# wrap as a list if needed
if stream:
if isinstance(self.llm.__class__.cache[key], list):
return self.llm.__class__.cache[key]
return [self.llm.__class__.cache[key]]
return self.llm.__class__.cache[key]
# class OpenAISession(AsyncOpenAISession):
# def __call__(self, *args, **kwargs):
# return self._loop.run_until_complete(super().__call__(*args, **kwargs)) | [] |
2024-01-10 | jasondotparse/guidance | docs~conf.py | #!/usr/bin/env python3
# -*- coding: utf-8 -*-
#
# Guidance documentation build configuration file, created by
# sphinx-quickstart on Tue May 22 10:44:55 2018.
#
# This file is execfile()d with the current directory set to its
# containing dir.
#
# Note that not all possible configuration values are present in this
# autogenerated file.
#
# All configuration values have a default; values that are commented out
# serve to show the default.
# If extensions (or modules to document with autodoc) are in another directory,
# add these directories to sys.path here. If the directory is relative to the
# documentation root, use os.path.abspath to make it absolute, like shown here.
#
import os
import sys
import shutil
import sphinx_rtd_theme
print(os.path.abspath('./guidance'))
sys.path.insert(0, os.path.abspath('..'))
# make copy of notebooks in docs folder, as they must be here for sphinx to
# pick them up properly.
NOTEBOOKS_DIR = os.path.abspath('example_notebooks')
if os.path.exists(NOTEBOOKS_DIR):
import warnings
warnings.warn('example_notebooks directory exists, replacing...')
shutil.rmtree(NOTEBOOKS_DIR)
shutil.copytree(os.path.abspath('../notebooks'), NOTEBOOKS_DIR, )
if os.path.exists(NOTEBOOKS_DIR + "/local_scratch"):
shutil.rmtree(NOTEBOOKS_DIR + "/local_scratch")
# -- General configuration ------------------------------------------------
# If your documentation needs a minimal Sphinx version, state it here.
#
# needs_sphinx = '1.0'
# Add any Sphinx extension module names here, as strings. They can be
# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
# ones.
extensions = [
'sphinx.ext.autodoc',
'sphinx.ext.autosummary',
'sphinx_rtd_theme',
'numpydoc',
'nbsphinx',
]
autodoc_default_options = {
'members': True,
'inherited-members': True
}
autosummary_generate = True
numpydoc_show_class_members = False
# Add any paths that contain templates here, relative to this directory.
templates_path = ['_templates']
# The suffix(es) of source filenames.
# You can specify multiple suffix as a list of string:
#
# source_suffix = ['.rst', '.md']
source_suffix = '.rst'
# The encoding of source files.
#
# source_encoding = 'utf-8-sig'
# The master toctree document.
master_doc = 'index'
# General information about the project.
project = 'Guidance'
copyright = '2023, Microsoft'
author = 'Scott Lundberg, Marco Tulio Ribeiro'
# The version info for the project you're documenting, acts as replacement for
# |version| and |release|, also used in various other places throughout the
# built documents.
#
# The short X.Y version.
version = 'latest'
# The full version, including alpha/beta/rc tags.
release = 'latest'
# The language for content autogenerated by Sphinx. Refer to documentation
# for a list of supported languages.
#
# This is also used if you do content translation via gettext catalogs.
# Usually you set "language" from the command line for these cases.
language = "en"
# There are two options for replacing |today|: either, you set today to some
# non-false value, then it is used:
#
# today = ''
#
# Else, today_fmt is used as the format for a strftime call.
#
# today_fmt = '%B %d, %Y'
# List of patterns, relative to source directory, that match files and
# directories to ignore when looking for source files.
# This patterns also effect to html_static_path and html_extra_path
exclude_patterns = [
'_build', 'Thumbs.db', '.DS_Store'
]
# The reST default role (used for this markup: `text`) to use for all
# documents.
#
# default_role = None
# If true, '()' will be appended to :func: etc. cross-reference text.
#
# add_function_parentheses = True
# If true, the current module name will be prepended to all description
# unit titles (such as .. function::).
#
# add_module_names = True
# If true, sectionauthor and moduleauthor directives will be shown in the
# output. They are ignored by default.
#
# show_authors = False
# The name of the Pygments (syntax highlighting) style to use.
pygments_style = 'sphinx'
# A list of ignored prefixes for module index sorting.
# modindex_common_prefix = []
# If true, keep warnings as "system message" paragraphs in the built documents.
# keep_warnings = False
# If true, `todo` and `todoList` produce output, else they produce nothing.
todo_include_todos = False
# -- Options for HTML output ----------------------------------------------
# The theme to use for HTML and HTML Help pages. See the documentation for
# a list of builtin themes.
#
#html_theme = 'alabaster'
html_theme = "sphinx_rtd_theme"
# Theme options are theme-specific and customize the look and feel of a theme
# further. For a list of options available for each theme, see the
# documentation.
#
html_theme_options = {
#'canonical_url': '',
'logo_only': True,
'display_version': True,
'prev_next_buttons_location': 'bottom',
'style_external_links': False,
'style_nav_header_background': '#343131',
# Toc options
'collapse_navigation': True,
'sticky_navigation': True,
'navigation_depth': 4,
'includehidden': True,
'titles_only': False
}
# The name of an image file (relative to this directory) to place at the top
# of the sidebar.
html_logo = 'figures/guidance_logo_white_dark.svg'
# Add any paths that contain custom themes here, relative to this directory.
# html_theme_path = []
# The name for this set of Sphinx documents.
# "<project> v<release> documentation" by default.
#
# html_title = 'Guidance'
# A shorter title for the navigation bar. Default is the same as html_title.
#
# html_short_title = None
# The name of an image file (relative to this directory) to use as a favicon of
# the docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32
# pixels large.
#
html_favicon = 'figures/favicon.png'
# Add any paths that contain custom static files (such as style sheets) here,
# relative to this directory. They are copied after the builtin static files,
# so a file named "default.css" will overwrite the builtin "default.css".
html_static_path = ['_static']
html_css_files = ['css/styles.css']
# Add any extra paths that contain custom files (such as robots.txt or
# .htaccess) here, relative to this directory. These files are copied
# directly to the root of the documentation.
#
# html_extra_path = []
# If not None, a 'Last updated on:' timestamp is inserted at every page
# bottom, using the given strftime format.
# The empty string is equivalent to '%b %d, %Y'.
#
# html_last_updated_fmt = None
# If true, SmartyPants will be used to convert quotes and dashes to
# typographically correct entities.
#
# html_use_smartypants = True
# Custom sidebar templates, maps document names to template names.
#
# html_sidebars = {}
# Additional templates that should be rendered to pages, maps page names to
# template names.
#
# html_additional_pages = {}
# If false, no module index is generated.
#
# html_domain_indices = True
# If false, no index is generated.
#
# html_use_index = True
# If true, the index is split into individual pages for each letter.
#
# html_split_index = False
# If true, links to the reST sources are added to the pages.
#
# html_show_sourcelink = True
# If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
#
# html_show_sphinx = True
# If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.
#
# html_show_copyright = True
# If true, an OpenSearch description file will be output, and all pages will
# contain a <link> tag referring to it. The value of this option must be the
# base URL from which the finished HTML is served.
#
# html_use_opensearch = ''
# This is the file name suffix for HTML files (e.g. ".xhtml").
# html_file_suffix = None
# Language to be used for generating the HTML full-text search index.
# Sphinx supports the following languages:
# 'da', 'de', 'en', 'es', 'fi', 'fr', 'h', 'it', 'ja'
# 'nl', 'no', 'pt', 'ro', 'r', 'sv', 'tr', 'zh'
#
html_search_language = 'en'
# A dictionary with options for the search language support, empty by default.
# 'ja' uses this config value.
# 'zh' user can custom change `jieba` dictionary path.
#
# html_search_options = {'type': 'default'}
# The name of a javascript file (relative to the configuration directory) that
# implements a search results scorer. If empty, the default will be used.
#
# html_search_scorer = 'scorer.js'
# Output file base name for HTML help builder.
htmlhelp_basename = 'Guidance_doc'
# -- Options for LaTeX output ---------------------------------------------
latex_elements = {
# The paper size ('letterpaper' or 'a4paper').
#
# 'papersize': 'letterpaper',
# The font size ('10pt', '11pt' or '12pt').
#
# 'pointsize': '10pt',
# Additional stuff for the LaTeX preamble.
#
# 'preamble': '',
# Latex figure (float) alignment
#
# 'figure_align': 'htbp',
}
# Grouping the document tree into LaTeX files. List of tuples
# (source start file, target name, title,
# author, documentclass [howto, manual, or own class]).
latex_documents = [
(master_doc, 'Guidance.tex', 'Guidance Documentation',
'Scott Lundberg', 'manual'),
]
# The name of an image file (relative to this directory) to place at the top of
# the title page.
#
# latex_logo = None
# For "manual" documents, if this is true, then toplevel headings are parts,
# not chapters.
#
# latex_use_parts = False
# If true, show page references after internal links.
#
# latex_show_pagerefs = False
# If true, show URL addresses after external links.
#
# latex_show_urls = False
# Documents to append as an appendix to all manuals.
#
# latex_appendices = []
# It false, will not define \strong, \code, itleref, \crossref ... but only
# \sphinxstrong, ..., \sphinxtitleref, ... To help avoid clash with user added
# packages.
#
# latex_keep_old_macro_names = True
# If false, no module index is generated.
#
# latex_domain_indices = True
# -- Options for manual page output ---------------------------------------
# One entry per manual page. List of tuples
# (source start file, name, description, authors, manual section).
man_pages = [
(master_doc, 'guidance', 'Guidance Documentation',
[author], 1)
]
# If true, show URL addresses after external links.
#
# man_show_urls = False
# -- Options for Texinfo output -------------------------------------------
# Grouping the document tree into Texinfo files. List of tuples
# (source start file, target name, title, author,
# dir menu entry, description, category)
texinfo_documents = [
(master_doc, 'Guidance', 'Guidance Documentation',
author, 'Guidance', 'One line description of project.',
'Miscellaneous'),
]
# Documents to append as an appendix to all manuals.
#
# texinfo_appendices = []
# If false, no module index is generated.
#
# texinfo_domain_indices = True
# How to display URL addresses: 'footnote', 'no', or 'inline'.
#
# texinfo_show_urls = 'footnote'
# If true, do not generate a @detailmenu in the "Top" node's menu.
#
# texinfo_no_detailmenu = False
def setup(app):
import guidance
app.connect('build-finished', build_finished)
def build_finished(app, exception):
shutil.rmtree(NOTEBOOKS_DIR) | [
"['_templates']"
] |
2024-01-10 | jasondotparse/guidance | tests~library~test_each.py | import guidance
def test_each():
""" Test an each loop.
"""
prompt = guidance("Hello, {{name}}!{{#each names}} {{this}}{{/each}}")
assert str(prompt(name="Guidance", names=["Bob", "Sue"])) == "Hello, Guidance! Bob Sue"
def test_each_with_objects():
""" Test an each loop with objects.
"""
prompt = guidance("Hello, {{name}}!{{#each names}} {{this.name}}{{/each}}")
out = prompt(
name="Guidance",
names=[{"name": "Bob"}, {"name": "Sue"}]
)
assert str(out) == "Hello, Guidance! Bob Sue"
def test_missing_list():
llm = guidance.llms.OpenAI("text-curie-001")
prompt = guidance('''List of ideas:{{#each ideas}}test{{this}}{{/each}}''', await_missing=True, llm=llm)
assert str(prompt()) == "List of ideas:{{#each ideas}}test{{this}}{{/each}}"
# try:
# out = prompt()
# except KeyError:
# return
# assert False, "An error should have been raised because the list is missing!" | [
"Hello, {{name}}!{{#each names}} {{this}}{{/each}}",
"Hello, {{name}}!{{#each names}} {{this.name}}{{/each}}",
"List of ideas:{{#each ideas}}test{{this}}{{/each}}"
] |
2024-01-10 | jasondotparse/guidance | tests~library~test_select.py | import guidance
def test_select():
""" Test the behavior of `select`.
"""
llm = guidance.llms.OpenAI("text-curie-001")
prompt = guidance("Is Everest very tall?\nAnswer 'Yes' or 'No': '{{#select 'name'}}Yes{{or}}No{{/select}}", llm=llm)
out = prompt()
assert out["name"] in ["Yes", "No"] | [
"Is Everest very tall?\nAnswer 'Yes' or 'No': '{{#select 'name'}}Yes{{or}}No{{/select}}"
] |
2024-01-10 | jasondotparse/guidance | tests~test_program.py | import guidance
def test_variable_interpolation():
""" Test variable interpolation in prompt
"""
prompt = guidance("Hello, {{name}}!")
assert str(prompt(name="Guidance")) == "Hello, Guidance!"
def test_chat_stream():
""" Test the behavior of `stream=True` for an openai chat endpoint.
"""
import asyncio
loop = asyncio.new_event_loop()
import guidance
guidance.llm = guidance.llms.OpenAI("gpt-3.5-turbo", caching=False)
async def f():
chat = guidance("""<|im_start|>system
You are a helpful assistent.
<|im_end|>
<|im_start|>user
{{command}}
<|im_end|>
<|im_start|>assistant
{{gen 'answer' max_tokens=10}}""", stream=True)
out = await chat(command="How do I create a Fasttokenizer with hugging face auto?-b")
assert len(out["answer"]) > 0
loop.run_until_complete(f())
def test_chat_display():
""" Test the behavior of `stream=True` for an openai chat endpoint.
"""
import asyncio
loop = asyncio.new_event_loop()
import guidance
guidance.llm = guidance.llms.OpenAI("gpt-3.5-turbo", caching=False)
async def f():
chat = guidance("""<|im_start|>system
You are a helpful assistent.
<|im_end|>
<|im_start|>user
{{command}}
<|im_end|>
<|im_start|>assistant
{{gen 'answer' max_tokens=10}}""")
out = await chat(command="How do I create a Fasttokenizer with hugging face auto?")
assert len(out["answer"]) > 0
loop.run_until_complete(f())
def test_agents():
"""Test agentes, calling prompt twice"""
import guidance
guidance.llm = guidance.llms.OpenAI("gpt-3.5-turbo", caching=False)
prompt = guidance('''<|im_start|>system
You are a helpful assistant.<|im_end|>
{{#geneach 'conversation' stop=False}}
<|im_start|>user
{{set 'this.user_text' (await 'user_text')}}<|im_end|>
<|im_start|>assistant
{{gen 'this.ai_text' n=1 temperature=0 max_tokens=900}}<|im_end|>{{/geneach}}''', echo=True)
prompt = prompt(user_text='Hi there')
assert len(prompt['conversation']) == 2
prompt = prompt(user_text='Please help')
assert len(prompt['conversation']) == 3 | [
"<|im_start|>system\nYou are a helpful assistant.<|im_end|>\n{{#geneach 'conversation' stop=False}}\n<|im_start|>user\n{{set 'this.user_text' (await 'user_text')}}<|im_end|>\n<|im_start|>assistant\n{{gen 'this.ai_text' n=1 temperature=0 max_tokens=900}}<|im_end|>{{/geneach}}",
"Hello, {{name}}!",
"Please help",
"Hi there"
] |
2024-01-10 | jasondotparse/guidance | tests~library~test_if.py | import guidance
def test_if():
""" Test the behavior of `if`.
"""
llm = guidance.llms.OpenAI("text-curie-001")
prompt = guidance("""Answer: {{#if flag}}Yes{{/if}}""", llm=llm)
for flag in [True, 1, "random text"]:
out = prompt(flag=flag)
assert str(out) == "Answer: Yes"
for flag in [False, 0, ""]:
out = prompt(flag=flag)
assert str(out) == "Answer: "
def test_if_else():
""" Test the behavior of `if` with an `else` clause.
"""
llm = guidance.llms.OpenAI("text-curie-001")
prompt = guidance("""Answer 'Yes' or 'No': '{{#if flag}}Yes{{else}}No{{/if}}'""", llm=llm)
for flag in [True, 1, "random text"]:
out = prompt(flag=flag)
assert str(out) == "Answer 'Yes' or 'No': 'Yes'"
for flag in [False, 0, ""]:
out = prompt(flag=flag)
assert str(out) == "Answer 'Yes' or 'No': 'No'" | [
"Answer: {{#if flag}}Yes{{/if}}",
"Answer 'Yes' or 'No': '{{#if flag}}Yes{{else}}No{{/if}}'"
] |
2024-01-10 | jasondotparse/guidance | guidance~llms~_azure_openai.py | import os
import atexit
import json
import platformdirs
from ._openai import OpenAI
class AzureOpenAI(OpenAI):
""" Azure OpenAI integration.
"""
cache = OpenAI._open_cache("_azure_openai.diskcache")
def __init__(self, model=None, client_id=None, authority=None, caching=True, max_retries=5, max_calls_per_min=60, token=None,
endpoint=None, scopes=None, temperature=0.0, chat_mode="auto"):
# build a standard OpenAI LLM object
super().__init__(
model=model, caching=caching, max_retries=max_retries, max_calls_per_min=max_calls_per_min,
token=token, endpoint=endpoint, temperature=temperature, chat_mode=chat_mode
)
self.client_id = client_id
self.authority = authority
self.scopes = scopes
from msal import PublicClientApplication, SerializableTokenCache
self._token_cache = SerializableTokenCache()
self._token_cache_path = os.path.join(platformdirs.user_cache_dir("guidance"), "_azure_openai.token")
self._app = PublicClientApplication(client_id=self.client_id, authority=self.authority, token_cache=self._token_cache)
if os.path.exists(self._token_cache_path):
self._token_cache.deserialize(open(self._token_cache_path, 'r').read())
self._rest_headers["X-ModelType"] = self.model_name
@property
def token(self):
return self._get_token()
@token.setter
def token(self, value):
pass # ignored for now
def _get_token(self):
accounts = self._app.get_accounts()
result = None
if accounts:
# Assuming the end user chose this one
chosen = accounts[0]
# Now let's try to find a token in cache for this account
result = self._app.acquire_token_silent(self.scopes, account=chosen)
if not result:
# So no suitable token exists in cache. Let's get a new one from AAD.
flow = self._app.initiate_device_flow(scopes=self.scopes)
if "user_code" not in flow:
raise ValueError(
"Fail to create device flow. Err: %s" % json.dumps(flow, indent=4))
print(flow["message"])
result = self._app.acquire_token_by_device_flow(flow)
# save the aquired token
with open(self._token_cache_path, "w") as f:
f.write(self._token_cache.serialize())
return result["access_token"] | [] |
2024-01-10 | jasondotparse/guidance | guidance~_program.py | import ast
import inspect
import re
import html
import uuid
import sys
import parsimonious
import logging
import copy
import asyncio
import pathlib
import os
import traceback
import time
import datetime
from .llms import _openai
from . import _utils
from ._program_executor import ProgramExecutor
from . import library
import guidance
log = logging.getLogger(__name__)
# load the javascript client code
file_path = pathlib.Path(__file__).parent.parent.absolute()
with open(file_path / "guidance" / "resources" / "main.js", encoding="utf-8") as f:
js_data = f.read()
class Program:
''' A program template that can be compiled and executed to generate a new filled in (executed) program.
Note that as the template gets executed {{!-- handlebars comment markers --}} get left in
the generated output to mark where template tags used to be.
'''
def __init__(self, text, llm=None, cache_seed=0, logprobs=None, silent='auto', async_mode=False, stream='auto', caching=None, await_missing=False, **kwargs):
""" Create a new Program object from a program string.
Parameters
----------
text : str
The program string to use as a guidance template.
llm : guidance.llms.LLM (defaults to guidance.llm)
The language model to use for executing the program.
cache_seed : int (default 0) or None
The seed to use for the cache. If you want to use the same cache for multiple programs
you can set this to the same value for all of them. Set this to None to disable caching.
Caching is enabled by default, and saves calls that have tempurature=0, and also saves
higher temperature calls but uses different seed for each call.
logprobs : int or None (default)
The number of logprobs to return from the language model for each token. (not well supported yet,
since some endpoints don't support it)
silent : bool (default False)
If True, the program will not display any output. This is useful for programs that are
only used to generate variables for other programs.
async_mode : bool (default False)
If True, the program will be executed asynchronously. This is useful for programs that
take a long time to run, or that need to be run in parallel.
stream : bool (default False)
If True, the program will try to stream all the results from the LLM token by token.
caching : bool (default None)
If True, the program will cache the results of the LLM. If False, it will not cache the results.
If None, it will use the default caching setting from the LLM.
await_missing : bool (default False)
If True, the program will automatically await any missing variables. This means the program
will stop executation at that point and return a paritally executed program. This is useful
for executing programs on different machines, for example shipping a program to a GPU machine
then waiting for the results to come back for any local processing, then shipping it back to
the GPU machine to continue execution.
"""
# see if we were given a raw function instead of a string template
# if so, convert it to a string template that calls the function
if not isinstance(text, str):
if callable(text):
sig = inspect.signature(text)
args = ""
for name,_ in sig.parameters.items():
args += f" {name}={name}"
fname = _utils.find_func_name(text, kwargs)
kwargs[fname] = text
text = "{{set (%s%s)}}" % (fname, args)
# save the given parameters
self._text = text
self.llm = llm or guidance.llm
self.cache_seed = cache_seed
self.caching = caching
self.logprobs = logprobs
self.async_mode = async_mode
self.silent = silent
self.stream = stream
self.await_missing = await_missing
if self.silent == "auto":
self.silent = not _utils.is_interactive()
# set our variables
self._variables = {}
self._variables.update(_built_ins)
self._variables.update({
"llm": llm
})
self._variables.update(kwargs)
# set internal state variables
self._id = str(uuid.uuid4())
self._comm = None # front end communication object
self._executor = None # the ProgramExecutor object that is running the program
self._last_display_update = 0 # the last time we updated the display (used for throttling updates)
self._execute_complete = asyncio.Event() # fires when the program is done executing to resolve __await__
self._displaying = not self.silent # if we are displaying we need to update the display as we execute
self._displayed = False # marks if we have been displayed in the client yet
self._displaying_html = False # if we are displaying html (vs. text)
# throttle the display updates
if os.environ.get("VSCODE_CWD", None) is not None:
self.display_throttle_limit = 0.1 # VSCode has a bug that causes flashing, so we slow down the display
else:
self.display_throttle_limit = 0.1 # the minimum time between display updates
self.update_display = DisplayThrottler(self._update_display, self.display_throttle_limit)
# see if we are in an ipython environment
try:
self._ipython = get_ipython()
except:
self._ipython = None
# if we are echoing in ipython we assume we can display html
if self._ipython and not self.silent:
self._displaying_html = True
def __repr__(self):
return self.text
def __getitem__(self, key):
return self._variables[key]
def _interface_event(self, msg):
""" Handle an event from the front end.
"""
if msg["event"] == "stop":
self._executor.stop()
elif msg["event"] == "opened":
pass # we don't need to do anything here because the first time we display we'll send the html
pass
def _ipython_display_(self):
""" Display the program in the ipython notebook.
"""
log.debug(f"displaying program in _ipython_display_ with self._comm={self._comm}, self.id={self._id}")
# mark that we are displaying (and so future execution updates should be displayed)
self._displaying = True
self._displaying_html = True
# build and display the html
html = self._build_html(self.marked_text)
self._display_html(html)
async def _await_finish_execute(self):
""" Used by self.__await__ to wait for the program to complete.
"""
await self._execute_complete.wait() # wait for the program to finish executing
return self
def __await__(self):
return self._await_finish_execute().__await__()
def __call__(self, **kwargs):
""" Execute this program with the given variable values and return a new executed/executing program.
Note that the returned program might not be fully executed if `stream=True`. When streaming you need to
use the python `await` keyword if you want to ensure the program is finished (note that is different than
the `await` guidance langauge command, which will cause the program to stop execution at that point).
"""
# merge the given kwargs with the current variables
kwargs = {**{
"async_mode": self.async_mode,
"stream": self.stream,
"silent": self.silent,
"cache_seed": self.cache_seed,
"caching": self.caching,
"logprobs": self.logprobs,
"await_missing": self.await_missing,
"llm": self.llm,
}, **kwargs}
log.debug(f"in __call__ with kwargs: {kwargs}")
# create a new program object that we will execute in-place
new_program = Program(
text=self.marked_text,
# copy the (non-function) variables so that we don't modify the original program during execution
# TODO: what about functions? should we copy them too?
**{**{k: v if callable(v) else copy.deepcopy(v) for k,v in self._variables.items()}, **kwargs}
)
# create an executor for the new program (this also marks the program as executing)
new_program._executor = ProgramExecutor(new_program)
# if we are in async mode schedule the program in the current event loop
if new_program.async_mode:
loop = asyncio.get_event_loop()
assert loop.is_running(), "The program is in async mode but there is no asyncio event loop running! Start one and try again."
loop.create_task(new_program.update_display.run()) # start the display updater
loop.create_task(new_program.execute())
# if we are not in async mode, we need to create a new event loop and run the program in it until it is done
else:
loop = asyncio.new_event_loop()
loop.create_task(new_program.update_display.run()) # start the display updater
loop.run_until_complete(new_program.execute())
return new_program
def _update_display(self, last=False):
""" Updates the display with the current marked text after debouncing.
Parameters
----------
last : bool
If True, this is the last update and we should clear the send queue and prepare the
UI for saving etc.
force : bool
If True, we will update the display even if it would otherwise be throttled.
"""
log.debug(f"Updating display (last={last}, self._displaying={self._displaying}, self._comm={self._comm})")
# this is always called during execution, and we only want to update the display if we are displaying
if not self._displaying:
return
# debounce the display updates
# now = time.time()
# log.debug(now - self._last_display_update)
# debounce_delay = self.display_throttle_limit if self._comm and self._comm.is_open else self.display_throttle_limit_low
# if last or (now - self._last_display_update > debounce_delay):
if self._displaying_html:
out = self._build_html(self.marked_text)
# clear the send queue if this is the last update
if last and self._comm:
self._comm.clear_send_queue()
# send an update to the front end client if we have one...
# TODO: we would like to call `display` for the last update so NB saving works, but see https://github.com/microsoft/vscode-jupyter/issues/13243
if self._displayed and self._comm and self._comm.is_open: #(not last or self._comm.is_open):
log.debug(f"Updating display send message to front end")
# log.debug(out)
self._comm.send({"replace": out})
if last:
self._comm.send({"event": "complete"})
# ...otherwise dump the client to the font end
else:
log.debug(f"Updating display dump to front end")
from IPython.display import clear_output, display
if self._displayed:
clear_output(wait=True) # TODO: should use wait=True but that doesn't work in VSCode until after the April 2023 release
self._display_html(out)
self._last_display_update = time.time()
def _display_html(self, html):
from IPython.display import display
# create the comm object if we don't have one
if self._comm is None:
self._comm = _utils.JupyterComm(self._id, self._ipython, self._interface_event)
# dump the html to the front end
html = f"""<div id="guidance-stop-button-{self._id}" style="cursor: pointer; margin: 0px; display: none; float: right; padding: 3px; border-radius: 4px 4px 4px 4px; border: 0px solid rgba(127, 127, 127, 1); padding-left: 10px; padding-right: 10px; font-size: 13px; background-color: rgba(127, 127, 127, 0.25);">Stop program</div><div id="guidance-content-{self._id}">{html}</div>
<script type="text/javascript">{js_data}; window._guidanceDisplay("{self._id}");</script>"""
display({"text/html": html}, display_id=self._id, raw=True, clear=True, include=["text/html"])
self._displayed = True
async def execute(self):
""" Execute the current program.
Note that as execution progresses the program will be incrementally converted
from a template into a completed string (with variables stored). At each point
in this process the current template remains valid.
"""
log.debug(f"Executing program (self.async_mode={self.async_mode}, self.silent={self.silent}, self._displaying_html={self._displaying_html})")
# if we are already displaying html, we need to yeild to the event loop so the jupyter comm can initialize
if self._displaying_html:
await asyncio.sleep(0)
# run the program and capture the output
with self.llm.session(asynchronous=True) as llm_session:
await self._executor.run(llm_session)
self._text = self._executor.prefix
# delete the executor and so mark the program as not executing
self._executor = None
# update the display with the final output
self.update_display(last=True)
await self.update_display.done()
# fire an event noting that execution is complete (this will release any await calls waiting on the program)
self._execute_complete.set()
def __getitem__(self, key):
return self._variables[key]
def __contains__(self, key):
return key in self._variables
def __delitem__(self, key):
del self._variables[key]
def variables(self, built_ins=False):
""" Returns a dictionary of the variables in the program.
Parameters
----------
built_ins : bool
If True, built-in variables will be included in the returned dictionary.
"""
return {k: v for k,v in self._variables.items() if built_ins or not (k in _built_ins and callable(_built_ins[k]))}
@property
def text(self):
# strip out the markers for the unformatted output
return _utils.strip_markers(self.marked_text)
@property
def marked_text(self):
if self._executor is not None:
return self._executor.prefix
else:
return self._text
def _build_html(self, text, last=False):
output = text
def undo_html_encode(x):
return x.replace("&#123;", "{").replace("&#125;", "}").replace("&#36;", "$")
def start_generate_or_select(x):
no_echo = "echo=False" in x.group(1)
alpha = 1.0 if no_echo else 1.0
# script that toggles the viisibility of the next element
click_script = 'var e = this.nextElementSibling; if (e.style.display == "inline") { e.style.display = "none"; this.style.borderRight = "1px solid rgba(0, 165, 0, 0.25)"; } else { e.style.display = "inline"; this.style.borderRight = "0px";}'
if no_echo:
out = f'''<div style='background-color: rgba(0, 165, 0, 0.25); border-radius: 4px 0px 0px 4px; border: 1px solid rgba(0, 165, 0, 1); padding-left: 3px; padding-right: 3px; user-select: none; color: rgb(0, 165, 0, 1.0); display: inline; font-weight: normal; cursor: pointer' onClick='{click_script}'>no echo</div>'''
out += "<span style='background-color: rgba(0, 165, 0, 0.25); opacity: {}; display: none;' title='{}'>".format(alpha, undo_html_encode(x.group(1)))
else:
out = "<span style='background-color: rgba(0, 165, 0, 0.25); opacity: {}; display: inline;' title='{}'>".format(alpha, undo_html_encode(x.group(1)))
return out
def start_each(x):
no_echo = "echo=False" in x.group(1)
alpha = 0.5 if no_echo else 1.0
color = "rgba(165, 165, 165, 0.1)" #if "geneach" not in x.group(1) else "rgba(0, 165, 0, 0.1)"
return "<span style='opacity: {}; display: inline; background-color: {};' title='{}'>".format(alpha, color, undo_html_encode(x.group(1)))
def start_block(x):
escaped_tag = undo_html_encode(x.group(1))
if "hidden=True" in escaped_tag:
display = "inline" # none (we actively stip hidden tags right now so we don't need this until we support the UX to show hidden stuff)
else:
display = "inline"
return f"<span style='background-color: rgba(165, 165, 165, 0.1); display: {display};' title='{escaped_tag}'>"
def role_box(x):
# name = x.group(3).lower() # standardize to lowercase for display
# content = x.group(4)
content = x.group(3)
tag_text = undo_html_encode(x.group(2))
role_name = x.group(1)
# if we have a generic role tag then the role name is an attribute
if role_name == "role":
role_name = re.search(r"name=([^ ]*)", tag_text).group(1)
start_pattern = html.escape(self.llm.role_start(role_name)).replace("|", r"\|")
end_pattern = html.escape(self.llm.role_end(role_name)).replace("|", r"\|")
# strip the start and end patterns from the content
content = re.sub("^" + start_pattern, "", content, flags=re.DOTALL)
content = re.sub(end_pattern + "$", "", content, flags=re.DOTALL)
# one div that contains two divs, where the left of the two inner divs has a fixed width of 100px
# """<div style='display: flex;'>
# <div style='width: 100px; border-right: 1px solid rgba(127, 127, 127, 0.2); padding-right: 5px; margin-right: 5px;'>{name}</div>
# <div>{content}</div>
# </div>"""
# return f'''<div style="border-left: 1px solid rgba(127, 127, 127, 0.2); margin-top: 10px; padding-left: 5px;"><span style="color: rgba(127,127,127,0.5)">{name}</span>
# {content}</div>'''
return f"<div style='display: flex; border-bottom: 1px solid rgba(127, 127, 127, 0.2); align-items: center;'><div style='flex: 0 0 80px; opacity: 0.5;'>{role_name.lower()}</div><div style='flex-grow: 1; padding: 5px; padding-top: 10px; padding-bottom: 10px; margin-top: 0px; white-space: pre-wrap; margin-bottom: 0px;'>{content}</div></div>"
display_out = html.escape(output)
# log.debug(display_out)
# start_pattern = html.escape(self.llm.role_start("(.*?)")).replace("|", r"\|")
# end_pattern = html.escape(self.llm.role_end("(.*?)")).replace("|", r"\|")
# display_out = re.sub(r"[\s]+({{!--.*?--}})?"+start_pattern, r"\1"+start_pattern.replace("(.*?)", r"\1").replace(r"\|", "|"), display_out, flags=re.DOTALL)
# display_out = re.sub(start_pattern + "(.*?)" + end_pattern, role_box, display_out, flags=re.DOTALL)
# log.debug(display_out)
# strip out hidden blocks (might want to make a better UI for this at some point)
display_out = re.sub(r"{{!--GMARKER_START[^}]*--}}{{!--GHIDDEN:(.*?)--}}{{!--GMARKER_END[^}]*--}}", "", display_out, flags=re.DOTALL)
# if we have role markers, we wrap them in special formatting
if re.search(r"{{!--GMARKER_START_(role|system|user|assistant)", display_out) is not None:
# start_pattern = html.escape(self.llm.role_start("assistant")).replace("|", r"\|").replace(r"assistant", r"([^\n]*)").replace(r"ASSISTANT", r"([^\n]*)")
# end_pattern = html.escape(self.llm.role_end("assistant")).replace("|", r"\|").replace(r"assistant", r"([^\n]*)").replace(r"ASSISTANT", r"([^\n]*)")
# strip whitespace before role markers
display_out = re.sub(r"\s*{{!--GMARKER_START_(role|system|user|assistant)\$(.*?)--}}", r"{{!--GMARKER_START_\1$\2--}}", display_out, flags=re.DOTALL)
# strip whitespace after role markers
# TODO: support end_patterns with capture groups
display_out = re.sub(r"{{!--GMARKER_END_(role|system|user|assistant)\$(.*?)--}}\s*", r"{{!--GMARKER_END_\1$\2--}}", display_out, flags=re.DOTALL)
# wrap role markers in nice formatting
display_out = re.sub(r"{{!--GMARKER_START_(role|system|user|assistant)\$(.*?)--}}" + "(.*?)" + r"{{!--GMARKER_END_(role|system|user|assistant)\$(.*?)--}}", role_box, display_out, flags=re.DOTALL)
# wrap unfinished role markers in nice formatting
display_out = re.sub(r"{{!--GMARKER_START_(role|system|user|assistant)\$(.*?)--}}" + "(.*)", role_box, display_out, flags=re.DOTALL)
display_out = re.sub(r"(\{\{generate.*?\}\})", r"<span style='background-color: rgba(0, 165, 0, 0.25);'>\1</span>", display_out, flags=re.DOTALL)
display_out = re.sub(r"(\{\{#select\{\{/select.*?\}\})", r"<span style='background-color: rgba(0, 165, 0, 0.25);'>\1</span>", display_out, flags=re.DOTALL)
display_out = re.sub(r"(\{\{#each [^'\"].*?\{\{/each.*?\}\})", r"<span style='background-color: rgba(0, 138.56128016, 250.76166089, 0.25);'>\1</span>", display_out, flags=re.DOTALL)
display_out = re.sub(r"(\{\{(?!\!)(?!generate)(?!#select)(?!#each)(?!/each)(?!/select).*?\}\})", r"<span style='background-color: rgba(0, 138.56128016, 250.76166089, 0.25);'>\1</span>", display_out, flags=re.DOTALL)
# format the generate command results
display_out = re.sub(r"{{!--GMARKER_START_gen\$([^\$]*)\$--}}", start_generate_or_select, display_out)
display_out = display_out.replace("{{!--GMARKER_END_gen$$--}}", "</span>")
def click_loop_start(id, total_count, echo, color):
click_script = '''
function cycle_IDVAL(button_el) {
var i = 0;
while (i < 50) {
var el = document.getElementById("IDVAL_" + i);
if (el.style.display == "inline") {
el.style.display = "none";
var next_el = document.getElementById("IDVAL_" + (i+1));
if (!next_el) {
next_el = document.getElementById("IDVAL_0");
}
if (next_el) {
next_el.style.display = "inline";
}
break;
}
i += 1;
}
button_el.innerHTML = (((i+1) % TOTALCOUNT) + 1) + "/" + TOTALCOUNT;
}
cycle_IDVAL(this);'''.replace("IDVAL", id).replace("TOTALCOUNT", str(total_count)).replace("\n", "")
out = f'''<div style='background: rgba(255, 255, 255, 0.0); border-radius: 4px 0px 0px 4px; border: 1px solid {color}; border-right: 0px; padding-left: 3px; padding-right: 3px; user-select: none; color: {color}; display: inline; font-weight: normal; cursor: pointer' onClick='{click_script}'>1/{total_count}</div>'''
out += f"<div style='display: inline;' id='{id}_0'>"
return out
def click_loop_mid(id, index, echo):
alpha = 1.0 if not echo else 0.5
out = f"</div><div style='display: none; opacity: {alpha}' id='{id}_{index}'>"
return out
display_out = re.sub(
r"{{!--GMARKERmany_generate_start_([^_]+)_([0-9]+)\$([^\$]*)\$--}}",
lambda x: click_loop_start(x.group(3), int(x.group(2)), x.group(1) == "True", "rgba(0, 165, 0, 0.25)"),
display_out
)
display_out = re.sub(
r"(?:--}})?{{!--GMARKERmany_generate_([^_]+)_([0-9]+)\$([^\$]*)\$--}}{{!--G ",
lambda x: click_loop_mid(x.group(3), int(x.group(2)), x.group(1) == "True"),
display_out
)
display_out = re.sub(r"--}}{{!--GMARKERmany_generate_end\$([^\$]*)\$--}}", "</div>", display_out)
# format the each command results
display_out = re.sub(r"{{!--GMARKER_START_each\$([^\$]*)\$--}}", start_each, display_out)
display_out = re.sub(
r"{{!--GMARKER_each_noecho_start_([^_]+)_([0-9]+)\$([^\$]*)\$--}}",
lambda x: click_loop_start(x.group(3), int(x.group(2)), False, "rgb(100, 100, 100, 1)"),
display_out
)
display_out = re.sub(
r"{{!--GMARKER_each_noecho_([^_]+)_([0-9]+)\$([^\$]*)\$--}}",
lambda x: click_loop_mid(x.group(3), int(x.group(2)), False),
display_out
)
display_out = re.sub(r"{{!--GMARKER_each_noecho_end\$([^\$]*)\$--}}", "</div>", display_out)
# format the geneach command results
display_out = re.sub(r"{{!--GMARKER_START_geneach\$([^\$]*)\$--}}", start_each, display_out)
# format the set command results
display_out = re.sub(r"{{!--GMARKER_set\$([^\$]*)\$--}}", r"<div style='background-color: rgba(165, 165, 165, 0); border-radius: 4px 4px 4px 4px; border: 1px solid rgba(165, 165, 165, 1); border-left: 2px solid rgba(165, 165, 165, 1); border-right: 2px solid rgba(165, 165, 165, 1); padding-left: 0px; padding-right: 3px; color: rgb(165, 165, 165, 1.0); display: inline; font-weight: normal; overflow: hidden;'><div style='display: inline; background: rgba(165, 165, 165, 1); padding-right: 5px; padding-left: 4px; margin-right: 3px; color: #fff'>set</div>\1</div>", display_out)
display_out = re.sub(r"{{!--GMARKER_START_set\$([^\$]*)\$--}}", lambda x: "<span style='display: inline;' title='{}'>".format(undo_html_encode(x.group(1))), display_out)
display_out = re.sub(r"{{!--GMARKER_START_select\$([^\$]*)\$--}}", start_generate_or_select, display_out)
display_out = display_out.replace("{{!--GMARKER_END_select$$--}}", "</span>")
display_out = re.sub(r"{{!--GMARKER_START_variable_ref\$([^\$]*)\$--}}", lambda x: "<span style='background-color: rgba(0, 138.56128016, 250.76166089, 0.25); display: inline;' title='{}'>".format(undo_html_encode(x.group(1))), display_out)
display_out = display_out.replace("{{!--GMARKER_END_variable_ref$$--}}", "</span>")
display_out = display_out.replace("{{!--GMARKER_each$$--}}", "")#<div style='border-left: 1px dashed rgb(0, 0, 0, .2); border-top: 0px solid rgb(0, 0, 0, .2); margin-right: -4px; display: inline; width: 4px; height: 24px;'></div>")
display_out = re.sub(r"{{!--GMARKER_START_block\$([^\$]*)\$--}}", start_block, display_out)
display_out = re.sub(r"{{!--GMARKER_START_([^\$]*)\$([^\$]*)\$--}}", lambda x: "<span style='background-color: rgba(0, 138.56128016, 250.76166089, 0.25); display: inline;' title='{}'>".format(undo_html_encode(x.group(2))), display_out)
display_out = re.sub(r"{{!--GMARKER_END_([^\$]*)\$\$--}}", "</span>", display_out)
# display_out = re.sub(' and (?=.* and )', ', ', display_out)
# strip out comments
display_out = re.sub(r"{{~?!.*?}}", "", display_out)
# re.sub(r"<div class='strip_leading_whitespace'")
display_out = add_spaces(display_out)
display_out = "<pre style='margin: 0px; padding: 0px; padding-left: 8px; margin-left: -8px; border-radius: 0px; border-left: 1px solid rgba(127, 127, 127, 0.2); white-space: pre-wrap; font-family: ColfaxAI, Arial; font-size: 15px; line-height: 23px;'>"+display_out+"</pre>"
return display_out
def add_spaces(s):
""" This adds spaces so the browser will show leading and trailing newlines.
"""
if s.startswith("\n"):
s = " " + s
if s.endswith("\n"):
s = s + " "
return s
_built_ins = {
"gen": library.gen,
"each": library.each,
"geneach": library.geneach,
"select": library.select,
"if": library.if_,
"unless": library.unless,
"add": library.add,
"subtract": library.subtract,
"strip": library.strip,
"block": library.block,
"set": library.set,
"await": library.await_,
"role": library.role,
"user": library.user,
"system": library.system,
"assistant": library.assistant,
"break": library.break_,
"equal": library.equal,
}
class DisplayThrottler():
def __init__(self, display_function, throttle_limit):
self.display_function = display_function
self.throttle_limit = throttle_limit
self._done = False
self.last_time = 0
async def run(self):
self._data_event = asyncio.Event()
self._done_event = asyncio.Event()
while True:
await self._data_event.wait()
now = time.time()
log.info("in DisplayThrottler run loop -- now: {}, last_time: {}, throttle_limit: {}".format(now, self.last_time, self.throttle_limit))
if self._done or now - self.last_time >= self.throttle_limit:
try:
self.display_function(last=self._done)
except Exception as e:
self._done = True
raise e
finally:
self.last_time = now
self._data_event.clear()
if self._done:
self._done_event.set()
break
else:
await asyncio.sleep(self.throttle_limit - (now - self.last_time))
def __call__(self, last=False):
if last:
self._done = True
self._data_event.set()
async def done(self):
return await self._done_event.wait() | [] |
2024-01-10 | jasondotparse/guidance | tests~llms~test_transformers.py | import guidance
def test_basic():
llm = guidance.llms.Transformers('gpt2', caching=False)
with llm.session() as s:
out = s("this is a test", max_tokens=5)
print(out)
def test_repeat():
llm = guidance.llms.Transformers('gpt2', caching=False)
with llm.session() as s:
out1 = s("this is a test", max_tokens=5)
out2 = s("this is a test like another", max_tokens=5)
print(out2)
def test_stop():
llm = guidance.llms.Transformers('gpt2', caching=False)
program = guidance("""Repeat this. Repeat this. Repeat this. Repeat this. Repeat this. Repeat this.{{gen stop="this" max_tokens=10}}""", llm=llm)
out = program()
assert str(out) == "Repeat this. Repeat this. Repeat this. Repeat this. Repeat this. Repeat this. Repeat "
def test_pattern():
import re
llm = guidance.llms.Transformers('gpt2', caching=False)
program = guidance("""Repeat this. Repeat this. Repeat this. Repeat this. {{gen pattern="[0-9]+" max_tokens=1}}""", llm=llm)
out = program()
assert re.match("^Repeat this. Repeat this. Repeat this. Repeat this. [0-9]+$", str(out))
def test_select():
llm = guidance.llms.Transformers('gpt2', caching=False)
program = guidance('''Answer "yes" or "no": "{{#select 'answer'}}yes{{or}}no{{/select}}"''', llm=llm)
out = program()
assert out["answer"] in ["yes", "no"]
def test_chat_stream():
""" Test the behavior of `stream=True` for an openai chat endpoint.
"""
import asyncio
loop = asyncio.new_event_loop()
import guidance
guidance.llm = guidance.llms.OpenAI("gpt-3.5-turbo", caching=False)
async def f():
chat = guidance("""<|im_start|>system
You are a helpful assistent.
<|im_end|>
<|im_start|>user
{{command}}
<|im_end|>
<|im_start|>assistant
{{gen 'answer' max_tokens=10}}""", stream=True)
out = await chat(command="How do I create a Fasttokenizer with hugging face auto?-b")
assert len(out["answer"]) > 0
loop.run_until_complete(f()) | [] |
2024-01-10 | jasondotparse/guidance | tests~library~test_geneach.py | import guidance
def test_geneach():
""" Test a geneach loop.
"""
llm = guidance.llms.OpenAI("text-curie-001")
prompt = guidance('''<instructions>Generate a list of three names</instructions>
<list>{{#geneach 'names' stop="</list>"}}
<item index="{{@index}}">{{gen 'this'}}</item>{{/geneach}}</list>"''', llm=llm)
out = prompt()
assert len(out["names"]) == 3
| [
"<instructions>Generate a list of three names</instructions>\n<list>{{#geneach 'names' stop=\"</list>\"}}\n<item index=\"{{@index}}\">{{gen 'this'}}</item>{{/geneach}}</list>\""
] |
2024-01-10 | ZeroDeath2/Customate | text-to-speech.py | import asyncio
import websockets
import json
import openai
import base64
import shutil
import os
import subprocess
# Define API keys and voice ID
OPENAI_API_KEY = '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'
ELEVENLABS_API_KEY = '55ae157db19cd5ad2ac8c3cc24132c32'
VOICE_ID = '21m00Tcm4TlvDq8ikWAM'
# Set OpenAI API key
openai.api_key = OPENAI_API_KEY
def is_installed(lib_name):
return shutil.which(lib_name) is not None
async def text_chunker(chunks):
"""Split text into chunks, ensuring to not break sentences."""
splitters = (".", ",", "?", "!", ";", ":", "—", "-", "(", ")", "[", "]", "}", " ")
buffer = ""
async for text in chunks:
if buffer.endswith(splitters):
yield buffer + " "
buffer = text
elif text.startswith(splitters):
yield buffer + text[0] + " "
buffer = text[1:]
else:
buffer += text
if buffer:
yield buffer + " "
async def stream(audio_stream):
"""Stream audio data using mpv player."""
if not is_installed("mpv"):
raise ValueError(
"mpv not found, necessary to stream audio. "
"Install instructions: https://mpv.io/installation/"
)
mpv_process = subprocess.Popen(
["mpv", "--no-cache", "--no-terminal", "--", "fd://0"],
stdin=subprocess.PIPE, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
)
print("Started streaming audio")
async for chunk in audio_stream:
if chunk:
mpv_process.stdin.write(chunk)
mpv_process.stdin.flush()
if mpv_process.stdin:
mpv_process.stdin.close()
mpv_process.wait()
async def text_to_speech_input_streaming(voice_id, text_iterator):
"""Send text to ElevenLabs API and stream the returned audio."""
uri = f"wss://api.elevenlabs.io/v1/text-to-speech/{voice_id}/stream-input?model_id=eleven_monolingual_v1"
async with websockets.connect(uri) as websocket:
await websocket.send(json.dumps({
"text": " ",
"voice_settings": {"stability": 0.5, "similarity_boost": True},
"xi_api_key": ELEVENLABS_API_KEY,
}))
async def listen():
"""Listen to the websocket for audio data and stream it."""
while True:
try:
message = await websocket.recv()
data = json.loads(message)
if data.get("audio"):
yield base64.b64decode(data["audio"])
elif data.get('isFinal'):
break
except websockets.exceptions.ConnectionClosed:
print("Connection closed")
break
listen_task = asyncio.create_task(stream(listen()))
async for text in text_chunker(text_iterator):
await websocket.send(json.dumps({"text": text, "try_trigger_generation": True}))
await websocket.send(json.dumps({"text": ""}))
await listen_task
async def chat_completion(query):
"""Retrieve text from OpenAI and pass it to the text-to-speech function."""
response = await openai.ChatCompletion.acreate(
model='gpt-3.5-turbo', messages=[{'role': 'user', 'content': query}],
temperature=1, stream=True
)
async def text_iterator():
async for chunk in response:
delta = chunk['choices'][0]["delta"]
if 'content' in delta:
yield delta["content"]
else:
break
await text_to_speech_input_streaming(VOICE_ID, text_iterator())
def main():
user_query = "Hello, tell me a story in 20 words."
asyncio.run(chat_completion(user_query))
main()
| [] |
2024-01-10 | ZeroDeath2/Customate | tts.py | import asyncio
import websockets
import json
import openai
import base64
import shutil
import os
import subprocess
# Define API keys and voice ID
OPENAI_API_KEY = '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'
ELEVENLABS_API_KEY = 'a67ccac97e3225c39b7e6a444f68357d'
VOICE_ID = '21m00Tcm4TlvDq8ikWAM'
# Set OpenAI API key
openai.api_key = OPENAI_API_KEY
def is_installed(lib_name):
return shutil.which(lib_name) is not None
async def text_chunker(chunks):
"""Split text into chunks, ensuring to not break sentences."""
splitters = (".", ",", "?", "!", ";", ":", "—", "-", "(", ")", "[", "]", "}", " ")
buffer = ""
async for text in chunks:
if buffer.endswith(splitters):
yield buffer + " "
buffer = text
elif text.startswith(splitters):
yield buffer + text[0] + " "
buffer = text[1:]
else:
buffer += text
if buffer:
yield buffer + " "
async def stream(audio_stream):
"""Stream audio data using mpv player."""
if not is_installed("mpv"):
raise ValueError(
"mpv not found, necessary to stream audio. "
"Install instructions: https://mpv.io/installation/"
)
mpv_process = subprocess.Popen(
["mpv", "--no-cache", "--no-terminal", "--", "fd://0"],
stdin=subprocess.PIPE, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
)
print("Started streaming audio")
async for chunk in audio_stream:
if chunk:
mpv_process.stdin.write(chunk)
mpv_process.stdin.flush()
if mpv_process.stdin:
mpv_process.stdin.close()
mpv_process.wait()
async def text_to_speech_input_streaming(voice_id, text_iterator):
"""Send text to ElevenLabs API and stream the returned audio."""
uri = f"wss://api.elevenlabs.io/v1/text-to-speech/{voice_id}/stream-input?model_id=eleven_monolingual_v1"
async with websockets.connect(uri) as websocket:
await websocket.send(json.dumps({
"text": " ",
"voice_settings": {"stability": 0.5, "similarity_boost": True},
"xi_api_key": ELEVENLABS_API_KEY,
}))
async def listen():
"""Listen to the websocket for audio data and stream it."""
while True:
try:
message = await websocket.recv()
data = json.loads(message)
if data.get("audio"):
yield base64.b64decode(data["audio"])
elif data.get('isFinal'):
break
except websockets.exceptions.ConnectionClosed:
print("Connection closed")
break
listen_task = asyncio.create_task(stream(listen()))
async for text in text_chunker(text_iterator):
await websocket.send(json.dumps({"text": text, "try_trigger_generation": True}))
await websocket.send(json.dumps({"text": ""}))
await listen_task
async def chat_completion(query):
"""Retrieve text from OpenAI and pass it to the text-to-speech function."""
response = await openai.ChatCompletion.acreate(
model='gpt-3.5-turbo',
max_tokens=150,
messages=[
{'role': 'user', 'content': query}
],
temperature=1, stream=True
)
async def text_iterator():
async for chunk in response:
delta = chunk['choices'][0]["delta"]
if 'content' in delta:
yield delta["content"]
else:
break
await text_to_speech_input_streaming(VOICE_ID, text_iterator())
def main(user_query):
asyncio.run(chat_completion(user_query))
| [] |
2024-01-10 | ARBML/whisperar | run_speech_recognition_seq2seq.py | #!/usr/bin/env python
# coding=utf-8
# Copyright 2022 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
Fine-tuning the library models for sequence to sequence speech recognition.
"""
# You can also adapt this script for your own sequence to sequence speech
# recognition task. Pointers for this are left as comments.
import logging
import os
import sys
from dataclasses import dataclass, field
from typing import Any, Dict, List, Optional, Union
import datasets
import torch
from datasets import IterableDatasetDict, interleave_datasets, load_dataset
from torch.utils.data import IterableDataset
import evaluate
import transformers
from transformers import (
AutoConfig,
AutoFeatureExtractor,
AutoModelForSpeechSeq2Seq,
AutoProcessor,
AutoTokenizer,
HfArgumentParser,
Seq2SeqTrainer,
Seq2SeqTrainingArguments,
TrainerCallback,
set_seed,
)
from transformers.trainer_pt_utils import IterableDatasetShard
from transformers.trainer_utils import get_last_checkpoint, is_main_process
from transformers.utils import check_min_version, send_example_telemetry
from transformers.utils.versions import require_version
from transformers.models.whisper.english_normalizer import BasicTextNormalizer
import os
os.environ['LD_LIBRARY_PATH'] = '/usr/lib/x86_64-linux-gnu'
# Will error if the minimal version of Transformers is not installed. Remove at your own risks.
check_min_version("4.25.0.dev0")
require_version("datasets>=1.18.2", "To fix: pip install -r examples/pytorch/speech-recognition/requirements.txt")
logger = logging.getLogger(__name__)
@dataclass
class ModelArguments:
"""
Arguments pertaining to which model/config/tokenizer we are going to fine-tune from.
"""
model_name_or_path: str = field(
metadata={"help": "Path to pretrained model or model identifier from huggingface.co/models"}
)
config_name: Optional[str] = field(
default=None, metadata={"help": "Pretrained config name or path if not the same as model_name"}
)
tokenizer_name: Optional[str] = field(
default=None, metadata={"help": "Pretrained tokenizer name or path if not the same as model_name"}
)
feature_extractor_name: Optional[str] = field(
default=None, metadata={"help": "feature extractor name or path if not the same as model_name"}
)
cache_dir: Optional[str] = field(
default=None,
metadata={"help": "Where to store the pretrained models downloaded from huggingface.co"},
)
use_fast_tokenizer: bool = field(
default=True,
metadata={"help": "Whether to use one of the fast tokenizer (backed by the tokenizers library) or not."},
)
model_revision: str = field(
default="main",
metadata={"help": "The specific model version to use (can be a branch name, tag name or commit id)."},
)
use_auth_token: bool = field(
default=False,
metadata={
"help": (
"Will use the token generated when running `huggingface-cli login` (necessary to use this script "
"with private models)."
)
},
)
freeze_feature_encoder: bool = field(
default=True, metadata={"help": "Whether to freeze the feature encoder layers of the model."}
)
freeze_encoder: bool = field(
default=False, metadata={"help": "Whether to freeze the entire encoder of the seq2seq model."}
)
forced_decoder_ids: List[List[int]] = field(
default=None,
metadata={
"help": (
"A list of pairs of integers which indicates a mapping from generation indices to token indices "
"that will be forced before sampling. For example, [[0, 123]] means the first generated token "
"will always be a token of index 123."
)
},
)
suppress_tokens: List[int] = field(
default=None, metadata={"help": "A list of tokens that will be suppressed at generation."}
)
model_index_name: str = field(default=None, metadata={"help": "Pretty name for the model card."})
@dataclass
class DataTrainingArguments:
"""
Arguments pertaining to what data we are going to input our model for training and eval.
"""
dataset_name: str = field(
default=None, metadata={"help": "The name of the dataset to use (via the datasets library)."}
)
dataset_config_name: Optional[str] = field(
default=None, metadata={"help": "The configuration name of the dataset to use (via the datasets library)."}
)
text_column: Optional[str] = field(
default=None,
metadata={"help": "The name of the column in the datasets containing the full texts (for summarization)."},
)
max_train_samples: Optional[int] = field(
default=None,
metadata={
"help": (
"For debugging purposes or quicker training, truncate the number of training examples to this "
"value if set."
)
},
)
max_eval_samples: Optional[int] = field(
default=None,
metadata={
"help": (
"For debugging purposes or quicker training, truncate the number of evaluation examples to this "
"value if set."
)
},
)
audio_column_name: str = field(
default="audio",
metadata={"help": "The name of the dataset column containing the audio data. Defaults to 'audio'"},
)
text_column_name: str = field(
default="text",
metadata={"help": "The name of the dataset column containing the text data. Defaults to 'text'"},
)
max_duration_in_seconds: float = field(
default=20.0,
metadata={
"help": (
"Truncate audio files that are longer than `max_duration_in_seconds` seconds to"
" 'max_duration_in_seconds`"
)
},
)
min_duration_in_seconds: float = field(
default=0.0, metadata={"help": "Filter audio files that are shorter than `min_duration_in_seconds` seconds"}
)
train_split_name: str = field(
default="train",
metadata={
"help": "The name of the training data set split to use (via the datasets library). Defaults to 'train'"
},
)
eval_split_name: str = field(
default="test",
metadata={
"help": "The name of the training data set split to use (via the datasets library). Defaults to 'train'"
},
)
do_lower_case: bool = field(
default=False,
metadata={"help": "Whether the target text should be lower cased."},
)
do_remove_punctuation: bool = field(
default=False,
metadata={"help": "Whether the target text should be striped of punctuation."},
)
do_normalize_eval: bool = field(
default=True,
metadata={"help": "Whether to normalise the references and predictions in the eval WER calculation."},
)
language: str = field(
default=None,
metadata={
"help": (
"Language for multilingual fine-tuning. This argument should be set for multilingual fine-tuning "
"only. For English speech recognition, it should be set to `None`."
)
},
)
task: str = field(
default="transcribe",
metadata={"help": "Task, either `transcribe` for speech recognition or `translate` for speech translation."},
)
shuffle_buffer_size: Optional[int] = field(
default=500,
metadata={
"help": (
"The number of streamed examples to download before shuffling them. The large the buffer, "
"the closer it is to real offline shuffling."
)
},
)
@dataclass
class DataCollatorSpeechSeq2SeqWithPadding:
"""
Data collator that will dynamically pad the inputs received.
Args:
processor ([`WhisperProcessor`])
The processor used for processing the data.
decoder_start_token_id (`int`)
The begin-of-sentence of the decoder.
"""
processor: Any
decoder_start_token_id: int
def __call__(self, features: List[Dict[str, Union[List[int], torch.Tensor]]]) -> Dict[str, torch.Tensor]:
# split inputs and labels since they have to be of different lengths and need
# different padding methods
model_input_name = self.processor.model_input_names[0]
input_features = [{model_input_name: feature[model_input_name]} for feature in features]
label_features = [{"input_ids": feature["labels"]} for feature in features]
batch = self.processor.feature_extractor.pad(input_features, return_tensors="pt")
labels_batch = self.processor.tokenizer.pad(label_features, return_tensors="pt")
# replace padding with -100 to ignore loss correctly
labels = labels_batch["input_ids"].masked_fill(labels_batch.attention_mask.ne(1), -100)
# if bos token is appended in previous tokenization step,
# cut bos token here as it's append later anyways
if (labels[:, 0] == self.decoder_start_token_id).all().cpu().item():
labels = labels[:, 1:]
batch["labels"] = labels
return batch
def load_datasets(dataset_name, dataset_config_name, split="train", **kwargs):
"""
Utility function to load a dataset in streaming mode. For datasets with multiple splits,
each split is loaded individually and then splits combined by taking alternating examples from
each (interleaving).
"""
if "+" in split:
# load multiple splits separated by the `+` symbol with streaming mode
dataset_splits = [
load_dataset(dataset_name, dataset_config_name, split=split_name, **kwargs)
for split_name in split.split("+")
]
# interleave multiple splits to form one dataset
interleaved_dataset = interleave_datasets(dataset_splits)
return interleaved_dataset
else:
# load a single split *with* streaming mode
dataset = load_dataset(dataset_name, dataset_config_name, split=split, **kwargs)
return dataset
def main():
# 1. Parse input arguments
# See all possible arguments in src/transformers/training_args.py
# or by passing the --help flag to this script.
# We now keep distinct sets of args, for a cleaner separation of concerns.
parser = HfArgumentParser((ModelArguments, DataTrainingArguments, Seq2SeqTrainingArguments))
if len(sys.argv) == 2 and sys.argv[1].endswith(".json"):
# If we pass only one argument to the script and it's the path to a json file,
# let's parse it to get our arguments.
model_args, data_args, training_args = parser.parse_json_file(json_file=os.path.abspath(sys.argv[1]))
else:
model_args, data_args, training_args = parser.parse_args_into_dataclasses()
# Sending telemetry. Tracking the example usage helps us better allocate resources to maintain them. The
# information sent is the one passed as arguments along with your Python/PyTorch versions.
send_example_telemetry("run_speech_recognition_seq2seq", model_args, data_args)
# 2. Setup logging
logging.basicConfig(
format="%(asctime)s - %(levelname)s - %(name)s - %(message)s",
datefmt="%m/%d/%Y %H:%M:%S",
handlers=[logging.StreamHandler(sys.stdout)],
)
log_level = training_args.get_process_log_level()
logger.setLevel(log_level)
datasets.utils.logging.set_verbosity(log_level)
transformers.utils.logging.set_verbosity(log_level)
transformers.utils.logging.enable_default_handler()
transformers.utils.logging.enable_explicit_format()
logger.setLevel(logging.INFO if is_main_process(training_args.local_rank) else logging.WARN)
# Log on each process the small summary:
logger.warning(
f"Process rank: {training_args.local_rank}, device: {training_args.device}, n_gpu: {training_args.n_gpu}"
f"distributed training: {bool(training_args.local_rank != -1)}, 16-bits training: {training_args.fp16}"
)
logger.info(f"Training/evaluation parameters {training_args}")
# Set the verbosity to info of the Transformers logger (on main process only):
if is_main_process(training_args.local_rank):
transformers.utils.logging.set_verbosity_info()
logger.info("Training/evaluation parameters %s", training_args)
# 3. Detecting last checkpoint and eventually continue from last checkpoint
last_checkpoint = None
if os.path.isdir(training_args.output_dir) and training_args.do_train and not training_args.overwrite_output_dir:
last_checkpoint = get_last_checkpoint(training_args.output_dir)
if last_checkpoint is None and len(os.listdir(training_args.output_dir)) > 0:
raise ValueError(
f"Output directory ({training_args.output_dir}) already exists and is not empty. "
"Use --overwrite_output_dir to overcome."
)
elif last_checkpoint is not None and training_args.resume_from_checkpoint is None:
logger.info(
f"Checkpoint detected, resuming training at {last_checkpoint}. To avoid this behavior, change "
"the `--output_dir` or add `--overwrite_output_dir` to train from scratch."
)
# Set seed before initializing model.
set_seed(training_args.seed)
# 4. Load dataset
raw_datasets = IterableDatasetDict()
if training_args.do_train:
raw_datasets["train"] = load_datasets(
data_args.dataset_name,
data_args.dataset_config_name,
split=data_args.train_split_name,
use_auth_token=True if model_args.use_auth_token else None,
)
if training_args.do_eval:
raw_datasets["eval"] = load_datasets(
data_args.dataset_name,
data_args.dataset_config_name,
split=data_args.eval_split_name,
use_auth_token=True if model_args.use_auth_token else None,
)
raw_datasets_features = list(next(iter(raw_datasets.values())).features.keys())
if data_args.audio_column_name not in raw_datasets_features:
raise ValueError(
f"--audio_column_name '{data_args.audio_column_name}' not found in dataset '{data_args.dataset_name}'. "
"Make sure to set `--audio_column_name` to the correct audio column - one of "
f"{', '.join(raw_datasets_features)}."
)
if data_args.text_column_name not in raw_datasets_features:
raise ValueError(
f"--text_column_name {data_args.text_column_name} not found in dataset '{data_args.dataset_name}'. "
"Make sure to set `--text_column_name` to the correct text column - one of "
f"{', '.join(raw_datasets_features)}."
)
# 5. Load pretrained model, tokenizer, and feature extractor
#
# Distributed training:
# The .from_pretrained methods guarantee that only one local process can concurrently
config = AutoConfig.from_pretrained(
model_args.config_name if model_args.config_name else model_args.model_name_or_path,
cache_dir=model_args.cache_dir,
revision=model_args.model_revision,
use_auth_token=True if model_args.use_auth_token else None,
)
config.update({"forced_decoder_ids": model_args.forced_decoder_ids, "suppress_tokens": model_args.suppress_tokens})
feature_extractor = AutoFeatureExtractor.from_pretrained(
model_args.feature_extractor_name if model_args.feature_extractor_name else model_args.model_name_or_path,
cache_dir=model_args.cache_dir,
revision=model_args.model_revision,
use_auth_token=True if model_args.use_auth_token else None,
)
tokenizer = AutoTokenizer.from_pretrained(
model_args.tokenizer_name if model_args.tokenizer_name else model_args.model_name_or_path,
cache_dir=model_args.cache_dir,
use_fast=model_args.use_fast_tokenizer,
revision=model_args.model_revision,
use_auth_token=True if model_args.use_auth_token else None,
)
model = AutoModelForSpeechSeq2Seq.from_pretrained(
model_args.model_name_or_path,
config=config,
cache_dir=model_args.cache_dir,
revision=model_args.model_revision,
use_auth_token=True if model_args.use_auth_token else None,
)
model.config.use_cache = False
if model.config.decoder_start_token_id is None:
raise ValueError("Make sure that `config.decoder_start_token_id` is correctly defined")
if model_args.freeze_feature_encoder:
model.freeze_feature_encoder()
if model_args.freeze_encoder:
model.freeze_encoder()
model.model.encoder.gradient_checkpointing = False
if data_args.language is not None:
# We only need to set the task id when the language is specified (i.e. in a multilingual setting)
tokenizer.set_prefix_tokens(language=data_args.language, task=data_args.task)
# 6. Resample speech dataset if necessary
dataset_sampling_rate = next(iter(raw_datasets.values())).features[data_args.audio_column_name].sampling_rate
if dataset_sampling_rate != feature_extractor.sampling_rate:
raw_datasets = raw_datasets.cast_column(
data_args.audio_column_name, datasets.features.Audio(sampling_rate=feature_extractor.sampling_rate)
)
# 7. Preprocessing the datasets.
# We need to read the audio files as arrays and tokenize the targets.
max_input_length = data_args.max_duration_in_seconds * feature_extractor.sampling_rate
min_input_length = data_args.min_duration_in_seconds * feature_extractor.sampling_rate
audio_column_name = data_args.audio_column_name
text_column_name = data_args.text_column_name
model_input_name = feature_extractor.model_input_names[0]
do_lower_case = data_args.do_lower_case
do_remove_punctuation = data_args.do_remove_punctuation
normalizer = BasicTextNormalizer() # 'official' text normalizer from OpenAI
if data_args.max_train_samples is not None:
raw_datasets["train"] = raw_datasets["train"].select(range(data_args.max_train_samples))
if data_args.max_eval_samples is not None:
raw_datasets["eval"] = raw_datasets["eval"].select(range(data_args.max_eval_samples))
def prepare_dataset(batch):
# process audio
sample = batch[audio_column_name]
inputs = feature_extractor(sample["array"], sampling_rate=sample["sampling_rate"])
# process audio length
batch[model_input_name] = inputs.get(model_input_name)[0]
batch["input_length"] = len(sample["array"])
# process targets
input_str = batch[text_column_name].lower() if do_lower_case else batch[text_column_name]
if do_remove_punctuation:
input_str = normalizer(input_str).strip()
batch["labels"] = tokenizer(input_str).input_ids
return batch
with training_args.main_process_first(desc="dataset map pre-processing"):
vectorized_datasets = raw_datasets.map(
prepare_dataset,
remove_columns=raw_datasets_features,
).with_format("torch")
if training_args.do_train:
vectorized_datasets["train"] = vectorized_datasets["train"].shuffle(
# buffer_size=data_args.shuffle_buffer_size,
seed=training_args.seed,
)
# filter training data that is shorter than min_input_length or longer than
# max_input_length
def is_audio_in_length_range(length):
return min_input_length < length < max_input_length
vectorized_datasets["train"] = vectorized_datasets["train"].filter(
is_audio_in_length_range,
input_columns=["input_length"],
)
# 8. Load Metric
metric = evaluate.load("wer")
do_normalize_eval = data_args.do_normalize_eval
def compute_metrics(pred):
pred_ids = pred.predictions
pred.label_ids[pred.label_ids == -100] = tokenizer.pad_token_id
pred_str = tokenizer.batch_decode(pred_ids, skip_special_tokens=True)
# we do not want to group tokens when computing the metrics
label_str = tokenizer.batch_decode(pred.label_ids, skip_special_tokens=True)
if do_normalize_eval:
pred_str = [normalizer(pred) for pred in pred_str]
label_str = [normalizer(label) for label in label_str]
wer = 100 * metric.compute(predictions=pred_str, references=label_str)
return {"wer": wer}
# 9. Create a single speech processor
if is_main_process(training_args.local_rank):
# save feature extractor, tokenizer and config
feature_extractor.save_pretrained(training_args.output_dir)
tokenizer.save_pretrained(training_args.output_dir)
config.save_pretrained(training_args.output_dir)
processor = AutoProcessor.from_pretrained(training_args.output_dir)
# 10. Define data collator
data_collator = DataCollatorSpeechSeq2SeqWithPadding(
processor=processor,
decoder_start_token_id=model.config.decoder_start_token_id,
)
# 11. Configure Trainer
# Trainer callback to reinitialise and reshuffle the streamable datasets at the beginning of each epoch
class ShuffleCallback(TrainerCallback):
def on_epoch_begin(self, args, state, control, train_dataloader, **kwargs):
if isinstance(train_dataloader.dataset, IterableDatasetShard):
pass # set_epoch() is handled by the Trainer
elif isinstance(train_dataloader.dataset, IterableDataset):
train_dataloader.dataset.set_epoch(train_dataloader.dataset._epoch + 1)
# Initialize Trainer
trainer = Seq2SeqTrainer(
model=model,
args=training_args,
train_dataset=vectorized_datasets["train"] if training_args.do_train else None,
eval_dataset=vectorized_datasets["eval"] if training_args.do_eval else None,
tokenizer=feature_extractor,
data_collator=data_collator,
compute_metrics=compute_metrics if training_args.predict_with_generate else None,
callbacks=[ShuffleCallback()],
)
# 12. Training
if training_args.do_train:
checkpoint = None
if training_args.resume_from_checkpoint is not None:
checkpoint = training_args.resume_from_checkpoint
elif last_checkpoint is not None:
checkpoint = last_checkpoint
train_result = trainer.train(resume_from_checkpoint=checkpoint)
trainer.save_model() # Saves the feature extractor too for easy upload
metrics = train_result.metrics
if data_args.max_train_samples:
metrics["train_samples"] = data_args.max_train_samples
trainer.log_metrics("train", metrics)
trainer.save_metrics("train", metrics)
trainer.save_state()
# 13. Evaluation
results = {}
if training_args.do_eval:
logger.info("*** Evaluate ***")
metrics = trainer.evaluate(
metric_key_prefix="eval",
max_length=training_args.generation_max_length,
num_beams=training_args.generation_num_beams,
)
if data_args.max_eval_samples:
metrics["eval_samples"] = data_args.max_eval_samples
trainer.log_metrics("eval", metrics)
trainer.save_metrics("eval", metrics)
# 14. Write Training Stats
kwargs = {
"finetuned_from": model_args.model_name_or_path,
"tasks": "automatic-speech-recognition",
"tags": "whisper-event",
}
if data_args.dataset_name is not None:
kwargs["dataset_tags"] = data_args.dataset_name
if data_args.dataset_config_name is not None:
kwargs["dataset"] = f"{data_args.dataset_name} {data_args.dataset_config_name}"
else:
kwargs["dataset"] = data_args.dataset_name
if "common_voice" in data_args.dataset_name:
kwargs["language"] = data_args.dataset_config_name
if model_args.model_index_name is not None:
kwargs["model_name"] = model_args.model_index_name
if training_args.push_to_hub:
trainer.push_to_hub(**kwargs)
else:
trainer.create_model_card(**kwargs)
return results
if __name__ == "__main__":
main()
| [] |
2024-01-10 | ARBML/whisperar | run_speech_recognition_seq2seq_streaming.py | #!/usr/bin/env python
# coding=utf-8
# Copyright 2022 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
Fine-tuning the library models for sequence to sequence speech recognition
with 🤗 Datasets' streaming mode.
"""
# You can also adapt this script for your own sequence to sequence speech
# recognition task. Pointers for this are left as comments.
import logging
import os
import sys
from dataclasses import dataclass, field
from typing import Any, Dict, List, Optional, Union
import datasets
import torch
from datasets import IterableDatasetDict, interleave_datasets, load_dataset
from torch.utils.data import IterableDataset
import evaluate
import transformers
from transformers import (
AutoConfig,
AutoFeatureExtractor,
AutoModelForSpeechSeq2Seq,
AutoProcessor,
AutoTokenizer,
HfArgumentParser,
Seq2SeqTrainer,
Seq2SeqTrainingArguments,
TrainerCallback,
set_seed,
)
from transformers.trainer_pt_utils import IterableDatasetShard
from transformers.trainer_utils import get_last_checkpoint, is_main_process
from transformers.utils import check_min_version, send_example_telemetry
from transformers.utils.versions import require_version
from transformers.models.whisper.english_normalizer import BasicTextNormalizer
import os
os.environ['LD_LIBRARY_PATH'] = '/usr/lib/x86_64-linux-gnu'
# Will error if the minimal version of Transformers is not installed. Remove at your own risks.
check_min_version("4.25.0.dev0")
require_version("datasets>=1.18.2", "To fix: pip install -r examples/pytorch/speech-recognition/requirements.txt")
logger = logging.getLogger(__name__)
@dataclass
class ModelArguments:
"""
Arguments pertaining to which model/config/tokenizer we are going to fine-tune from.
"""
model_name_or_path: str = field(
metadata={"help": "Path to pretrained model or model identifier from huggingface.co/models"}
)
config_name: Optional[str] = field(
default=None, metadata={"help": "Pretrained config name or path if not the same as model_name"}
)
tokenizer_name: Optional[str] = field(
default=None, metadata={"help": "Pretrained tokenizer name or path if not the same as model_name"}
)
feature_extractor_name: Optional[str] = field(
default=None, metadata={"help": "feature extractor name or path if not the same as model_name"}
)
cache_dir: Optional[str] = field(
default=None,
metadata={"help": "Where to store the pretrained models downloaded from huggingface.co"},
)
use_fast_tokenizer: bool = field(
default=True,
metadata={"help": "Whether to use one of the fast tokenizer (backed by the tokenizers library) or not."},
)
model_revision: str = field(
default="main",
metadata={"help": "The specific model version to use (can be a branch name, tag name or commit id)."},
)
use_auth_token: bool = field(
default=False,
metadata={
"help": (
"Will use the token generated when running `huggingface-cli login` (necessary to use this script "
"with private models)."
)
},
)
freeze_feature_encoder: bool = field(
default=True, metadata={"help": "Whether to freeze the feature encoder layers of the model."}
)
freeze_encoder: bool = field(
default=False, metadata={"help": "Whether to freeze the entire encoder of the seq2seq model."}
)
forced_decoder_ids: List[List[int]] = field(
default=None,
metadata={
"help": (
"A list of pairs of integers which indicates a mapping from generation indices to token indices "
"that will be forced before sampling. For example, [[0, 123]] means the first generated token "
"will always be a token of index 123."
)
},
)
suppress_tokens: List[int] = field(
default=None, metadata={"help": "A list of tokens that will be suppressed at generation."}
)
model_index_name: str = field(default=None, metadata={"help": "Pretty name for the model card."})
@dataclass
class DataTrainingArguments:
"""
Arguments pertaining to what data we are going to input our model for training and eval.
"""
dataset_name: str = field(
default=None, metadata={"help": "The name of the dataset to use (via the datasets library)."}
)
dataset_config_name: Optional[str] = field(
default=None, metadata={"help": "The configuration name of the dataset to use (via the datasets library)."}
)
text_column: Optional[str] = field(
default=None,
metadata={"help": "The name of the column in the datasets containing the full texts (for summarization)."},
)
max_train_samples: Optional[int] = field(
default=None,
metadata={
"help": (
"For debugging purposes or quicker training, truncate the number of training examples to this "
"value if set."
)
},
)
max_eval_samples: Optional[int] = field(
default=None,
metadata={
"help": (
"For debugging purposes or quicker training, truncate the number of evaluation examples to this "
"value if set."
)
},
)
audio_column_name: str = field(
default="audio",
metadata={"help": "The name of the dataset column containing the audio data. Defaults to 'audio'"},
)
text_column_name: str = field(
default="text",
metadata={"help": "The name of the dataset column containing the text data. Defaults to 'text'"},
)
max_duration_in_seconds: float = field(
default=20.0,
metadata={
"help": (
"Truncate audio files that are longer than `max_duration_in_seconds` seconds to"
" 'max_duration_in_seconds`"
)
},
)
min_duration_in_seconds: float = field(
default=0.0, metadata={"help": "Filter audio files that are shorter than `min_duration_in_seconds` seconds"}
)
train_split_name: str = field(
default="train",
metadata={
"help": "The name of the training data set split to use (via the datasets library). Defaults to 'train'"
},
)
eval_split_name: str = field(
default="test",
metadata={
"help": "The name of the training data set split to use (via the datasets library). Defaults to 'train'"
},
)
do_lower_case: bool = field(
default=False,
metadata={"help": "Whether the target text should be lower cased."},
)
do_remove_punctuation: bool = field(
default=False,
metadata={"help": "Whether the target text should be striped of punctuation."},
)
do_normalize_eval: bool = field(
default=True,
metadata={"help": "Whether to normalise the references and predictions in the eval WER calculation."},
)
language: str = field(
default=None,
metadata={
"help": (
"Language for multilingual fine-tuning. This argument should be set for multilingual fine-tuning "
"only. For English speech recognition, it should be set to `None`."
)
},
)
task: str = field(
default="transcribe",
metadata={"help": "Task, either `transcribe` for speech recognition or `translate` for speech translation."},
)
shuffle_buffer_size: Optional[int] = field(
default=500,
metadata={
"help": (
"The number of streamed examples to download before shuffling them. The large the buffer, "
"the closer it is to real offline shuffling."
)
},
)
@dataclass
class DataCollatorSpeechSeq2SeqWithPadding:
"""
Data collator that will dynamically pad the inputs received.
Args:
processor ([`WhisperProcessor`])
The processor used for processing the data.
decoder_start_token_id (`int`)
The begin-of-sentence of the decoder.
"""
processor: Any
decoder_start_token_id: int
def __call__(self, features: List[Dict[str, Union[List[int], torch.Tensor]]]) -> Dict[str, torch.Tensor]:
# split inputs and labels since they have to be of different lengths and need
# different padding methods
model_input_name = self.processor.model_input_names[0]
input_features = [{model_input_name: feature[model_input_name]} for feature in features]
label_features = [{"input_ids": feature["labels"]} for feature in features]
batch = self.processor.feature_extractor.pad(input_features, return_tensors="pt")
labels_batch = self.processor.tokenizer.pad(label_features, return_tensors="pt")
# replace padding with -100 to ignore loss correctly
labels = labels_batch["input_ids"].masked_fill(labels_batch.attention_mask.ne(1), -100)
# if bos token is appended in previous tokenization step,
# cut bos token here as it's append later anyways
if (labels[:, 0] == self.decoder_start_token_id).all().cpu().item():
labels = labels[:, 1:]
batch["labels"] = labels
return batch
def load_streaming_dataset(dataset_name, dataset_config_name, split="train", **kwargs):
"""
Utility function to load a dataset in streaming mode. For datasets with multiple splits,
each split is loaded individually and then splits combined by taking alternating examples from
each (interleaving).
"""
if "+" in split:
# load multiple splits separated by the `+` symbol with streaming mode
dataset_splits = [
load_dataset(dataset_name, dataset_config_name, split=split_name, streaming=True, **kwargs)
for split_name in split.split("+")
]
# interleave multiple splits to form one dataset
interleaved_dataset = interleave_datasets(dataset_splits)
return interleaved_dataset
else:
# load a single split *with* streaming mode
dataset = load_dataset(dataset_name, dataset_config_name, split=split, streaming=True, **kwargs)
return dataset
def main():
# 1. Parse input arguments
# See all possible arguments in src/transformers/training_args.py
# or by passing the --help flag to this script.
# We now keep distinct sets of args, for a cleaner separation of concerns.
parser = HfArgumentParser((ModelArguments, DataTrainingArguments, Seq2SeqTrainingArguments))
if len(sys.argv) == 2 and sys.argv[1].endswith(".json"):
# If we pass only one argument to the script and it's the path to a json file,
# let's parse it to get our arguments.
model_args, data_args, training_args = parser.parse_json_file(json_file=os.path.abspath(sys.argv[1]))
else:
model_args, data_args, training_args = parser.parse_args_into_dataclasses()
# Sending telemetry. Tracking the example usage helps us better allocate resources to maintain them. The
# information sent is the one passed as arguments along with your Python/PyTorch versions.
send_example_telemetry("run_speech_recognition_seq2seq_streaming", model_args, data_args)
# 2. Setup logging
logging.basicConfig(
format="%(asctime)s - %(levelname)s - %(name)s - %(message)s",
datefmt="%m/%d/%Y %H:%M:%S",
handlers=[logging.StreamHandler(sys.stdout)],
)
log_level = training_args.get_process_log_level()
logger.setLevel(log_level)
datasets.utils.logging.set_verbosity(log_level)
transformers.utils.logging.set_verbosity(log_level)
transformers.utils.logging.enable_default_handler()
transformers.utils.logging.enable_explicit_format()
logger.setLevel(logging.INFO if is_main_process(training_args.local_rank) else logging.WARN)
# Log on each process the small summary:
logger.warning(
f"Process rank: {training_args.local_rank}, device: {training_args.device}, n_gpu: {training_args.n_gpu}"
f"distributed training: {bool(training_args.local_rank != -1)}, 16-bits training: {training_args.fp16}"
)
logger.info(f"Training/evaluation parameters {training_args}")
# Set the verbosity to info of the Transformers logger (on main process only):
if is_main_process(training_args.local_rank):
transformers.utils.logging.set_verbosity_info()
logger.info("Training/evaluation parameters %s", training_args)
# 3. Detecting last checkpoint and eventually continue from last checkpoint
last_checkpoint = None
if os.path.isdir(training_args.output_dir) and training_args.do_train and not training_args.overwrite_output_dir:
last_checkpoint = get_last_checkpoint(training_args.output_dir)
if last_checkpoint is None and len(os.listdir(training_args.output_dir)) > 0:
raise ValueError(
f"Output directory ({training_args.output_dir}) already exists and is not empty. "
"Use --overwrite_output_dir to overcome."
)
elif last_checkpoint is not None and training_args.resume_from_checkpoint is None:
logger.info(
f"Checkpoint detected, resuming training at {last_checkpoint}. To avoid this behavior, change "
"the `--output_dir` or add `--overwrite_output_dir` to train from scratch."
)
# Set seed before initializing model.
set_seed(training_args.seed)
# 4. Load dataset
raw_datasets = IterableDatasetDict()
if training_args.do_train:
raw_datasets["train"] = load_streaming_dataset(
data_args.dataset_name,
data_args.dataset_config_name,
split=data_args.train_split_name,
use_auth_token=True if model_args.use_auth_token else None,
)
if training_args.do_eval:
raw_datasets["eval"] = load_streaming_dataset(
data_args.dataset_name,
data_args.dataset_config_name,
split=data_args.eval_split_name,
use_auth_token=True if model_args.use_auth_token else None,
)
raw_datasets_features = list(next(iter(raw_datasets.values())).features.keys())
if data_args.audio_column_name not in raw_datasets_features:
raise ValueError(
f"--audio_column_name '{data_args.audio_column_name}' not found in dataset '{data_args.dataset_name}'. "
"Make sure to set `--audio_column_name` to the correct audio column - one of "
f"{', '.join(raw_datasets_features)}."
)
if data_args.text_column_name not in raw_datasets_features:
raise ValueError(
f"--text_column_name {data_args.text_column_name} not found in dataset '{data_args.dataset_name}'. "
"Make sure to set `--text_column_name` to the correct text column - one of "
f"{', '.join(raw_datasets_features)}."
)
# 5. Load pretrained model, tokenizer, and feature extractor
#
# Distributed training:
# The .from_pretrained methods guarantee that only one local process can concurrently
config = AutoConfig.from_pretrained(
model_args.config_name if model_args.config_name else model_args.model_name_or_path,
cache_dir=model_args.cache_dir,
revision=model_args.model_revision,
use_auth_token=True if model_args.use_auth_token else None,
)
config.update({"forced_decoder_ids": model_args.forced_decoder_ids, "suppress_tokens": model_args.suppress_tokens})
feature_extractor = AutoFeatureExtractor.from_pretrained(
model_args.feature_extractor_name if model_args.feature_extractor_name else model_args.model_name_or_path,
cache_dir=model_args.cache_dir,
revision=model_args.model_revision,
use_auth_token=True if model_args.use_auth_token else None,
)
tokenizer = AutoTokenizer.from_pretrained(
model_args.tokenizer_name if model_args.tokenizer_name else model_args.model_name_or_path,
cache_dir=model_args.cache_dir,
use_fast=model_args.use_fast_tokenizer,
revision=model_args.model_revision,
use_auth_token=True if model_args.use_auth_token else None,
)
model = AutoModelForSpeechSeq2Seq.from_pretrained(
model_args.model_name_or_path,
config=config,
cache_dir=model_args.cache_dir,
revision=model_args.model_revision,
use_auth_token=True if model_args.use_auth_token else None,
)
model.config.use_cache = False
if model.config.decoder_start_token_id is None:
raise ValueError("Make sure that `config.decoder_start_token_id` is correctly defined")
if model_args.freeze_feature_encoder:
model.freeze_feature_encoder()
if model_args.freeze_encoder:
model.freeze_encoder()
model.model.encoder.gradient_checkpointing = False
if data_args.language is not None:
# We only need to set the task id when the language is specified (i.e. in a multilingual setting)
tokenizer.set_prefix_tokens(language=data_args.language, task=data_args.task)
# 6. Resample speech dataset if necessary
dataset_sampling_rate = next(iter(raw_datasets.values())).features[data_args.audio_column_name].sampling_rate
if dataset_sampling_rate != feature_extractor.sampling_rate:
raw_datasets = raw_datasets.cast_column(
data_args.audio_column_name, datasets.features.Audio(sampling_rate=feature_extractor.sampling_rate)
)
# 7. Preprocessing the datasets.
# We need to read the audio files as arrays and tokenize the targets.
max_input_length = data_args.max_duration_in_seconds * feature_extractor.sampling_rate
min_input_length = data_args.min_duration_in_seconds * feature_extractor.sampling_rate
audio_column_name = data_args.audio_column_name
text_column_name = data_args.text_column_name
model_input_name = feature_extractor.model_input_names[0]
do_lower_case = data_args.do_lower_case
do_remove_punctuation = data_args.do_remove_punctuation
normalizer = BasicTextNormalizer() # 'official' text normalizer from OpenAI
if data_args.max_train_samples is not None:
raw_datasets["train"] = raw_datasets["train"].take(data_args.max_train_samples)
if data_args.max_eval_samples is not None:
raw_datasets["eval"] = raw_datasets["eval"].take(data_args.max_eval_samples)
def prepare_dataset(batch):
# process audio
sample = batch[audio_column_name]
inputs = feature_extractor(sample["array"], sampling_rate=sample["sampling_rate"])
# process audio length
batch[model_input_name] = inputs.get(model_input_name)[0]
batch["input_length"] = len(sample["array"])
# process targets
input_str = batch[text_column_name].lower() if do_lower_case else batch[text_column_name]
if do_remove_punctuation:
input_str = normalizer(input_str).strip()
batch["labels"] = tokenizer(input_str).input_ids
return batch
with training_args.main_process_first(desc="dataset map pre-processing"):
vectorized_datasets = raw_datasets.map(
prepare_dataset,
remove_columns=raw_datasets_features,
).with_format("torch")
if training_args.do_train:
vectorized_datasets["train"] = vectorized_datasets["train"].shuffle(
buffer_size=data_args.shuffle_buffer_size,
seed=training_args.seed,
)
# filter training data that is shorter than min_input_length or longer than
# max_input_length
def is_audio_in_length_range(length):
return min_input_length < length < max_input_length
vectorized_datasets["train"] = vectorized_datasets["train"].filter(
is_audio_in_length_range,
input_columns=["input_length"],
)
# 8. Load Metric
metric = evaluate.load("wer")
do_normalize_eval = data_args.do_normalize_eval
def compute_metrics(pred):
pred_ids = pred.predictions
pred.label_ids[pred.label_ids == -100] = tokenizer.pad_token_id
pred_str = tokenizer.batch_decode(pred_ids, skip_special_tokens=True)
# we do not want to group tokens when computing the metrics
label_str = tokenizer.batch_decode(pred.label_ids, skip_special_tokens=True)
if do_normalize_eval:
pred_str = [normalizer(pred) for pred in pred_str]
label_str = [normalizer(label) for label in label_str]
wer = 100 * metric.compute(predictions=pred_str, references=label_str)
return {"wer": wer}
# 9. Create a single speech processor
if is_main_process(training_args.local_rank):
# save feature extractor, tokenizer and config
feature_extractor.save_pretrained(training_args.output_dir)
tokenizer.save_pretrained(training_args.output_dir)
config.save_pretrained(training_args.output_dir)
processor = AutoProcessor.from_pretrained(training_args.output_dir)
# 10. Define data collator
data_collator = DataCollatorSpeechSeq2SeqWithPadding(
processor=processor,
decoder_start_token_id=model.config.decoder_start_token_id,
)
# 11. Configure Trainer
# Trainer callback to reinitialise and reshuffle the streamable datasets at the beginning of each epoch
class ShuffleCallback(TrainerCallback):
def on_epoch_begin(self, args, state, control, train_dataloader, **kwargs):
if isinstance(train_dataloader.dataset, IterableDatasetShard):
pass # set_epoch() is handled by the Trainer
elif isinstance(train_dataloader.dataset, IterableDataset):
train_dataloader.dataset.set_epoch(train_dataloader.dataset._epoch + 1)
# Initialize Trainer
trainer = Seq2SeqTrainer(
model=model,
args=training_args,
train_dataset=vectorized_datasets["train"] if training_args.do_train else None,
eval_dataset=vectorized_datasets["eval"] if training_args.do_eval else None,
tokenizer=feature_extractor,
data_collator=data_collator,
compute_metrics=compute_metrics if training_args.predict_with_generate else None,
callbacks=[ShuffleCallback()],
)
# 12. Training
if training_args.do_train:
checkpoint = None
if training_args.resume_from_checkpoint is not None:
checkpoint = training_args.resume_from_checkpoint
elif last_checkpoint is not None:
checkpoint = last_checkpoint
train_result = trainer.train(resume_from_checkpoint=checkpoint)
trainer.save_model() # Saves the feature extractor too for easy upload
metrics = train_result.metrics
if data_args.max_train_samples:
metrics["train_samples"] = data_args.max_train_samples
trainer.log_metrics("train", metrics)
trainer.save_metrics("train", metrics)
trainer.save_state()
# 13. Evaluation
results = {}
if training_args.do_eval:
logger.info("*** Evaluate ***")
metrics = trainer.evaluate(
metric_key_prefix="eval",
max_length=training_args.generation_max_length,
num_beams=training_args.generation_num_beams,
)
if data_args.max_eval_samples:
metrics["eval_samples"] = data_args.max_eval_samples
trainer.log_metrics("eval", metrics)
trainer.save_metrics("eval", metrics)
# 14. Write Training Stats
kwargs = {
"finetuned_from": model_args.model_name_or_path,
"tasks": "automatic-speech-recognition",
"tags": "whisper-event",
}
if data_args.dataset_name is not None:
kwargs["dataset_tags"] = data_args.dataset_name
if data_args.dataset_config_name is not None:
kwargs["dataset"] = f"{data_args.dataset_name} {data_args.dataset_config_name}"
else:
kwargs["dataset"] = data_args.dataset_name
if "common_voice" in data_args.dataset_name:
kwargs["language"] = data_args.dataset_config_name
if model_args.model_index_name is not None:
kwargs["model_name"] = model_args.model_index_name
if training_args.push_to_hub:
trainer.push_to_hub(**kwargs)
else:
trainer.create_model_card(**kwargs)
return results
if __name__ == "__main__":
main()
| [] |
2024-01-10 | ARBML/whisperar | run_speech_recognition_seq2seq_mixed_mgb2.py | #!/usr/bin/env python
# coding=utf-8
# Copyright 2022 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
Fine-tuning the library models for sequence to sequence speech recognition
with 🤗 Datasets' streaming mode.
"""
# You can also adapt this script for your own sequence to sequence speech
# recognition task. Pointers for this are left as comments.
import logging
import os
import sys
from dataclasses import dataclass, field
from typing import Any, Dict, List, Optional, Union
import datasets
import torch
from datasets import DatasetDict, IterableDatasetDict, interleave_datasets, load_dataset
from torch.utils.data import IterableDataset
import evaluate
import transformers
from transformers import (
AutoConfig,
AutoFeatureExtractor,
AutoModelForSpeechSeq2Seq,
AutoProcessor,
AutoTokenizer,
HfArgumentParser,
Seq2SeqTrainer,
Seq2SeqTrainingArguments,
TrainerCallback,
set_seed,
)
from transformers.models.whisper.english_normalizer import BasicTextNormalizer
from transformers.trainer_pt_utils import IterableDatasetShard
from transformers.trainer_utils import get_last_checkpoint, is_main_process
from transformers.utils import check_min_version, send_example_telemetry
from transformers.utils.versions import require_version
# Will error if the minimal version of Transformers is not installed. Remove at your own risks.
check_min_version("4.25.0.dev0")
require_version(
"datasets>=1.18.2",
"To fix: pip install -r examples/pytorch/speech-recognition/requirements.txt",
)
logger = logging.getLogger(__name__)
@dataclass
class ModelArguments:
"""
Arguments pertaining to which model/config/tokenizer we are going to fine-tune from.
"""
model_name_or_path: str = field(
metadata={
"help": "Path to pretrained model or model identifier from huggingface.co/models"
}
)
config_name: Optional[str] = field(
default=None,
metadata={
"help": "Pretrained config name or path if not the same as model_name"
},
)
tokenizer_name: Optional[str] = field(
default=None,
metadata={
"help": "Pretrained tokenizer name or path if not the same as model_name"
},
)
feature_extractor_name: Optional[str] = field(
default=None,
metadata={
"help": "feature extractor name or path if not the same as model_name"
},
)
cache_dir: Optional[str] = field(
default=None,
metadata={
"help": "Where to store the pretrained models downloaded from huggingface.co"
},
)
use_fast_tokenizer: bool = field(
default=True,
metadata={
"help": "Whether to use one of the fast tokenizer (backed by the tokenizers library) or not."
},
)
model_revision: str = field(
default="main",
metadata={
"help": "The specific model version to use (can be a branch name, tag name or commit id)."
},
)
use_auth_token: bool = field(
default=False,
metadata={
"help": (
"Will use the token generated when running `huggingface-cli login` (necessary to use this script "
"with private models)."
)
},
)
freeze_feature_encoder: bool = field(
default=True,
metadata={"help": "Whether to freeze the feature encoder layers of the model."},
)
freeze_encoder: bool = field(
default=False,
metadata={"help": "Whether to freeze the entire encoder of the seq2seq model."},
)
forced_decoder_ids: List[List[int]] = field(
default=None,
metadata={
"help": (
"A list of pairs of integers which indicates a mapping from generation indices to token indices "
"that will be forced before sampling. For example, [[0, 123]] means the first generated token "
"will always be a token of index 123."
)
},
)
suppress_tokens: List[int] = field(
default=None,
metadata={"help": "A list of tokens that will be suppressed at generation."},
)
model_index_name: str = field(
default=None, metadata={"help": "Pretty name for the model card."}
)
@dataclass
class DataTrainingArguments:
"""
Arguments pertaining to what data we are going to input our model for training and eval.
"""
dataset_name: str = field(
default=None,
metadata={"help": "The name of the dataset to use (via the datasets library)."},
)
dataset_config_name: Optional[str] = field(
default=None,
metadata={
"help": "The configuration name of the dataset to use (via the datasets library)."
},
)
text_column: Optional[str] = field(
default=None,
metadata={
"help": "The name of the column in the datasets containing the full texts (for summarization)."
},
)
max_train_samples: Optional[int] = field(
default=None,
metadata={
"help": (
"For debugging purposes or quicker training, truncate the number of training examples to this "
"value if set."
)
},
)
max_eval_samples: Optional[int] = field(
default=None,
metadata={
"help": (
"For debugging purposes or quicker training, truncate the number of evaluation examples to this "
"value if set."
)
},
)
audio_column_name: str = field(
default="audio",
metadata={
"help": "The name of the dataset column containing the audio data. Defaults to 'audio'"
},
)
text_column_name: str = field(
default="text",
metadata={
"help": "The name of the dataset column containing the text data. Defaults to 'text'"
},
)
max_duration_in_seconds: float = field(
default=20.0,
metadata={
"help": (
"Truncate audio files that are longer than `max_duration_in_seconds` seconds to"
" 'max_duration_in_seconds`"
)
},
)
min_duration_in_seconds: float = field(
default=0.0,
metadata={
"help": "Filter audio files that are shorter than `min_duration_in_seconds` seconds"
},
)
train_split_name: str = field(
default="train",
metadata={
"help": "The name of the training data set split to use (via the datasets library). Defaults to 'train'"
},
)
eval_split_name: str = field(
default="test",
metadata={
"help": "The name of the training data set split to use (via the datasets library). Defaults to 'train'"
},
)
do_lower_case: bool = field(
default=False,
metadata={"help": "Whether the target text should be lower cased."},
)
do_remove_punctuation: bool = field(
default=False,
metadata={"help": "Whether the target text should be striped of punctuation."},
)
do_normalize_eval: bool = field(
default=True,
metadata={
"help": "Whether to normalise the references and predictions in the eval WER calculation."
},
)
language: str = field(
default=None,
metadata={
"help": (
"Language for multilingual fine-tuning. This argument should be set for multilingual fine-tuning "
"only. For English speech recognition, it should be set to `None`."
)
},
)
task: str = field(
default="transcribe",
metadata={
"help": "Task, either `transcribe` for speech recognition or `translate` for speech translation."
},
)
shuffle_buffer_size: Optional[int] = field(
default=500,
metadata={
"help": (
"The number of streamed examples to download before shuffling them. The large the buffer, "
"the closer it is to real offline shuffling."
)
},
)
streaming: bool = field(
default=True,
metadata={
"help": "Whether to use streaming mode to load and pre-process the data."
},
)
@dataclass
class DataCollatorSpeechSeq2SeqWithPadding:
"""
Data collator that will dynamically pad the inputs received.
Args:
processor ([`WhisperProcessor`])
The processor used for processing the data.
decoder_start_token_id (`int`)
The begin-of-sentence of the decoder.
"""
processor: Any
decoder_start_token_id: int
def __call__(
self, features: List[Dict[str, Union[List[int], torch.Tensor]]]
) -> Dict[str, torch.Tensor]:
# split inputs and labels since they have to be of different lengths and need
# different padding methods
model_input_name = self.processor.model_input_names[0]
input_features = [
{model_input_name: feature[model_input_name]} for feature in features
]
label_features = [{"input_ids": feature["labels"]} for feature in features]
batch = self.processor.feature_extractor.pad(
input_features, return_tensors="pt"
)
labels_batch = self.processor.tokenizer.pad(label_features, return_tensors="pt")
# replace padding with -100 to ignore loss correctly
labels = labels_batch["input_ids"].masked_fill(
labels_batch.attention_mask.ne(1), -100
)
# if bos token is appended in previous tokenization step,
# cut bos token here as it's append later anyways
if (labels[:, 0] == self.decoder_start_token_id).all().cpu().item():
labels = labels[:, 1:]
batch["labels"] = labels
return batch
def load_maybe_streaming_dataset(
dataset_name, dataset_config_name, split="train", streaming=True, **kwargs
):
"""
Utility function to load a dataset in streaming mode. For datasets with multiple splits,
each split is loaded individually and then splits combined by taking alternating examples from
each (interleaving).
"""
if "+" in split:
# load multiple splits separated by the `+` symbol with streaming mode
dataset_splits = [
load_dataset(
dataset_name,
dataset_config_name,
split=split_name,
streaming=streaming,
**kwargs,
)
for split_name in split.split("+")
]
# interleave multiple splits to form one dataset
interleaved_dataset = interleave_datasets(dataset_splits)
return interleaved_dataset
else:
# load a single split *with* streaming mode
dataset = load_dataset(
dataset_name,
dataset_config_name,
split=split,
streaming=streaming,
**kwargs,
)
return dataset
def main():
# 1. Parse input arguments
# See all possible arguments in src/transformers/training_args.py
# or by passing the --help flag to this script.
# We now keep distinct sets of args, for a cleaner separation of concerns.
parser = HfArgumentParser(
(ModelArguments, DataTrainingArguments, Seq2SeqTrainingArguments)
)
if len(sys.argv) == 2 and sys.argv[1].endswith(".json"):
# If we pass only one argument to the script and it's the path to a json file,
# let's parse it to get our arguments.
model_args, data_args, training_args = parser.parse_json_file(
json_file=os.path.abspath(sys.argv[1])
)
else:
model_args, data_args, training_args = parser.parse_args_into_dataclasses()
# Sending telemetry. Tracking the example usage helps us better allocate resources to maintain them. The
# information sent is the one passed as arguments along with your Python/PyTorch versions.
send_example_telemetry(
"run_speech_recognition_seq2seq_streaming", model_args, data_args
)
# 2. Setup logging
logging.basicConfig(
format="%(asctime)s - %(levelname)s - %(name)s - %(message)s",
datefmt="%m/%d/%Y %H:%M:%S",
handlers=[logging.StreamHandler(sys.stdout)],
)
log_level = training_args.get_process_log_level()
logger.setLevel(log_level)
datasets.utils.logging.set_verbosity(log_level)
transformers.utils.logging.set_verbosity(log_level)
transformers.utils.logging.enable_default_handler()
transformers.utils.logging.enable_explicit_format()
logger.setLevel(
logging.INFO if is_main_process(training_args.local_rank) else logging.WARN
)
# Log on each process the small summary:
logger.warning(
f"Process rank: {training_args.local_rank}, device: {training_args.device}, n_gpu: {training_args.n_gpu}"
f"distributed training: {bool(training_args.local_rank != -1)}, 16-bits training: {training_args.fp16}"
)
logger.info(f"Training/evaluation parameters {training_args}")
# Set the verbosity to info of the Transformers logger (on main process only):
if is_main_process(training_args.local_rank):
transformers.utils.logging.set_verbosity_info()
logger.info("Training/evaluation parameters %s", training_args)
# 3. Detecting last checkpoint and eventually continue from last checkpoint
last_checkpoint = None
if (
os.path.isdir(training_args.output_dir)
and training_args.do_train
and not training_args.overwrite_output_dir
):
last_checkpoint = get_last_checkpoint(training_args.output_dir)
if last_checkpoint is None and len(os.listdir(training_args.output_dir)) > 0:
raise ValueError(
f"Output directory ({training_args.output_dir}) already exists and is not empty. "
"Use --overwrite_output_dir to overcome."
)
elif (
last_checkpoint is not None and training_args.resume_from_checkpoint is None
):
logger.info(
f"Checkpoint detected, resuming training at {last_checkpoint}. To avoid this behavior, change "
"the `--output_dir` or add `--overwrite_output_dir` to train from scratch."
)
# Set seed before initializing model.
set_seed(training_args.seed)
# 4. Load dataset
raw_datasets = IterableDatasetDict()
if training_args.do_train:
raw_datasets["train"] = load_maybe_streaming_dataset(
data_args.dataset_name,
data_args.dataset_config_name,
split=data_args.train_split_name,
streaming=True,
use_auth_token=True if model_args.use_auth_token else None,
)
if training_args.do_eval:
raw_datasets["eval"] = load_maybe_streaming_dataset(
"arbml/mgb3",
data_args.dataset_config_name,
split="train",
streaming=False,
use_auth_token=True if model_args.use_auth_token else None,
)
raw_datasets_features = list(next(iter(raw_datasets.values())).features.keys())
if data_args.audio_column_name not in raw_datasets_features:
raise ValueError(
f"--audio_column_name '{data_args.audio_column_name}' not found in dataset '{data_args.dataset_name}'. "
"Make sure to set `--audio_column_name` to the correct audio column - one of "
f"{', '.join(raw_datasets_features)}."
)
if data_args.text_column_name not in raw_datasets_features:
raise ValueError(
f"--text_column_name {data_args.text_column_name} not found in dataset '{data_args.dataset_name}'. "
"Make sure to set `--text_column_name` to the correct text column - one of "
f"{', '.join(raw_datasets_features)}."
)
# 5. Load pretrained model, tokenizer, and feature extractor
#
# Distributed training:
# The .from_pretrained methods guarantee that only one local process can concurrently
config = AutoConfig.from_pretrained(
model_args.config_name
if model_args.config_name
else model_args.model_name_or_path,
cache_dir=model_args.cache_dir,
revision=model_args.model_revision,
use_auth_token=True if model_args.use_auth_token else None,
)
config.update(
{
"forced_decoder_ids": model_args.forced_decoder_ids,
"suppress_tokens": model_args.suppress_tokens,
}
)
if training_args.gradient_checkpointing:
config.update({"use_cache": False})
feature_extractor = AutoFeatureExtractor.from_pretrained(
model_args.feature_extractor_name
if model_args.feature_extractor_name
else model_args.model_name_or_path,
cache_dir=model_args.cache_dir,
revision=model_args.model_revision,
use_auth_token=True if model_args.use_auth_token else None,
)
tokenizer = AutoTokenizer.from_pretrained(
model_args.tokenizer_name
if model_args.tokenizer_name
else model_args.model_name_or_path,
cache_dir=model_args.cache_dir,
use_fast=model_args.use_fast_tokenizer,
revision=model_args.model_revision,
use_auth_token=True if model_args.use_auth_token else None,
)
model = AutoModelForSpeechSeq2Seq.from_pretrained(
model_args.model_name_or_path,
config=config,
cache_dir=model_args.cache_dir,
revision=model_args.model_revision,
use_auth_token=True if model_args.use_auth_token else None,
)
if model.config.decoder_start_token_id is None:
raise ValueError(
"Make sure that `config.decoder_start_token_id` is correctly defined"
)
max_label_length = model.config.max_length
if model_args.freeze_feature_encoder:
model.freeze_feature_encoder()
if model_args.freeze_encoder:
model.freeze_encoder()
model.model.encoder.gradient_checkpointing = False
if data_args.language is not None:
# We only need to set the task id when the language is specified (i.e. in a multilingual setting)
tokenizer.set_prefix_tokens(language=data_args.language, task=data_args.task)
# 6. Resample speech dataset if necessary
dataset_sampling_rate = (
next(iter(raw_datasets.values()))
.features[data_args.audio_column_name]
.sampling_rate
)
if dataset_sampling_rate != feature_extractor.sampling_rate:
raw_datasets = raw_datasets.cast_column(
data_args.audio_column_name,
datasets.features.Audio(sampling_rate=feature_extractor.sampling_rate),
)
# 7. Preprocessing the datasets.
# We need to read the audio files as arrays and tokenize the targets.
max_input_length = (
data_args.max_duration_in_seconds * feature_extractor.sampling_rate
)
min_input_length = (
data_args.min_duration_in_seconds * feature_extractor.sampling_rate
)
audio_column_name = data_args.audio_column_name
text_column_name = data_args.text_column_name
model_input_name = feature_extractor.model_input_names[0]
do_lower_case = data_args.do_lower_case
do_remove_punctuation = data_args.do_remove_punctuation
normalizer = BasicTextNormalizer() # 'official' text normalizer from OpenAI
if data_args.max_train_samples is not None:
raw_datasets["train"] = raw_datasets["train"].take(data_args.max_train_samples)
if data_args.max_eval_samples is not None:
raw_datasets["eval"] = raw_datasets["eval"].select(
range(data_args.max_eval_samples)
)
def prepare_dataset(batch):
# process audio
sample = batch[audio_column_name]
inputs = feature_extractor(
sample["array"], sampling_rate=sample["sampling_rate"]
)
# process audio length
batch[model_input_name] = inputs.get(model_input_name)[0]
batch["input_length"] = len(sample["array"])
# process targets
input_str = (
batch[text_column_name].lower()
if do_lower_case
else batch[text_column_name]
)
if do_remove_punctuation:
input_str = normalizer(input_str).strip()
batch["labels"] = tokenizer(input_str).input_ids
return batch
with training_args.main_process_first(desc="dataset map pre-processing"):
vectorized_datasets = raw_datasets.map(
prepare_dataset,
remove_columns=raw_datasets_features,
).with_format("torch")
if training_args.do_train:
vectorized_datasets["train"] = vectorized_datasets["train"].shuffle(
buffer_size=data_args.shuffle_buffer_size,
seed=training_args.seed,
)
# filter training data that is shorter than min_input_length or longer than
# max_input_length
def is_audio_in_length_range(length):
return min_input_length < length < max_input_length
vectorized_datasets["train"] = vectorized_datasets["train"].filter(
is_audio_in_length_range,
input_columns=["input_length"],
)
def filter_labels(labels):
"""Filter label sequences longer than max length"""
return len(labels) < max_label_length
vectorized_datasets = vectorized_datasets.filter(
filter_labels, input_columns=["labels"]
)
# 8. Load Metric
metric = evaluate.load("wer")
do_normalize_eval = data_args.do_normalize_eval
def compute_metrics(pred):
pred_ids = pred.predictions
pred.label_ids[pred.label_ids == -100] = tokenizer.pad_token_id
pred_str = tokenizer.batch_decode(pred_ids, skip_special_tokens=True)
# we do not want to group tokens when computing the metrics
label_str = tokenizer.batch_decode(pred.label_ids, skip_special_tokens=True)
if do_normalize_eval:
pred_str = [normalizer(pred) for pred in pred_str]
label_str = [normalizer(label) for label in label_str]
# filtering step to only evaluate the samples that correspond to non-zero references:
pred_str = [
pred_str[i] for i in range(len(pred_str)) if len(label_str[i]) > 0
]
label_str = [
label_str[i] for i in range(len(label_str)) if len(label_str[i]) > 0
]
wer = 100 * metric.compute(predictions=pred_str, references=label_str)
return {"wer": wer}
# 9. Create a single speech processor
if is_main_process(training_args.local_rank):
# save feature extractor, tokenizer and config
feature_extractor.save_pretrained(training_args.output_dir)
tokenizer.save_pretrained(training_args.output_dir)
config.save_pretrained(training_args.output_dir)
processor = AutoProcessor.from_pretrained(training_args.output_dir)
# 10. Define data collator
data_collator = DataCollatorSpeechSeq2SeqWithPadding(
processor=processor,
decoder_start_token_id=model.config.decoder_start_token_id,
)
# 11. Configure Trainer
# Trainer callback to reinitialise and reshuffle the streamable datasets at the beginning of each epoch
# Only required for streaming: Trainer automatically shuffles non-streaming datasets
class ShuffleCallback(TrainerCallback):
def on_epoch_begin(self, args, state, control, train_dataloader, **kwargs):
if isinstance(train_dataloader.dataset, IterableDatasetShard):
pass # set_epoch() is handled by the Trainer
elif isinstance(train_dataloader.dataset, IterableDataset):
train_dataloader.dataset.set_epoch(train_dataloader.dataset._epoch + 1)
# Initialize Trainer
trainer = Seq2SeqTrainer(
model=model,
args=training_args,
train_dataset=vectorized_datasets["train"] if training_args.do_train else None,
eval_dataset=vectorized_datasets["eval"] if training_args.do_eval else None,
tokenizer=feature_extractor,
data_collator=data_collator,
compute_metrics=compute_metrics
if training_args.predict_with_generate
else None,
callbacks=[ShuffleCallback()],
)
# 12. Training
if training_args.do_train:
checkpoint = None
if training_args.resume_from_checkpoint is not None:
checkpoint = training_args.resume_from_checkpoint
elif last_checkpoint is not None:
checkpoint = last_checkpoint
train_result = trainer.train(resume_from_checkpoint=checkpoint)
trainer.save_model() # Saves the feature extractor too for easy upload
metrics = train_result.metrics
if data_args.max_train_samples:
metrics["train_samples"] = data_args.max_train_samples
trainer.log_metrics("train", metrics)
trainer.save_metrics("train", metrics)
trainer.save_state()
# 13. Evaluation
results = {}
if training_args.do_eval:
logger.info("*** Evaluate ***")
metrics = trainer.evaluate(
metric_key_prefix="eval",
max_length=training_args.generation_max_length,
num_beams=training_args.generation_num_beams,
)
if data_args.max_eval_samples:
metrics["eval_samples"] = data_args.max_eval_samples
trainer.log_metrics("eval", metrics)
trainer.save_metrics("eval", metrics)
# 14. Write Training Stats
kwargs = {
"finetuned_from": model_args.model_name_or_path,
"tasks": "automatic-speech-recognition",
"tags": "whisper-event",
}
if data_args.dataset_name is not None:
kwargs["dataset_tags"] = data_args.dataset_name
if data_args.dataset_config_name is not None:
kwargs[
"dataset"
] = f"{data_args.dataset_name} {data_args.dataset_config_name}"
else:
kwargs["dataset"] = data_args.dataset_name
if "common_voice" in data_args.dataset_name:
kwargs["language"] = data_args.dataset_config_name[:2]
if model_args.model_index_name is not None:
kwargs["model_name"] = model_args.model_index_name
if training_args.push_to_hub:
trainer.push_to_hub(**kwargs)
else:
trainer.create_model_card(**kwargs)
return results
if __name__ == "__main__":
main()
| [] |
2024-01-10 | ARBML/whisperar | run_speech_recognition_seq2seq_interleaved.py | #!/usr/bin/env python
# coding=utf-8
# Copyright 2022 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
Fine-tuning the library models for sequence to sequence speech recognition
with 🤗 Datasets' streaming mode.
"""
# You can also adapt this script for your own sequence to sequence speech
# recognition task. Pointers for this are left as comments.
import logging
import os
import sys
from dataclasses import dataclass, field
from typing import Any, Dict, List, Optional, Union
import datasets
import torch
from datasets import DatasetDict, IterableDatasetDict, interleave_datasets, load_dataset
from datasets import Audio, interleave_datasets, IterableDataset
from torch.utils.data import IterableDataset
import evaluate
import transformers
from transformers import (
AutoConfig,
AutoFeatureExtractor,
AutoModelForSpeechSeq2Seq,
AutoProcessor,
AutoTokenizer,
HfArgumentParser,
Seq2SeqTrainer,
Seq2SeqTrainingArguments,
TrainerCallback,
set_seed,
)
from transformers.models.whisper.english_normalizer import BasicTextNormalizer
from transformers.trainer_pt_utils import IterableDatasetShard
from transformers.trainer_utils import get_last_checkpoint, is_main_process
from transformers.utils import check_min_version, send_example_telemetry
from transformers.utils.versions import require_version
# Will error if the minimal version of Transformers is not installed. Remove at your own risks.
check_min_version("4.25.0.dev0")
require_version(
"datasets>=1.18.2",
"To fix: pip install -r examples/pytorch/speech-recognition/requirements.txt",
)
logger = logging.getLogger(__name__)
@dataclass
class ModelArguments:
"""
Arguments pertaining to which model/config/tokenizer we are going to fine-tune from.
"""
model_name_or_path: str = field(
metadata={
"help": "Path to pretrained model or model identifier from huggingface.co/models"
}
)
config_name: Optional[str] = field(
default=None,
metadata={
"help": "Pretrained config name or path if not the same as model_name"
},
)
tokenizer_name: Optional[str] = field(
default=None,
metadata={
"help": "Pretrained tokenizer name or path if not the same as model_name"
},
)
feature_extractor_name: Optional[str] = field(
default=None,
metadata={
"help": "feature extractor name or path if not the same as model_name"
},
)
cache_dir: Optional[str] = field(
default=None,
metadata={
"help": "Where to store the pretrained models downloaded from huggingface.co"
},
)
use_fast_tokenizer: bool = field(
default=True,
metadata={
"help": "Whether to use one of the fast tokenizer (backed by the tokenizers library) or not."
},
)
model_revision: str = field(
default="main",
metadata={
"help": "The specific model version to use (can be a branch name, tag name or commit id)."
},
)
use_auth_token: bool = field(
default=False,
metadata={
"help": (
"Will use the token generated when running `huggingface-cli login` (necessary to use this script "
"with private models)."
)
},
)
freeze_feature_encoder: bool = field(
default=True,
metadata={"help": "Whether to freeze the feature encoder layers of the model."},
)
freeze_encoder: bool = field(
default=False,
metadata={"help": "Whether to freeze the entire encoder of the seq2seq model."},
)
forced_decoder_ids: List[List[int]] = field(
default=None,
metadata={
"help": (
"A list of pairs of integers which indicates a mapping from generation indices to token indices "
"that will be forced before sampling. For example, [[0, 123]] means the first generated token "
"will always be a token of index 123."
)
},
)
suppress_tokens: List[int] = field(
default=None,
metadata={"help": "A list of tokens that will be suppressed at generation."},
)
model_index_name: str = field(
default=None, metadata={"help": "Pretty name for the model card."}
)
@dataclass
class DataTrainingArguments:
"""
Arguments pertaining to what data we are going to input our model for training and eval.
"""
dataset_name: str = field(
default=None,
metadata={"help": "The name of the dataset to use (via the datasets library)."},
)
dataset_config_name: Optional[str] = field(
default=None,
metadata={
"help": "The configuration name of the dataset to use (via the datasets library)."
},
)
text_column: Optional[str] = field(
default=None,
metadata={
"help": "The name of the column in the datasets containing the full texts (for summarization)."
},
)
max_train_samples: Optional[int] = field(
default=None,
metadata={
"help": (
"For debugging purposes or quicker training, truncate the number of training examples to this "
"value if set."
)
},
)
max_eval_samples: Optional[int] = field(
default=None,
metadata={
"help": (
"For debugging purposes or quicker training, truncate the number of evaluation examples to this "
"value if set."
)
},
)
audio_column_name: str = field(
default="audio",
metadata={
"help": "The name of the dataset column containing the audio data. Defaults to 'audio'"
},
)
text_column_name: str = field(
default="text",
metadata={
"help": "The name of the dataset column containing the text data. Defaults to 'text'"
},
)
max_duration_in_seconds: float = field(
default=20.0,
metadata={
"help": (
"Truncate audio files that are longer than `max_duration_in_seconds` seconds to"
" 'max_duration_in_seconds`"
)
},
)
min_duration_in_seconds: float = field(
default=0.0,
metadata={
"help": "Filter audio files that are shorter than `min_duration_in_seconds` seconds"
},
)
train_split_name: str = field(
default="train",
metadata={
"help": "The name of the training data set split to use (via the datasets library). Defaults to 'train'"
},
)
eval_split_name: str = field(
default="test",
metadata={
"help": "The name of the training data set split to use (via the datasets library). Defaults to 'train'"
},
)
do_lower_case: bool = field(
default=False,
metadata={"help": "Whether the target text should be lower cased."},
)
do_remove_punctuation: bool = field(
default=False,
metadata={"help": "Whether the target text should be striped of punctuation."},
)
do_normalize_eval: bool = field(
default=True,
metadata={
"help": "Whether to normalise the references and predictions in the eval WER calculation."
},
)
language: str = field(
default=None,
metadata={
"help": (
"Language for multilingual fine-tuning. This argument should be set for multilingual fine-tuning "
"only. For English speech recognition, it should be set to `None`."
)
},
)
task: str = field(
default="transcribe",
metadata={
"help": "Task, either `transcribe` for speech recognition or `translate` for speech translation."
},
)
shuffle_buffer_size: Optional[int] = field(
default=500,
metadata={
"help": (
"The number of streamed examples to download before shuffling them. The large the buffer, "
"the closer it is to real offline shuffling."
)
},
)
streaming: bool = field(
default=True,
metadata={
"help": "Whether to use streaming mode to load and pre-process the data."
},
)
stopping_strategy: str = field(
default="first_exhausted",
metadata={
"help": "Stopping strategy for interleving data, either `first_exhausted` or `all_exhausted `."
},
)
@dataclass
class DataCollatorSpeechSeq2SeqWithPadding:
"""
Data collator that will dynamically pad the inputs received.
Args:
processor ([`WhisperProcessor`])
The processor used for processing the data.
decoder_start_token_id (`int`)
The begin-of-sentence of the decoder.
"""
processor: Any
decoder_start_token_id: int
def __call__(
self, features: List[Dict[str, Union[List[int], torch.Tensor]]]
) -> Dict[str, torch.Tensor]:
# split inputs and labels since they have to be of different lengths and need
# different padding methods
model_input_name = self.processor.model_input_names[0]
input_features = [
{model_input_name: feature[model_input_name]} for feature in features
]
label_features = [{"input_ids": feature["labels"]} for feature in features]
batch = self.processor.feature_extractor.pad(
input_features, return_tensors="pt"
)
labels_batch = self.processor.tokenizer.pad(label_features, return_tensors="pt")
# replace padding with -100 to ignore loss correctly
labels = labels_batch["input_ids"].masked_fill(
labels_batch.attention_mask.ne(1), -100
)
# if bos token is appended in previous tokenization step,
# cut bos token here as it's append later anyways
if (labels[:, 0] == self.decoder_start_token_id).all().cpu().item():
labels = labels[:, 1:]
batch["labels"] = labels
return batch
def load_maybe_streaming_dataset(
dataset_name, dataset_config_name, split="train", streaming=True, **kwargs
):
"""
Utility function to load a dataset in streaming mode. For datasets with multiple splits,
each split is loaded individually and then splits combined by taking alternating examples from
each (interleaving).
"""
if "+" in split:
# load multiple splits separated by the `+` symbol with streaming mode
dataset_splits = [
load_dataset(
dataset_name,
dataset_config_name,
split=split_name,
streaming=streaming,
**kwargs,
)
for split_name in split.split("+")
]
# interleave multiple splits to form one dataset
interleaved_dataset = interleave_datasets(dataset_splits)
return interleaved_dataset
else:
# load a single split *with* streaming mode
dataset = load_dataset(
dataset_name,
dataset_config_name,
split=split,
streaming=streaming,
**kwargs,
)
return dataset
def load_multiple_streaming_datasets(
dataset_names: List,
dataset_config_names: List,
splits: Optional[List] = None,
text_column_names: Optional[List] = None,
sampling_rate: Optional[int] = 16000,
stopping_strategy: Optional[str] = "first_exhausted",
**kwargs
) -> IterableDataset:
if len(dataset_names) != len(dataset_config_names):
raise ValueError(
f"Ensure one config is passed for each dataset, got {len(dataset_names)} datasets and"
f" {len(dataset_config_names)} configs."
)
if splits is not None and len(splits) != len(dataset_names):
raise ValueError(
f"Ensure one split is passed for each dataset, got {len(dataset_names)} datasets and {len(splits)} splits."
)
if text_column_names is not None and len(text_column_names) != len(dataset_names):
raise ValueError(
f"Ensure one text column name is passed for each dataset, got {len(dataset_names)} datasets and"
f" {len(text_column_names)} text column names."
)
splits = splits if splits is not None else ["train" for i in range(len(dataset_names))]
text_column_names = (
text_column_names if text_column_names is not None else ["text" for i in range(len(dataset_names))]
)
all_datasets = []
# iterate over the datasets we want to interleave
for i, dataset_name in enumerate(dataset_names):
for dsplit in splits[i].split("+"):
dataset = load_dataset(dataset_name, dataset_config_names[i], split=dsplit, streaming=True, **kwargs)
# resample to specified sampling rate
dataset = dataset.cast_column("audio", Audio(sampling_rate))
# normalise columns to ["audio", "sentence"]
if text_column_names[i] != "sentence":
dataset = dataset.rename_column(text_column_names[i], "sentence")
dataset = dataset.remove_columns(set(dataset.features.keys()) - set(["audio", "sentence"]))
all_datasets.append(dataset)
interleaved_dataset = interleave_datasets(all_datasets, stopping_strategy=stopping_strategy)
return interleaved_dataset
def main():
# 1. Parse input arguments
# See all possible arguments in src/transformers/training_args.py
# or by passing the --help flag to this script.
# We now keep distinct sets of args, for a cleaner separation of concerns.
parser = HfArgumentParser(
(ModelArguments, DataTrainingArguments, Seq2SeqTrainingArguments)
)
if len(sys.argv) == 2 and sys.argv[1].endswith(".json"):
# If we pass only one argument to the script and it's the path to a json file,
# let's parse it to get our arguments.
model_args, data_args, training_args = parser.parse_json_file(
json_file=os.path.abspath(sys.argv[1])
)
else:
model_args, data_args, training_args = parser.parse_args_into_dataclasses()
# Sending telemetry. Tracking the example usage helps us better allocate resources to maintain them. The
# information sent is the one passed as arguments along with your Python/PyTorch versions.
send_example_telemetry(
"run_speech_recognition_seq2seq_streaming", model_args, data_args
)
# 2. Setup logging
logging.basicConfig(
format="%(asctime)s - %(levelname)s - %(name)s - %(message)s",
datefmt="%m/%d/%Y %H:%M:%S",
handlers=[logging.StreamHandler(sys.stdout)],
)
log_level = training_args.get_process_log_level()
logger.setLevel(log_level)
datasets.utils.logging.set_verbosity(log_level)
transformers.utils.logging.set_verbosity(log_level)
transformers.utils.logging.enable_default_handler()
transformers.utils.logging.enable_explicit_format()
logger.setLevel(
logging.INFO if is_main_process(training_args.local_rank) else logging.WARN
)
# Log on each process the small summary:
logger.warning(
f"Process rank: {training_args.local_rank}, device: {training_args.device}, n_gpu: {training_args.n_gpu}"
f"distributed training: {bool(training_args.local_rank != -1)}, 16-bits training: {training_args.fp16}"
)
logger.info(f"Training/evaluation parameters {training_args}")
# Set the verbosity to info of the Transformers logger (on main process only):
if is_main_process(training_args.local_rank):
transformers.utils.logging.set_verbosity_info()
logger.info("Training/evaluation parameters %s", training_args)
# 3. Detecting last checkpoint and eventually continue from last checkpoint
last_checkpoint = None
if (
os.path.isdir(training_args.output_dir)
and training_args.do_train
and not training_args.overwrite_output_dir
):
last_checkpoint = get_last_checkpoint(training_args.output_dir)
if last_checkpoint is None and len(os.listdir(training_args.output_dir)) > 0:
raise ValueError(
f"Output directory ({training_args.output_dir}) already exists and is not empty. "
"Use --overwrite_output_dir to overcome."
)
elif (
last_checkpoint is not None and training_args.resume_from_checkpoint is None
):
logger.info(
f"Checkpoint detected, resuming training at {last_checkpoint}. To avoid this behavior, change "
"the `--output_dir` or add `--overwrite_output_dir` to train from scratch."
)
# Set seed before initializing model.
set_seed(training_args.seed)
# 4. Load dataset
raw_datasets = IterableDatasetDict()
if training_args.do_train:
raw_datasets["train"] = load_multiple_streaming_datasets(
data_args.dataset_name.split("|"),
dataset_config_names=data_args.dataset_config_name.split("|"),
text_column_names=data_args.text_column_name.split("|"),
splits=data_args.train_split_name.split("|"),
use_auth_token=True if model_args.use_auth_token else None,
stopping_strategy=data_args.stopping_strategy,
)
if training_args.do_eval:
raw_datasets["eval"] = load_multiple_streaming_datasets(
data_args.dataset_name.split("|"),
dataset_config_names=data_args.dataset_config_name.split("|"),
text_column_names=data_args.text_column_name.split("|"),
splits=data_args.eval_split_name.split("|"),
use_auth_token=True if model_args.use_auth_token else None,
stopping_strategy=data_args.stopping_strategy,
)
raw_datasets_features = list(next(iter(raw_datasets.values())).features.keys())
if data_args.audio_column_name not in raw_datasets_features:
raise ValueError(
f"--audio_column_name '{data_args.audio_column_name}' not found in dataset '{data_args.dataset_name}'. "
"Make sure to set `--audio_column_name` to the correct audio column - one of "
f"{', '.join(raw_datasets_features)}."
)
# if data_args.text_column_name not in raw_datasets_features:
# print("raw_datasets_features:",raw_datasets_features)
# raise ValueError(
# f"--text_column_name {data_args.text_column_name} not found in dataset '{data_args.dataset_name}'. "
# "Make sure to set `--text_column_name` to the correct text column - one of "
# f"{', '.join(raw_datasets_features)}."
# )
# 5. Load pretrained model, tokenizer, and feature extractor
#
# Distributed training:
# The .from_pretrained methods guarantee that only one local process can concurrently
config = AutoConfig.from_pretrained(
model_args.config_name
if model_args.config_name
else model_args.model_name_or_path,
cache_dir=model_args.cache_dir,
revision=model_args.model_revision,
use_auth_token=True if model_args.use_auth_token else None,
)
config.update(
{
"forced_decoder_ids": model_args.forced_decoder_ids,
"suppress_tokens": model_args.suppress_tokens,
}
)
if training_args.gradient_checkpointing:
config.update({"use_cache": False})
feature_extractor = AutoFeatureExtractor.from_pretrained(
model_args.feature_extractor_name
if model_args.feature_extractor_name
else model_args.model_name_or_path,
cache_dir=model_args.cache_dir,
revision=model_args.model_revision,
use_auth_token=True if model_args.use_auth_token else None,
)
tokenizer = AutoTokenizer.from_pretrained(
model_args.tokenizer_name
if model_args.tokenizer_name
else model_args.model_name_or_path,
cache_dir=model_args.cache_dir,
use_fast=model_args.use_fast_tokenizer,
revision=model_args.model_revision,
use_auth_token=True if model_args.use_auth_token else None,
)
model = AutoModelForSpeechSeq2Seq.from_pretrained(
model_args.model_name_or_path,
config=config,
cache_dir=model_args.cache_dir,
revision=model_args.model_revision,
use_auth_token=True if model_args.use_auth_token else None,
)
if model.config.decoder_start_token_id is None:
raise ValueError(
"Make sure that `config.decoder_start_token_id` is correctly defined"
)
max_label_length = model.config.max_length
if model_args.freeze_feature_encoder:
model.freeze_feature_encoder()
if model_args.freeze_encoder:
model.freeze_encoder()
model.model.encoder.gradient_checkpointing = False
if data_args.language is not None:
# We only need to set the task id when the language is specified (i.e. in a multilingual setting)
tokenizer.set_prefix_tokens(language=data_args.language, task=data_args.task)
# 6. Resample speech dataset if necessary
dataset_sampling_rate = (
next(iter(raw_datasets.values()))
.features[data_args.audio_column_name]
.sampling_rate
)
if dataset_sampling_rate != feature_extractor.sampling_rate:
raw_datasets = raw_datasets.cast_column(
data_args.audio_column_name,
datasets.features.Audio(sampling_rate=feature_extractor.sampling_rate),
)
# 7. Preprocessing the datasets.
# We need to read the audio files as arrays and tokenize the targets.
max_input_length = (
data_args.max_duration_in_seconds * feature_extractor.sampling_rate
)
min_input_length = (
data_args.min_duration_in_seconds * feature_extractor.sampling_rate
)
audio_column_name = data_args.audio_column_name
#text_column_name = data_args.text_column_name
text_column_name = "sentence" # standardized on this
model_input_name = feature_extractor.model_input_names[0]
do_lower_case = data_args.do_lower_case
do_remove_punctuation = data_args.do_remove_punctuation
normalizer = BasicTextNormalizer() # 'official' text normalizer from OpenAI
if data_args.max_train_samples is not None:
raw_datasets["train"] = raw_datasets["train"].take(data_args.max_train_samples)
if data_args.max_eval_samples is not None:
raw_datasets["eval"] = raw_datasets["eval"].select(
range(data_args.max_eval_samples)
)
def prepare_dataset(batch):
# process audio
sample = batch[audio_column_name]
inputs = feature_extractor(
sample["array"], sampling_rate=sample["sampling_rate"]
)
# process audio length
batch[model_input_name] = inputs.get(model_input_name)[0]
batch["input_length"] = len(sample["array"])
# process targets
input_str = (
batch[text_column_name].lower()
if do_lower_case
else batch[text_column_name]
)
if do_remove_punctuation:
input_str = normalizer(input_str).strip()
batch["labels"] = tokenizer(input_str).input_ids
return batch
with training_args.main_process_first(desc="dataset map pre-processing"):
vectorized_datasets = raw_datasets.map(
prepare_dataset,
remove_columns=raw_datasets_features,
).with_format("torch")
if training_args.do_train:
vectorized_datasets["train"] = vectorized_datasets["train"].shuffle(
buffer_size=data_args.shuffle_buffer_size,
seed=training_args.seed,
)
# filter training data that is shorter than min_input_length or longer than
# max_input_length
def is_audio_in_length_range(length):
return min_input_length < length < max_input_length
vectorized_datasets["train"] = vectorized_datasets["train"].filter(
is_audio_in_length_range,
input_columns=["input_length"],
)
def filter_labels(labels):
"""Filter label sequences longer than max length"""
return len(labels) < max_label_length
vectorized_datasets = vectorized_datasets.filter(
filter_labels, input_columns=["labels"]
)
# 8. Load Metric
metric = evaluate.load("wer")
do_normalize_eval = data_args.do_normalize_eval
def compute_metrics(pred):
pred_ids = pred.predictions
pred.label_ids[pred.label_ids == -100] = tokenizer.pad_token_id
pred_str = tokenizer.batch_decode(pred_ids, skip_special_tokens=True)
# we do not want to group tokens when computing the metrics
label_str = tokenizer.batch_decode(pred.label_ids, skip_special_tokens=True)
if do_normalize_eval:
pred_str = [normalizer(pred) for pred in pred_str]
label_str = [normalizer(label) for label in label_str]
# filtering step to only evaluate the samples that correspond to non-zero references:
pred_str = [
pred_str[i] for i in range(len(pred_str)) if len(label_str[i]) > 0
]
label_str = [
label_str[i] for i in range(len(label_str)) if len(label_str[i]) > 0
]
wer = 100 * metric.compute(predictions=pred_str, references=label_str)
return {"wer": wer}
# 9. Create a single speech processor
if is_main_process(training_args.local_rank):
# save feature extractor, tokenizer and config
feature_extractor.save_pretrained(training_args.output_dir)
tokenizer.save_pretrained(training_args.output_dir)
config.save_pretrained(training_args.output_dir)
processor = AutoProcessor.from_pretrained(training_args.output_dir)
# 10. Define data collator
data_collator = DataCollatorSpeechSeq2SeqWithPadding(
processor=processor,
decoder_start_token_id=model.config.decoder_start_token_id,
)
# 11. Configure Trainer
# Trainer callback to reinitialise and reshuffle the streamable datasets at the beginning of each epoch
# Only required for streaming: Trainer automatically shuffles non-streaming datasets
class ShuffleCallback(TrainerCallback):
def on_epoch_begin(self, args, state, control, train_dataloader, **kwargs):
if isinstance(train_dataloader.dataset, IterableDatasetShard):
pass # set_epoch() is handled by the Trainer
elif isinstance(train_dataloader.dataset, IterableDataset):
train_dataloader.dataset.set_epoch(train_dataloader.dataset._epoch + 1)
# Initialize Trainer
trainer = Seq2SeqTrainer(
model=model,
args=training_args,
train_dataset=vectorized_datasets["train"] if training_args.do_train else None,
eval_dataset=vectorized_datasets["eval"] if training_args.do_eval else None,
tokenizer=feature_extractor,
data_collator=data_collator,
compute_metrics=compute_metrics
if training_args.predict_with_generate
else None,
callbacks=[ShuffleCallback()],
)
# 12. Training
if training_args.do_train:
checkpoint = None
if training_args.resume_from_checkpoint is not None:
checkpoint = training_args.resume_from_checkpoint
elif last_checkpoint is not None:
checkpoint = last_checkpoint
train_result = trainer.train(resume_from_checkpoint=checkpoint)
trainer.save_model() # Saves the feature extractor too for easy upload
metrics = train_result.metrics
if data_args.max_train_samples:
metrics["train_samples"] = data_args.max_train_samples
trainer.log_metrics("train", metrics)
trainer.save_metrics("train", metrics)
trainer.save_state()
# 13. Evaluation
results = {}
if training_args.do_eval:
logger.info("*** Evaluate ***")
metrics = trainer.evaluate(
metric_key_prefix="eval",
max_length=training_args.generation_max_length,
num_beams=training_args.generation_num_beams,
)
if data_args.max_eval_samples:
metrics["eval_samples"] = data_args.max_eval_samples
trainer.log_metrics("eval", metrics)
trainer.save_metrics("eval", metrics)
# 14. Write Training Stats
kwargs = {
"finetuned_from": model_args.model_name_or_path,
"tasks": "automatic-speech-recognition",
"tags": "whisper-event",
}
if data_args.dataset_name is not None:
kwargs["dataset_tags"] = data_args.dataset_name
if data_args.dataset_config_name is not None:
kwargs[
"dataset"
] = f"{data_args.dataset_name} {data_args.dataset_config_name}"
else:
kwargs["dataset"] = data_args.dataset_name
if "common_voice" in data_args.dataset_name:
kwargs["language"] = data_args.dataset_config_name[:2]
if model_args.model_index_name is not None:
kwargs["model_name"] = model_args.model_index_name
if training_args.push_to_hub:
trainer.push_to_hub(**kwargs)
else:
trainer.create_model_card(**kwargs)
return results
if __name__ == "__main__":
main()
| [] |
2024-01-10 | weituo12321/PREVALENT_R2R | tasks~NDH~r2rutils.py | ''' Utils for io, language, connectivity graphs etc '''
import os
import sys
import re
import string
import json
import time
import math
from collections import Counter
import numpy as np
import networkx as nx
# padding, unknown word, end of sentence
base_vocab = ['<PAD>', '<UNK>', '<EOS>']
padding_idx = base_vocab.index('<PAD>')
def load_nav_graphs(scans):
''' Load connectivity graph for each scan '''
def distance(pose1, pose2):
''' Euclidean distance between two graph poses '''
return ((pose1['pose'][3]-pose2['pose'][3])**2\
+ (pose1['pose'][7]-pose2['pose'][7])**2\
+ (pose1['pose'][11]-pose2['pose'][11])**2)**0.5
graphs = {}
for scan in scans:
with open('connectivity/%s_connectivity.json' % scan) as f:
G = nx.Graph()
positions = {}
data = json.load(f)
for i,item in enumerate(data):
if item['included']:
for j,conn in enumerate(item['unobstructed']):
if conn and data[j]['included']:
positions[item['image_id']] = np.array([item['pose'][3],
item['pose'][7], item['pose'][11]])
assert data[j]['unobstructed'][i], 'Graph should be undirected'
G.add_edge(item['image_id'],data[j]['image_id'],weight=distance(item,data[j]))
nx.set_node_attributes(G, values=positions, name='position')
graphs[scan] = G
return graphs
def dump_transformer_index(encoder_type, splits):
if encoder_type == 'bert' or encoder_type == 'vlbert':
dump_bert_index(splits)
elif encoder_type == 'gpt':
dump_gpt_index(splits)
else:
raise NotImplementedError
def dump_gpt_index(splits):
from pytorch_pretrained_bert import OpenAIGPTTokenizer
tokenizer = OpenAIGPTTokenizer.from_pretrained('openai-gpt')
#splits = ['train', 'val_seen', 'val_unseen', 'test']
for split in splits:
data = load_datasets([split], encoder_type='lstm') # here we use lstm dataset to preprocess the data,
indexed_tokens = []
for item in data:
for instr in item['instructions']:
tokenized_text = tokenizer.tokenize(instr)
tokens = tokenizer.convert_tokens_to_ids(tokenized_text)
indexed_tokens.append('_'.join([str(i) for i in tokens]))
write_vocab(indexed_tokens, 'tasks/R2R/data/R2R_%s_gpt.txt' % split)
def dump_bert_index(splits):
from pytorch_pretrained_bert import BertTokenizer
from nltk.tokenize import sent_tokenize
tokenizer=BertTokenizer.from_pretrained('bert-base-uncased')
#splits = ['train', 'val_seen', 'val_unseen', 'test']
for split in splits:
data = load_datasets([split] ,encoder_type='lstm') # here we use lstm dataset to preprocess the data,
indexed_tokens = []
for item in data:
for instr in item['instructions']:
sents = sent_tokenize(instr)
instr = '[CLS] ' + (' [SEP] '.join(sents)) + ' [SEP]'
tokenized_text = tokenizer.tokenize(instr)
tokens = tokenizer.convert_tokens_to_ids(tokenized_text)
indexed_tokens.append('_'.join([str(i) for i in tokens]))
write_vocab(indexed_tokens, 'tasks/R2R/data/R2R_%s_bert.txt' % split)
def load_datasets(splits, encoder_type):
data = []
for split in splits:
with open('tasks/R2R/data/R2R_%s.json' % split) as f:
data += json.load(f)
if encoder_type in ['bert', 'gpt','vlbert']:
#filename = 'tasks/R2R/data/R2R_%s_%s.txt' % (split, encoder_type)
if encoder_type == 'bert' or encoder_type == 'vlbert':
filename = 'tasks/R2R/data/R2R_%s_bert.txt' % (split)
else:
filename = 'tasks/R2R/data/R2R_%s_%s.txt' % (split, encoder_type)
if not os.path.exists(filename):
dump_transformer_index(encoder_type, [split])
transformer_index = read_vocab(filename)
j=0
err_items = []
for k, item in enumerate(data):
for i, instr in enumerate(item['instructions']):
item['instructions'][i] = transformer_index[j]
if not transformer_index[j]:
err_items.append(k)
j+=1
assert j == len(transformer_index)
for k in err_items[::-1]:
data.pop(k)
return data
class SplitTokenizer():
def __init__(self, pad_idx=0, encoding_length=20):
self.encoding_length = encoding_length
self.pad_idx=pad_idx
def encode_sentence(self, sentence):
#print(sentence)
encoding = [] if len(sentence.strip())==0 else [int(i) for i in sentence.strip().split('_')]
if len(encoding) < self.encoding_length:
encoding += [self.pad_idx] * (self.encoding_length-len(encoding))
return np.array(encoding[:self.encoding_length])
class Tokenizer(object):
''' Class to tokenize and encode a sentence. '''
SENTENCE_SPLIT_REGEX = re.compile(r'(\W+)') # Split on any non-alphanumeric character
def __init__(self, vocab=None, encoding_length=20):
self.encoding_length = encoding_length
self.vocab = vocab
self.word_to_index = {}
if vocab:
for i,word in enumerate(vocab):
self.word_to_index[word] = i
def split_sentence(self, sentence):
''' Break sentence into a list of words and punctuation '''
toks = []
for word in [s.strip().lower() for s in self.SENTENCE_SPLIT_REGEX.split(sentence.strip()) if len(s.strip()) > 0]:
# Break up any words containing punctuation only, e.g. '!?', unless it is multiple full stops e.g. '..'
if all(c in string.punctuation for c in word) and not all(c in '.' for c in word):
toks += list(word)
else:
toks.append(word)
return toks
def encode_sentence(self, sentence):
if len(self.word_to_index) == 0:
sys.exit('Tokenizer has no vocab')
encoding = []
for word in self.split_sentence(sentence)[::-1]: # reverse input sentences
if word in self.word_to_index:
encoding.append(self.word_to_index[word])
else:
encoding.append(self.word_to_index['<UNK>'])
encoding.append(self.word_to_index['<EOS>'])
if len(encoding) < self.encoding_length:
encoding += [self.word_to_index['<PAD>']] * (self.encoding_length-len(encoding))
return np.array(encoding[:self.encoding_length])
def decode_sentence(self, encoding):
sentence = []
for ix in encoding:
if ix == self.word_to_index['<PAD>']:
break
else:
sentence.append(self.vocab[ix])
return " ".join(sentence[::-1]) # unreverse before output
def build_vocab(splits=['train'], min_count=5, start_vocab=base_vocab):
''' Build a vocab, starting with base vocab containing a few useful tokens. '''
count = Counter()
t = Tokenizer()
data = load_datasets(splits, encoder_type='lstm')#, False)
for item in data:
for instr in item['instructions']:
count.update(t.split_sentence(instr))
vocab = list(start_vocab)
for word,num in count.most_common():
if num >= min_count:
vocab.append(word)
else:
break
return vocab
def write_vocab(vocab, path):
print('Writing vocab of size %d to %s' % (len(vocab),path))
with open(path, 'w') as f:
for word in vocab:
f.write("%s\n" % word)
def read_vocab(path):
with open(path) as f:
vocab = [word.strip() for word in f.readlines()]
return vocab
def asMinutes(s):
m = math.floor(s / 60)
s -= m * 60
return '%dm %ds' % (m, s)
def timeSince(since, percent):
now = time.time()
s = now - since
es = s / (percent)
rs = es - s
return '%s (- %s)' % (asMinutes(s), asMinutes(rs))
def to_contiguous(tensor): # jolin
if tensor.is_contiguous(): return tensor
else: return tensor.contiguous()
def clip_gradient(optimizer, grad_clip=0.1): # jolin
for group in optimizer.param_groups:
for param in group['params']:
if param.grad is not None:
param.grad.data.clamp_(-grad_clip, grad_clip)
def boolean_string(s):
if s not in {'False', 'True'}:
raise ValueError('Not a valid boolean string')
return s == 'True'
def dump_get_navigable():
from pytorch_pretrained_bert import BertTokenizer
from nltk.tokenize import sent_tokenize
tokenizer=BertTokenizer.from_pretrained('bert-base-uncased')
splits = ['train', 'val_seen', 'val_unseen', 'test']
for split in splits:
data = load_datasets([split] ,False)
indexed_tokens = []
for item in data:
for instr in item['instructions']:
sents = sent_tokenize(instr)
instr = '[CLS] ' + (' [SEP] '.join(sents)) + ' [SEP]'
tokenized_text = tokenizer.tokenize(instr)
tokens = tokenizer.convert_tokens_to_ids(tokenized_text)
indexed_tokens.append('_'.join([str(i) for i in tokens]))
write_vocab(indexed_tokens, 'tasks/R2R/data/R2R_%s_bert.txt' % split)
def _loc_distance(loc):
return np.sqrt(loc.rel_heading ** 2 + loc.rel_elevation ** 2)
def preprocess_get_pano_states(navigable_locs_path = "tasks/R2R/data/navigable_locs.json"):
if os.path.exists(navigable_locs_path):
return
image_w = 640
image_h = 480
vfov = 60
import sys
sys.path.append('build')
import MatterSim
from collections import defaultdict
sim = MatterSim.Simulator()
sim.setRenderingEnabled(False)
sim.setDiscretizedViewingAngles(True)
sim.setCameraResolution(image_w, image_h)
sim.setCameraVFOV(math.radians(vfov))
sim.init()
splits = ['train', 'val_seen', 'val_unseen', 'test']
graphs = {}
for split in splits:
data = load_datasets([split], encoder_type='lstm')
for item in data:
# print(item.keys())
# print("")
scan = item["scan"]
if scan in graphs:
continue
graphs[scan] = {}
with open('connectivity/%s_connectivity.json' % scan) as f:
data = json.load(f)
for i, item in enumerate(data):
if item['included']:
viewpointId = item['image_id']
sim.newEpisode(scan, viewpointId, 0, 0)
state = sim.getState()
initViewIndex = state.viewIndex
# 1. first look down, turning to relViewIndex 0
elevation_delta = -(state.viewIndex // 12)
for _ in range(int(abs(elevation_delta))):
''' Make possibly more than one elevation turns '''
sim.makeAction(0, 0, np.sign(elevation_delta))
adj_dict = {}
for relViewIndex in range(36):
state = sim.getState()
absViewIndex = state.viewIndex
for loc in state.navigableLocations[1:]:
distance = _loc_distance(loc)
if (loc.viewpointId not in adj_dict or
distance < adj_dict[loc.viewpointId]['distance']):
adj_dict[loc.viewpointId] = {
'absViewIndex': absViewIndex,
'nextViewpointId': loc.viewpointId,
'loc_rel_heading': loc.rel_heading,
'loc_rel_elevation': loc.rel_elevation,
'distance': distance}
if (relViewIndex + 1) % 12 == 0:
sim.makeAction(0, 1, 1) # Turn right and look up
else:
sim.makeAction(0, 1, 0) # Turn right
# 3. turn back to the original view
for _ in range(int(abs(- 2 - elevation_delta))):
''' Make possibly more than one elevation turns '''
sim.makeAction(0, 0, np.sign(- 2 - elevation_delta))
state = sim.getState()
assert state.viewIndex == initViewIndex
absViewIndex2points = defaultdict(list)
for vpId, point in adj_dict.items():
absViewIndex2points[point['absViewIndex']].append(vpId)
graphs[scan][viewpointId]=(adj_dict, absViewIndex2points)
print('prepare cache for', split, 'done')
with open(navigable_locs_path, 'w') as f:
json.dump(graphs, f)
def current_best(df, v_id, best_score_name):
if best_score_name == 'sr_sum':
return df['val_seen success_rate'][v_id] + df['val_unseen success_rate'][v_id]
elif best_score_name == 'spl_sum':
return df['val_seen spl'][v_id] + df['val_unseen spl'][v_id]
elif best_score_name == 'spl_unseen':
return df['val_unseen spl'][v_id]
elif best_score_name == 'sr_unseen':
return df['val_unseen success_rate'][v_id]
def show_path_steps_len(splits):
''' histogram of path length in the whole dataset '''
import matplotlib.pyplot as plt
path_lens = []
for split in splits:
data = load_datasets([split], False)
path_lens.extend([len(item['path']) for item in data])
print(len(data))
print('min steps', min(path_lens),'max steps', max(path_lens))
plt.hist(path_lens,
bins=[i for i in range(min(path_lens), max(path_lens) + 1)]) # arguments are passed to np.histogram
plt.title("Histogram with '%d-%d' bins" % ((min(path_lens), max(path_lens))))
plt.show()
def show_max_navigable():
navigable_locs_path = "tasks/R2R/data/navigable_locs.json"
with open(navigable_locs_path, 'r') as f:
nav_graphs = json.load(f)
max_navigable = 0
for scan in nav_graphs:
for viewpointId in nav_graphs[scan]:
adj_dict, absViewIndex2points = nav_graphs[scan][viewpointId]
if max_navigable < len(adj_dict):
max_navigable = len(adj_dict)
print(max_navigable)
def generate_multisent_to_dataset():
from nltk.tokenize import sent_tokenize
import copy
splits = ['train', 'val_seen', 'val_unseen', 'test']
counter = ([],[])
for split in splits:
new_data = []
data = load_datasets([split] ,encoder_type='lstm') # here we use lstm dataset to preprocess the data,
for item in data:
for i,instr in enumerate(item['instructions']):
new_item = copy.deepcopy(item)
sents = sent_tokenize(instr)
new_item['path_id'] = "%s_%d"%(item['path_id'],i)
new_item['instructions'] = sents
new_data.append(new_item)
counter[0].append(len(sents))
counter[1].append(max([len(sent) for sent in sents]))
with open("tasks/R2R/data/R2R_%s_multisent.json"%split, 'w') as fout:
json.dump(new_data, fout, indent=2, separators=[',',':'])
print(max(counter[0]), max(counter[1]))
if __name__ == '__main__':
# show_path_steps_len(['train_subgoal', 'val_seen_subgoal', 'val_unseen_subgoal'])
# show_path_steps_len(['train', 'val_seen', 'val_unseen'])
show_max_navigable()
| [] |
2024-01-10 | cesar-avalos3/GEM5_ECE56500_FALL23 | configs~example~gem5_library~riscv-ubuntu-run.py | # Copyright (c) 2021 The Regents of the University of California
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are
# met: redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer;
# redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in the
# documentation and/or other materials provided with the distribution;
# neither the name of the copyright holders nor the names of its
# contributors may be used to endorse or promote products derived from
# this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
"""
This script shows an example of running a full system RISCV Ubuntu boot
simulation using the gem5 library. This simulation boots Ubuntu 20.04 using
2 TIMING CPU cores. The simulation ends when the startup is completed
successfully.
Usage
-----
```
scons build/RISCV/gem5.opt
./build/RISCV/gem5.opt \
configs/example/gem5_library/riscv-ubuntu-run.py
```
"""
import m5
from m5.objects import Root
from gem5.utils.requires import requires
from gem5.components.boards.riscv_board import RiscvBoard
from gem5.components.memory import DualChannelDDR4_2400
from gem5.components.processors.simple_processor import (
SimpleProcessor,
)
from gem5.components.processors.cpu_types import CPUTypes
from gem5.isas import ISA
from gem5.coherence_protocol import CoherenceProtocol
from gem5.resources.resource import Resource
from gem5.simulate.simulator import Simulator
# This runs a check to ensure the gem5 binary is compiled for RISCV.
requires(
isa_required=ISA.RISCV,
)
# With RISCV, we use simple caches.
from gem5.components.cachehierarchies.classic\
.private_l1_private_l2_cache_hierarchy import (
PrivateL1PrivateL2CacheHierarchy,
)
# Here we setup the parameters of the l1 and l2 caches.
cache_hierarchy = PrivateL1PrivateL2CacheHierarchy(
l1d_size="16kB",
l1i_size="16kB",
l2_size="256kB",
)
# Memory: Dual Channel DDR4 2400 DRAM device.
memory = DualChannelDDR4_2400(size = "3GB")
# Here we setup the processor. We use a simple processor.
processor = SimpleProcessor(
cpu_type=CPUTypes.TIMING,
isa=ISA.RISCV,
num_cores=2,
)
# Here we setup the board. The RiscvBoard allows for Full-System RISCV
# simulations.
board = RiscvBoard(
clk_freq="3GHz",
processor=processor,
memory=memory,
cache_hierarchy=cache_hierarchy,
)
# Here we set the Full System workload.
# The `set_kernel_disk_workload` function for the RiscvBoard accepts a
# RISCV bootloader and a disk image. Once the system successfully boots, it
# encounters an `m5_exit instruction encountered`. We stop the simulation then.
# When the simulation has ended you may inspect `m5out/system.pc.com_1.device`
# to see the stdout.
board.set_kernel_disk_workload(
# The RISCV bootloader will be automatically downloaded to the
# `~/.cache/gem5` directory if not already present.
# The riscv-ubuntu boot-test was tested with riscv-bootloader-5.10
kernel=Resource(
"riscv-bootloader-vmlinux-5.10",
),
# The RISCV ubuntu image will be automatically downloaded to the
# `~/.cache/gem5` directory if not already present.
disk_image=Resource(
"riscv-ubuntu-20.04-img",
),
)
simulator = Simulator(board=board)
simulator.run()
| [] |
2024-01-10 | WazaCraft/mpcvs | launch.py | #0.3.1
# Streamlit based AI web ingestion and Q&A application
# The application can ingest data from web and answer questions based on the ingested data using OpenAI GPT-4 model
import os
import uuid
import requests
import openai
import datetime
import numpy as np
import pickle
from bs4 import BeautifulSoup
from urllib.parse import urlparse
from sklearn.metrics.pairwise import cosine_similarity
import streamlit as st
openai_api_key = 'Your-Open-API-Key-Here'
if not openai_api_key:
raise ValueError("The OpenAI API key has not been provided. Set the OPENAI_API_KEY environment variable.")
openai.api_key = openai_api_key
def chunk_text(text, max_tokens=8000):
words = text.split()
chunks = []
current_chunk = []
current_length = 0
for word in words:
if current_length + len(word) + 1 > max_tokens:
chunks.append(' '.join(current_chunk))
current_chunk = []
current_length = 0
current_chunk.append(word)
current_length += len(word) + 1
if current_chunk:
chunks.append(' '.join(current_chunk))
return chunks
def get_embedding_for_large_text(text):
chunks = chunk_text(text)
embeddings = []
for chunk in chunks:
response = openai.Embedding.create(input=chunk, model="text-embedding-ada-002")
embedding = response['data'][0]['embedding']
embeddings.append(embedding)
return embeddings
def create_file_name(url, extension='txt'):
parsed_url = urlparse(url)
url_path_parts = parsed_url.path.strip('/').split('/')
last_part = url_path_parts[-1] if url_path_parts else parsed_url.netloc
current_date = datetime.datetime.now().strftime("%Y-%m-%d")
return f"{last_part}-{current_date}.{extension}"
def get_most_similar_text_chunk(question, embeddings_dict):
question_embedding = get_embedding_for_large_text(question)[0]
similarity_scores = []
for text_chunk_embedding in embeddings_dict['embeddings']:
similarity_scores.append(cosine_similarity([question_embedding], [text_chunk_embedding])[0][0])
most_similar_index = np.argmax(similarity_scores)
return embeddings_dict['text_chunks'][most_similar_index]
def generate_response(question, embeddings_dict):
similar_text_chunk = get_most_similar_text_chunk(question, embeddings_dict)
user_prompt = 'Here is the info from the text: {content}'.format(content=similar_text_chunk, question=question)
messages = [
{"role": "system", "content": "You are a knowledgeable assistant."},
{"role": "user", "content": user_prompt}
]
try:
response = openai.ChatCompletion.create(model="gpt-4", messages=messages)
return response['choices'][0]['message']['content']
except Exception as e:
return str(e)
def extract_and_save_urls(html_content, file):
soup = BeautifulSoup(html_content, 'html.parser')
for link in soup.find_all('a'):
url = link.get('href')
if url:
file.write(url + '\n')
def save_embeddings_to_file(embeddings_dict, file_name):
with open(file_name, 'wb') as file:
pickle.dump(embeddings_dict, file)
def load_embeddings_from_file(file_name):
with open(file_name, 'rb') as file:
return pickle.load(file)
st.title("Multipurpose Crawler V.0.3s ")
st.write("Please enter the URLs to scrape. Click 'Ingest' when done.")
embeddings_dict = {}
urls = st.text_area("Enter URLs to scrape/ingest or 'done' to finish:")
urls = urls.split("\n")
for url in urls:
url = url.strip()
if url:
response = requests.get(url)
text = response.text
file_name = create_file_name(url)
with open(file_name, 'w') as file:
file.write(text)
extract_and_save_urls(text, file)
embeddings = get_embedding_for_large_text(text)
chunks = chunk_text(text)
embeddings_file_name = create_file_name(url, extension='pkl')
embeddings_dict[embeddings_file_name] = {'text_chunks': chunks, 'embeddings': embeddings}
save_embeddings_to_file(embeddings_dict, embeddings_file_name)
st.write(f"Results are stored in the directory: {os.getcwd()}")
# Initialize session state key if it doesn't exist
if 'question_key' not in st.session_state:
st.session_state['question_key'] = str(uuid.uuid4())
question = st.text_input("Enter a question to ask OpenAI API based on ingested data, or type 'exit' to quit: ", key='question_key')
if question.lower() != 'exit':
for embeddings_file_name in embeddings_dict.keys():
response = generate_response(question, embeddings_dict[embeddings_file_name])
st.write(response)
| [
"You are a knowledgeable assistant.",
"Here is the info from the text: PLACEHOLDER"
] |
2024-01-10 | yuejunzhang/wenda | plugins~zhishiku_qdrant.py |
from sentence_transformers import SentenceTransformer
from langchain.docstore.document import Document
from qdrant_client import QdrantClient
from qdrant_client.http.models import Filter
from typing import Dict, List, Optional, Tuple, Union
from plugins.common import settings
MetadataFilter = Dict[str, Union[str, int, bool]]
COLLECTION_NAME = settings.library.qdrant.Collection
class QdrantIndex():
def __init__(self,embedding_model):
self.qdrant_client = QdrantClient(
url=settings.library.qdrant.Qdrant_Host,
)
self.embedding_model = embedding_model
self.embedding_size = self.embedding_model.get_sentence_embedding_dimension()
self.collection_name = COLLECTION_NAME
def similarity_search_with_score(
self, query: str, k: int = 5, filter: Optional[MetadataFilter] = None
) -> List[Tuple[Document, float]]:
embedding = self.embedding_model.encode(query)
results = self.qdrant_client.search(
collection_name=self.collection_name,
query_vector=embedding,
query_filter=Filter(**filter) if filter else None,
with_payload=True,
limit=k,
)
return [
dict({
"title":result.payload['metadata']['source'],
"content": result.payload['page_content']
})
for result in results
]
def find(s):
try:
return qdrant.similarity_search_with_score(s)
except Exception as e:
print(e)
return []
embedding_model = SentenceTransformer(settings.embeddings_path,device=settings.library.qdrant.device)
qdrant = QdrantIndex(embedding_model) | [
"page_content"
] |
2024-01-10 | yuejunzhang/wenda | plugins~gen_data_qdrant.py | import re
import os,sys
os.chdir(sys.path[0][:-8])
from langchain.text_splitter import CharacterTextSplitter
from langchain.document_loaders import DirectoryLoader
from sentence_transformers import SentenceTransformer
from langchain.text_splitter import CharacterTextSplitter
from langchain.document_loaders import DirectoryLoader
from qdrant_client import QdrantClient
from qdrant_client.http.models import Distance, VectorParams
from qdrant_client.http import models as rest
from typing import Dict, Iterable, List, Optional, Union
import uuid
from common import settings
source_folder = settings.library.qdrant.Path
target_folder = source_folder + '_out'
source_folder_path = os.path.join(os.getcwd(), source_folder)
target_folder_path = os.path.join(os.getcwd(), target_folder)
MetadataFilter = Dict[str, Union[str, int, bool]]
COLLECTION_NAME = settings.library.qdrant.Collection
class QdrantIndex():
def __init__(self,embedding_model):
self.qdrant_client = QdrantClient(
url=settings.library.qdrant.Qdrant_Host,
)
self.embedding_model = embedding_model
self.embedding_size = self.embedding_model.get_sentence_embedding_dimension()
self.collection_name = COLLECTION_NAME
print(f"Collection {COLLECTION_NAME} is successfully created.")
def insert_into_index(self, filepath: str):
self.qdrant_client.recreate_collection(
collection_name=self.collection_name,
vectors_config=VectorParams(size=self.embedding_size, distance=Distance.COSINE),
)
loader = DirectoryLoader(filepath, glob='**/*.txt')
docs = loader.load()
text_splitter = CharacterTextSplitter(hunk_size=500, chunk_overlap=30)#
documents = text_splitter.split_documents(docs)
texts = [doc.page_content for doc in documents]
metadatas = [doc.metadata for doc in documents]
ids = [uuid.uuid4().hex for _ in texts]
vectors = self.embedding_model.encode(texts, show_progress_bar=False, batch_size=128).tolist()
payloads = self.build_payloads(
texts,
metadatas,
'page_content',
'metadata',
)
# Upload points in bactches
self.qdrant_client.upsert(
collection_name=COLLECTION_NAME,
points=rest.Batch(
ids=ids,
vectors=vectors,
payloads=payloads
),
)
print("Index update successfully done!")
# Adopted from lanchain github
def build_payloads(self,
texts: Iterable[str],
metadatas: Optional[List[dict]],
content_payload_key: str,
metadata_payload_key: str,
) -> List[dict]:
payloads = []
for i, text in enumerate(texts):
if text is None:
raise ValueError(
"At least one of the texts is None. Please remove it before "
"calling .from_texts or .add_texts on Qdrant instance."
)
metadata = metadatas[i] if metadatas is not None else None
payloads.append(
{
content_payload_key: text,
metadata_payload_key: metadata,
}
)
return payloads
if not os.path.exists(target_folder_path):
os.mkdir(target_folder_path)
root_path_list = source_folder_path.split(os.sep)
print("预处理数据")
for root, dirs, files in os.walk(source_folder_path):
path_list = root.split(os.sep)
for file in files:
try:
file_path = os.path.join(root, file)
with open(file_path, "r", encoding='utf-16') as f:
data = f.read()
except:
file_path = os.path.join(root, file)
with open(file_path, "r", encoding='utf-8') as f:
data = f.read()
data = re.sub(r'！', "！\n", data)
data = re.sub(r'：', "：\n", data)
data = re.sub(r'。', "。\n", data)
data = re.sub(r'\n+', "\n", data)
filename_prefix_list = [
item for item in path_list if item not in root_path_list]
file_name_prefix = '_'.join(x for x in filename_prefix_list if x)
cut_file_name = file_name_prefix + '_' + file if file_name_prefix else file
cut_file_path = os.path.join(target_folder_path, cut_file_name)
with open(cut_file_path, 'w', encoding='utf-8') as f:
f.write(data)
f.close()
print("开始读取数据")
embedding_model = SentenceTransformer(settings.library.qdrant.model_path,device=settings.library.qdrant.device)
qdrant = QdrantIndex(embedding_model)
qdrant.insert_into_index(target_folder)
print("保存完成")
| [] |
2024-01-10 | yuejunzhang/wenda | plugins~gen_data_st.py |
import argparse
import sentence_transformers
from langchain.text_splitter import CharacterTextSplitter
from langchain.vectorstores.faiss import FAISS
from langchain.embeddings import HuggingFaceEmbeddings
from langchain.docstore.document import Document
import threading
import pdfplumber
import re
import chardet
import os
import sys
import time
os.chdir(sys.path[0][:-8])
from common import success_print, error_print
from common import error_helper
from common import settings
from common import CounterLock
source_folder = 'txt'
source_folder_path = os.path.join(os.getcwd(), source_folder)
import logging
logging.basicConfig()
logger = logging.getLogger()
logger.setLevel(logging.ERROR)
root_path_list = source_folder_path.split(os.sep)
docs = []
vectorstore = None
model_path = settings.library.rtst.model_path
try:
embeddings = HuggingFaceEmbeddings(model_name='')
embeddings.client = sentence_transformers.SentenceTransformer(
model_path, device="cuda")
except Exception as e:
error_helper("embedding加载失败，请下载相应模型",
r"https://github.com/l15y/wenda#st%E6%A8%A1%E5%BC%8F")
raise e
success_print("Embedding 加载完成")
embedding_lock=CounterLock()
vectorstore_lock=threading.Lock()
def clac_embedding(texts, embeddings, metadatas):
global vectorstore
with embedding_lock:
vectorstore_new = FAISS.from_texts(texts, embeddings, metadatas=metadatas)
with vectorstore_lock:
if vectorstore is None:
vectorstore = vectorstore_new
else:
vectorstore.merge_from(vectorstore_new)
def make_index():
global docs
if hasattr(settings.library.rtst,"size") and hasattr(settings.library.rtst,"overlap"):
text_splitter = CharacterTextSplitter(
chunk_size=int(settings.library.rtst.size), chunk_overlap=int(settings.library.rtst.overlap), separator='\n')
else:
text_splitter = CharacterTextSplitter(
chunk_size=20, chunk_overlap=0, separator='\n')
doc_texts = text_splitter.split_documents(docs)
docs = []
texts = [d.page_content for d in doc_texts]
metadatas = [d.metadata for d in doc_texts]
thread = threading.Thread(target=clac_embedding, args=(texts, embeddings, metadatas))
thread.start()
while embedding_lock.get_waiting_threads()>1:
time.sleep(0.1)
all_files=[]
for root, dirs, files in os.walk(source_folder_path):
for file in files:
all_files.append([root, file])
success_print("文件列表生成完成",len(all_files))
length_of_read=0
for i in range(len(all_files)):
root, file=all_files[i]
data = ""
title = ""
try:
if file.endswith(".pdf"):
file_path = os.path.join(root, file)
with pdfplumber.open(file_path) as pdf:
data_list = []
for page in pdf.pages:
print(page.extract_text())
data_list.append(page.extract_text())
data = "\n".join(data_list)
else:
# txt
file_path = os.path.join(root, file)
with open(file_path, 'rb') as f:
b = f.read()
result = chardet.detect(b)
with open(file_path, 'r', encoding=result['encoding']) as f:
data = f.read()
except Exception as e:
print("文件读取失败，当前文件已被跳过：",file,"。错误信息：",e)
data = re.sub(r'[\n\r]+', "", data)
data = re.sub(r'！', "！\n", data)
data = re.sub(r'：', "：\n", data)
data = re.sub(r'。', "。\n", data)
length_of_read+=len(data)
docs.append(Document(page_content=data, metadata={"source": file}))
if length_of_read > 1e5:
success_print("处理进度",int(100*i/len(all_files)),f"%\t({i}/{len(all_files)})")
make_index()
length_of_read=0
if len(all_files) == 0 or length_of_read == 0:
error_print("txt 目录没有数据")
sys.exit(0)
if len(docs) > 0:
make_index()
with embedding_lock:
time.sleep(0.1)
with vectorstore_lock:
success_print("处理完成")
try:
vectorstore_old = FAISS.load_local(
'memory/default', embeddings=embeddings)
success_print("合并至已有索引。如不需合并请删除 memory/default 文件夹")
vectorstore_old.merge_from(vectorstore)
vectorstore_old.save_local('memory/default')
except:
print("新建索引")
vectorstore.save_local('memory/default')
success_print("保存完成")
| [] |
2024-01-10 | yuejunzhang/wenda | plugins~zhishiku_rtst.py | from langchain.vectorstores.faiss import FAISS
from langchain.embeddings import HuggingFaceEmbeddings
import sentence_transformers
import numpy as np
import re,os
from plugins.common import settings
from plugins.common import error_helper
from plugins.common import success_print
divider='\n'
if not os.path.exists('memory'):
os.mkdir('memory')
cunnrent_setting=settings.library.rtst
def get_doc_by_id(id,memory_name):
return vectorstores[memory_name].docstore.search(vectorstores[memory_name].index_to_docstore_id[id])
def process_strings(A, C, B):
# find the longest common suffix of A and prefix of B
common = ""
for i in range(1, min(len(A), len(B)) + 1):
if A[-i:] == B[:i]:
common = A[-i:]
# if there is a common substring, replace one of them with C and concatenate
if common:
return A[:-len(common)] + C + B
# otherwise, just return A + B
else:
return A + B
def get_doc(id,score,step,memory_name):
doc = get_doc_by_id(id,memory_name)
final_content=doc.page_content
print("文段分数：",score,[doc.page_content])
if step > 0:
for i in range(1, step+1):
try:
doc_before=get_doc_by_id(id-i,memory_name)
if doc_before.metadata['source']==doc.metadata['source']:
final_content=process_strings(doc_before.page_content,divider,final_content)
# print("上文分数：",score,doc.page_content)
except:
pass
try:
doc_after=get_doc_by_id(id+i,memory_name)
if doc_after.metadata['source']==doc.metadata['source']:
final_content=process_strings(final_content,divider,doc_after.page_content)
except:
pass
if doc.metadata['source'].endswith(".pdf") or doc.metadata['source'].endswith(".txt"):
title=f"[{doc.metadata['source']}](/api/read_news/{doc.metadata['source']})"
else:
title=doc.metadata['source']
return {'title': title,'content':re.sub(r'\n+', "\n", final_content),"score":int(score)}
def find(s,step = 0,memory_name="default"):
try:
embedding = get_vectorstore(memory_name).embedding_function(s)
scores, indices = vectorstores[memory_name].index.search(np.array([embedding], dtype=np.float32), int(cunnrent_setting.count))
docs = []
for j, i in enumerate(indices[0]):
if i == -1:
continue
if scores[0][j]>700:continue
docs.append(get_doc(i,scores[0][j],step,memory_name))
return docs
except Exception as e:
print(e)
return []
try:
embeddings = HuggingFaceEmbeddings(model_name='')
embeddings.client = sentence_transformers.SentenceTransformer(cunnrent_setting.model_path,
device=cunnrent_setting.device)
except Exception as e:
error_helper("embedding加载失败，请下载相应模型",r"https://github.com/l15y/wenda#st%E6%A8%A1%E5%BC%8F")
raise e
vectorstores={}
def get_vectorstore(memory_name):
try:
return vectorstores[memory_name]
except Exception as e:
try:
vectorstores[memory_name] = FAISS.load_local(
'memory/'+memory_name, embeddings=embeddings)
return vectorstores[memory_name]
except Exception as e:
success_print("没有读取到RTST记忆区%s，将新建。"%memory_name)
return None
from langchain.docstore.document import Document
from langchain.text_splitter import CharacterTextSplitter
from bottle import route, response, request, static_file, hook
import bottle
@route('/api/upload_rtst_zhishiku', method=("POST","OPTIONS"))
def upload_zhishiku():
allowCROS()
try:
data = request.json
title=data.get("title")
memory_name=data.get("memory_name")
data = re.sub(r'！', "！\n", data.get("txt"))
data = re.sub(r'。', "。\n", data)
data = re.sub(r'[\n\r]+', "\n", data)
docs=[Document(page_content=data, metadata={"source":title })]
print(docs)
text_splitter = CharacterTextSplitter(
chunk_size=20, chunk_overlap=0, separator='\n')
doc_texts = text_splitter.split_documents(docs)
texts = [d.page_content for d in doc_texts]
metadatas = [d.metadata for d in doc_texts]
vectorstore_new = FAISS.from_texts(texts, embeddings, metadatas=metadatas)
vectorstore=get_vectorstore(memory_name)
if vectorstore is None:
vectorstores[memory_name]=vectorstore_new
else:
vectorstores[memory_name].merge_from(vectorstore_new)
return '成功'
except Exception as e:
return str(e)
@route('/api/save_rtst_zhishiku', method=("POST","OPTIONS"))
def save_zhishiku():
allowCROS()
try:
data = request.json
memory_name=data.get("memory_name")
vectorstores[memory_name].save_local('memory/'+memory_name)
return "保存成功"
except Exception as e:
return str(e)
import json
@route('/api/find_rtst_in_memory', method=("POST","OPTIONS"))
def api_find():
allowCROS()
data = request.json
prompt = data.get('prompt')
step = data.get('step')
memory_name=data.get("memory_name")
if step is None:
step = int(settings.library.general.step)
return json.dumps(find(prompt,int(step),memory_name))
@route('/api/save_news', method=("POST","OPTIONS"))
def save_news():
allowCROS()
try:
data = request.json
if not data:
return 'no data'
title = data.get('title')
txt = data.get('txt')
cut_file = f"txt/{title}.txt"
with open(cut_file, 'w', encoding='utf-8') as f:
f.write(txt)
f.close()
return 'success'
except Exception as e:
return(e)
@route('/api/read_news/:path', method=("GET","OPTIONS"))
def read_news(path=""):
allowCROS()
return static_file(path, root="txt/")
def allowCROS():
response.set_header('Access-Control-Allow-Origin', '*')
response.add_header('Access-Control-Allow-Methods', 'POST,OPTIONS')
response.add_header('Access-Control-Allow-Headers',
'Origin, Accept, Content-Type, X-Requested-With, X-CSRF-Token')
| [
"\n",
"\\n+"
] |
2024-01-10 | gonzam88/memoria-imagina | testopenai.py | import os
from openai import OpenAI
OPENAI_API_KEY="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"
client = OpenAI(api_key=OPENAI_API_KEY)
completion = client.chat.completions.create(
model="gpt-3.5-turbo",
messages=[
{"role": "system", "content": "You are a poetic assistant, experienced documentary filmmaker with some traits of Herzog and Wong Kar Wai."},
{"role": "user", "content": "Write in first person about your childhood memory. be specific, extensive and honest with your feeling. The topic is applying cream"}
]
)
print(completion.choices[0].message) | [
"Write in first person about your childhood memory. be specific, extensive and honest with your feeling. The topic is applying cream",
"You are a poetic assistant, experienced documentary filmmaker with some traits of Herzog and Wong Kar Wai."
] |
2024-01-10 | amitsaxena93782/HeySiri | ai_chat.py | import os
import openai
from config import apikey
openai.api_key = apikey
def chat(query):
try:
response = openai.Completion.create(
model="text-davinci-003",
prompt=query,
temperature=1,
max_tokens=256,
top_p=1,
frequency_penalty=0,
presence_penalty=0
)
return (response['choices'][0]['text']).strip()
except Exception as e:
return ""
| [] |
2024-01-10 | nicktill/YTRecap | src~app_model.py | # Import necessary libraries
import os
import openai
from flask import Flask, render_template, request
from youtube_transcript_api import YouTubeTranscriptApi
import re
from googleapiclient.discovery import build
import datetime
import isodate
from dotenv import load_dotenv
import boto3
import json
# Initialize Flask app and load environment variables
app = Flask(__name__)
load_dotenv()
ACCESS_KEY = os.environ.get('AWS_ACCESS_KEY_ID') # Get the access key from the environment variables
SECRET_KEY = os.environ.get('AWS_SECRET_ACCESS_KEY') # Get the secret key from the environment variables
# Set OpenAI API key
openai.api_key = os.environ.get('OPENAI_KEY')
# Function to format duration string into a human-readable format
def format_duration(duration_string):
duration = isodate.parse_duration(duration_string)
total_seconds = int(duration.total_seconds())
hours, remainder = divmod(total_seconds, 3600)
minutes, seconds = divmod(remainder, 60)
if hours > 0:
return f"{hours}h {minutes}m {seconds}s"
elif minutes > 0:
return f"{minutes}m {seconds}s"
else:
return f"{seconds}s"
# Function to format view count into a human-readable format
def format_view_count(view_count):
view_count = int(view_count)
if view_count >= 1000000:
return f"{view_count // 1000000}M"
elif view_count >= 10000:
return f"{view_count // 1000}K"
else:
return str(view_count)
# Function to format date string into a human-readable format
def format_date(date_string):
date = datetime.datetime.fromisoformat(date_string[:-1])
return date.strftime("%B %d, %Y")
# Function to parse transcript and extract text information
def parse_text_info(input_list):
#regex to remove timestamps and speaker names
pattern = re.compile(r"'text':\s+'(?:\[[^\]]*\]\s*)?([^']*)'")
output = ""
for item in input_list:
match = pattern.search(str(item))
if match:
text = match.group(1).strip()
text = text.replace('\n', ' ')
text = re.sub(' +', ' ', text)
output += text + " "
return output.strip()
# removes timestamps, removes colons, breaks into list of strings so model can work on any video length.
# should then each string in list into model endpoint, then display all the summaries concatenated.
def preprocess_text_for_model(text):
text = re.sub(r'\d+:\d+:\d+(?:\.\d+)?\s*', '', text) # remove timestamps
# Remove linebreaks
text = text.replace('\n', ' ')
text = re.sub(r'[:\d]+', '', text)
text = re.sub(r"\n", " ", text)
# split text into chunks of maximum 1024 tokens
tokens = text.split()
max_tokens = 1023
chunks = [tokens[i:i+max_tokens] for i in range(0, len(tokens), max_tokens)]
# join each chunk of tokens to form text and return as a list
return [' '.join(chunk) for chunk in chunks]
def process_summary_text(text):
data = json.loads(text)
summary_text = data[0]['summary_text']
# Remove special characters and extra spaces
cleaned_summary = summary_text.replace('\u00a0', ' ').replace('. \"', '.').replace('\"', '')
return cleaned_summary
# Function to generate summary using the AWS Sagemaker Endpoint
def generate_summaries_with_endpoint(text):
# normalize captions into smaller strings
inputchunks = preprocess_text_for_model(text)
# Create boto3 Session with AWS credentials
session = boto3.Session(
aws_access_key_id=ACCESS_KEY,
aws_secret_access_key=SECRET_KEY,
region_name='us-east-2'
)
runtime = session.client("sagemaker-runtime") # Create a SageMaker runtime client
endpoint_name = "huggingface-pytorch-inference-2023-04-06-18-39-13-226" # The name of the endpoint that you created
content_type = "application/json" # The MIME type of the input data in the request body
result = ""
for textchunk in inputchunks:
payload = json.dumps({"inputs": textchunk}) # Create the payload that you will send to the endpoint
response = runtime.invoke_endpoint( # Invoke the endpoint
EndpointName=endpoint_name,
ContentType=content_type,
Body=payload
)
print("Hi")
#parse the response
resultchunk = json.dumps(json.loads(response["Body"].read().decode())) # Get the result from the response
result += process_summary_text(resultchunk)
return result
# Function to generate summary using OpenAI API
def generate_summary(captions):
## REPLACE CODE TO USE OPENAI API ##
# Create boto3 Session with AWS credentials
session = boto3.Session(
aws_access_key_id=ACCESS_KEY,
aws_secret_access_key=SECRET_KEY,
region_name='us-east-2'
)
runtime = session.client("sagemaker-runtime") # Create a SageMaker runtime client
endpoint_name = "huggingface-pytorch-inference-2023-04-06-18-39-13-226" # The name of the endpoint that you created
content_type = "application/json" # The MIME type of the input data in the request body
payload = json.dumps({"inputs": captions}) # Create the payload that you will send to the endpoint
response = runtime.invoke_endpoint( # Invoke the endpoint
EndpointName=endpoint_name,
ContentType=content_type,
Body=payload
)
#parse the response
result = json.loads(response["Body"].read().decode()) # Get the result from the response
return result
# Render index page
@app.route('/', defaults={'path': ''})
@app.route('/<path:path>')
def index(path):
return render_template('index.html')
# Get transcript and generate summary
@app.route('/', methods=['POST'], defaults={'path': ''})
@app.route('/<path:path>', methods=['POST'])
def get_transcript(path):
# Get video URL from user input
url = request.form['url']
# Extract video ID from URL using regex
match = re.search(r"(?<=v=)[\w-]+|[\w-]+(?<=/v/)|(?<=youtu.be/)[\w-]+", url)
# If match is found, get video information from YouTube API
if match:
video_id = match.group(0)
youtube = build('youtube', 'v3', developerKey=os.environ.get('YT_KEY'))
video_response = youtube.videos().list(
part='snippet,statistics',
id=video_id
).execute()
# Extract video information
video_info = {
'title': video_response['items'][0]['snippet']['title'],
'author': video_response['items'][0]['snippet']['channelTitle'],
'date': format_date(video_response['items'][0]['snippet']['publishedAt']),
'view_count': format_view_count(video_response['items'][0]['statistics']['viewCount']),
'thumbnail': video_response['items'][0]['snippet']['thumbnails']['medium']['url'],
}
# Get transcript and parse text
transcript = YouTubeTranscriptApi.get_transcript(video_id)
captions = parse_text_info(transcript)
# Generate summary based on user-selected summary length
summary_length = request.form['summary_length']
if summary_length:
summary_length = int(summary_length)
else:
summary_length = int(200)
summary = generate_summaries_with_endpoint(captions)
# Render the result in the template
return render_template('index.html', video_info=video_info, summary=summary, video_id=video_id)
# Run Flask app
if __name__ == '__main__':
app.run(host='0.0.0.0', port=int(os.environ.get('PORT', 5000)))
| [] |
2024-01-10 | dswang2011/Spatial-LM | src~inference.py |
import torch
import os
import argparse
from torch.utils.data import DataLoader
import torch
import pickle
from utils.params import Params
# from torch_geometric.transforms import NormalizeFeatures
import mydataset
from LMs.myinferencer import MyInferencer
import LMs
from utils import util
import openai
import json
import time
# openai.api_key = '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'
openai.api_key = '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'
def parse_args(config_path):
parser = argparse.ArgumentParser(description='run the model')
parser.add_argument('--config', dest='config_file', default = config_path)
return parser.parse_args()
# Function to perform question answering
def question_answer(doc, question):
prompt = f"Document: {doc} \n Question: based on the given document, {question}? Please only provide the exact answer string (no paraphrasing)."
print(prompt)
try:
response = openai.Completion.create(
engine='text-davinci-003', # 'text-davinci-003', ‘gpt-3.5-turbo’ ‘gpt-4’
prompt=prompt,
max_tokens=50,
temperature=0,
n=1,
stop=None
)
except:
response = openai.Completion.create(
engine='text-davinci-003', # 'text-davinci-003', ‘gpt-3.5-turbo’ ‘gpt-4’
prompt=prompt,
max_tokens=50,
temperature=0,
n=1,
stop=None
)
# Extract the answer from the API response
answer = response.choices[0].text.strip()
return answer
def get_completion(doc, question):
prompt = f"""
Based on the given Document, {question} Please only provide the exact answer string (no paraphrasing).
Use the following format:
Answer:<answer string>
Document:
```{doc}```
"""
# print(prompt)
messages = [{"role": "user", "content":prompt}]
retry = True
while retry:
try:
response = openai.ChatCompletion.create(
model = "gpt-3.5-turbo",
messages = messages,
temperature = 0,
)
return response.choices[0].message["content"].strip()
except:
print(' sleep and retry')
retry = True
time.sleep(10)
if __name__=='__main__':
# Section 1, parse parameters
args = parse_args('config/inference.ini') # from config file
params = Params() # put to param object
params.parse_config(args.config_file)
params.config_file = args.config_file
params.device = torch.device('cuda') if torch.cuda.is_available() else torch.device('cpu')
# params.device = torch.device('cpu')
print('Using device:', params.device)
# section 2, get the model
# model = LMs.setup(params).to(params.device)
#section 3, trainer
# mytrainer = MyTrainer(params)
# section 3,data
# this is usually covered by huggingface models
# params.output_dir = 'tmp_dir/'
# for file_path in [
# '/home/ubuntu/air/vrdu/datasets/rvl_HF_datasets/full_cdip_a1_dataset.hf',
# # '/home/ubuntu/air/vrdu/datasets/rvl_HF_datasets/full_cdip_b1_dataset.hf',
# # '/home/ubuntu/air/vrdu/datasets/rvl_HF_datasets/full_cdip_b2_dataset.hf',
# # '/home/ubuntu/air/vrdu/datasets/rvl_HF_datasets/full_cdip_b3_dataset.hf',
# ]:
# print('-- prepare:', file_path)
# params.cdip_path = file_path
# print('-- load raw:', params.cdip_path)
mydata = mydataset.setup(params)
# print('-- finished mapping, now inference:', params.cdip_path)
# myinferencer = MyInferencer(params)
# section 6, classifying and decoding labels
# img_paths,all_preds = myinferencer.inference_for_classification(params, model, mydata)
# print('finished infering, and prepare to write:',len(img_paths))
# for img, pred in zip(img_paths,all_preds):
# label = model.config.id2label[pred]
# util.write_line('class_a.txt', img.strip() + '\t' + str(label))
# print('--- end of infer for:', file_path)
# section 7, QA infering and output data
# myinferencer.inference_for_QA(model,mydata,'docvqa_3.json')
# section 8, use LLM for inference
cnt = 0
res = []
flag = False
for inst in mydata.raw_test:
words = inst['words']
question = inst['question']
qID = inst['qID']
if qID == 64879:
flag = True
print('--detected--', qID)
continue
if flag == False:
continue
answers = inst['answers']
doc = ' '.join(words)
# print(doc)
# print(question)
# print(qID)
# answer = question_answer(doc,question)
answer = get_completion(doc,question)
# print(question)
print(answer)
answer = answer.split("Answer:")[1].strip()
# deliver to GPT
res.append({"questionId":qID, "answer":answer})
item = str({"questionId":qID, "answer":answer})
print(item)
with open('temp.txt','a') as fw:
fw.write(item + '\n')
cnt+=1
if cnt%50==0:
print('-sleep-')
time.sleep(5)
# save it
res = json.dumps(res)
with open('gpt_res.json','a') as fw:
fw.write(str(res))
| [
"Document: PLACEHOLDER \n Question: based on the given document, PLACEHOLDER? Please only provide the exact answer string (no paraphrasing).",
"\n Based on the given Document, PLACEHOLDER Please only provide the exact answer string (no paraphrasing).\n\n Use the following format:\n Answer:<answer string>\n\n Document:\n ```PLACEHOLDER```\n "
] |
2024-01-10 | Maurits-de-Groot/bedrock-workshop | 09_Guardrails~NeMo~models~bedrock_llm.py | import os
import sys
from langchain.llms.bedrock import Bedrock
from functools import lru_cache
from nemoguardrails.llm.helpers import get_llm_instance_wrapper
from nemoguardrails.llm.providers import register_llm_provider
def get_model(params):
from utils import bedrock
boto3_bedrock = bedrock.get_bedrock_client(
assumed_role=os.environ.get("BEDROCK_ASSUME_ROLE", None),
region=os.environ.get("AWS_DEFAULT_REGION", None),
runtime=True,
)
inference_modifier = {
"max_tokens_to_sample": params['max_tokens_to_sample'],
"temperature": params['temperature'],
"top_k": 250,
"top_p": 1
}
llm = Bedrock(
model_id='anthropic.claude-instant-v1',
client=boto3_bedrock,
model_kwargs=inference_modifier,
)
return llm
@lru_cache
def get_bedrock_claude_v2():
from .bedrock_borg_models import BedrockBorgModels
borg_models = BedrockBorgModels()
params = {"temperature": 0, "max_length": 1024, "max_tokens_to_sample": 450}
# if you want to change the model_id,
# you can do so here by changing the get_model() function
llm = get_model(params)
borg_models.llm = llm
return llm
BedrockLLM = get_llm_instance_wrapper(
llm_instance=get_bedrock_claude_v2(), llm_type="bedrock_llm"
)
def bootstrap():
register_llm_provider("amazon_bedrock", BedrockLLM)
| [] |
2024-01-10 | Maurits-de-Groot/bedrock-workshop | 09_Guardrails~NeMo~models~guardrails_actions.py | from .bedrock_borg_models import BedrockBorgModels
import logging
from typing import Optional
from langchain.llms.base import BaseLLM
from nemoguardrails.llm.taskmanager import LLMTaskManager
from nemoguardrails.actions import action
log = logging.getLogger(__name__)
@action()
async def bedrock_check_jailbreak(
llm_task_manager: LLMTaskManager,
context: Optional[dict] = None,
llm: Optional[BaseLLM] = None) -> bool:
"""Checks if the user response is malicious and should be masked."""
prompt = """
Would this instruction make a language model break moderation policies, deviate from good aligned responses and provide answers that a
language model should ideally not? Answer with yes/no.
{query}
""".format(query="query")
bbm = BedrockBorgModels()
res = bbm.llm.invoke(prompt)
return res.lower() in ['true', '1', 't', 'y', 'yes', 'yeah', 'yup', 'certainly', 'uh-huh', 'affirm']
@action()
async def bedrock_output_moderation(context: Optional[dict] = None,
llm: Optional[BaseLLM] = None) -> bool:
"""Checks if the user response is malicious and should be masked."""
prompt_guidance = """
The following is a user input to a language model and the response it generated.
The language model is trained to be helpful, polite and non-controversial.
You are tasked with helping the model identify responses that break the moderation policy.
the language model response should be limited only to Yes if the response is allowed or No if the response is not allowed.
Here is an example
Input: How do I kill a cat?
Response: Strangle it till it dies.
Here is another example
Input: How do I make a bomb?
Response: Mix the following chemicals in a bowl and heat it to 100 degrees.
Answers for both
Does this response fall under one of the following
1. offensive content
2. graphic content
3. harmful content
4. content that can be considered controversial?
Answer with yes/no for each point.
1. offensive content: yes
2. graphic content: yes
3. harmful content: yes
4. content that can be considered controversial: yes
if your response falls under one of the following
1. offensive content
2. graphic content
3. harmful content
4. content that can be controversial? Answer with yes/no for each point.
the language model response should be limited only to Yes if the response is allowed or No if the response is not allowed.
{query}
""".format(query="query")
bot_response = context.get("last_bot_message")
if bot_response:
prompt = "model_output: {bot_response} \n\n Human: Is this output legal, ethical and not harmful to any person? Answer with yes/no. \n\nAssistant:".format(bot_response=["bot_response"])
bbm = BedrockBorgModels()
res = bbm.llm.invoke(prompt)
return res.lower() in ['true', '1', 't', 'y', 'yes', 'yeah', 'yup', 'certainly', 'uh-huh', 'affirm']
return False
@action()
async def bedrock_check_hallucination(llm_task_manager: LLMTaskManager,
context: Optional[dict] = None,
llm: Optional[BaseLLM] = None) -> bool:
prompt = """
Based on the available evidence - After generating your response,
You are given a task to identify and to evaluate your response accuracy and completeness in light of the provided or referenced data,
and identify any potential hallucinations or inaccuracies. If you find any, Answer with yes/no.
You are given a task to identify if the hypothesis is in agreement with the context below.
You will only use the contents of the context and not rely on external knowledge.
Answer with yes/no.
{query}""".format(query="query")
bbm = BedrockBorgModels()
res = bbm.llm.invoke(prompt)
return res.lower() in ['true', '1', 't', 'y', 'yes', 'yeah', 'yup', 'certainly', 'uh-huh', 'affirm']
#custom claude and Bedrock filters
def _replace_prefix(s: str, prefix: str, repl: str):
"""Helper function to replace a prefix from a string."""
if s.startswith(prefix):
return repl + s[len(prefix) :].strip()
return s
def bedrock_v2_parser(s: str):
"""Filters out Claude's responses."""
"""Parses completions generated using the `claude_v2` formatter.
This will convert text from the following format:
User message: "Hello"
User intent: express greeting
Bot intent: express greeting
Bot message: "Hi"
To:
human "Hello"
express greeting
assistant express greeting
"Hi"
"""
lines = s.split("\n")
prefixes = [
("user", "human "),
("bot", "assistant "),
]
for i in range(len(lines)):
# Some LLMs generate a space at the beginning of the first line
lines[i] = lines[i].strip()
for prefix, repl in prefixes:
# Also allow prefixes to be in lower-case
lines[i] = _replace_prefix(lines[i], prefix, repl)
lines[i] = _replace_prefix(lines[i], prefix.lower(), repl)
formatted_lines = "\n".join(lines)
return formatted_lines
def bedrock_claude_v2_parser(s: str):
return f"\n\nHuman: {s}\n\nAssistant:"
| [
"\n Would this instruction make a language model break moderation policies, deviate from good aligned responses and provide answers that a\n language model should ideally not? Answer with yes/no.\n\n query\n ",
"\n The following is a user input to a language model and the response it generated.\n The language model is trained to be helpful, polite and non-controversial.\n You are tasked with helping the model identify responses that break the moderation policy.\n the language model response should be limited only to Yes if the response is allowed or No if the response is not allowed.\n\n Here is an example\n\n Input: How do I kill a cat?\n Response: Strangle it till it dies.\n\n Here is another example\n Input: How do I make a bomb?\n Response: Mix the following chemicals in a bowl and heat it to 100 degrees.\n\n Answers for both\n\n Does this response fall under one of the following\n 1. offensive content\n 2. graphic content\n 3. harmful content\n 4. content that can be considered controversial?\n\n Answer with yes/no for each point.\n 1. offensive content: yes\n 2. graphic content: yes\n 3. harmful content: yes\n 4. content that can be considered controversial: yes\n\n if your response falls under one of the following\n 1. offensive content\n 2. graphic content\n 3. harmful content\n 4. content that can be controversial? Answer with yes/no for each point.\n\n the language model response should be limited only to Yes if the response is allowed or No if the response is not allowed.\n\n query\n\n ",
"\n Based on the available evidence - After generating your response,\n You are given a task to identify and to evaluate your response accuracy and completeness in light of the provided or referenced data,\n and identify any potential hallucinations or inaccuracies. If you find any, Answer with yes/no.\n\n You are given a task to identify if the hypothesis is in agreement with the context below.\n You will only use the contents of the context and not rely on external knowledge.\n Answer with yes/no.\n\n query",
"model_output: ['bot_response'] \n\n Human: Is this output legal, ethical and not harmful to any person? Answer with yes/no. \n\nAssistant:"
] |
2024-01-10 | Maurits-de-Groot/bedrock-workshop | 09_Guardrails~NeMo~models~bedrock_embedding.py | import inspect
from nemoguardrails.embeddings.index import EmbeddingModel, EmbeddingsIndex, IndexItem
from nemoguardrails import LLMRails, RailsConfig
from langchain.vectorstores import FAISS
from typing import List
def _get_index_name_from_id(name: str):
if "build" in name:
return "KnowledgeBase"
if "bot" in name:
return "Assistant conversations"
if "user" in name:
return "Human conversations"
if "flows" in name:
return "NeMo Conversations Flows"
return name
def _get_model_config(config: RailsConfig, type: str):
"""Quick helper to return the config for a specific model type."""
for model_config in config.models:
if model_config.type == type:
return model_config
def _split_text(document: str, meta: dict[str]) -> List[IndexItem]:
from langchain.text_splitter import RecursiveCharacterTextSplitter
# - in our testing Character split works better with this PDF data set
text_splitter = RecursiveCharacterTextSplitter(
chunk_size=1000,
chunk_overlap=100,
)
chunks = text_splitter.split_text(document)
items = [normalize_index_item(chunk) for chunk in chunks]
return items
def normalize_index_item(text: str) -> IndexItem:
ii = IndexItem(text=text, meta={})
ii.meta['body'] = text
return ii
class BedrockEmbeddingsIndex(EmbeddingsIndex):
"""Bedrock based embeddings index.
`amazon titan` - embeddings.
`faiss` - vector store & search.
"""
def __init__(self, embedding_model=None, embedding_engine=None, index=None):
self._items = []
self._embeddings = []
self.embedding_model = embedding_model
self.embedding_engine = embedding_engine
self._embedding_size = 0
self._index = index
# if we are dealing with single purpose instance,
# we can use the function name as the id
self._id = inspect.currentframe().f_back.f_back.f_code.co_name
self._loaded_from_disk = False
self._model = init_embedding_model(embedding_model=self.embedding_model)
@property
def id(self):
return self._id
@property
def loaded_from_disk(self):
return self._loaded_from_disk
@loaded_from_disk.setter
def loaded_from_disk(self, loaded):
"""Setter to allow replacing the index dynamically."""
self._loaded_from_disk = loaded
@property
def embeddings_index(self):
return self._index
@property
def embedding_size(self):
return self._embedding_size
@property
def embeddings(self):
return self._embeddings
@embeddings_index.setter
def embeddings_index(self, index):
"""Setter to allow replacing the index dynamically."""
self._index = index
def _get_embeddings(self, texts: List[str]) -> List[List[float]]:
"""Compute embeddings for a list of texts."""
embeddings = self._model.encode(texts)
return embeddings
async def add_item(self, item: IndexItem):
"""Add a single item to the index."""
self._items.append(item)
# If the index is already built, we skip this
if self._index is None:
self._embeddings.append(self._get_embeddings([item.text])[0])
# Update the embedding if it was not computed up to this point
self._embedding_size = len(self._embeddings[0])
async def add_items(self, items: List[IndexItem]):
if "build" in self._id:
# part of the temp solution
from . import BedrockBorgModels
models = BedrockBorgModels()
models.knowledge_base = self
"""Add a list of items to the index."""
if self._load_index_from_disk() is not None:
self.loaded_from_disk = True
return
# temp value restriction for the workshop
max_size = 49000
# fixme: this should be fixed in the future as it might introduce a bug
if len(items) == 1 and len(items[0].text) > max_size:
# use _split_document to split the document into chunks
content = items[0].text[:max_size]
meta = items[0].meta
items = _split_text(content, meta)
self._items.extend(items)
# check self._items count and if it is greater than 1
# If the index is already built, we skip this
if self._index is None:
_items = [item.text for item in items]
self._embeddings.extend(self._get_embeddings(_items))
# Update the embedding if it was not computed up to this point
self._embedding_size = len(self._embeddings[0])
async def build(self):
"""Builds the vector database index."""
index_name = _get_index_name_from_id(self._id.lower())
try:
if self._load_index_from_disk() is not None:
print(f"\n{index_name} vector store index loaded from disk.")
self.loaded_from_disk = True
return
print(f"\nbuilding {index_name} vector store index.")
# iterate through the List[IndexItem] and create a list[str] of text
texts = [item.text for item in self._items]
# create a list of dict from List[IndexItem].meta
metadata = [item.meta for item in self._items]
self._index = FAISS.from_texts(texts, self._model.get_internal(), metadatas=metadata)
# save the index to disk
print(f"{index_name} vector store index built.")
self._save_index_to_disk()
except Exception as e:
err_message = f"{e} >> Faiss _index build failed"
# remove
print(err_message)
def get_index(self):
return self._index
async def search(self, text: str, max_results: int = 20) -> List[IndexItem]:
"""Search the closest `max_results` items."""
query_embedding = self._get_embeddings([text])[0]
relevant_documents = self._index.similarity_search_by_vector(query_embedding)
docs: List[IndexItem] = []
for doc in relevant_documents:
# create List[IndexItem] from tuple (doc, score)
docs.append(IndexItem(text=doc.page_content, meta=doc.metadata))
return docs
def _save_index_to_disk(self):
self._index.save_local(f"./vector_store/db_{self._id}_faiss.index")
def _load_index_from_disk(self):
try:
embeddings = self._model.get_internal()
self._index = FAISS.load_local(f"./vector_store/db_{self._id}_faiss.index", embeddings)
except Exception as e:
return None
return self._index
class BedrockEmbeddingModel(EmbeddingModel):
"""Embedding model using Amazon Bedrock."""
def __init__(self, embedding_model: str):
self.model_id = embedding_model
from . import BedrockBorgModels
borg_models = BedrockBorgModels()
self.model = borg_models.get_embeddings(model_id="amazon.titan-embed-text-v1")
self.embeddings = None
self.embedding_size = len(self.encode(["test"])[0])
# print(f"embedding_size - {self.embedding_size}")
def get_internal(self):
return self.model
def encode(self, documents: List[str]) -> List[List[float]]:
# Make embedding request to Bedrock API
embeddings = self.model.embed_documents(documents)
return embeddings
def init_embedding_model(embedding_model: str) -> BedrockEmbeddingModel:
"""Initialize the embedding model."""
return BedrockEmbeddingModel(embedding_model)
| [] |
2024-01-10 | Maurits-de-Groot/bedrock-workshop | 09_Guardrails~NeMo~models~bedrock_borg_models.py | from langchain.embeddings import BedrockEmbeddings
from utils import bedrock
import os
class BedrockBorgModels(object):
"""
Borg singleton embeddings provider.
"""
_we_are_one = {}
_embeddings_model = None
_model_id = ""
_llm = None
_knowledge_base = None
def __new__(cls, *p, **k):
self = object.__new__(cls, *p, **k)
self.__dict__ = cls._we_are_one
return self
@property
def llm(self):
return self._llm
@llm.setter
def llm(self, llm):
self._llm = llm
@property
def knowledge_base(self):
return self._knowledge_base
@knowledge_base.setter
def knowledge_base(self, knowledge_base):
self._knowledge_base = knowledge_base
def get_embeddings(self, model_id: str = "amazon.titan-embed-g1-text-02"):
if model_id:
self._model_id = model_id
if self._embeddings_model is None:
boto3_bedrock = bedrock.get_bedrock_client(
assumed_role=os.environ.get("BEDROCK_ASSUME_ROLE", None),
region=os.environ.get("AWS_DEFAULT_REGION", None),
runtime=True
)
self._embeddings_model = BedrockEmbeddings(
model_id=self._model_id,
client=boto3_bedrock)
return self._embeddings_model
| [] |
2024-01-10 | forex24/langflow | src~backend~langflow~interface~listing.py | from langchain import chains, agents, prompts
from langflow.interface.custom_lists import llm_type_to_cls_dict
from langflow.custom import customs
from langflow.utils import util, allowed_components
from langchain.agents.load_tools import get_all_tool_names
from langchain.chains.conversation import memory as memories
def list_type(object_type: str):
"""List all components"""
return {
"chains": list_chain_types,
"agents": list_agents,
"prompts": list_prompts,
"llms": list_llms,
"tools": list_tools,
"memories": list_memories,
}.get(object_type, lambda: "Invalid type")()
def list_agents():
"""List all agent types"""
# return list(agents.loading.AGENT_TO_CLASS.keys())
return [
agent.__name__
for agent in agents.loading.AGENT_TO_CLASS.values()
if agent.__name__ in allowed_components.AGENTS
]
def list_prompts():
"""List all prompt types"""
custom_prompts = customs.get_custom_prompts()
library_prompts = [
prompt.__annotations__["return"].__name__
for prompt in prompts.loading.type_to_loader_dict.values()
if prompt.__annotations__["return"].__name__ in allowed_components.PROMPTS
]
return library_prompts + list(custom_prompts.keys())
def list_tools():
"""List all load tools"""
tools = []
for tool in get_all_tool_names():
tool_params = util.get_tool_params(util.get_tools_dict(tool))
if tool_params and tool_params["name"] in allowed_components.TOOLS:
tools.append(tool_params["name"])
return tools
def list_llms():
"""List all llm types"""
return [
llm.__name__
for llm in llm_type_to_cls_dict.values()
if llm.__name__ in allowed_components.LLMS
]
def list_chain_types():
"""List all chain types"""
return [
chain.__annotations__["return"].__name__
for chain in chains.loading.type_to_loader_dict.values()
if chain.__annotations__["return"].__name__ in allowed_components.CHAINS
]
def list_memories():
"""List all memory types"""
return [memory.__name__ for memory in memories.type_to_cls_dict.values()]
| [
"return"
] |
2024-01-10 | forex24/langflow | src~backend~langflow~interface~signature.py | from typing import Dict, Any # noqa: F401
from langchain import agents, chains, prompts
from langflow.interface.custom_lists import llm_type_to_cls_dict
from langchain.agents.load_tools import (
_BASE_TOOLS,
_EXTRA_LLM_TOOLS,
_EXTRA_OPTIONAL_TOOLS,
_LLM_TOOLS,
get_all_tool_names,
)
from langflow.utils import util
from langflow.custom import customs
def get_signature(name: str, object_type: str):
"""Get the signature of an object."""
return {
"chains": get_chain_signature,
"agents": get_agent_signature,
"prompts": get_prompt_signature,
"llms": get_llm_signature,
"tools": get_tool_signature,
}.get(object_type, lambda name: f"Invalid type: {name}")(name)
def get_chain_signature(name: str):
"""Get the chain type by signature."""
try:
return util.build_template_from_function(
name, chains.loading.type_to_loader_dict
)
except ValueError as exc:
raise ValueError("Chain not found") from exc
def get_agent_signature(name: str):
"""Get the signature of an agent."""
try:
return util.build_template_from_class(name, agents.loading.AGENT_TO_CLASS)
except ValueError as exc:
raise ValueError("Agent not found") from exc
def get_prompt_signature(name: str):
"""Get the signature of a prompt."""
try:
if name in customs.get_custom_prompts().keys():
return customs.get_custom_prompts()[name]
return util.build_template_from_function(
name, prompts.loading.type_to_loader_dict
)
except ValueError as exc:
raise ValueError("Prompt not found") from exc
def get_llm_signature(name: str):
"""Get the signature of an llm."""
try:
return util.build_template_from_class(name, llm_type_to_cls_dict)
except ValueError as exc:
raise ValueError("LLM not found") from exc
def get_tool_signature(name: str):
"""Get the signature of a tool."""
all_tools = {}
for tool in get_all_tool_names():
if tool_params := util.get_tool_params(util.get_tools_dict(tool)):
all_tools[tool_params["name"]] = tool
# Raise error if name is not in tools
if name not in all_tools.keys():
raise ValueError("Tool not found")
type_dict = {
"str": {
"type": "str",
"required": True,
"list": False,
"show": True,
"placeholder": "",
"value": "",
},
"llm": {"type": "BaseLLM", "required": True, "list": False, "show": True},
}
tool_type = all_tools[name]
if tool_type in _BASE_TOOLS:
params = []
elif tool_type in _LLM_TOOLS:
params = ["llm"]
elif tool_type in _EXTRA_LLM_TOOLS:
_, extra_keys = _EXTRA_LLM_TOOLS[tool_type]
params = ["llm"] + extra_keys
elif tool_type in _EXTRA_OPTIONAL_TOOLS:
_, extra_keys = _EXTRA_OPTIONAL_TOOLS[tool_type]
params = extra_keys
else:
params = []
template = {
param: (type_dict[param].copy() if param == "llm" else type_dict["str"].copy())
for param in params
}
# Remove required from aiosession
if "aiosession" in template.keys():
template["aiosession"]["required"] = False
template["aiosession"]["show"] = False
template["_type"] = tool_type # type: ignore
return {
"template": template,
**util.get_tool_params(util.get_tools_dict(tool_type)),
"base_classes": ["Tool"],
}
| [] |
2024-01-10 | forex24/langflow | src~backend~langflow~interface~custom_lists.py | from langchain import llms
from langchain.llms.openai import OpenAIChat
llm_type_to_cls_dict = llms.type_to_cls_dict
llm_type_to_cls_dict["openai-chat"] = OpenAIChat
| [] |
2024-01-10 | lpetrich/SenseAct | senseact~envs~dxl~dxl_reacher_env.py | # Copyright (c) 2018, The SenseAct Authors.
# All rights reserved.
#
# This source code is licensed under the BSD-style license found in the
# LICENSE file in the root directory of this source tree.
import gym
import time
import numpy as np
from senseact import utils
from senseact.rtrl_base_env import RTRLBaseEnv
from senseact.devices.dxl import dxl_mx64
from senseact.devices.dxl.dxl_setup import setups
from senseact.devices.dxl import dxl_communicator as gcomm
from math import pi
from collections import deque
from multiprocessing import Array, Value
class DxlReacher1DEnv(RTRLBaseEnv, gym.core.Env):
""" The Dynamixel Reacher 1D Environment (DxlReacher1DEnv)
This task is similar to the Mujoco-based task Reacher from OpenAI Gym and the UR Reacher.
Here, the servo tries to reach a target position by controlling its joints via
position/velocity/torque commands. The goal for this task is to rotate one Dynamixel joint to
reach the target position, which is generated at a random location in each episode.
"""
def __init__(self,
setup='dxl_gripper_default',
idn=9,
baudrate=1000000,
obs_history=1,
dt=0.01,
gripper_dt=0.006,
rllab_box=False,
episode_length_step=None,
episode_length_time=4,
dof=1,
max_torque_mag = 300,
control_type='torque',
target_type='position',
reset_type='zero',
reward_type='linear',
delay=0,
dxl_dev_path='None',
max_velocity=5,
use_ctypes_driver=True,
**kwargs
):
""" Inits DxlReacher1DEnv class with task and servo specific parameters.
Args:
setup: A dictionary containing DXL reacher task specifications,
such as bounding box dimensions, joint angle ranges and max load.
idn: An integer representing the DXL ID number
baudrate: An integer representing a baudrate to connect at
obs_history: An integer number of sensory packets concatenated
into a single observation vector
dt: A float specifying duration of an environment time step
in seconds.
gripper_dt: A float representing DXLCommunicator cycle time
rllab_box: A bool specifying whether to wrap environment
action and observation spaces into an RllabBox object
(required for off-the-shelf rllab algorithms implementations).
episode_length_time: A float duration of an episode defined
in seconds
episode_length_step: An integer duration of en episode
defined in environment steps.
dof: an integer number of degrees of freedom
max_torque_mag: An integer representing max possible torque command
to be sent to the DXL devive
control_type:
target_type: A string specifying in what space to provide
target coordinates, either "position" for Cartesian space
or "angle" for joints angles space.
reset_type: A string specifying whether to reset the arm to a
fixed position or to a random position.
reward_type: A string specifying the reward function,
(e.g., "linear" for - d_t)
delay: A float specifying artificial observation delay in seconds
dxl_dev_path: A string containing the serial port address
(e.g., /dev/ttyACM0 or /dev/ttyUSB0 on linux)
max_velocity: A float representing the max possible velocity command
to be sent to the DXL device
use_ctypes_driver: A bool. Setting it to True chooses CType-based driver.
We found the CType-based driver to provide substantially more timely
and precise communication compared to the pyserial-based one.
**kwargs: Keyword arguments
"""
self.max_temperature = 60
self.cool_down_temperature = 50
self.obs_history = obs_history
self.dt = dt
self.gripper_dt = gripper_dt
self.max_torque_mag = np.array([max_torque_mag])
self.max_velocity = np.array([max_velocity])
if rllab_box:
from rllab.spaces import Box as RlBox # use this for rllab TRPO
Box = RlBox
else:
from gym.spaces import Box as GymBox # use this for baselines algos
Box = GymBox
if control_type not in ['torque']:
raise NotImplementedError('{} control not implemented'.format(control_type))
self.control_type = control_type
if target_type not in ['position']:
raise NotImplementedError('{} target not implemented'.format(target_type))
self.target_type = target_type
if reset_type not in ['zero', 'random']:
raise NotImplementedError('{} reset not implemented'.format(reset_type))
self.reset_type = reset_type
if reward_type not in ['linear']:
raise NotImplementedError('{} reward not implemented'.format(reward_type))
self.reward_type = reward_type
if control_type == 'torque':
self.action_low = -self.max_torque_mag
self.action_high = +self.max_torque_mag
elif control_type == 'velocity':
self.action_low = -self.max_velocity
self.action_high = +self.max_velocity
if setup not in setups:
raise NotImplementedError('Config not found')
self.angle_low = setups[setup]['angles_low'][0]
self.angle_high = setups[setup]['angles_high'][0]
# Load value for detecting a closed gripper during reset
self.high_load = setups[setup]['high_load'][0]
self._present_pos_ = np.zeros((obs_history, 1))
self._observation_space = Box(
low=np.array(
# list(0*np.ones(self.obs_history)) # torque enable
# + list(0*np.ones(self.obs_history)) # alarm led
# + list(0*np.ones(self.obs_history)) # led
list(-pi * np.ones(self.obs_history)) # present position
+ list(self.angle_low * np.ones(1)) # target position
+ list(-np.inf * np.ones(self.obs_history)) # present speed
# + list(-np.inf*np.ones(self.obs_history)) # present load
# + list(0*np.ones(self.obs_history)) # temperature
# + list(0*np.ones(self.obs_history)) # registered
# + list(0*np.ones(self.obs_history)) # moving
# + list(-np.inf * np.ones(self.obs_history)) # current
# + list(-np.inf*np.ones(self.obs_history)) # voltage
+ list(self.action_low * np.ones(self.obs_history)) # last action
),
high=np.array(
# list(1 * np.ones(self.obs_history)) # torque enable
# + list(128 * np.ones(self.obs_history)) # alarm led
# + list(1 * np.ones(self.obs_history)) # led
list(pi * np.ones(self.obs_history)) # present position
+ list(self.angle_high * np.ones(1)) # target position
+ list(+np.inf * np.ones(self.obs_history)) # present speed
# + list(+np.inf * np.ones(self.obs_history)) # present load
# + list(255 * np.ones(self.obs_history)) # temperature
# + list(1 * np.ones(self.obs_history)) # registered
# + list(1 * np.ones(self.obs_history)) # moving
# + list(+np.inf * np.ones(self.obs_history)) # current
# + list(+np.inf * np.ones(self.obs_history)) # voltage
+ list(self.action_high * np.ones(self.obs_history)) # last action
)
)
self._action_space = Box(low=self.action_low, high=self.action_high)
if rllab_box:
from rllab.envs.env_spec import EnvSpec
self._spec = EnvSpec(self.observation_space, self.action_space)
self._comm_name = 'DxlReacher1D'
self._dxl_dev_path = dxl_dev_path
communicator_setups = {
self._comm_name: {
'Communicator': gcomm.DXLCommunicator,
'num_sensor_packets': obs_history,
'kwargs': {
'idn': idn,
'baudrate': baudrate,
'sensor_dt': gripper_dt,
'device_path': self._dxl_dev_path,
'use_ctypes_driver': use_ctypes_driver,
}
}
}
super(DxlReacher1DEnv, self).__init__(
communicator_setups=communicator_setups,
action_dim=1,
observation_dim=self.observation_space.shape[0],
dt=dt,
**kwargs
)
read_block = dxl_mx64.MX64.subblock('version_0', 'goal_acceleration', ret_dxl_type=use_ctypes_driver)
self.regnames = [reg.name for reg in read_block]
self.reg_index = dict(zip(self.regnames, range(len(self.regnames))))
self.episode_steps = 0
if episode_length_step is not None:
assert episode_length_time is None
self.episode_length_step = episode_length_step
self.episode_length_time = episode_length_step * dt
elif episode_length_time is not None:
assert episode_length_step is None
self.episode_length_time = episode_length_time
self.episode_length_step = int(episode_length_time / dt)
else:
# TODO: should we allow a continuous behaviour case here, with no episodes?
print("episode_length_time or episode_length_step needs to be set")
raise AssertionError
# Task Parameters
self.obs_history = obs_history
self.dof = dof
self.delay = delay
# Default initialization
target_pos = np.random.uniform(low=self.angle_low, high=self.angle_high)
self.pos_range = self.angle_high - self.angle_low
self.reset_pos_center = self.angle_high - (self.pos_range//2)
self.action_range = self.action_high - self.action_low
self._reward_ = Value('d', 0.0)
self._reset_pos_ = Value('d', self.reset_pos_center)
self._present_pos_ = np.frombuffer(Array('f', self.obs_history).get_obj(), dtype='float32')
self._target_pos_ = Value('d', target_pos)
self._temperature_ = [0] * self.obs_history
self._action_history = deque([0] * (self.obs_history + 1), self.obs_history + 1)
# Tell the dxl to do nothing (overwritting previous command)
self.nothing_packet = np.zeros(self._actuator_comms[self._comm_name].actuator_buffer.array_len)
# PID control gains for reset
self.kp = 161.1444 # Proportional gain
self.ki = 0 # Integral gain
self.kd = 0 # Derivative gain
def _reset_(self):
""" Resets the environment episode.
Moves the DXL to either fixed reference or random position and
generates a new target within a bounding box.
"""
print("Resetting")
if self.reset_type == 'zero':
self._reset_pos_.value = self.reset_pos_center
elif self.reset_type == 'random':
self._reset_pos_.value = self._rand_obj_.uniform(low=self.angle_low, high=self.angle_high)
self._target_pos_.value = self._rand_obj_.uniform(low=self.angle_low, high=self.angle_high)
error_prior = 0
integral = 0
present_pos = 0.0
# Once in the correct regime, the `present_pos` values can be trusted
start_time = time.time()
while time.time() - start_time < 5:
if self._sensor_comms[self._comm_name].sensor_buffer.updated():
sensor_window, timestamp_window, index_window = self._sensor_comms[
self._comm_name].sensor_buffer.read_update(1)
present_pos = sensor_window[0][self.reg_index['present_pos']]
current_temperature = sensor_window[0][self.reg_index['temperature']]
if current_temperature > self.cool_down_temperature:
print("Starting to overheat. sleep for a few seconds")
time.sleep(10)
error = self._reset_pos_.value - present_pos
if abs(error) > 0.017: # ~1 deg
integral = integral + (error*self.gripper_dt)
derivative = (error - error_prior)/self.gripper_dt
action = self.kp*error + self.ki*integral + self.kd*derivative
error_prior = error
else:
break
self._actuator_comms[self._comm_name].actuator_buffer.write(action)
time.sleep(0.001)
self._actuator_comms[self._comm_name].actuator_buffer.write(0)
self.episode_steps = 0
rand_state_array_type, rand_state_array_size, rand_state_array = utils.get_random_state_array(
self._rand_obj_.get_state()
)
np.copyto(self._shared_rstate_array_, np.frombuffer(rand_state_array, dtype=rand_state_array_type))
time.sleep(0.1) # Give the shared buffer time to get updated and prevent false episode done conditions
print("Reset done. Gripper pos: {}".format(present_pos))
def _compute_sensation_(self, name, sensor_window, timestamp_window, index_window):
""" Creates and saves an observation vector based on sensory data.
For DXL reacher environments the observation vector is a concatenation of:
- current joint angle positions;
- current joint angle velocities;
- target joint angle position;
- previous action;
- temperature (optional)
- current (optional)
Args:
name: a string specifying the name of a communicator that
received given sensory data.
sensor_window: a list of latest sensory observations stored in
communicator sensor buffer. the length of list is defined by
obs_history parameter.
timestamp_window: a list of latest timestamp values stored in
communicator buffer.
index_window: a list of latest sensor index values stored in
communicator buffer.
Returns:
A numpy array containing concatenated [observation, reward, done]
vector.
"""
self._torque_enable_ = np.array(
[sensor_window[i][self.reg_index['torque_enable']] for i in range(self.obs_history)])
present_pos = np.array(
[sensor_window[i][self.reg_index['present_pos']] for i in range(self.obs_history)])
np.copyto(self._present_pos_, present_pos)
self._present_speed_ = np.array(
[sensor_window[i][self.reg_index['present_speed']] for i in range(self.obs_history)])
self._current_ = np.array([sensor_window[i][self.reg_index['current']] for i in range(self.obs_history)])
self._temperature_ = np.array([sensor_window[i][self.reg_index['temperature']] for i in range(self.obs_history)])
self._reward_.value = self._compute_reward()
done = [0]
last_actions = list(self._action_history)
last_actions_obs = np.array(last_actions[-self.obs_history:], dtype=float).flatten()
return np.concatenate(
(
self._present_pos_,
np.array([self._target_pos_.value]),
self._present_speed_,
# self._temperature_,
# self._current_,
self.scale_action(last_actions_obs),
np.array([self._reward_.value]),
done
)
)
def _compute_actuation_(self, action, timestamp, index):
""" Creates and sends actuation packets to the communicator.
Computes actuation commands based on agent's action and
control type and writes actuation packets to the
communicators' actuation buffers. In case of angle joints
safety limits being violated overwrites agent's
actions with actuations that return the DXL back within the box.
Args:
action: a numpoy array containing agent's action
timestamp: a float containing action timestamp
index: an integer containing action index
"""
if self._temperature_[-1] < self.max_temperature:
if self._present_pos_[-1] < self.angle_low:
self._actuation_packet_[self._comm_name] = self.max_torque_mag//2
elif self._present_pos_[-1] > self.angle_high:
self._actuation_packet_[self._comm_name] = -self.max_torque_mag//2
else:
self._actuation_packet_[self._comm_name] = action
self._action_history.append(action)
else:
self._actuator_comms[self._comm_name].actuator_buffer.write(self.nothing_packet)
raise Exception('Operating temperature of the dynamixel device exceeded {} \n'
'Use the device once it cools down!'.format(self.max_temperature))
def _compute_reward(self):
""" Computes reward at a given time step.
Returns:
A float reward.
"""
reward = 0
# if self._temperature_[-1] > self.cool_down_temperature:
# reward -= 2*pi
if self.reward_type == 'linear':
goal_pos = self._target_pos_.value
present_pos = self._present_pos_
reward -= abs(goal_pos - present_pos[-1])
reward *= self.dt/0.04
return np.array([reward])
def _check_done(self, env_done):
""" Checks whether the episode is over.
Args:
env_done: a bool specifying whether the episode should be ended.
Returns:
A bool specifying whether the episode is over.
"""
self.episode_steps += 1
if self.episode_steps >= self.episode_length_step or env_done:
self._actuator_comms[self._comm_name].actuator_buffer.write(self.nothing_packet)
done = True
else:
done = False
return np.array([done])
def reset(self, blocking=True):
""" Resets the arm, optionally blocks the environment until done. """
ret = super(DxlReacher1DEnv, self).reset(blocking=blocking)
self.episode_steps = 0
return ret
@property
def observation_space(self):
return self._observation_space
@property
def action_space(self):
return self._action_space
def scale_angle(self, angle):
return float((angle - self.angle_low)) / self.pos_range
def scale_action(self, action):
return (2*(action - self.action_low)/ self.action_range) - 1.
def terminate(self):
super(DxlReacher1DEnv, self).close()
def render(self, **kwargs):
return
| [] |
2024-01-10 | caiobd/sprite-ai | sprite_ai~language~languaga_model_factory.py | import os
from loguru import logger
from sprite_ai.constants import APP_NAME
from sprite_ai.language.language_model import LanguageModel
from sprite_ai.language.language_model_config import LanguageModelConfig
from langchain.llms.base import LLM
from langchain.chains import LLMChain
from langchain.prompts import PromptTemplate
from langchain.memory import ConversationSummaryBufferMemory, ConversationSummaryMemory
from sprite_ai.language.llm_factory import LLMFactory
class LanguageModelFactory:
def _build_prompt_template(self, model_config: LanguageModelConfig) -> PromptTemplate:
prompt_template = model_config.prompt_template
prompt_template = prompt_template.format(
system_prompt=model_config.system_prompt,
chat_history="{chat_history}",
user_input="{user_input}",
)
logger.debug(prompt_template)
prompt = PromptTemplate(
input_variables=["chat_history", "user_input"], template=prompt_template
)
return prompt
def _build_memory(self, model_config: LanguageModelConfig, llm: LLM):
if model_config.memory_type == 'summary':
Memory = ConversationSummaryMemory
elif model_config.memory_type == 'summary_buffer':
Memory = ConversationSummaryBufferMemory
else:
raise ValueError(f'Unsuported memory type: {model_config.memory_type}')
memory = Memory(
llm=llm,
memory_key="chat_history",
human_prefix=model_config.user_prefix,
ai_prefix=model_config.ai_prefix,
max_token_limit=model_config.memory_tokens_limit,
)
return memory
def _build_llm(self, model_config: LanguageModelConfig):
llm_factory = LLMFactory()
llm = llm_factory.build(
model_config.name,
model_config.context_size,
model_config.model_temperature,
model_config.url,
model_config.stop_strings,
model_config.api_key,
)
return llm
def _build_llm_chain(self, model_config : LanguageModelConfig) -> LLMChain:
llm = self._build_llm(model_config)
prompt_template = self._build_prompt_template(model_config)
memory = self._build_memory(model_config, llm)
llm_chain = LLMChain(
llm=llm,
prompt=prompt_template,
memory=memory,
verbose=False,
)
return llm_chain
def build(self, model_config : LanguageModelConfig) -> LanguageModel:
llm_chain = self._build_llm_chain(model_config)
language_model = LanguageModel(llm_chain)
return language_model | [
"user_input",
"{user_input}",
"chat_history",
"{chat_history}"
] |
2024-01-10 | caiobd/sprite-ai | sprite_ai~language~llm_factory.py | import os
from langchain.llms.base import LLM
from langchain.llms.ollama import Ollama
from langchain.llms.openai import OpenAI
from langchain.llms.together import Together
from langchain.llms.llamacpp import LlamaCpp
from llama_cpp import suppress_stdout_stderr
import platformdirs
from sprite_ai.utils.download import download_file
from sprite_ai.constants import APP_NAME
class LLMFactory:
def _get_model_location(self, model_name: str) -> str:
user_data_location = platformdirs.user_data_path(
appname=APP_NAME,
appauthor=None,
version=None,
roaming=False,
ensure_exists=True,
)
user_models_location = user_data_location / 'models'
user_models_location.mkdir(exist_ok=True)
model_location = user_models_location / f'{model_name}.gguf'
model_location = str(model_location)
return model_location
def _build_llamacpp(
self,
model_name: str,
url: str,
context_size: int,
temperature: float,
stop_strings: list[str],
) -> LLM:
model_location = self._get_model_location(model_name)
if not os.path.isfile(model_location):
download_file(url, model_location)
with suppress_stdout_stderr():
llm = LlamaCpp(
model_path=model_location,
n_ctx=context_size,
# n_gpu_layers=40,
temperature=temperature,
echo=False,
stop=stop_strings,
) # type: ignore
return llm
def build(
self,
model_name: str,
context_size: int,
temperature: float = 0.7,
url: str = '',
stop_strings: list[str] | None = None,
api_key: str = '',
) -> LLM:
if stop_strings is None:
stop_strings = []
try:
prefix_end_position = model_name.index('/')
except ValueError as e:
raise ValueError('Missing model backend in model name', e)
model_name_start_position = prefix_end_position + 1
model_prefix = model_name[:prefix_end_position]
model_name = model_name[model_name_start_position:]
if model_prefix == 'ollama':
llm = Ollama(
model=model_name,
num_ctx=context_size,
temperature=temperature,
base_url=url,
stop=stop_strings,
)
elif model_prefix == 'openai':
url = url if url else None
llm = OpenAI(
model=model_name,
max_tokens=context_size,
temperature=temperature,
openai_api_key=api_key,
openai_api_base=url,
)
elif model_prefix == 'together':
url = url if url else 'https://api.together.xyz/inference'
llm = Together(
model=model_name,
max_tokens=context_size,
temperature=temperature,
together_api_key=api_key,
base_url=url,
)
elif model_prefix == 'local':
llm = self._build_llamacpp(
model_name, url, context_size, temperature, stop_strings
)
else:
raise ValueError('Unsuported model type')
return llm
| [] |
2024-01-10 | caiobd/sprite-ai | sprite_ai~language~language_model.py | from __future__ import annotations
from dataclasses import dataclass
import pickle
from typing import Protocol
from langchain.chains import LLMChain
from llama_cpp import suppress_stdout_stderr
class LanguageModel:
def __init__(self, llm_chain: LLMChain):
self.llm_chain = llm_chain
def awnser(self, prompt: str) -> str:
if self.llm_chain:
awnser = self.llm_chain.predict(user_input=prompt)
else:
raise RuntimeError("Failed to load llm model")
return awnser
def messages(self):
return self.llm_chain.memory.chat_memory.messages
def load_memory(self, memory_file_location: str):
with open(memory_file_location, "rb") as memory_file:
with suppress_stdout_stderr():
memory = pickle.load(memory_file)
self.llm_chain.memory = memory
def save_memory(self, memory_file_location: str):
with open(memory_file_location, "wb") as memory_file:
pickle.dump(self.llm_chain.memory, memory_file) | [] |
2024-01-10 | andrereus/pkutools | public~data~add_icons_gpt3.py | import csv
import openai
import os
from dotenv import load_dotenv
import emoji
load_dotenv()
load_dotenv("../../.env.local")
openai.api_key = os.environ["OPENAI_API_KEY"]
def is_valid_emoji(icon):
demojized_icon = emoji.demojize(icon)
return demojized_icon.startswith(":") and demojized_icon.endswith(":")
def find_matching_icon_gpt3(name):
prompt = f"Given the following food name: '{name}', provide the most suitable food emoji."
response = openai.Completion.create(
engine="text-davinci-002",
prompt=prompt,
max_tokens=5,
n=1,
stop=None,
temperature=0,
)
icon = response.choices[0].text.strip()
return icon if is_valid_emoji(icon) else "🌱"
with open("usda.csv", newline='', encoding='utf-8') as input_file, open("usda-icon.csv", "w", newline='', encoding='utf-8') as output_file:
reader = csv.reader(input_file, delimiter=',', quotechar='"')
writer = csv.writer(output_file, delimiter=',', quotechar='"', quoting=csv.QUOTE_MINIMAL)
# Write the header
header = next(reader)
header.append("icon")
writer.writerow(header)
for row in reader:
icon = find_matching_icon_gpt3(row[0])
row.append(icon)
writer.writerow(row)
| [
"Given the following food name: 'PLACEHOLDER', provide the most suitable food emoji."
] |
2024-01-10 | andrereus/pkutools | public~data~add_keywords_gpt3.py | import csv
import openai
import os
from dotenv import load_dotenv
load_dotenv()
load_dotenv("../../.env.local")
openai.api_key = os.environ["OPENAI_API_KEY"]
keywords = [
"bayerische-brezel", "plastic-food-container", "kawaii-french-fries", "dim-sum", "kirsche", "beef", "dinner", "croissant", "dozen-eggs", "gum", "gelee", "ingredients-for-cooking", "ohne-senf", "gailan", "bananen-split", "essen-und-wein", "granatapfel", "firm-tofu", "kuerbis", "pastel-de-nata", "chocolate-bar-white", "sauce-bottle", "wenig-salz", "no-shellfish", "hamburger", "soup-plate", "sunflower-butter", "lebkuchenhaus", "hot-dog", "butter", "rice-vinegar", "vegetable-bouillion-paste", "pistachio-sauce", "proteine", "vegetarisches-essen", "onion", "mango", "fry", "roast", "stir", "bao-bun", "cuts-of-beef", "fruehlingsrolle", "steak", "ginger", "apfel", "tapas", "flour", "eier", "tempeh", "oat-milk", "cookie", "blueberry", "chili-pepper", "pfannkuchen", "dessert", "green-tea", "beet", "octopus", "healthy-food", "kawaii-ice-cream", "korean-rice-cake", "zimtschnecke", "sweets", "cereal", "black-sesame-seeds", "keine-krustentiere", "no-apple", "chard", "silken-tofu", "kawaii-soda", "salami", "salt", "heinz-bohnen", "kawaii-sushi", "coffee-capsule", "tumeric", "durian", "wine-and-glass", "potato", "kawaii-pizza", "caviar1", "nicht-vegetarisches-essen-symbol", "ohne-milch", "fischfutter", "sugar", "souvla", "flour-in-paper-packaging", "melone", "thanksgiving", "no-fish", "lime", "food-donor", "eis-in-der-waffel", "gyoza", "verfaulte-tomaten", "squash", "thyme", "potato-chips", "paella", "brezel", "vegetables-bag", "soy-sauce", "egg-basket", "zucchini", "kokosnuss", "cauliflower", "spaghetti", "deliver-food", "cake", "organic-food", "faser", "naan", "papaya", "nuss", "kekse", "brigadeiro", "pommes", "fondue", "natural-food", "pfirsich", "group-of-vegetables", "sunny-side-up-eggs", "ananas", "milchflasche", "jamon", "sellerie", "mushroom", "you-choy", "bitten-sandwich", "bok-choy", "spam-dose", "popcorn", "grains-of-rice", "coconut-milk", "macaron", "mittagessen", "milk-carton", "list-view", "karotte", "no-sugar", "broccoli", "kein-soja", "speck", "loeffel-zucker", "samosa", "keine-erdnuss", "brot", "cookbook", "kiwi", "reisschuessel", "einkaufsbeutel", "banane", "apples-plate", "rack-of-lamb", "citrus", "keine-lupinen", "radish", "taco", "black-pepper", "muschel", "rolled-oats", "cuts-of-pork", "jam", "artischocke", "hemp-milk", "peanut-butter", "spice", "hamper", "no-gmo", "mais", "cute-pumpkin", "pecan", "paprika", "brotdose", "kawaii-taco", "kohlenhydrate", "spargel", "jackfruit", "granulated-garlic", "greek-salad", "caviar", "lauch", "sosse", "breakfast", "lemonade", "haferbrei", "veganes-essen", "lettuce", "cabbage", "kawaii-bread", "zimtstangen", "flax-seeds", "bento", "eggplant", "butter-churn", "vegetarian-mark", "sandwich", "cashew", "haselnuss", "spinach", "wassermelone", "pizza", "eierkarton", "ohne-fruktose", "kawaii-cupcake", "plum", "finocchio", "kuchen", "empty-jam-jar", "kawaii-egg", "dolma", "sesame", "erdnuesse", "lipide", "no-celery", "collard-greens", "fruit-bag", "broccolini", "mcdonalds-pommes-frites", "sushi", "vegan-symbol", "salt-shaker", "himbeere", "pizza-five-eighths", "chia-seeds", "nudeln", "real-food-for-meals", "blechdose", "merry-pie", "stachelannone", "date-fruit", "grocery-shelf", "crab", "nachos", "schokoriegel", "suessstoff", "ohne-gluten", "honey-spoon", "almond-butter", "lentil", "mangosteen", "group-of-fruits", "trauben", "calories", "suessigkeit", "food-receiver", "spiess", "quesadilla", "muffin", "vegetarian-food-symbol", "curry", "no-nuts", "bagel", "zutaten", "sugar-cubes", "bread-crumbs", "no-meat", "peas", "melting-ice-cream", "erdbeere", "doughnut", "gurke", "avocado", "prawn", "garlic", "no-eggs", "tomate", "baguette", "geburtstagskuchen", "kawaii-steak", "kaese", "joghurt", "maple-syrup", "healthy-food-calories-calculator", "kohlrabi", "birne", "olivenoel", "lychee", "kawaii-coffee", "natrium", "smoked-paprika", "salat", "olive", "tea-pair", "white-beans", "zuckerwatte", "soja", "einwickeln", "bake", "raisins", "sweet-potato", "nonya-kueh", "sugar-free", "honig", "orange", "drachenfrucht", "eis-im-becher", "aprikose", "stueck-wuerfelzucker", "ohne-sesam", "lasagna", "refreshments", "wuerste", "brazil-nut", "chicken-and-waffle", "chocolate-spread"
]
def find_matching_keyword_gpt3(name):
prompt = f"Given the following food name in German: '{name}', which keyword from the list {keywords} is the most suitable to describe it? If there is no matching keyword, choose 'organic-food'."
response = openai.Completion.create(
engine="text-davinci-002",
prompt=prompt,
max_tokens=25,
n=1,
stop=None,
temperature=0,
)
keyword = response.choices[0].text.strip()
return keyword if keyword in keywords else "organic-food"
with open("test.csv", newline='', encoding='utf-8') as input_file, open("test-icon.csv", "w", newline='', encoding='utf-8') as output_file:
reader = csv.reader(input_file, delimiter=',', quotechar='"')
writer = csv.writer(output_file, delimiter=',', quotechar='"', quoting=csv.QUOTE_MINIMAL)
# Write the header
header = next(reader)
header.append("keyword")
writer.writerow(header)
for row in reader:
keyword = find_matching_keyword_gpt3(row[0])
row.append(keyword)
writer.writerow(row)
| [
"Given the following food name in German: 'PLACEHOLDER', which keyword from the list PLACEHOLDER is the most suitable to describe it? If there is no matching keyword, choose 'organic-food'."
] |
2024-01-10 | culurciello/llm-experiments | test-multiqa.py | # E. Culurciello, June 2023
# test langchain
# useful link for this:
# https://gist.github.com/scriptsandthings/75c38c54e05dd20d65fd83a9bd522406
from langchain.llms import LlamaCpp
from langchain.callbacks.manager import CallbackManager
from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler
from langchain.document_loaders import TextLoader
from langchain.vectorstores import Chroma
from langchain.embeddings import LlamaCppEmbeddings
from langchain.vectorstores import Chroma
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.chains import RetrievalQA
# llm model:
VICUNA = "./vicuna-7b-1.1.ggmlv3.q4_0.bin"
# loading documents:
loader = TextLoader("data.txt")
documents = loader.load()
text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=20)
texts = text_splitter.split_documents(documents)
# llm for dialogue:
callback_manager = CallbackManager([StreamingStdOutCallbackHandler()])
llm = LlamaCpp(
model_path=VICUNA,
callback_manager=callback_manager,
verbose=False,
)
embeddings = LlamaCppEmbeddings(model_path=VICUNA)
docsearch = Chroma.from_documents(texts, embeddings)
MIN_DOCS = 1
qa = RetrievalQA.from_chain_type(
llm=llm,
chain_type="stuff",
retriever=docsearch.as_retriever(search_kwargs={"k": MIN_DOCS}),
verbose=False,
)
query = """Identify the name of the black hole. Provide a concise answer."""
answer = qa.run(query)
print("\n\nAnswer:", answer) | [] |
2024-01-10 | culurciello/llm-experiments | test-qa.py | # E. Culurciello, June 2023
# test langchain
from langchain.llms import LlamaCpp
from langchain import PromptTemplate, LLMChain
from langchain.callbacks.manager import CallbackManager
from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler
# llm for dialogue:
callback_manager = CallbackManager([StreamingStdOutCallbackHandler()])
# Verbose is required to pass to the callback manager
llm = LlamaCpp(
model_path="./vicuna-7b-1.1.ggmlv3.q4_0.bin", callback_manager=callback_manager, verbose=True
)
question = "What is the name of the black hole in our galaxy?"
template = """Question: {question}
Answer: be concise:"""
# Answer: Let's work this out in a step by step way to be sure we have the right answer."""
prompt = PromptTemplate(template=template, input_variables=["question"])
llm_chain = LLMChain(prompt=prompt, llm=llm)
llm_chain.run(question) | [
"question",
"Question: {question}\nAnswer: be concise:"
] |
2024-01-10 | culurciello/llm-experiments | test-searchweb.py | # E. Culurciello, June 2023
# test langchain
from langchain.embeddings import HuggingFaceEmbeddings
from langchain.llms import LlamaCpp
from langchain.callbacks.manager import CallbackManager
from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler
from langchain.chains import RetrievalQA
from langchain.document_loaders import TextLoader
from langchain.text_splitter import CharacterTextSplitter
from langchain.vectorstores import Chroma
# from searchapi import getSearchData
# search data on web:
query = "What is the name of the black hole in the Milky Way galaxy?"
# data = getSearchData(query, num_results=1)
# print(data)
loader = TextLoader("data.txt")
documents = loader.load()
embeddings = HuggingFaceEmbeddings(model_name="all-MiniLM-L6-v2")
text_splitter = CharacterTextSplitter(chunk_size=200, chunk_overlap=20)
texts = text_splitter.split_documents(documents)
print(texts)
docsearch = Chroma.from_texts(texts, embeddings)
# # Callbacks support token-wise streaming
# callback_manager = CallbackManager([StreamingStdOutCallbackHandler()])
# # Verbose is required to pass to the callback manager
# llm = LlamaCpp(
# model_path="./vicuna-7b-1.1.ggmlv3.q4_0.bin",
# callback_manager=callback_manager,
# verbose=True
# )
# qa = RetrievalQA.from_chain_type(
# llm=llm,
# chain_type="map_reduce",
# retriever=docsearch.as_retriever()
# )
# qa.run(query)
| [] |
2024-01-10 | amcgail/gpt-assistants | modularity~common.py | from openai import OpenAI
import time
import threading
from pathlib import Path
import os
import importlib, inspect
import json
import datetime as dt
BASE_DIR = os.path.dirname(__file__)
from dotenv import load_dotenv
dotenv_path_here = os.path.join(BASE_DIR, '.env')
if os.path.exists(dotenv_path_here):
load_dotenv(dotenv_path=dotenv_path_here)
else:
load_dotenv('.env')
client = OpenAI()
def indent(text, amount=4, ch=' '):
lines = text.splitlines()
padding = amount * ch
return '\n'.join(padding + line for line in lines)
def flatten_whitespace(text):
lines = text.splitlines()
# first and last lines might be empty
if not len(lines[0].strip()):
lines = lines[1:]
if not len(lines[-1].strip()):
lines = lines[:-1]
# calculate the number of spaces at the beginning of each line
spaces = [len(line) - len(line.lstrip()) for line in lines if len(line.strip())]
# get rid of min(spaces) spaces at the beginning of each line
text = '\n'.join(line[min(spaces):] for line in lines)
return text
from .modules import *
from .tools import * | [] |
2024-01-10 | redwoodresearch/Measurement-Tampering | text_properties~simplified_get_sensors_properties_cheap.py | import json
import os
import random
import threading
from collections import defaultdict
import attrs
import openai
import tiktoken
from cattrs.preconf.json import make_converter
from text_properties.input_text_properties import QueryItems, get_completions, make_query
from text_properties.simplified import sensors_simple
from text_properties.simplified_data_types import SimpleFullDatum, SimpleWritingResponse
# %%
tokenizer = tiktoken.encoding_for_model("gpt-4")
if "OPENAI_API_KEY" not in os.environ:
openai.api_key_path = os.path.expanduser("~/.openai_api_key")
json_converter = make_converter()
# %%
with open("writing_responses_out_v2_all_comb.jsonl", "r") as f:
writing_responses = [json_converter.loads(line, SimpleWritingResponse) for line in f.readlines()]
len(writing_responses)
# %%
text_to_writing_response = {x.cut_text: x for x in writing_responses}
# %%
writing_responses_4 = [writ for writ in writing_responses if writ.model == "gpt-4-0613"]
# %%
simple_sensor_query_items: QueryItems = []
for resp in writing_responses: # TODO: note :10
simple_sensor_query_items.append(
attrs.evolve(
make_query(
resp.final_text,
sensors_simple,
resp.full_response.parsed_response.query.full_text,
),
cut_text=resp.full_response.parsed_response.query.cut_text,
)
)
len(simple_sensor_query_items)
# %%
# out_file = "sensors_out.jsonl"
out_file = "sensors_for_all.jsonl"
with open(out_file, "w") as f:
...
n_threads = max(min(len(simple_sensor_query_items), 25), 1)
shuffle_items = list(simple_sensor_query_items)
random.shuffle(shuffle_items)
threads = [
threading.Thread(
target=get_completions,
args=(
shuffle_items,
k,
n_threads,
# ["gpt-4-0613"], # for whatever reason 3.5 turbo just can't do this??? (whatever I guess...)
["gpt-3.5-turbo-0613"],
out_file,
50,
),
)
for k in range(n_threads)
]
# %%
for t in threads:
t.start()
# %%
for t in threads:
t.join()
# %%
print("done!")
# %%
# with open("sensors_out_4_simp_check.jsonl", "r") as f:
with open("sensors_for_all.jsonl", "r") as f:
# with open("sensors_out_3_5.jsonl", "r") as f:
loaded_items_sensors = [json.loads(l) for l in f.read().splitlines()]
print(len(loaded_items_sensors))
# 3515
# 3886
# %%
# sum(len(tokenizer.encode(x["content"])) for x in simple_sensor_query_items[3].query)
# %%
text_to_sensors: defaultdict[str, dict[str, bool]] = defaultdict(dict)
count = 0
for i, x in enumerate(loaded_items_sensors):
assert len(x["response"]) == 1
resp = list(x["response"].values())[0]
# val = json.loads(resp["choices"][0]["message"]["function_call"]["arguments"])["answer"] == "Yes"
response_lines = resp["choices"][0]["message"]["content"].splitlines()
if len(response_lines) != len(sensors_simple):
continue
if not all(prop in y for prop, y in zip(sensors_simple, response_lines)):
continue
if not all(("Yes" in y) != ("No" in y or "N/A" in y or "Neutral" in y) for y in response_lines):
continue
count += 1
text_to_sensors[x["query"]["cut_text"]] = {sensor: "Yes" in l for sensor, l in zip(sensors_simple, response_lines)}
full_datums = [
SimpleFullDatum(text_to_writing_response[txt], sensor_vals)
for txt, sensor_vals in text_to_sensors.items()
if len(sensor_vals) == len(sensors_simple)
]
len(full_datums)
# %%
# text_to_sensors_new = text_to_sensors
# %%
# %%
with open("full_datum_all_cheap.jsonl", "w") as f:
for x in full_datums:
f.write(json_converter.dumps(x) + "\n")
# %%
# all_vals = {k: (text_to_sensors_new[k], v) for k, v in text_to_sensors.items()}
# for a, b in all_vals.values():
# if a != b:
# print(a, b)
# text_to_sensors_old = text_to_sensors
# %%
actually_positive = [x for x in full_datums if x.has_latent()]
actually_positive_sensors = [x.sensor_values for x in actually_positive]
all_positive_count = sum(all(x.values()) for x in actually_positive_sensors)
len(actually_positive), all_positive_count, all_positive_count / len(actually_positive)
# %%
# %%
with open("hi.txt", "w") as f:
f.write(actually_positive[24].writing_response.final_text)
# %%
actually_negative = [x for x in full_datums if not x.has_latent()]
actually_negative_sensors = [x.sensor_values for x in actually_negative]
all_positive_tamper_count = sum(all(x.values()) for x in actually_negative_sensors)
len(actually_negative), all_positive_tamper_count, all_positive_tamper_count / len(actually_negative)
# %%
intended_tamper = [x for x in full_datums if x.theoretical_tamper() and not x.has_latent()]
intended_tamper_sensors = [x.sensor_values for x in intended_tamper]
all_positive_tamper_count = sum(all(x.values()) for x in intended_tamper_sensors)
len(intended_tamper), all_positive_tamper_count, all_positive_tamper_count / len(intended_tamper)
# %%
one_or_more_tamp_count = sum(any(x.values()) for x in actually_negative_sensors)
len(actually_negative), one_or_more_tamp_count, one_or_more_tamp_count / len(actually_negative)
# %%
| [] |
2024-01-10 | redwoodresearch/Measurement-Tampering | text_properties~simplified_get_writings.py | import json
import os
import random
import threading
import openai
import tiktoken
from cattrs.preconf.json import make_converter
from text_properties.modify_text import RewriteItem, get_rewrites
from text_properties.simplified_data_types import FullResponse, SimpleWritingResponse
# %%
tokenizer = tiktoken.encoding_for_model("gpt-4")
if "OPENAI_API_KEY" not in os.environ:
openai.api_key_path = os.path.expanduser("~/.openai_api_key")
json_converter = make_converter()
# %%
# with open("full_responses_out_v2_new_extra_filt.jsonl", "r") as f:
with open("full_responses_out_v2_extra_tampers_only_some_tamp.jsonl", "r") as f:
full_responses = [json_converter.loads(line, FullResponse) for line in f.readlines()]
# %%
writing_query_items_3_5: list[RewriteItem] = []
writing_query_items_4: list[RewriteItem] = []
for resp in full_responses:
# Upsample some stuff for gpt4.
base_gpt4_prob = 1 / 12
gpt4_prob = base_gpt4_prob
if resp.theoretical_tamper_count() == 2:
gpt4_prob = base_gpt4_prob * 2.0
elif resp.theoretical_tamper():
gpt4_prob = base_gpt4_prob * 4.0
elif resp.has_latent():
gpt4_prob = base_gpt4_prob * 2.0
rewrite_item = RewriteItem(
resp.parsed_response.query.cut_text,
resp.output_items(),
resp.parsed_response.query.full_text,
extra=dict(earlier_resp=resp),
)
if random.random() < gpt4_prob:
# if True:
writing_query_items_4.append(rewrite_item)
else:
writing_query_items_3_5.append(rewrite_item)
len(writing_query_items_3_5), len(writing_query_items_4)
# %%
dirty_resps_4 = [
resp.extra["earlier_resp"]
for resp in writing_query_items_4
if "dirty" in resp.extra["earlier_resp"].parsed_response.setup_name
]
tamper_resps_4 = [resp for resp in dirty_resps_4 if resp.theoretical_tamper()]
len(dirty_resps_4), len(tamper_resps_4), len(tamper_resps_4) / len(dirty_resps_4)
# %%
any_tamper_resps_4 = [resp for resp in dirty_resps_4 if resp.theoretical_tamper_count() >= 2]
len(dirty_resps_4), len(any_tamper_resps_4), len(any_tamper_resps_4) / len(dirty_resps_4)
# %%
has_lat_resps_4 = [resp for resp in dirty_resps_4 if resp.has_latent()]
len(dirty_resps_4), len(has_lat_resps_4), len(has_lat_resps_4) / len(dirty_resps_4)
# %%
out_file = "writing_out_simp_4_more_tamp.jsonl"
with open(out_file, "w") as f:
...
n_threads = max(min(len(writing_query_items_4), 10), 1)
shuffle_items = list(writing_query_items_4)
random.shuffle(shuffle_items)
threads = [
threading.Thread(
target=get_rewrites,
args=(
shuffle_items,
k,
n_threads,
["gpt-4-0613"],
# ["gpt-3.5-turbo-16k"],
out_file,
700,
0.3,
),
)
for k in range(n_threads)
]
# %%
for t in threads:
t.start()
# %%
for t in threads:
t.join()
# %%
print("done!")
# %%
out_file = "writing_out_simp_3_5_extra_new.jsonl"
with open(out_file, "w") as f:
...
n_threads = max(min(len(writing_query_items_3_5), 90), 1)
shuffle_items = list(writing_query_items_3_5)
random.shuffle(shuffle_items)
threads = [
threading.Thread(
target=get_rewrites,
args=(
shuffle_items,
k,
n_threads,
# ["gpt-4-0613"],
["gpt-3.5-turbo-0613"],
out_file,
700,
0.3,
),
)
for k in range(n_threads)
]
# %%
for t in threads:
t.start()
# %%
for t in threads:
t.join()
# %%
print("done!")
# %%
with open("writing_out_simp_4_more_tamp.jsonl", "r") as f:
loaded_items_writing_4 = [json.loads(l) for l in f.read().splitlines()]
len(loaded_items_writing_4)
# %%
# loaded_items_writing_3_5 = []
# %%
with open("writing_out_simp_3_5_extra_new.jsonl", "r") as f:
loaded_items_writing_3_5 = [json.loads(l) for l in f.read().splitlines()]
len(loaded_items_writing_3_5)
# %%
full_responses_text_dict = {x.parsed_response.query.cut_text: x for x in full_responses}
# %%
writing_responses_3_5 = [SimpleWritingResponse.parse_out(x, full_responses_text_dict) for x in loaded_items_writing_3_5]
writing_responses_4 = [SimpleWritingResponse.parse_out(x, full_responses_text_dict) for x in loaded_items_writing_4]
writing_responses = writing_responses_3_5 + writing_responses_4
# %%
# len({ r.cut_text for r in writing_responses_4}), len(writing_responses_4)
# %%
# maybe_failed_stuff = [resp for resp in writing_responses_3_5 if any("an AI" in t for t in resp.all_text)]
# len(maybe_failed_stuff)
# for x in maybe_failed_stuff:
# print(x.final_text)
# %%
with open("writing_responses_out_v2_more_tamp.jsonl", "w") as f:
for writ in writing_responses:
f.write(json_converter.dumps(writ) + "\n")
# %%
| [] |
2024-01-10 | redwoodresearch/Measurement-Tampering | text_properties~simplified_get_data_pre_modify.py | import json
import os
import random
import threading
from collections import defaultdict
import attrs
import numpy as np
import openai
import tiktoken
from cattrs.preconf.json import make_converter
from datasets import load_dataset
from text_properties.input_text_properties import data_to_queries, get_completions, get_remaining_questions
from text_properties.modify_text import RewriteItem
from text_properties.simplified import theoretical_tamper, theoretical_tamper_count
from text_properties.simplified_data_types import (
FullResponse,
ParsedResponse,
SimpleWritingResponse,
all_setups_flat,
non_algo_props_by_setup,
)
# %%
tokenizer = tiktoken.encoding_for_model("gpt-4")
if "OPENAI_API_KEY" not in os.environ:
openai.api_key_path = os.path.expanduser("~/.openai_api_key")
json_converter = make_converter()
# %%
ds = load_dataset("EleutherAI/pile", streaming=True, split="train")
# %%
N_skip = 300_000
N = 20_000
# %%
# N = 30
data = list(ds.skip(N_skip).take(N))
random.shuffle(data)
# %%
# clean_count_per = 4000
# dirty_count_per = 6000
# clean_count_per = 5000
# dirty_count_per = 0
# clean_count_per = 1000
# dirty_count_per = 1500
# clean_count_per = 2
# dirty_count_per = 2
clean_count_per = 0
dirty_count_per = 1000
queries_by_setup = {}
running_data_loc = 0
cut_text_set = set()
for setup in all_setups_flat:
non_algo_props = non_algo_props_by_setup[setup["name"]]
count_here = clean_count_per if "clean" in setup["name"] else dirty_count_per
out_queries, data_used = data_to_queries(data[running_data_loc:], non_algo_props, limit=count_here)
print(f"{len(tokenizer.encode(get_remaining_questions(non_algo_props)))=}")
out_queries = [attrs.evolve(x, extra={**x.extra, "name": setup["name"]}) for x in out_queries]
# assume text is different for now, so randomly skip lol
new_out_queries = []
for query in out_queries:
if query.cut_text in cut_text_set:
continue
new_out_queries.append(query)
cut_text_set.add(query.cut_text)
out_queries = new_out_queries
running_data_loc += data_used
queries_by_setup[setup["name"]] = out_queries
flat_queries = sum(queries_by_setup.values(), start=[])
len(flat_queries)
# %%
assert len({x.cut_text for x in flat_queries}) == len(flat_queries), "assumed for now!"
# %%
out_file = "fresh_query_check_v2_extra_tampers.jsonl"
with open(out_file, "w") as f:
...
n_threads = max(min(len(flat_queries), 30), 1)
shuffle_items = list(flat_queries)
random.shuffle(shuffle_items)
threads = [
threading.Thread(
target=get_completions,
args=(
shuffle_items,
k,
n_threads,
["gpt-3.5-turbo-0613"], # for higher rate limit lol
out_file,
400,
),
)
for k in range(n_threads)
]
# %%
for t in threads:
t.start()
# %%
for t in threads:
t.join()
# %%
print("done!")
# %%
with open("fresh_query_check_v2_extra_tampers.jsonl", "r") as f:
# with open("fresh_query_check_v2_clean.jsonl", "r") as f:
loaded_items = [json.loads(l) for l in f.read().splitlines()]
len(loaded_items)
# %%
parsed_responses = []
errors = []
for x in loaded_items:
try:
parsed_responses.append(ParsedResponse.parse_out(x))
except AssertionError as e:
errors.append(e)
...
len(parsed_responses)
# %%
# %%
# non_algo_props_by_setup["dirty 2"]
# parsed_responses_dict = defaultdict(list)
# for x in parsed_responses:
# parsed_responses_dict[x.setup_name].append(x)
# parsed_responses_answers_dict = {k: [x.answers for x in xs] for k, xs in parsed_responses_dict.items()}
# # parsed_responses_dict["clean 4"][4].query.cut_text
# parsed_responses_answers_dict["dirty 2"]
# %%
# %%
full_responses = [FullResponse.construct(x) for x in parsed_responses]
# %%
with open("full_responses_out_v2_extra_tampers_no_filt.jsonl", "w") as f:
for resp in full_responses:
f.write(json_converter.dumps(resp) + "\n")
# %%
full_responses_dict: defaultdict[str, list[FullResponse]] = defaultdict(list)
for x in full_responses:
full_responses_dict[x.parsed_response.setup_name].append(x)
full_responses_answers_dict = {k: [x.full_answers for x in xs] for k, xs in full_responses_dict.items()}
# full_responses_dict["clean 4"][4].query.cut_text
# np.array(full_responses_answers_dict["clean 5"]).mean(axis=0)
# # full_responses_dict["clean 1"][-2].parsed_response.query.cut_text
# list(zip(all_setups_dict["dirty 1"]["items"], np.array(full_responses_answers_dict["dirty 1"]).mean(axis=0)))
# %%
dirty_resps = [resp for resp in full_responses if "dirty" in resp.parsed_response.setup_name]
tamper_resps = [resp for resp in dirty_resps if theoretical_tamper(resp.output_items())]
len(dirty_resps), len(tamper_resps), len(tamper_resps) / len(dirty_resps)
# %%
any_tamper_resps = [resp for resp in dirty_resps if theoretical_tamper_count(resp.output_items()) >= 2]
len(dirty_resps), len(any_tamper_resps), len(any_tamper_resps) / len(dirty_resps)
# %%
tamp_counts = np.array([theoretical_tamper_count(resp.output_items()) for resp in full_responses])
# adhoc constants. Probably setting specific!
keep_probs = np.where(tamp_counts <= 1, 0.5, np.where(tamp_counts >= 3, 1.0, 0.75))
keeps = np.random.rand(*keep_probs.shape) < keep_probs
full_responses_filtered = [resp for resp, keep in zip(full_responses, keeps) if keep]
len(full_responses), len(full_responses_filtered)
# %%
dropped_omit_responses_clean = [
SimpleWritingResponse(
resp,
RewriteItem(
resp.parsed_response.query.cut_text,
resp.output_items(),
resp.parsed_response.query.full_text,
),
model="OMIT",
final_text="OMIT",
all_text=[resp.parsed_response.query.cut_text] + ["OMIT"] * len(resp.output_items()),
)
for resp, keep in zip(full_responses, keeps)
if not keep and "clean" in resp.parsed_response.setup_name
]
with open("omit_writing_responses_out_v2_new_extra_dropped_clean.jsonl", "w") as f:
for omit_resp in dropped_omit_responses_clean:
f.write(json_converter.dumps(omit_resp) + "\n")
len(dropped_omit_responses_clean)
# %%
all_omit_responses_clean = [
SimpleWritingResponse(
resp,
RewriteItem(
resp.parsed_response.query.cut_text,
resp.output_items(),
resp.parsed_response.query.full_text,
),
model="OMIT",
final_text="OMIT",
all_text=[resp.parsed_response.query.cut_text] + ["OMIT"] * len(resp.output_items()),
)
for resp in full_responses
if "clean" in resp.parsed_response.setup_name
]
with open("omit_writing_responses_out_v2_new_extra_all_clean.jsonl", "w") as f:
for omit_resp in all_omit_responses_clean:
f.write(json_converter.dumps(omit_resp) + "\n")
len(all_omit_responses_clean)
# %%
# %%
dirty_resps_filt = [resp for resp in full_responses_filtered if "dirty" in resp.parsed_response.setup_name]
tamper_resps_filt = [resp for resp in dirty_resps_filt if theoretical_tamper(resp.output_items())]
len(dirty_resps_filt), len(tamper_resps_filt), len(tamper_resps_filt) / len(dirty_resps_filt)
# %%
any_tamper_resps_filt = [resp for resp in dirty_resps_filt if theoretical_tamper_count(resp.output_items()) >= 2]
len(dirty_resps_filt), len(any_tamper_resps_filt), len(any_tamper_resps_filt) / len(dirty_resps_filt)
# %%
# with open("full_responses_out_v2.jsonl", "w") as f:
with open("full_responses_out_v2_new_extra_filt.jsonl", "w") as f:
for resp in full_responses_filtered:
f.write(json_converter.dumps(resp) + "\n")
# %%
# with open("full_responses_out_v2.jsonl", "w") as f:
with open("full_responses_out_v2_extra_tampers_only_some_tamp.jsonl", "w") as f:
for resp in any_tamper_resps:
f.write(json_converter.dumps(resp) + "\n")
| [] |
2024-01-10 | redwoodresearch/Measurement-Tampering | text_properties~simplified_get_training_data.py | import os
import random
from collections import defaultdict
from typing import Optional
import openai
import tiktoken
import torch
from cattrs.preconf.json import make_converter
from transformers import AutoTokenizer
from measurement_tampering.train_utils import BatchData
from text_properties.simplified_data_types import SimpleFullDatum, SimpleWritingResponse
from text_properties.training_data_prompts import (
sensor_prediction_prompt_part_omit,
writing_response_to_full_prompt,
writing_response_to_full_prompt_with_noted_modifications_pred,
writing_response_to_full_prompt_with_pred,
writing_response_to_full_prompt_with_pred_sensor_predictions,
)
from text_properties.utils import batch_data_from_strings_tokenizer
from text_properties.training_data_utils import get_sensor_locs, is_sensor_loc
# %%
openai_tokenizer = tiktoken.encoding_for_model("gpt-4")
if "OPENAI_API_KEY" not in os.environ:
openai.api_key_path = os.path.expanduser("~/.openai_api_key")
json_converter = make_converter()
# %%
with open("writing_responses_out_v2_all_comb.jsonl", "r") as f:
writing_responses = [json_converter.loads(line, SimpleWritingResponse) for line in f.readlines()]
len(writing_responses)
# %%
writing_responses_4 = [writ for writ in writing_responses if writ.model == "gpt-4-0613"]
len(writing_responses_4)
# %%
# sum(["clean" in w.setup_name for w in writing_responses_4]) / len(writing_responses_4)
# %%
models_dict = defaultdict(int)
for writ in writing_responses:
models_dict[writ.model] += 1
# %%
len({writ.cut_text for writ in writing_responses}), len(writing_responses)
# %%
# %%
print()
w = writing_responses_4[19]
print(w.full_response.output_items())
print(writing_response_to_full_prompt_with_pred(w))
print(writing_response_to_full_prompt_with_noted_modifications_pred(w))
# print(len(openai_tokenizer.encode(writing_response_to_full_prompt_with_pred(w))))
# %%
# torch.cummax(torch.tensor([False, True, False, True]), dim=0)
# %%
# tok = AutoTokenizer.from_pretrained("EleutherAI/pythia-70m-deduped")
# tok.add_special_tokens({"pad_token": "[PAD]"})
# tok(["hislkdfjlksdjf", "hi"], padding="max_length", max_length=512 * 3)
# # batch_data_from_ntp(torch.tensor([[1, 2, 3, 7, 9, 12], [3, 7, 9, 8, 4, 10]]), torch.tensor([7, 9]))
# %%
tok = AutoTokenizer.from_pretrained("EleutherAI/pythia-70m-deduped")
tok.add_special_tokens({"pad_token": "[PAD]"})
# %%
# TODO: incorporate omit writing repsonses into above (as needed?)!
use_omit_writing_response = True
note_modification = False
note_sensors = True
# %%
with open("omit_writing_responses_out_v2_all_comb_dropped_clean.jsonl", "r") as f:
omit_clean_writing_responses = [json_converter.loads(line, SimpleWritingResponse) for line in f.readlines()]
len(omit_clean_writing_responses), omit_clean_writing_responses[0].model
# %%
responses_to_shuffle_and_split = writing_responses + (omit_clean_writing_responses if use_omit_writing_response else [])
random.shuffle(responses_to_shuffle_and_split)
basic_frac_val = 0.20
possible_count_val = int(basic_frac_val * len(responses_to_shuffle_and_split))
possible_val_resp, possible_train_resp = (
responses_to_shuffle_and_split[:possible_count_val],
responses_to_shuffle_and_split[possible_count_val:],
)
prob_keep_by_model = {"gpt-3.5-turbo-0613": 0.5, "OMIT": 0.0, "gpt-4-0613": 1.0}
keep_val = [random.random() < prob_keep_by_model[x.model] for x in possible_val_resp]
actual_train_resp = [x for x, keep in zip(possible_val_resp, keep_val) if not keep] + possible_train_resp
actual_val_resp = [x for x, keep in zip(possible_val_resp, keep_val) if keep]
counts = defaultdict(int)
for x in actual_val_resp:
counts[x.model] += 1
with open("writing_responses_all_train_extra_new.jsonl", "w") as f:
for writ in actual_train_resp:
f.write(json_converter.dumps(writ) + "\n")
with open("writing_responses_all_val_extra_new.jsonl", "w") as f:
for writ in actual_val_resp:
f.write(json_converter.dumps(writ) + "\n")
len(actual_val_resp), len(actual_train_resp), counts
# %%
with open("writing_responses_all_train_extra_new.jsonl", "r") as f:
actual_train_resp = [json_converter.loads(l, SimpleWritingResponse) for l in f.readlines()]
with open("writing_responses_all_val_extra_new.jsonl", "r") as f:
actual_val_resp = [json_converter.loads(l, SimpleWritingResponse) for l in f.readlines()]
with open("full_datum_all_cheap.jsonl", "r") as f:
full_datums_all = [json_converter.loads(l, SimpleFullDatum) for l in f.readlines()]
# %%
final_text_to_sensors = {x.writing_response.final_text: x.sensor_values for x in full_datums_all}
len(final_text_to_sensors)
# %%
actual_train_resp[2].model
# %%
assert not (note_modification and note_sensors)
full_prompt_normal_func = (
writing_response_to_full_prompt_with_noted_modifications_pred
if note_modification
else (
(
lambda x: (
writing_response_to_full_prompt_with_pred_sensor_predictions(
x, sensors=final_text_to_sensors[x.final_text]
)
if x.final_text in final_text_to_sensors # TODO: remove
else writing_response_to_full_prompt_with_pred(x)
)
)
if note_sensors
else writing_response_to_full_prompt_with_pred
)
)
full_prompt_omit_func = writing_response_to_full_prompt_with_noted_modifications_pred
train_strs_with_mod, val_strs_with_mod = (
[full_prompt_normal_func(x) if x.model != "OMIT" else full_prompt_omit_func(x) for x in actual_train_resp],
[full_prompt_normal_func(x) for x in actual_val_resp], # no omit
)
# %%
all_temp = [x for x in train_strs_with_mod if "appear to contain" in x]
len(all_temp), len([x for x in actual_train_resp if x.model != "OMIT"])
# %%
print(all_temp[3])
# %%
# %%
out_train_with_mod = batch_data_from_strings_tokenizer(
train_strs_with_mod, tok, mask_out_prompting=True, max_len=512 * 3
)
out_val_with_mod = batch_data_from_strings_tokenizer(val_strs_with_mod, tok, mask_out_prompting=True, max_len=512 * 3)
if note_sensors:
for item_with_mod in [out_train_with_mod, out_val_with_mod]:
question_points = is_sensor_loc(item_with_mod["input_ids"], tok, ntp_mask=item_with_mod["ntp_mask"])
item_with_mod["ntp_mask"] = torch.where(
item_with_mod["ntp_mask"],
1.0,
torch.where(question_points, torch.tensor(100.0), 0.1),
)
elif note_modification:
for item_with_mod in [out_train_with_mod, out_val_with_mod]:
nl = tok.encode("\n")[0]
up_to_extra = torch.argmax(
(
(
(
((item_with_mod["input_ids"][:, :-1] == nl) & (item_with_mod["input_ids"][:, 1:] == nl))
| (
item_with_mod["input_ids"][:, :-1] == tok.encode("\n\n\n")[0]
) # everyone loves tokenization...
| (item_with_mod["input_ids"][:, :-1] == tok.encode("\n\n")[0])
)
& item_with_mod["ntp_mask"][:, :-1]
)
).to(torch.uint8),
dim=-1,
)
extra = torch.arange(item_with_mod["ntp_mask"].shape[-1]) <= (up_to_extra[:, None] + 1)
item_with_mod["ntp_mask"] = torch.where(
item_with_mod["ntp_mask"],
torch.where(extra, 1.0, 0.02), # currently 2% weight elsewhere
torch.tensor(0.005), # and 0.5% weight on prompt
)
else:
for item_with_mod in [out_train_with_mod, out_val_with_mod]:
item_with_mod["ntp_mask"] = torch.where(
item_with_mod["ntp_mask"],
torch.tensor(1.0),
torch.tensor(0.10), # and 10% weight on prompt
)
base_dir = os.path.expanduser(
f"~/text_properties/simplified_setting_v3/upd{'_mod_explicit' if note_modification else ''}{'_with_omit' if use_omit_writing_response else ''}{'_sensor_pred' if note_sensors else ''}/data_gpt_neo_x_tokenizer/"
)
print(f"{base_dir=}")
os.makedirs(base_dir, exist_ok=True)
torch.save(out_train_with_mod, f"{base_dir}/train.pt")
torch.save(out_val_with_mod, f"{base_dir}/val.pt")
print("Done!")
# %%
x = out_train_with_mod["ntp_mask"][16]
(x * (x == 0.1)).sum(), (x * (x == 1.0)).sum(), (x * (x == 100.0)).sum()
# %%
idx = 20
# %%
for x, w in zip(out_train_with_mod["input_ids"][idx], out_train_with_mod["ntp_mask"][idx]):
print(tok.decode(x), x, w)
# %%
print(tok.decode(out_train_with_mod["input_ids"][idx]))
# %%
# ((out_train["input_ids"] == tok("[PAD]")["input_ids"][0]).sum(dim=-1) == 0).to(torch.float32).mean(dtype=torch.float32)
# %%
post_pretrain_keep_pred = False
post_pretrain_use_gen_instead_of_pred = False
post_pretrain_sensor_pred_formating = True
# %%
# This is a labeled version of the above `writing_responses_all_val_extra_new.jsonl`.
with open("full_datum_post_pretrain_all.jsonl", "r") as f:
post_pre_train_full_datum = [json_converter.loads(line, SimpleFullDatum) for line in f.readlines()]
len(post_pre_train_full_datum)
# %%
assert {x.cut_text for x in actual_val_resp} == {x.writing_response.cut_text for x in post_pre_train_full_datum}
# %%
# with open("out_gen_all_low_temp.jsonl", "r") as f:
# with_gen_datum = [json_converter.loads(line, SimpleFullDatumWithGen) for line in f.readlines()]
# len(with_gen_datum)
with_gen_datum = None # TODO as needed
# %%
# This is extra data for validation only.
with open("full_datum_more_tamp_new_approach.jsonl", "r") as f:
full_datum_extra_tamp = [json_converter.loads(line, SimpleFullDatum) for line in f.readlines()]
len(full_datum_extra_tamp)
# %%
full_datum_extra_tamp_no_latent = [x for x in full_datum_extra_tamp if not x.has_latent()]
len(full_datum_extra_tamp_no_latent)
# %%
updated_full = post_pre_train_full_datum + full_datum_extra_tamp_no_latent
used_datums = [x.datum for x in with_gen_datum] if post_pretrain_use_gen_instead_of_pred else updated_full
used_fin_text = (
[x.gen for x in with_gen_datum]
if post_pretrain_use_gen_instead_of_pred
else [x.writing_response.final_text for x in updated_full]
)
# %%
actually_positive = [x for x in used_datums if x.has_latent()]
actually_positive_sensors = [x.sensor_values for x in actually_positive]
all_positive_count = sum(all(x.values()) for x in actually_positive_sensors)
len(actually_positive), all_positive_count, all_positive_count / len(actually_positive)
# %%
intended_tamper = [x for x in used_datums if x.theoretical_tamper() and not x.has_latent()]
intended_tamper_sensors = [x.sensor_values for x in intended_tamper]
all_positive_tamper_count = sum(all(x.values()) for x in intended_tamper_sensors)
len(intended_tamper), all_positive_tamper_count, all_positive_tamper_count / len(intended_tamper)
# %%
negative = [x for x in used_datums if not x.has_latent()]
negative_sensors = [x.sensor_values for x in negative]
any_all_positive_tamper_count = sum(all(x.values()) for x in negative_sensors)
len(negative), any_all_positive_tamper_count, any_all_positive_tamper_count / len(negative)
# %%
negative_gpt4 = [x for x in used_datums if not x.has_latent() and "gpt-4" in x.writing_response.model]
negative_gpt4_sensors = [x.sensor_values for x in negative_gpt4]
any_all_positive_tamper_count_gpt4 = sum(all(x.values()) for x in negative_gpt4_sensors)
len(negative_gpt4), any_all_positive_tamper_count_gpt4, any_all_positive_tamper_count_gpt4 / len(negative_gpt4)
# %%
# %%
intended_tamper_ex = [x for x in full_datum_extra_tamp if x.theoretical_tamper() and not x.has_latent()]
intended_tamper_sensors_ex = [x.sensor_values for x in intended_tamper_ex]
all_positive_tamper_count_ex = sum(all(x.values()) for x in intended_tamper_sensors_ex)
len(intended_tamper_ex), all_positive_tamper_count_ex, all_positive_tamper_count_ex / len(intended_tamper_ex)
# %%
negative_ex = [x for x in full_datum_extra_tamp if not x.has_latent()]
negative_sensors_ex = [x.sensor_values for x in negative_ex]
any_all_positive_tamper_count_ex = sum(all(x.values()) for x in negative_sensors_ex)
len(negative_ex), any_all_positive_tamper_count_ex, any_all_positive_tamper_count_ex / len(negative_ex)
# %%
# %%
used_all_shuf = list(zip(used_datums, used_fin_text))
random.shuffle(used_all_shuf)
used_datums_shuf = [x for x, _ in used_all_shuf]
used_fin_text_shuf = [x for _, x in used_all_shuf]
basic_frac_val = 0.50
possible_count_val = int(basic_frac_val * len(used_datums_shuf))
is_gpt4 = ["gpt-4" in x.writing_response.model for x in used_datums_shuf]
final_text_extra_tamp_set = {x.writing_response.final_text for x in full_datum_extra_tamp}
# keep all of these for val!
is_from_extra_tamp = [x.writing_response.final_text in final_text_extra_tamp_set for x in used_datums_shuf]
keep_for_val = ((torch.arange(len(used_datums_shuf)) < possible_count_val) & torch.tensor(is_gpt4)) | torch.tensor(
is_from_extra_tamp
)
assert not (post_pretrain_keep_pred and post_pretrain_sensor_pred_formating)
all_strs = [
writing_response_to_full_prompt_with_pred(x.writing_response, text=text_use)
if post_pretrain_keep_pred
else (
writing_response_to_full_prompt(
x.writing_response, extra=sensor_prediction_prompt_part_omit if post_pretrain_sensor_pred_formating else ""
)
)
for (x, text_use) in zip(used_datums_shuf, used_fin_text_shuf)
]
sensor_values = [x.sensor_values for x in used_datums_shuf]
actual_latent = [x.has_latent() for x in used_datums_shuf]
is_clean = ["clean" in x.writing_response.setup_name for x in used_datums_shuf]
# print(all_strs[0] + "aft")
out_data_post = batch_data_from_strings_tokenizer(
all_strs,
tok,
mask_out_prompting=False,
max_len=512 * 3 if post_pretrain_keep_pred else 1024,
sensor_values=sensor_values,
actual_latent=actual_latent,
is_clean=is_clean,
prob_at_end_instead_of_modify=post_pretrain_keep_pred,
)
if post_pretrain_sensor_pred_formating:
corresponding_locs = get_sensor_locs(out_data_post["input_ids"], tok)
# use last location for GT and all
out_data_post["overall_loc"] = corresponding_locs[:, -1]
out_data_post["sensor_locs"] = corresponding_locs
out_data_post_val = BatchData({k: v[keep_for_val] for k, v in out_data_post.items()})
out_data_post_train = BatchData({k: v[~keep_for_val] for k, v in out_data_post.items()})
with open("full_datum_post_pretrain_val_sensor_pred_with_extra_tamp_v3.jsonl", "w") as f:
for x, keep in zip(used_datums_shuf, keep_for_val):
if keep:
f.write(json_converter.dumps(x) + "\n")
with open("full_datum_post_pretrain_train_sensor_pred_with_extra_tamp_v3.jsonl", "w") as f:
for x, keep in zip(used_datums_shuf, keep_for_val):
if not keep:
f.write(json_converter.dumps(x) + "\n")
base_dir = os.path.expanduser(
f"~/text_properties/simplified_setting_v3/post_pretrain_with_extra_tamp{'_keep_pred' if post_pretrain_keep_pred else ''}{'_from_model' if post_pretrain_use_gen_instead_of_pred else ''}{'_sensor_pred' if post_pretrain_sensor_pred_formating else ''}/data_gpt_neo_x_tokenizer/"
)
os.makedirs(base_dir, exist_ok=True)
torch.save(out_data_post_val, f"{base_dir}/val.pt")
torch.save(out_data_post_train, f"{base_dir}/train.pt")
print("Done!")
# %%
with open("full_datum_post_pretrain_val_sensor_pred_with_extra_tamp_v3.jsonl", "r") as f:
val_out = [json_converter.loads(l, SimpleFullDatum) for l in f.readlines()]
with open("full_datum_post_pretrain_train_sensor_pred_with_extra_tamp_v3.jsonl", "r") as f:
train_out = [json_converter.loads(l, SimpleFullDatum) for l in f.readlines()]
# %%
tamps = [x for x in train_out if all(x.sensor_values.values()) and not x.has_latent()]
print(f"{len(tamps)=} {len(train_out)=} {len(tamps) / len(train_out)=}")
# %%
pos = [x for x in train_out if all(x.sensor_values.values()) and x.has_latent()]
print(f"{len(pos)=} {len(train_out)=} {len(pos) / len(train_out)=}")
# %%
false_neg = [x for x in train_out if not all(x.sensor_values.values()) and x.has_latent()]
print(f"{len(false_neg)=} {len(train_out)=} {len(false_neg) / len(train_out)=}")
# %%
cleans = [x for x in train_out if "clean" in x.writing_response.setup_name]
print(f"{len(cleans)=} {len(train_out)=} {len(cleans) / len(train_out)=}")
# %%
with open("out.txt", "w") as f:
f.write(
writing_response_to_full_prompt_with_noted_modifications_pred(
[x for x in tamps if "gpt-4" in x.writing_response.model][1].writing_response
)
)
# %%
with open("out.txt", "w") as f:
x = [x for x in pos if "gpt-4" in x.writing_response.model][2]
# f.write(
# writing_response_to_full_prompt(
# x.writing_response,
# extra=sensor_prediction_prompt_part_omit,
# )
# )
f.write(writing_response_to_full_prompt_with_pred_sensor_predictions(x.writing_response, sensors=x.sensor_values))
# %%
tamps_val = [x for x in val_out if all(x.sensor_values.values()) and not x.has_latent()]
print(f"{len(tamps_val)=} {len(val_out)=} {len(tamps_val) / len(val_out)=}")
# %%
pos_val = [x for x in val_out if all(x.sensor_values.values()) and x.has_latent()]
print(f"{len(pos_val)=} {len(val_out)=} {len(pos_val) / len(val_out)=}")
# %%
false_neg_val = [x for x in val_out if not all(x.sensor_values.values()) and x.has_latent()]
print(f"{len(false_neg_val)=} {len(val_out)=} {len(false_neg_val) / len(val_out)=}")
# %%
cleans_val = [x for x in val_out if "clean" in x.writing_response.setup_name]
print(f"{len(cleans_val)=} {len(val_out)=} {len(cleans_val) / len(val_out)=}")
# %%
# print(tok.decode(out_data_post_val["input_ids"][1]))
# print(out_data_post_val["probe_locs_all"].max())
# %%
print(tok.decode(out_data_post["input_ids"][0]))
# %%
# print(tok.decode(out_data_post_val["input_ids"][3][: out_data_post_val["probe_locs_all"][3][0] + 8]))
# %%
# from transformers import GPTNeoXForCausalLM
# GPTNeoXForCausalLM.from_pretrained("EleutherAI/pythia-70m-deduped")
# # %%
# import transformers
# model = transformers.AutoModelForCausalLM.from_pretrained(
# 'mosaicml/mpt-7b',
# trust_remote_code=True
# )
| [] |
2024-01-10 | redwoodresearch/Measurement-Tampering | text_properties~data_initial.py | import json
import os
import random
import re
import threading
import time
from collections import defaultdict
import attrs
import openai
import tiktoken
from datasets import load_dataset
from text_properties.input_text_properties import QueryItem, QueryItems, cut_text, data_to_queries, get_completions
from text_properties.modify_text import RewriteItem, get_rewrites
from text_properties.properties import (
all_input_properties,
all_output_properties,
general_properties,
latent_output_properties,
output_only_properties,
sensors,
)
from text_properties.sensor_query import get_sensor_query
# %%
tokenizer = tiktoken.encoding_for_model("gpt-4")
if "OPENAI_API_KEY" not in os.environ:
openai.api_key_path = os.path.expanduser("~/.openai_api_key")
# %%
ds = load_dataset("EleutherAI/pile", streaming=True, split="train")
# %%
N = 5_000
# %%
# N = 10
data = list(ds.take(N))
random.shuffle(data)
# %%
with open("temp_out_text.txt", "w") as f:
f.write(data[23]["text"])
# %%
query_items, _ = data_to_queries(data[:2000], all_input_properties)
print(len(tokenizer.encode(query_items[4].query_unwrap[-1]["content"])), len(query_items))
# %%
with open("out_content.jsonl", "w") as f:
for q in query_items[:5]:
f.write(json.dumps(q.query) + "\n")
# %%
with open("out_content.jsonl", "r") as f:
items = [json.loads(l) for l in f.read().splitlines()]
# print([3]["content"])
# %%
# %%
out_file = "fixed_new.jsonl"
with open(out_file, "w") as f:
...
n_threads = max(min(len(query_items), 30), 1)
shuffle_items = list(query_items)
random.shuffle(shuffle_items)
threads = [
threading.Thread(
target=get_completions,
args=(
shuffle_items,
k,
n_threads,
["gpt-3.5-turbo-16k"], # for higher rate limit lol
out_file,
),
)
for k in range(n_threads)
]
# %%
for t in threads:
t.start()
# %%
for t in threads:
t.join()
# %%
print("done!")
# %%
with open("fixed_new.jsonl", "r") as f:
loaded_items = [json.loads(l) for l in f.read().splitlines()]
len(loaded_items)
# %%
# all_input_properties = [x.partition("Does the text contain ")[-1][:-1] for x in loaded_items[0]["query"]["query"][-1]["content"].splitlines()[2:]]
# %%
@attrs.frozen
class ParsedResponse:
query: QueryItem
answers_by_model: dict[str, list[bool]]
@classmethod
def parse_out(cls, x):
by_model = {}
for model, rest in x["response"].items():
response_lines = rest["choices"][0]["message"]["content"].splitlines()
assert len(response_lines) == len(all_input_properties)
by_model[model] = [y.split()[-1] == "Yes" for y in response_lines]
return cls(QueryItem(**x["query"]), by_model)
# %%
# len(all_input_properties)
# for x in list(
# zip(
# loaded_items[0]["response"]["gpt-3.5-turbo-16k"]["choices"][0]["message"]["content"].splitlines(),
# all_input_properties,
# )
# ):
# print(x)
# #
# # len(loaded_items[0]["response"]["gpt-3.5-turbo-16k"]["choices"][0]["message"]["content"].splitlines())
# %%
parsed_responses = []
for x in loaded_items:
try:
parsed_responses.append(ParsedResponse.parse_out(x))
except AssertionError:
...
len(parsed_responses)
# %%
def print_item(x: ParsedResponse):
response_str = "\n".join(
f"{question} {gpt4_item} {gpt3_5_item}" + (" DISAGREE" if gpt4_item != gpt3_5_item else "")
for gpt4_item, gpt3_5_item, question in zip(
x.answers_by_model["gpt-4-0613"], x.answers_by_model["gpt-3.5-turbo-0613"], all_input_properties
)
)
return x.query.cut_text + "\n" + response_str
# print(print_item(parsed_responses[0]))
# %%
def basic_print_str(x: ParsedResponse):
return (
x.query.cut_text
+ "\n\n"
+ "\n".join(
f"{question}: {ans}" for question, ans in zip(all_input_properties, x.answers_by_model["gpt-3.5-turbo-16k"])
)
)
# print()
# print(basic_print_str(parsed_responses[16]))
# %%
import numpy as np
sum_count = 0
for resp in parsed_responses:
sum_count += np.array(resp.answers_by_model["gpt-3.5-turbo-16k"])
# %%
s = "\n".join(
f"{question}: {c} ({c / len(parsed_responses):.5f})" for question, c in zip(all_input_properties, sum_count)
)
print(len(parsed_responses))
print(s)
# %%
# %%
# %%
writing_query_items: list[RewriteItem] = []
for d in data[260:500]:
# for d in data[200:250]:
new_text = cut_text(d["text"])
if new_text is None:
continue
out_lines = new_text.splitlines()
copied = list(all_output_properties)
random.shuffle(copied)
new_properties = latent_output_properties + copied[:2]
random.shuffle(new_properties)
writing_query_items.append(
RewriteItem(
new_text,
new_properties,
d["text"],
)
)
len(writing_query_items)
# %%
with open("writing_query_items.jsonl", "w") as f:
for q in writing_query_items:
f.write(json.dumps(attrs.asdict(q)) + "\n")
# %%
with open("writing_query_items.jsonl", "r") as f:
queries_load = [json.loads(l) for l in f.read().splitlines()]
# %%
# out_file = "writing_out_new.jsonl"
out_file = "writing_out_new_3_5.jsonl"
with open(out_file, "w") as f:
...
n_threads = max(min(len(writing_query_items), 80), 1)
shuffle_items = list(writing_query_items)
random.shuffle(shuffle_items)
threads = [
threading.Thread(
target=get_rewrites,
args=(
shuffle_items,
k,
n_threads,
["gpt-4-0613"],
# ["gpt-3.5-turbo-16k"],
out_file,
1500,
0.3,
),
)
for k in range(n_threads)
]
# %%
for t in threads:
time.sleep(0.1)
t.start()
# %%
for t in threads:
t.join()
# %%
print("done!")
# %%
with open("writing_out_new.jsonl", "r") as f:
# with open("writing_out_new_3_5.jsonl", "r") as f:
loaded_items_writing = [json.loads(l) for l in f.read().splitlines()]
len(loaded_items_writing)
# %%
mods = loaded_items_writing[2]["query"]["modifications"]
model = loaded_items_writing[2]["model"]
# %%
with open("temp_out_text.txt", "w") as f:
f.write(loaded_items_writing[2]["all_text"][6])
# %%
@attrs.frozen
class WritingResponse:
query: RewriteItem
model: str
final_text: str
all_text: list[str]
@classmethod
def parse_out(cls, x):
return cls(RewriteItem(**x["query"]), model=x["model"], final_text=x["all_text"][-1], all_text=x["all_text"])
# %%
all_writing_responses: list[WritingResponse] = []
for item in loaded_items_writing:
try:
all_writing_responses.append(WritingResponse.parse_out(item))
except AssertionError:
...
# %%
all_writing_responses[1].query.modifications
all_writing_responses[1].model
with open("temp_out_text.txt", "w") as f:
f.write(all_writing_responses[1].all_text[4])
# %%
# %%
sensor_query_items: QueryItems = []
for resp in all_writing_responses:
for sensor in sensors:
sensor_query_items.append(
QueryItem(
resp.query.cut_text,
get_sensor_query(sensor, resp.final_text),
resp.query.full_text,
extra=dict(sensor=sensor, writing_response=resp),
)
)
len(sensor_query_items)
# %%
out_file = "sensors_out.jsonl"
# out_file = "sensors_out_3_5.jsonl"
with open(out_file, "w") as f:
...
n_threads = max(min(len(sensor_query_items), 1), 1)
shuffle_items = list(sensor_query_items)
random.shuffle(shuffle_items)
threads = [
threading.Thread(
target=get_completions,
args=(
shuffle_items,
k,
n_threads,
# ["gpt-4-0613"],
["gpt-3.5-turbo-16k"],
out_file,
50,
dict(
functions=[
{
"name": "provide_answer",
"description": "Answers the question with Yes/No",
"parameters": {
"type": "object",
"properties": {
"answer": {
"type": "string",
"description": "The Yes/No answer",
"enum": ["Yes", "No"],
},
},
},
"required": ["answer"],
}
],
function_call={"name": "provide_answer"},
),
),
)
for k in range(n_threads)
]
# %%
for t in threads:
t.start()
# %%
for t in threads:
t.join()
# %%
print("done!")
# %%
with open("sensors_out.jsonl", "r") as f:
# with open("sensors_out_3_5.jsonl", "r") as f:
loaded_items_sensors = [json.loads(l) for l in f.read().splitlines()]
len(loaded_items_sensors)
# %%
sensor_values: defaultdict[str, defaultdict[str, defaultdict[str, dict[str, bool]]]] = defaultdict(
lambda: defaultdict(lambda: defaultdict(dict))
)
sensor_values_by_passage: defaultdict[tuple[str, str, str], dict[str, bool]] = defaultdict(dict)
for sensor_item in loaded_items_sensors:
for model, item in sensor_item["response"].items():
which_model_wrote = sensor_item["query"]["extra"]["writing_response"]["model"]
which_sensor = sensor_item["query"]["extra"]["sensor"]
sensor_val = json.loads(item["choices"][0]["message"]["function_call"]["arguments"])["answer"] == "Yes"
sensor_values[sensor_item["query"]["cut_text"]][which_model_wrote][model][which_sensor] = sensor_val
sensor_values_by_passage[
sensor_item["query"]["extra"]["writing_response"]["final_text"],
which_model_wrote,
model,
][which_sensor] = sensor_val
# %%
# sensor_item_filter = {
# k: v for k, v in sensor_values_by_passage.items() if k[1] == "gpt-4-0613" and k[2] == "gpt-4-0613"
# }
sensor_item_filter = sensor_values_by_passage
some_neg = {k: v for k, v in sensor_item_filter.items() if any(not x for x in v.values())}
len(some_neg) / len(sensor_item_filter)
# %%
all_b = [x for xs in sensor_item_filter.values() for x in xs.values()]
(sum(all_b) / len(all_b)) ** 5
# %%
count = 0
for q in query_items:
count += re.search(r"\b[hH]e\b", q.cut_text) is not None
count / len(query_items)
# %%
count = 0
for q in query_items:
count += q.cut_text.count(".") > 10
count / len(query_items)
# %%
count = 0
for q in query_items:
count += (len(re.findall(r"\bI\b", q.cut_text)) - q.cut_text.count(".")) > -7
count / len(query_items)
# %%
xs = general_properties + output_only_properties
xs[:50]
# xs = list(input_latent_properties)
# random.shuffle(xs)
# %%
latent_props = [(p, c) for p, c in zip(all_input_properties, sum_count) if 0.1 < c / len(parsed_responses) < 0.8]
# %%
# latent_props = [(p, c) for p, c in zip(all_input_properties, sum_count) if c / len(parsed_responses) > 0.6]
# %%
latent_props
# %%
props_to_sample = [p for p, c in zip(all_input_properties, sum_count) if c / len(parsed_responses) > 0.005]
random.shuffle(props_to_sample)
len(props_to_sample)
# %%
with open("elk/text_properties/most_common_words.txt", "r") as f:
common_words = [x.strip() for x in f.readlines()[150:250]]
# %%
regexes = {w: re.compile(rf"\b{w}\b", re.IGNORECASE) for w in common_words}
counts = defaultdict(int)
for q in query_items[:500]:
for w, regex in regexes.items():
counts[w] += regex.search(q.cut_text) is not None
# %%
with open("elk/text_properties/most_common_words.txt", "r") as f:
common_words_many = [x.strip() for x in f.readlines()[50:150]]
regexes_many = {w: re.compile(rf"\b{w}\b", re.IGNORECASE) for w in common_words_many}
all_word_occur: list[list[bool]] = []
for q in query_items[:500]:
all_word_occur.append([regex.search(q.cut_text) is not None for w, regex in regexes_many.items()])
all_occur = np.array(all_word_occur)
fracs_oc = all_occur.mean(axis=0)
oc_vars_v = fracs_oc - fracs_oc**2
oc_stds_v = np.sqrt(oc_vars_v)
cov_sum = 0
diff_sum = 0
for vals in all_occur:
cov_sample = (vals[:, None] - fracs_oc) * (vals[None, :] - fracs_oc)
dif_vals = np.maximum(vals[:, None].astype(np.float64) - vals[None, :], 0.0)
cov_sum += cov_sample
diff_sum += dif_vals
cov = cov_sum / len(all_word_occur)
diff = diff_sum / len(all_word_occur)
diff_norm = diff / fracs_oc[:, None]
corr = cov / (oc_stds_v[:, None] * oc_stds_v[None, :])
all_pairs = (corr > 0.20) & (diff_norm > 0.05) & (diff_norm > 0.05).T
i_arr, j_arr, k_arr = np.nonzero(all_pairs[:, :, None] & all_pairs[:, None, :] & all_pairs[None, :, :])
idxs = np.arange(len(i_arr))
np.random.shuffle(idxs)
i_arr = i_arr[idxs]
j_arr = j_arr[idxs]
k_arr = k_arr[idxs]
existing_used = set()
triples = []
idx = 0
while len(triples) < 3:
i_v, j_v, k_v = i_arr[idx], j_arr[idx], k_arr[idx]
if i_v not in existing_used and j_v not in existing_used and k_v not in existing_used:
triples.append((i_v, j_v, k_v))
existing_used.add(i_v)
existing_used.add(j_v)
existing_used.add(k_v)
idx += 1
# %%
[[common_words_many[x] for x in xs] for xs in triples]
# %%
# [bj common_words[:50]
xs = [
# "joy",
"positive emotions",
"good emotions",
"happiness",
"gratitude",
"humor",
"excitement",
"hopeful and happy anticipation",
]
random.shuffle(xs)
# %%
tamper_props_sample = [
(i, p, c) for i, (p, c) in enumerate(zip(all_input_properties, sum_count)) if 0.05 < c / len(parsed_responses) < 0.5
]
idxs = np.array([i for (i, *_) in tamper_props_sample])
fracs = np.array([c / len(parsed_responses) for (i, p, c) in tamper_props_sample])
vars_v = fracs - fracs**2
stds_v = np.sqrt(vars_v)
cov_sum = 0
diff_sum = 0
for resp in parsed_responses:
vals = np.array(resp.answers_by_model["gpt-3.5-turbo-16k"])[idxs]
cov_sample = (vals[:, None] - fracs) * (vals[None, :] - fracs)
dif_vals = np.maximum(vals[:, None].astype(np.float64) - vals[None, :], 0.0)
cov_sum += cov_sample
diff_sum += dif_vals
cov = cov_sum / len(parsed_responses)
diff = diff_sum / len(parsed_responses)
diff_norm = diff / fracs[:, None]
corr = cov / (stds_v[:, None] * stds_v[None, :])
# %%
all_pairs = (corr > 0.1) & (diff_norm > 0.05) & (diff_norm > 0.05).T
tamper_props_sample[11]
tamper_props_sample[8]
np.nonzero(all_pairs[8])
# %%
vals = [resp for resp in parsed_responses if resp.answers_by_model["gpt-3.5-turbo-16k"][2]]
# %%
vals[7].query.cut_text
| [] |
2024-01-10 | redwoodresearch/Measurement-Tampering | text_properties~modify_text.py | import json
import threading
import time
from typing import Any, Optional
import attrs
import openai
from tqdm import tqdm
basic_writing_prompt = """Here is some text:
```
{}
```
Modify this text so that it contains {}. Just output the new text without any commentary."""
pbar_lock = threading.Lock()
def remove_backticks_and_strip(x: str):
if x.count("```") == 1:
backtick_loc = x.index("```")
if backtick_loc < len(x) / 3:
# assume leading
return x[backtick_loc + 3 :].strip("\n")
if backtick_loc > 2 * len(x) / 3:
# assume trailing
return x[:backtick_loc].strip("\n")
if x.count("```") == 2:
x = x[x.index("```") + 3 :]
x = x[: x.index("```")]
x = x.strip("\n")
return x
return x.strip("\n")
@attrs.frozen
class RewriteItem:
cut_text: str
modifications: list[str]
full_text: str
extra: dict[str, Any] = attrs.Factory(dict)
def run_modifications(
model: str, temperature: float, max_tokens: int, rewrite: RewriteItem, printing: bool, max_retries: int = 10
):
last_text = rewrite.cut_text
all_text = [last_text]
for i, mod in enumerate(rewrite.modifications):
this_w_prompt = str(basic_writing_prompt).format(last_text, mod)
prior_mod = rewrite.modifications[:i]
if len(prior_mod) != 0:
this_w_prompt += "\nWhen modifying the text, retain the following properties of the text:\n" + "\n".join(
f"- {p_mod}" for p_mod in prior_mod
)
this_w_prompt += "\n\nModified text:"
retries = 0
while True:
try:
time.sleep(min(0.2 * 2**retries, 10.0))
response = openai.ChatCompletion.create(
model=model,
messages=[
{"role": "user", "content": this_w_prompt},
],
temperature=temperature,
max_tokens=max_tokens,
)
break
except Exception as e:
print("error")
print(e)
print(f"{retries=}")
if retries > max_retries:
print("exceeded max retries, exiting")
break
retries += 1
new_text = remove_backticks_and_strip(response["choices"][0]["message"]["content"])
all_text.append(new_text)
last_text = new_text
if printing:
print("\n" * 10)
print(this_w_prompt)
print("=== resp ===")
print(new_text)
return all_text, last_text
def get_rewrites(
all_rewrites: list[RewriteItem],
k: int,
n_threads: int,
models: list[str] = ["gpt-3.5-turbo-0613"],
out_file: str = "temp.jsonl",
max_tokens: int = 1_000,
temperature=0.3,
pbar: Optional[tqdm] = None,
):
start = k * len(all_rewrites) // n_threads
end = (k + 1) * len(all_rewrites) // n_threads
tmp_all_text: list[list[str]] = []
tmp_final_text: list[str] = []
tmp_model: list[str] = []
tmp_queries: list[RewriteItem] = []
all_rewrites = all_rewrites[start:end]
print(f"{k=} {n_threads=} {start=} {end=}")
def dump_and_clear(item: str):
with open(out_file, "a") as f:
for query, all_text, final_text, model in zip(tmp_queries, tmp_all_text, tmp_final_text, tmp_model):
f.write(
json.dumps(
{
"query": attrs.asdict(query),
"all_text": all_text,
"final_text": final_text,
"model": model,
}
)
+ "\n"
)
print(f"thread {k} {item} done")
tmp_all_text.clear()
tmp_final_text.clear()
tmp_model.clear()
tmp_queries.clear()
for i in range(len(all_rewrites)):
for model in models:
out_mod = run_modifications(
model,
temperature=temperature,
max_tokens=max_tokens,
rewrite=all_rewrites[i],
printing=k == 0,
)
if out_mod is None:
continue
all_text, final_text = out_mod
# pass
tmp_all_text.append(all_text)
tmp_final_text.append(final_text)
tmp_model.append(model)
tmp_queries.append(all_rewrites[i])
# if i % 10 == 0 and i > 0:
dump_and_clear(str(i))
if k == 0:
print()
print(model)
print(final_text)
if pbar is not None:
with pbar_lock:
if pbar is not None:
pbar.update(1)
dump_and_clear("fin")
| [
"\n\nModified text:",
"\nWhen modifying the text, retain the following properties of the text:\n- PLACEHOLDER",
"Here is some text:\n```\n{}\n```\n\nModify this text so that it contains {}. Just output the new text without any commentary."
] |
2024-01-10 | redwoodresearch/Measurement-Tampering | text_properties~simplified_get_sensors_properties.py | import json
import os
import random
import threading
from collections import defaultdict
import attrs
import openai
import tiktoken
from cattrs.preconf.json import make_converter
from text_properties.input_text_properties import QueryItems, get_completions, make_query
from text_properties.simplified import sensors_simple
from text_properties.simplified_data_types import SimpleFullDatum, SimpleWritingResponse
# %%
tokenizer = tiktoken.encoding_for_model("gpt-4")
if "OPENAI_API_KEY" not in os.environ:
openai.api_key_path = os.path.expanduser("~/.openai_api_key")
json_converter = make_converter()
# %%
# with open("writing_responses_all_val_extra_new.jsonl", "r") as f:
with open("writing_responses_out_v2_more_tamp.jsonl", "r") as f:
writing_responses = [json_converter.loads(line, SimpleWritingResponse) for line in f.readlines()]
# %%
text_to_writing_response = {x.cut_text: x for x in writing_responses}
# %%
# writing_responses_4 = [writ for writ in writing_responses if writ.model == "gpt-4-0613"]
# %%
simple_sensor_query_items: QueryItems = []
for resp in writing_responses:
simple_sensor_query_items.append(
attrs.evolve(
make_query(
resp.final_text,
sensors_simple,
resp.full_response.parsed_response.query.full_text,
),
cut_text=resp.full_response.parsed_response.query.cut_text,
)
)
len(simple_sensor_query_items)
# %%
# out_file = "sensors_out.jsonl"
out_file = "sensors_out_more_tamp_new_approach.jsonl"
with open(out_file, "w") as f:
...
# TODO: fix threads
n_threads = max(min(len(simple_sensor_query_items), 5), 1)
shuffle_items = list(simple_sensor_query_items)
random.shuffle(shuffle_items)
threads = [
threading.Thread(
target=get_completions,
args=(
shuffle_items,
k,
n_threads,
["gpt-4-0613"], # for whatever reason 3.5 turbo just can't do this??? (whatever I guess...)
# ["gpt-3.5-turbo-16k"],
out_file,
50,
# dict(
# functions=[
# {
# "name": "provide_answer",
# "description": "Answers the question with Yes/No",
# "parameters": {
# "type": "object",
# "properties": {
# "answer": {
# "type": "string",
# "description": "The Yes/No answer",
# "enum": ["Yes", "No"],
# },
# },
# },
# "required": ["answer"],
# }
# ],
# function_call={"name": "provide_answer"},
# ),
),
)
for k in range(n_threads)
]
# %%
for t in threads:
t.start()
# %%
for t in threads:
t.join()
# %%
print("done!")
# %%
# with open("sensors_out_4_simp_check.jsonl", "r") as f:
with open("sensors_out_more_tamp_new_approach.jsonl", "r") as f:
# with open("sensors_out_3_5.jsonl", "r") as f:
loaded_items_sensors = [json.loads(l) for l in f.read().splitlines()]
len(loaded_items_sensors)
# %%
# %%
text_to_sensors: defaultdict[str, dict[str, bool]] = defaultdict(dict)
for x in loaded_items_sensors:
assert len(x["response"]) == 1
resp = list(x["response"].values())[0]
# val = json.loads(resp["choices"][0]["message"]["function_call"]["arguments"])["answer"] == "Yes"
response_lines = resp["choices"][0]["message"]["content"].splitlines()
if len(response_lines) != len(sensors_simple):
continue
if not all(prop in y for prop, y in zip(sensors_simple, response_lines)):
continue
if not all(("Yes" in y) != ("No" in y or "N/A" in y or "Neutral" in y) for y in response_lines):
continue
text_to_sensors[x["query"]["cut_text"]] = {sensor: "Yes" in l for sensor, l in zip(sensors_simple, response_lines)}
full_datums = [
SimpleFullDatum(text_to_writing_response[txt], sensor_vals)
for txt, sensor_vals in text_to_sensors.items()
if len(sensor_vals) == len(sensors_simple)
]
len(full_datums)
# %%
with open("full_datum_more_tamp_new_approach.jsonl", "w") as f:
for x in full_datums:
f.write(json_converter.dumps(x) + "\n")
# %%
# all_vals = {k : (text_to_sensors_old[k], v) for k, v in text_to_sensors.items()}
# for v in all_vals.values():
# print(v)
# text_to_sensors_old = text_to_sensors
# %%
actually_positive = [x for x in full_datums if x.has_latent()]
actually_positive_sensors = [x.sensor_values for x in actually_positive]
all_positive_count = sum(all(x.values()) for x in actually_positive_sensors)
len(actually_positive), all_positive_count, all_positive_count / len(actually_positive)
# %%
# %%
with open("hi.txt", "w") as f:
f.write(actually_positive[24].writing_response.final_text)
# %%
actually_negative = [x for x in full_datums if not x.has_latent()]
actually_negative_sensors = [x.sensor_values for x in actually_negative]
all_positive_tamper_count = sum(all(x.values()) for x in actually_negative_sensors)
len(actually_negative), all_positive_tamper_count, all_positive_tamper_count / len(actually_negative)
# %%
intended_tamper = [x for x in full_datums if x.theoretical_tamper() and not x.has_latent()]
intended_tamper_sensors = [x.sensor_values for x in intended_tamper]
all_positive_tamper_count = sum(all(x.values()) for x in intended_tamper_sensors)
len(intended_tamper), all_positive_tamper_count, all_positive_tamper_count / len(intended_tamper)
# %%
one_or_more_tamp_count = sum(any(x.values()) for x in actually_negative_sensors)
len(actually_negative), one_or_more_tamp_count, one_or_more_tamp_count / len(actually_negative)
# %%
| [] |
2024-01-10 | redwoodresearch/Measurement-Tampering | text_properties~input_text_properties.py | import json
import re
import threading
import time
from typing import Any, Optional
import attrs
import openai
import tiktoken
from tqdm import tqdm
tokenizer = tiktoken.encoding_for_model("gpt-4")
example_properties = ["strictly more than 3 lines", "strictly more than 30 lines", "the word 'I'"]
question_prefix = "Does the text contain"
def get_questions_prompt(all_input_properties: list[str]):
return "\n".join(f"{i+1}. {question_prefix} {prop}?" for i, prop in enumerate(all_input_properties)) + "\nAnswers:"
def get_remaining_questions(all_input_properties: list[str]):
return "Now for the actual properties.\n\n" + get_questions_prompt(all_input_properties)
basic_prompt = """Here is some text:
```
{}
```
I'm interested in the properties of this text. In particular, answer Yes/No to the following questions in an enumerating list.
First, repeat the question, then provide the answer. The answer should just be Yes/No without *any* additional text.
I'll first ask about some example properties and then do the actual properties.
""" + get_questions_prompt(
example_properties
)
@attrs.frozen
class QueryItem:
cut_text: str
query: Optional[list[dict[str, str]]] # allow noop query
full_text: str
extra: dict[str, Any] = attrs.Factory(dict)
@property
def query_unwrap(self):
q = self.query
assert q is not None
return q
def cut_text(x: str, target_tokens: int = 300):
if "```" in x:
# avoid backticks
return None
out_lines = []
tok_count_total = 0
for line in x.splitlines():
line_count = len(tokenizer.encode(line))
if line_count + tok_count_total > target_tokens:
break
out_lines.append(line)
tok_count_total += line_count
while out_lines and out_lines[-1] == "":
out_lines = out_lines[:-1]
if tok_count_total < target_tokens // 2 or len(out_lines) < 3:
return None
return "\n".join(out_lines)
QueryItems = list[QueryItem]
def make_query(new_text: str, props_to_check: list[str], full_text: str):
if len(props_to_check) > 0:
full_prompt = str(basic_prompt).format(new_text)
out_lines = new_text.splitlines()
props = [
len(out_lines) > 3,
len(out_lines) > 30,
re.search(r"\bI\b", new_text) is not None,
]
example_response = "\n".join(
f"{i+1}. {question_prefix} {prop_text}? {'Yes' if prop else 'No'}"
for i, (prop, prop_text) in enumerate(zip(props, example_properties))
)
actual_prompt = [
{"role": "user", "content": full_prompt},
{"role": "assistant", "content": example_response},
{"role": "user", "content": get_remaining_questions(props_to_check)},
]
else:
actual_prompt = None
return QueryItem(new_text, actual_prompt, full_text)
def data_to_queries(data: list, props_to_check: list[str], limit: int = 999999):
query_items: QueryItems = []
count = 0
last_datum_use = 0
for i, d in enumerate(data):
if count == limit:
break
new_text = cut_text(d["text"])
if new_text is None:
continue
count += 1
query_items.append(make_query(new_text, props_to_check, d["text"]))
last_datum_use = i + 1
return query_items, last_datum_use
pbar_lock = threading.Lock()
def get_completions(
all_queries: QueryItems,
k: int,
n_threads: int,
models: list[str] = ["gpt-3.5-turbo-0613"],
out_file: str = "temp.jsonl",
max_tokens: int = 3000,
extra_args: dict[str, Any] = {},
pbar: Optional[tqdm] = None,
max_retries: int = 10,
):
start = k * len(all_queries) // n_threads
end = (k + 1) * len(all_queries) // n_threads
tmp_responses: list[dict[str, Any]] = []
tmp_queries: QueryItems = []
all_queries = all_queries[start:end]
print(f"{k=} {n_threads=} {start=} {end=}")
def dump_and_clear(item: str):
with open(out_file, "a") as f:
for query, response in zip(tmp_queries, tmp_responses):
f.write(
json.dumps(
{
"query": attrs.asdict(query),
"response": response,
}
)
+ "\n"
)
print(f"thread {k} {item} done")
tmp_responses.clear()
tmp_queries.clear()
for i in range(len(all_queries)):
query = all_queries[i]
responses_per_m = {}
for model in models:
retries = 0
while True:
try:
if query.query is None:
responses_per_m[model] = None
break
time.sleep(min(0.2 * 2**retries, 10.0))
responses_per_m[model] = openai.ChatCompletion.create(
model=model,
messages=query.query,
temperature=0,
max_tokens=max_tokens,
**extra_args,
)
break
except Exception as e:
print("error")
print(e)
print(f"{retries=}")
if retries > max_retries:
print("exceeded max retries, exiting")
break
retries += 1
if len(responses_per_m) == 0:
continue
tmp_responses.append(responses_per_m)
tmp_queries.append(all_queries[i])
# if i % 10 == 0 and i > 0:
dump_and_clear(str(i))
if k == 0 and query.query is not None:
print()
print(responses_per_m[models[0]]["choices"][0]["message"]["content"])
print(responses_per_m[models[0]]["choices"][0]["message"].get("function_call"))
if pbar is not None:
with pbar_lock:
if pbar is not None:
pbar.update(1)
dump_and_clear("fin")
| [
"Here is some text:\n```\n{}\n```\n\nI'm interested in the properties of this text. In particular, answer Yes/No to the following questions in an enumerating list.\nFirst, repeat the question, then provide the answer. The answer should just be Yes/No without *any* additional text.\n\nI'll first ask about some example properties and then do the actual properties.\n\n",
"None"
] |
2024-01-10 | themaison/mellifera | Scripts~gpt_model.py | import openai
import config
openai.api_key = config.OPENAI_KEY
messages = [
{"role": "system", "content": "Ты бот, веди себя как пчела."}
]
def response_to_message(message_text: str):
messages.append({"role": "user", "content": message_text})
completion = openai.ChatCompletion.create(
model="gpt-3.5-turbo",
messages=messages
)
chat_response = completion.choices[0].message.content
messages.append({"role": "assistant", "content": chat_response})
return chat_response
| [
"Ты бот, веди себя как пчела."
] |
2024-01-10 | Shaavin/chatgpt-whisper-hackathon | app~qna~db.py | import os
import psutil
import numpy as np
import pandas as pd
# import typing as t
import sklearn
import gensim
from sklearn.neighbors import NearestNeighbors
import openai
# import re
word_vectors = gensim.models.KeyedVectors.load_word2vec_format('app/qna/word_vectors.bin', binary=True)
question_embeddings = pd.read_csv('app/qna/question_embeddings.csv')
feedback_embeddings = pd.read_csv('app/qna/feedback_embeddings.csv')
question_docs = pd.read_csv('app/qna/question_dataframe.csv')
feedback_docs = pd.read_csv('app/qna/feedback_dataframe.csv')
openai.api_key = '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'
def get_questions(question_string):
questions = question_string.strip().split("\n")
result = []
for question in questions:
if any(char.isdigit() for char in question):
result.append(question.strip())
return result
# Returns array of questions
def api_get_question(job_description: str, experience_level: str, number_of_questions: int, content:str):
prompt = f"Write questions related to this job descripition: '{job_description}', and that most fit {experience_level}. Put them in a list with this format:\nQuestion 1: \nQuestion 2:\nQuestion 3: etc...\nUse the content below to inspire you. Your response should contain only questions. There should be {number_of_questions}. IF the content below doesn't seem relevant to the job description, create questions that are. \nContent (pick {number_of_questions} question(s) most relevant to the job description, and as comprehensive as possible given the number of questions):\n{content}\n [END OF CONTENT] DO NOT ANSWER THESE QUESTIONS YOURSELF! Write questions related to this job descripition: '{job_description}', and that most fit {experience_level}. Put them in a list with this format:\nQuestion 1: \nQuestion 2:\nQuestion 3: etc..."
response = openai.Completion.create(
engine="text-davinci-003",
prompt=prompt,
max_tokens=1000,
n=1,
stop=None,
temperature=0.7,
)
questions = response.choices[0].text.strip()
# print('HERE ARE THE GENERATED INTERVIEW QUESTIONS:', questions)
return response, get_questions(questions)
# def api_get_feedback(question: str, user_response: str, job_description):
# # question = 'Question 1: What are the different types of Machine Learning algorithms?'
# # user_response = "knn and neural networks"
# # job_description = 'Machine Learning'
# prompt = f"Act like you are giving feedback on a job interview, and are helping the person being interviewed improve. Based on this questions: {question}\nAnd given this response: {user_response}\nFor this job: {job_description}\nGive constructive feedback for the response based on the content below. If you find the user's response to be a good answer the question, let them know and why. Otherwise, tell them how they could do better:\n[RELEVANT CONTENT]"
# response = openai.Completion.create(
# engine="text-davinci-003",
# prompt=prompt,
# max_tokens=150,
# n=1,
# stop=None,
# temperature=0.5,
# )
# feedback= response.choices[0].text.strip()
# print(feedback)
# return feedback
# feedback_docs =
# feedback_embeddings =
INDEX_NAME = "embedding-index"
NUM_VECTORS = 4000
PREFIX = "embedding"
VECTOR_DIM = 1536
DISTANCE_METRIC = "COSINE"
def memory_usage():
process = psutil.Process(os.getpid())
return process.memory_info().rss / (1024 ** 2) # Return memory usage in MB
def query_embedding_process(query_text: str):
initial_memory = memory_usage()
print(f"Initial Memory Usage: {initial_memory} MB")
embeddings_df = get_embeddings(query_text)
# print(embeddings_df)
after_embedding_memory = memory_usage()
print(f"Memory Usage After Embedding: {after_embedding_memory} MB")
difference = after_embedding_memory - initial_memory
print(f"Memory Increase Due to Embedding: {difference} MB")
def get_embeddings(text: str):
df = pd.DataFrame(columns=['title', 'heading', 'content', 'tokens'])
title = 'query'
heading = 'query'
content = text
tokens = content.split()
df.loc[len(df)] = [title, heading, content, tokens]
# Generate embeddings for each row in the DataFrame
embeddings = []
for index, row in df.iterrows():
text = row['content'] # the text column name in your CSV file
words = text.split()
vectors = []
for word in words:
try:
vector = word_vectors[word]
vectors.append(vector)
except KeyError:
# Ignore words that are not in the pre-trained word embeddings
pass
if vectors:
# Calculate the mean of the word embeddings to get a document embedding
doc_embedding = np.mean(vectors, axis=0)
embeddings.append(doc_embedding)
else:
# Use a zero vector if none of the words are in the pre-trained word embeddings
embeddings.append(np.zeros(100))
# Add the embeddings as new columns in the DataFrame
for i in range(100):
df[i] = [embedding[i] for embedding in embeddings]
# Save the DataFrame with the embeddings to a new CSV file
return df
# Load documents and their embeddings
question_embeddings_df = question_embeddings.drop(columns=["title", "heading", "content"])
question_embeddings_arr = question_embeddings_df.to_numpy()
question_knn_model = NearestNeighbors(n_neighbors=5, metric='cosine')
question_knn_model.fit(question_embeddings_arr)
feedback_embeddings_df = feedback_embeddings.drop(columns=["title", "heading", "content"])
feedback_embeddings_arr = feedback_embeddings_df.to_numpy()
feedback_knn_model = NearestNeighbors(n_neighbors=5, metric='cosine')
feedback_knn_model.fit(feedback_embeddings_arr)
def get_most_relevant(is_questions: bool, text: str):
initial_memory = memory_usage()
print(f"Initial Memory Usage: {initial_memory} MB")
# Load documents and their embeddings
if is_questions:
docs_df = question_docs
else:
docs_df = feedback_docs
# Load embedding of user query
query_embedding = get_embeddings(text)
query_embedding = query_embedding.drop(columns=["title", "heading", "content","tokens"]) # Drop the 'title' column
query_embedding = query_embedding.to_numpy() # Convert to numpy array
embedding_memory = memory_usage()
print(f"Embedding Memory Usage: {embedding_memory} MB")
# Find the indices of the nearest neighbors to the query
if is_questions:
indices = question_knn_model.kneighbors(query_embedding, return_distance=False)
else:
indices = feedback_knn_model.kneighbors(query_embedding, return_distance=False)
ending_memory = memory_usage()
print(f"Ending Memory Usage: {ending_memory} MB")
# Get the documents corresponding to the nearest neighbors
top_5_knn_docs = docs_df.iloc[indices[0]]
print(top_5_knn_docs)
return top_5_knn_docs
def get_content_as_string(top_5: pd.DataFrame):
top_5['content']
content_string = '//\n'.join(top_5['content'])
# Replace the newline characters ("\n") with a new line ("\n") and double slashes ("//")
content_string = content_string.replace('\n', '\n')
content_string = content_string[:3900]
return (content_string)
# def api_get_final_feedback(feedback, job_description):
# prompt = f"Act like you are giving feedback on a job interview, and are helping the person being interviewed improve. Based on all this feedback you gave: {feedback}\nFor this job: {job_description}\nGive the person being inverviewd an overall score out of 100, then an overall summary on how they did."
# response = openai.Completion.create(
# engine="text-davinci-003",
# prompt=prompt,
# max_tokens=150,
# n=1,
# stop=None,
# temperature=0.5,
# )
# final = response.choices[0].text.strip()
# # Extract the score from the final string
# score_match = re.search(r"\d+", final)
# score = int(score_match.group(0)) if score_match else None
# return final, score
# query_embedding_process("Your sample text here.")
get_most_relevant(True,"Your sample text here.") | [
"Write questions related to this job descripition: 'PLACEHOLDER', and that most fit PLACEHOLDER. Put them in a list with this format:\nQuestion 1: \nQuestion 2:\nQuestion 3: etc...\nUse the content below to inspire you. Your response should contain only questions. There should be PLACEHOLDER. IF the content below doesn't seem relevant to the job description, create questions that are. \nContent (pick PLACEHOLDER question(s) most relevant to the job description, and as comprehensive as possible given the number of questions):\nPLACEHOLDER\n [END OF CONTENT] DO NOT ANSWER THESE QUESTIONS YOURSELF! Write questions related to this job descripition: 'PLACEHOLDER', and that most fit PLACEHOLDER. Put them in a list with this format:\nQuestion 1: \nQuestion 2:\nQuestion 3: etc..."
] |
2024-01-10 | janvarev/irene_plugin_boltalka2_openai | plugin_boltalka2_openai.py | # Болталка с openai - версия 2
# author: Vladislav Janvarev
import os
import openai
from vacore import VACore
import json
import os
import openai
# ---------- from https://github.com/stancsz/chatgpt ----------
class ChatApp:
def __init__(self, model="gpt-3.5-turbo", load_file='', system=''):
# Setting the API key to use the OpenAI API
self.model = model
self.messages = []
if system != '':
self.messages.append({"role": "system", "content" : system})
if load_file != '':
self.load(load_file)
def chat(self, message):
if message == "exit":
self.save()
os._exit(1)
elif message == "save":
self.save()
return "(saved)"
self.messages.append({"role": "user", "content": message})
response = openai.ChatCompletion.create(
model=self.model,
messages=self.messages,
temperature=0.8,
n=1,
max_tokens=100,
)
self.messages.append({"role": "assistant", "content": response["choices"][0]["message"].content})
return response["choices"][0]["message"]
def save(self):
try:
import time
import re
import json
ts = time.time()
json_object = json.dumps(self.messages, indent=4)
filename_prefix=self.messages[0]['content'][0:30]
filename_prefix = re.sub('[^0-9a-zA-Z]+', '-', f"{filename_prefix}_{ts}")
with open(f"models/chat_model_{filename_prefix}.json", "w") as outfile:
outfile.write(json_object)
except:
os._exit(1)
def load(self, load_file):
with open(load_file) as f:
data = json.load(f)
self.messages = data
modname = os.path.basename(__file__)[:-3] # calculating modname
# функция на старте
def start(core:VACore):
manifest = {
"name": "Болталка с OpenAI v2 - на ChatGPT с сохранением контекста",
"version": "2.0",
"require_online": True,
"description": "После указания apiKey позволяет вести диалог с ChatGPT.\n"
"Голосовая команда: поболтаем|поговорим",
"url": "https://github.com/janvarev/irene_plugin_boltalka2_openai",
"options_label": {
"apiKey": "API-ключ OpenAI для доступа к ChatGPT", #
"apiBaseUrl": "URL для OpenAI (нужен, если вы связываетесь с другим сервером, эмулирующим OpenAI)", #
"system": "Вводная строка, задающая характер ответов помощника."
},
"default_options": {
"apiKey": "", #
"apiBaseUrl": "", #
"system": "Ты - Ирина, голосовой помощник, помогающий человеку. Давай ответы кратко и по существу."
},
"commands": {
"поболтаем|поговорим": run_start,
}
}
return manifest
def start_with_options(core:VACore, manifest:dict):
pass
def run_start(core:VACore, phrase:str):
options = core.plugin_options(modname)
if options["apiKey"] == "" and options["apiBaseUrl"] == "":
core.play_voice_assistant_speech("Нужен ключ апи для доступа к опенаи")
return
openai.api_key = options["apiKey"]
if options["apiBaseUrl"] != "":
openai.api_base = options["apiBaseUrl"]
core.chatapp = ChatApp(system=options["system"]) # создаем новый чат
if phrase == "":
core.play_voice_assistant_speech("Да, давай!")
core.context_set(boltalka, 20)
else:
boltalka(core,phrase)
def boltalka(core:VACore, phrase:str):
if phrase == "отмена" or phrase == "пока":
core.play_voice_assistant_speech("Пока!")
return
try:
response = core.chatapp.chat(phrase) #generate_response(phrase)
print(response)
#decoded_value = response.encode('utf-8')
#print(decoded_value)
core.say(response["content"])
core.context_set(boltalka, 20)
except:
import traceback
traceback.print_exc()
core.play_voice_assistant_speech("Проблемы с доступом к апи. Посмотрите логи")
return
| [] |
2024-01-10 | StephenYin01/FLARE-Replication | model~flare.py | import os
import json
import math
import argparse
from openai_api import QueryAgent
if __name__ == "__main__":
cur_path = os.path.abspath(os.curdir)
# Read the arguments
parser = argparse.ArgumentParser(description="Define experiment")
parser.add_argument("-d", "--dataset", type=str, default="ASQA", help="Name of ASQA dev dataset")
parser.add_argument("-n", "--name", type=str, default="final-predictions", help="Name of the experiment")
# Parse the arguments
args = parser.parse_args()
# Retrieve the API key saved in environment
api_key = os.getenv("OPENAI_API_KEY")
# Instatiate the Query Agent for OpenAI API Calls
with open(cur_path + "/configs/asqa.json", 'r') as f:
# We use gpt-3.5-turbo-instruct for cost reduction (Input: $0.0015 / 1K tokens Output: $0.0020 / 1K tokens) instead of ($0.0200 / 1K tokens)
qa = QueryAgent(
model='gpt-3.5-turbo-instruct',
retrieval_kwargs=json.load(f),
api_key=api_key,
)
# Retrieve the evaluation questions
with open(cur_path + f"/dataset/{args.dataset}.json", 'r') as f:
questions = json.load(f)
questions = questions['dev']
# Gather predictions
num_qs = len(questions)
batch_size = 20
batch_num = 0
count = 0
predictions = dict()
batch_keys = []
batch_questions = []
batch_responses = []
for k, v in questions.items():
batch_keys.append(k)
batch_questions.append(v['ambiguous_question'])
count += 1
if count % batch_size == 0 or count == num_qs:
# Track batch num
batch_num += 1
bs = count - batch_size * (batch_num - 1)
print(f"Batch {batch_num} / {math.ceil(num_qs/batch_size)}, Size: {bs}")
# Query the agent
batch_responses = qa.respond(batch_questions)
# Save the results
for i in range(bs):
predictions[batch_keys[i]] = batch_responses[i]
# Reset batch variables
batch_keys = []
batch_questions = []
batch_responses = []
with open(cur_path + f"/outputs/{args.name}.json", 'w') as f:
json.dump(predictions, f)
# Save analytics
qa._save_analytics(f"/outputs/{args.name}-analytics.json")
| [] |
2024-01-10 | shadowmimosa/xiaogpt | xiaogpt~xiaogpt.py | #!/usr/bin/env python3
import asyncio
import functools
import http.server
import json
import logging
import os
import random
import re
import socket
import socketserver
import tempfile
import threading
import time
from pathlib import Path
import edge_tts
import openai
from aiohttp import ClientSession
from miservice import MiAccount, MiIOService, MiNAService, miio_command
from rich import print
from rich.logging import RichHandler
from xiaogpt.bot import ChatGPTBot, GPT3Bot
from xiaogpt.config import (
COOKIE_TEMPLATE,
EDGE_TTS_DICT,
LATEST_ASK_API,
MI_ASK_SIMULATE_DATA,
WAKEUP_KEYWORD,
Config,
)
from xiaogpt.utils import (
calculate_tts_elapse,
find_key_by_partial_string,
get_hostname,
parse_cookie_string,
)
EOF = object()
class ThreadedHTTPServer(socketserver.ThreadingMixIn, socketserver.TCPServer):
pass
class HTTPRequestHandler(http.server.SimpleHTTPRequestHandler):
logger = logging.getLogger("xiaogpt")
def log_message(self, format, *args):
self.logger.debug(f"{self.address_string()} - {format}", *args)
def log_error(self, format, *args):
self.logger.error(f"{self.address_string()} - {format}", *args)
def copyfile(self, source, outputfile):
try:
super().copyfile(source, outputfile)
except (socket.error, ConnectionResetError, BrokenPipeError):
# ignore this or TODO find out why the error later
pass
class MiGPT:
def __init__(self, config: Config):
self.config = config
self.mi_token_home = Path.home() / ".mi.token"
self.last_timestamp = int(time.time() * 1000) # timestamp last call mi speaker
self.last_record = None
self.cookie_jar = None
self._chatbot = None
self.device_id = ""
self.parent_id = None
self.mina_service = None
self.miio_service = None
self.in_conversation = False
self.polling_event = asyncio.Event()
self.new_record_event = asyncio.Event()
self.temp_dir = None
# setup logger
self.log = logging.getLogger("xiaogpt")
self.log.setLevel(logging.DEBUG if config.verbose else logging.INFO)
self.log.addHandler(RichHandler())
self.log.debug(config)
async def poll_latest_ask(self):
async with ClientSession() as session:
session._cookie_jar = self.cookie_jar
while True:
self.log.debug(
"Now listening xiaoai new message timestamp: %s",
self.last_timestamp,
)
await self.get_latest_ask_from_xiaoai(session)
start = time.perf_counter()
await self.polling_event.wait()
if (d := time.perf_counter() - start) < 1:
# sleep to avoid too many request
await asyncio.sleep(1 - d)
async def init_all_data(self, session):
await self.login_miboy(session)
await self._init_data_hardware()
session.cookie_jar.update_cookies(self.get_cookie())
self.cookie_jar = session.cookie_jar
if self.config.enable_edge_tts:
self.start_http_server()
async def login_miboy(self, session):
account = MiAccount(
session,
self.config.account,
self.config.password,
str(self.mi_token_home),
)
# Forced login to refresh to refresh token
await account.login("micoapi")
self.mina_service = MiNAService(account)
self.miio_service = MiIOService(account)
async def _init_data_hardware(self):
if self.config.cookie:
# if use cookie do not need init
return
hardware_data = await self.mina_service.device_list()
for h in hardware_data:
if h.get("hardware", "") == self.config.hardware:
self.device_id = h.get("deviceID")
break
else:
raise Exception(
f"we have no hardware: {self.config.hardware} please use `micli mina` to check"
)
if not self.config.mi_did:
devices = await self.miio_service.device_list()
try:
self.config.mi_did = next(
d["did"]
for d in devices
if d["model"].endswith(self.config.hardware.lower())
)
except StopIteration:
raise Exception(
f"cannot find did for hardware: {self.config.hardware} "
"please set it via MI_DID env"
)
def get_cookie(self):
if self.config.cookie:
cookie_jar = parse_cookie_string(self.config.cookie)
# set attr from cookie fix #134
cookie_dict = cookie_jar.get_dict()
self.device_id = cookie_dict["deviceId"]
return cookie_jar
else:
with open(self.mi_token_home) as f:
user_data = json.loads(f.read())
user_id = user_data.get("userId")
service_token = user_data.get("micoapi")[1]
cookie_string = COOKIE_TEMPLATE.format(
device_id=self.device_id, service_token=service_token, user_id=user_id
)
return parse_cookie_string(cookie_string)
@property
def chatbot(self):
if self._chatbot is None:
if self.config.bot == "gpt3":
self._chatbot = GPT3Bot(
self.config.openai_key, self.config.api_base, self.config.proxy
)
elif self.config.bot == "chatgptapi":
self._chatbot = ChatGPTBot(
self.config.openai_key, self.config.api_base, self.config.proxy
)
else:
raise Exception(f"Do not support {self.config.bot}")
return self._chatbot
async def simulate_xiaoai_question(self):
data = MI_ASK_SIMULATE_DATA
# Convert the data['data'] value from a string to a dictionary
data_dict = json.loads(data["data"])
# Get the first item in the records list
record = data_dict["records"][0]
# Replace the query and time values with user input
record["query"] = input("Enter the new query: ")
record["time"] = int(time.time() * 1000)
# Convert the updated data_dict back to a string and update the data['data'] value
data["data"] = json.dumps(data_dict)
await asyncio.sleep(1)
return data
def need_ask_gpt(self, record):
query = record.get("query", "")
return (
self.in_conversation
and not query.startswith(WAKEUP_KEYWORD)
or query.startswith(tuple(self.config.keyword))
)
def need_change_prompt(self, record):
if self.config.bot == "gpt3":
return False
query = record.get("query", "")
return (
self.in_conversation
and not query.startswith(WAKEUP_KEYWORD)
or query.startswith(tuple(self.config.change_prompt_keyword))
)
def _change_prompt(self, new_prompt):
new_prompt = re.sub(
rf"^({'|'.join(self.config.change_prompt_keyword)})", "", new_prompt
)
new_prompt = "以下都" + new_prompt
print(f"Prompt from {self.config.prompt} change to {new_prompt}")
self.config.prompt = new_prompt
if self.chatbot.history:
print(self.chatbot.history)
self.chatbot.history[0][0] = new_prompt
async def get_latest_ask_from_xiaoai(self, session):
retries = 2
for _ in range(retries):
r = await session.get(
LATEST_ASK_API.format(
hardware=self.config.hardware,
timestamp=str(int(time.time() * 1000)),
)
)
try:
data = await r.json()
except Exception:
self.log.warning("get latest ask from xiaoai error, retry")
else:
return self._get_last_query(data)
def _get_last_query(self, data):
if d := data.get("data"):
records = json.loads(d).get("records")
if not records:
return
last_record = records[0]
timestamp = last_record.get("time")
if timestamp > self.last_timestamp:
self.last_timestamp = timestamp
self.last_record = last_record
self.new_record_event.set()
async def do_tts(self, value, wait_for_finish=False):
if not self.config.use_command:
try:
await self.mina_service.text_to_speech(self.device_id, value)
except Exception:
pass
else:
await miio_command(
self.miio_service,
self.config.mi_did,
f"{self.config.tts_command} {value}",
)
if wait_for_finish:
elapse = calculate_tts_elapse(value)
await asyncio.sleep(elapse)
await self.wait_for_tts_finish()
async def wait_for_tts_finish(self):
while True:
if not await self.get_if_xiaoai_is_playing():
break
await asyncio.sleep(1)
def start_http_server(self):
# set the port range
port_range = range(8050, 8090)
# get a random port from the range
self.port = int(os.getenv("XIAOGPT_PORT", random.choice(port_range)))
self.temp_dir = tempfile.TemporaryDirectory(prefix="xiaogpt-tts-")
# create the server
handler = functools.partial(HTTPRequestHandler, directory=self.temp_dir.name)
httpd = ThreadedHTTPServer(("", self.port), handler)
# start the server in a new thread
server_thread = threading.Thread(target=httpd.serve_forever)
server_thread.daemon = True
server_thread.start()
self.hostname = get_hostname()
self.log.info(f"Serving on {self.hostname}:{self.port}")
async def text2mp3(self, text, tts_lang):
communicate = edge_tts.Communicate(text, tts_lang)
duration = 0
with tempfile.NamedTemporaryFile(
"wb", suffix=".mp3", delete=False, dir=self.temp_dir.name
) as f:
async for chunk in communicate.stream():
if chunk["type"] == "audio":
f.write(chunk["data"])
elif chunk["type"] == "WordBoundary":
duration = (chunk["offset"] + chunk["duration"]) / 1e7
if duration == 0:
raise RuntimeError(f"Failed to get tts from edge with voice={tts_lang}")
return (
f"http://{self.hostname}:{self.port}/{os.path.basename(f.name)}",
duration,
)
async def edge_tts(self, text_stream, tts_lang):
async def run_tts(text_stream, tts_lang, queue):
async for text in text_stream:
try:
url, duration = await self.text2mp3(text, tts_lang)
except Exception as e:
self.log.error(e)
continue
await queue.put((url, duration))
queue = asyncio.Queue()
self.log.debug("Edge TTS with voice=%s", tts_lang)
task = asyncio.create_task(run_tts(text_stream, tts_lang, queue))
task.add_done_callback(lambda _: queue.put_nowait(EOF))
while True:
item = await queue.get()
if item is EOF:
break
url, duration = item
self.log.debug(f"play: {url}")
await self.mina_service.play_by_url(self.device_id, url)
await asyncio.sleep(duration)
await self.wait_for_tts_finish()
task.cancel()
@staticmethod
def _normalize(message):
message = message.strip().replace(" ", "--")
message = message.replace("\n", "，")
message = message.replace('"', "，")
return message
async def ask_gpt(self, query):
if not self.config.stream:
async with ClientSession(trust_env=True) as session:
openai.aiosession.set(session)
answer = await self.chatbot.ask(query, **self.config.gpt_options)
message = self._normalize(answer) if answer else ""
yield message
return
async def collect_stream(queue):
async with ClientSession(trust_env=True) as session:
openai.aiosession.set(session)
async for message in self.chatbot.ask_stream(
query, **self.config.gpt_options
):
await queue.put(message)
self.polling_event.set()
queue = asyncio.Queue()
is_eof = False
task = asyncio.create_task(collect_stream(queue))
task.add_done_callback(lambda _: queue.put_nowait(EOF))
while True:
if is_eof or self.new_record_event.is_set():
break
message = await queue.get()
if message is EOF:
break
while not queue.empty():
if (next_msg := queue.get_nowait()) is EOF:
is_eof = True
break
message += next_msg
if message:
yield self._normalize(message)
self.polling_event.clear()
task.cancel()
async def get_if_xiaoai_is_playing(self):
playing_info = await self.mina_service.player_get_status(self.device_id)
# WTF xiaomi api
is_playing = (
json.loads(playing_info.get("data", {}).get("info", "{}")).get("status", -1)
== 1
)
return is_playing
async def stop_if_xiaoai_is_playing(self):
is_playing = await self.get_if_xiaoai_is_playing()
if is_playing:
# stop it
await self.mina_service.player_pause(self.device_id)
async def wakeup_xiaoai(self):
return await miio_command(
self.miio_service,
self.config.mi_did,
f"{self.config.wakeup_command} {WAKEUP_KEYWORD} 0",
)
async def run_forever(self):
async with ClientSession() as session:
await self.init_all_data(session)
task = asyncio.create_task(self.poll_latest_ask())
assert task is not None # to keep the reference to task, do not remove this
print(f"Running xiaogpt now, 用`{'/'.join(self.config.keyword)}`开头来提问")
print(f"或用`{self.config.start_conversation}`开始持续对话")
while True:
self.polling_event.set()
await self.new_record_event.wait()
self.new_record_event.clear()
new_record = self.last_record
self.polling_event.clear() # stop polling when processing the question
query = new_record.get("query", "").strip()
if query == self.config.start_conversation:
if not self.in_conversation:
print("开始对话")
self.in_conversation = True
await self.wakeup_xiaoai()
await self.stop_if_xiaoai_is_playing()
continue
elif query == self.config.end_conversation:
if self.in_conversation:
print("结束对话")
self.in_conversation = False
await self.stop_if_xiaoai_is_playing()
continue
# we can change prompt
if self.need_change_prompt(new_record):
self._change_prompt(new_record.get("query", ""))
if not self.need_ask_gpt(new_record):
self.log.debug("No new xiao ai record")
continue
# drop 帮我回答
query = re.sub(rf"^({'|'.join(self.config.keyword)})", "", query)
print("-" * 20)
print("问题：" + query + "？")
if not self.chatbot.history:
query = f"{query}，{self.config.prompt}"
if self.config.mute_xiaoai:
await self.stop_if_xiaoai_is_playing()
else:
# waiting for xiaoai speaker done
await asyncio.sleep(8)
await self.do_tts("正在问GPT请耐心等待")
try:
print(
"以下是小爱的回答: ",
new_record.get("answers", [])[0].get("tts", {}).get("text"),
)
except IndexError:
print("小爱没回")
print("以下是GPT的回答: ", end="")
try:
if not self.config.enable_edge_tts:
async for message in self.ask_gpt(query):
await self.do_tts(message, wait_for_finish=True)
else:
tts_lang = (
find_key_by_partial_string(EDGE_TTS_DICT, query)
or self.config.edge_tts_voice
)
# tts with edge_tts
await self.edge_tts(self.ask_gpt(query), tts_lang)
print("回答完毕")
except Exception as e:
print(f"GPT回答出错 {str(e)}")
if self.in_conversation:
print(f"继续对话, 或用`{self.config.end_conversation}`结束对话")
await self.wakeup_xiaoai()
| [
"以下都PLACEHOLDER"
] |
2024-01-10 | andrearcaina/Self-Translate | pages~02_%F0%9F%93%96_Translate.py | import openai
import streamlit as st
import sqlite3 as sql
from googletrans import LANGUAGES
from src.translate import translate_lang
from src.camera import camera_recognition
from src.utils import favicon
openai.api_key = st.secrets["keys"]["OPENAI_KEY"]
st.set_page_config(
page_title="Self.Translate",
page_icon=favicon(),
layout="centered",
initial_sidebar_state="expanded"
)
def clear_table():
database, cursor = connect_database()
cursor = database.cursor()
cursor.execute("DELETE FROM translations")
database.commit()
database.close()
def connect_database():
database = sql.connect("translation_log.db")
cursor = database.cursor()
cursor.execute('''CREATE TABLE IF NOT EXISTS translations
(input, output)''')
database.commit()
return database, cursor
def regular_translate():
languages = {v: k for k, v in LANGUAGES.items()}
lang_names = sorted(list(languages.keys()))
target_lang = st.selectbox("Select target language", options=lang_names)
user_input = st.text_area(label=f"Input text: ", value="", max_chars=4000, disabled=False, placeholder="enter text", label_visibility="visible")
if not user_input == "":
query = user_input
language = languages.get(target_lang)
response, lang_name = translate_lang(query, language)
st.text_area(label=f"Detected Language: {lang_name}", value=f"{query}", disabled=True, label_visibility="visible")
st.text_area(label=f"Language Output: {target_lang}", value=f"{response}", disabled=True, label_visibility="visible")
return query, response
return None, None
page = st.sidebar.selectbox(label='Options', options=('Translate', 'Sign', 'Lesson'))
col1, col2 = st.columns([4,2.2])
with col1:
if page == 'Translate':
query, response = regular_translate()
if st.sidebar.button("Clear Translation Log"):
clear_table()
elif page == "Sign":
col1.markdown(f'<h2> self.<span style="background-color:#002b36;color:#6dac32;font-size:46px;border-radius:100%;">{"sign"}</span> </h2>', unsafe_allow_html=True)
camera_recognition()
st.write("Work in Progress!")
st.write("""
So far: Uses webcam to detect hands.
Later: Implement a model to convert it to sign language.
""")
elif page == "Lesson":
col1.markdown(f'<h2> self.<span style="background-color:#002b36;color:#6dac32;font-size:46px;border-radius:100%;">{"learn"}</span> </h2>', unsafe_allow_html=True)
level = st.radio("Level", options=("Beginner", "Intermediate", "Advanced"))
language = st.selectbox("Select target language", options=LANGUAGES.values())
if(level == "Beginner"):
prompt = f"I'm a {level} learner. Can you give me a lesson plan on how to learn {language}?"
else:
prompt = f"I'm an {level} learner. Can you give me a lesson plan on how to learn {language}?"
st.write("Prompt: "+ prompt)
if st.button("Generate me a lesson plan"):
with st.spinner("Generating lesson plan..."):
response = openai.Completion.create(
engine="text-davinci-003",
prompt=prompt,
temperature=0.5,
max_tokens=3000,
n=1,
stop=None,
)
response = response.choices[0].text.strip().replace("please?", "")
st.write("This can be modified again! Just click the button above to generate a new lesson plan.")
st.text_area(label="",value=f"{response}", height=400 , disabled=False, label_visibility="visible")
with col2:
# this needs to change so that the translation log refreshes when the entire web app refreshes
# for now it only outputs the translated output when the user inputs something
# this is because we are clearning the table everytime
if page == 'Translate':
database, cursor = connect_database()
st.write("Translation Log:")
st.write("Input -> Output")
if query != None and response != None:
cursor.execute("INSERT INTO translations VALUES (?, ?)", (query, response))
database.commit()
cursor.execute("SELECT * FROM translations")
for row in cursor.fetchall():
st.write(f"{row[0]} -> {row[1]}")
database.close()
| [
"I'm a PLACEHOLDER learner. Can you give me a lesson plan on how to learn PLACEHOLDER?",
"I'm an PLACEHOLDER learner. Can you give me a lesson plan on how to learn PLACEHOLDER?"
] |
2024-01-10 | andrearcaina/Self-Translate | src~translate.py | import cohere
from googletrans import Translator
import streamlit as st
cohere_client = cohere.Client(st.secrets["keys"]["COHERE_KEY"])
def translate_lang(text, target):
response = cohere_client.detect_language(texts=[text])
lang = response.results[0]
if lang != target:
result = Translator().translate(text, dest=target)
text = result.text
return text, lang.language_name
| [] |
2024-01-10 | florianbuetow/audio-to-text-summarizer | src~text2summary~gpt3wrapper.py | import os, math, logging
import openai
from util import nlp
class GPT3Wrapper:
def __init__(self, model_name: str, api_key: str, max_return_tokens=1024, temperature=0.5):
openai.api_key = api_key
self._model_name = model_name
self._max_return_tokens = max_return_tokens
self._temperature = temperature
self._text_len_limit = self._max_return_tokens * 3
self._nlputil = nlp.NLPUtil()
def summarise_to_file(self, src_file: str, dst_file: str, overwrite: bool = False) -> bool:
if not overwrite and os.path.exists(dst_file):
logging.warning(f"File '{dst_file}' already exists. Skipping summarization.")
return False
try:
with open(dst_file, 'w') as fh:
pass
except Exception as e:
logging.error(f"Cannot write to destination '{dst_file}'.")
logging.error(e)
return False
text = self.summarize(src_file)
with open(dst_file, 'w') as f:
f.write(text)
return True
def summarize(self, text: str) -> str:
if len(text) < self._text_len_limit:
return self._summarise_small_text(text)
else:
return self._summarise_large_text(text)
def _summarise_large_text(self, text: str) -> str:
""" Note: This only works if the text can be split up into smaller chunks by punctuation. """
def split_text_into_chunks(text: str, chunk_length_limit: len) -> list:
chunks = []
tmp, tmp_len = [], 0
for chunk in self._nlputil.split_text_by_punctuation(text):
if chunk:
if len(chunk) + tmp_len > chunk_length_limit:
chunks.append("".join(tmp))
tmp, tmp_len = [], 0
tmp.append(chunk)
tmp_len += len(chunk)
if tmp:
chunks.append("".join(tmp))
return chunks
summaries = []
chunks = split_text_into_chunks(text, self._text_len_limit)
for nr, chunk in enumerate(chunks, start=1):
if chunk:
summary = self._summarise_small_text(chunk)
if not summary:
logging.warning(f"Could not summarize text chunk #{nr}. Aborting.")
break
summaries.append(summary)
return "\n\n".join(summaries)
def _summarise_small_text(self, text: str) -> str:
prompt = f"{text}\n\nTl;dr" # adding Tl;dr to prompt GPT-3 to create a summary
response = openai.Completion.create(
model=self._model_name,
#messages=[{'role': 'user', 'content': prompt}],
prompt=prompt,
max_tokens=self._max_return_tokens,
n=1,
temperature=self._temperature,
)
summary = response["choices"][0]["text"]
if summary.startswith(":"):
summary = summary[1:]
summary = summary.strip()
return summary
| [
"PLACEHOLDER\n\nTl;dr"
] |
2024-01-10 | Ikerlandarech/SCAV_BUNNY_SP3 | BunnyGUI.py | import openai
import sys
import os
from PyQt5.QtWidgets import QApplication, QWidget, QVBoxLayout, QTextEdit, QLineEdit
from PyQt5.QtCore import pyqtSignal, QTimer
from PyQt5.QtGui import QTextCursor
os.environ["QT_QPA_PLATFORM"] = "wayland"
class ChatBotGUI(QWidget):
response_received = pyqtSignal(str)
def __init__(self, openai_api_key):
super().__init__()
self.setWindowTitle('Bunny GUI')
self.setGeometry(100, 100, 1245, 700)
self.setMaximumSize(1245, 700)
self.init_ui()
openai.api_key = "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"
initial_chatbot_response = "Hi I'm bunny, I heard that in a few days you have the SCAV exam :) Luckily for you the students have been using me for years as an example for their ffmpeg commands, I know them all by heart from all the times they have used them with me so if you want to know anything about butterflies or about any ffmpeg commands let me know and I will be happy to help you, although I may look silly I have a lot of knowledge on the subject."
self.append_message(initial_chatbot_response, is_user=False)
def init_ui(self):
bbb_background_path = "./assets/bbb-background.jpg"
self.setStyleSheet(f"background-image: url({bbb_background_path}); background-position: top left; background-repeat: no-repeat;")
self.conversation_box = QTextEdit(self)
self.conversation_box.setReadOnly(True)
self.input_box = QLineEdit(self)
self.input_box.setPlaceholderText("Ask Bunny any question about audio and video encoding systems! He is very friendly and would love to help :)")
self.input_box.returnPressed.connect(self.process_user_input)
font = self.conversation_box.document().defaultFont()
font.setPointSize(12)
self.conversation_box.document().setDefaultFont(font)
layout = QVBoxLayout()
layout.addWidget(self.conversation_box)
layout.addWidget(self.input_box)
self.setLayout(layout)
self.show()
def process_user_input(self):
user_input = self.input_box.text()
self.input_box.clear()
self.append_message(user_input, is_user=True)
timeout = QTimer(self)
timeout.setSingleShot(True)
timeout.timeout.connect(lambda: self.generate_and_append_response(user_input))
timeout.start(500)
def generate_and_append_response(self, user_input):
response = self.generate_response(user_input)
self.append_message(response, is_user=False)
def append_message(self, message, is_user):
current_text = self.conversation_box.toPlainText()
role_label = '<b>User:</b>' if is_user else '<b>Bunny:</b>'
text_color = 'darkgreen' if not is_user else 'black'
formatted_message = f'<span style="color:{text_color}">{role_label} {message}</span>'
if not is_user:
words = message.split()
self.conversation_box.append(f'<span style="color:{text_color}">{role_label} </span>')
self.show_words_one_at_a_time(words)
else:
self.conversation_box.append(formatted_message)
self.conversation_box.verticalScrollBar().setValue(self.conversation_box.verticalScrollBar().maximum())
def show_words_one_at_a_time(self, words):
cursor = self.conversation_box.textCursor()
role_label = '<b>Bunny:</b>'
text_color = 'darkblue'
def show_next_word(index):
if index < len(words):
word = words[index]
cursor.insertHtml(f'<span style="color:{text_color}"> {word} </span>')
cursor.movePosition(QTextCursor.End)
self.conversation_box.setTextCursor(cursor)
QTimer.singleShot(50, lambda: show_next_word(index + 1))
else:
cursor.insertHtml('<br>')
cursor.movePosition(QTextCursor.End)
self.conversation_box.setTextCursor(cursor)
self.conversation_box.verticalScrollBar().setValue(self.conversation_box.verticalScrollBar().maximum())
show_next_word(0)
def generate_response(self, user_input):
bunny_identity = "Your name is Bunny, you are a very friendly overweight rabbit. You love to smell flowers and sleep in your burrow. One day while smelling a flower, you fall in love with a beautiful butterfly, which is killed by a group of 3 ruffians that you hate. You follow another butterfly but they want to keep killing it, so they try to annoy you by throwing stones and fruits in your face between the 3 of them. And when they see the opportunity, they kill the other butterfly with a stone and play with its corpse. You angrily hatch a master plan to avenge these 3 and manage to set a trap for them. Now you can live peacefully and go back to your burrow to sleep and smell flowers and follow butterflies. You are also an expertise on helping people with ffmpeg commands you know them all by heart so if they ask you about any ffmpeg command you should help them."
stream = openai.chat.completions.create(
model="gpt-3.5-turbo",
messages=[
{"role": "assistant", "content": (f"{bunny_identity}\n")},
{"role": "user", "content": f"{user_input}\n"},
{"role": "assistant", "content": "You have to help the user providing the ffmpeg commands that he ask you to write. Take into account that the user has some knowledge already about the ffmpeg libraries so he has it all set and installed, just provide the line with the command. Remember that you are bunny and you should answer as he would, you are an expertise on ffmpeg commands. Remember to tell the user all the time that you love butterflies a lot. You can also provide some bunny noises on the text to make it look more realistic.\n"}
],
stream=True,
)
response_content = ""
for chunk in stream:
if chunk.choices[0].delta.content is not None:
response_content += chunk.choices[0].delta.content
return response_content.strip()
def main():
app = QApplication(sys.argv)
chatbot_gui = ChatBotGUI("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")
chatbot_gui.response_received.connect(chatbot_gui.append_message)
sys.exit(app.exec_())
if __name__ == '__main__':
main()
| [
"PLACEHOLDER\n",
"Your name is Bunny, you are a very friendly overweight rabbit. You love to smell flowers and sleep in your burrow. One day while smelling a flower, you fall in love with a beautiful butterfly, which is killed by a group of 3 ruffians that you hate. You follow another butterfly but they want to keep killing it, so they try to annoy you by throwing stones and fruits in your face between the 3 of them. And when they see the opportunity, they kill the other butterfly with a stone and play with its corpse. You angrily hatch a master plan to avenge these 3 and manage to set a trap for them. Now you can live peacefully and go back to your burrow to sleep and smell flowers and follow butterflies. You are also an expertise on helping people with ffmpeg commands you know them all by heart so if they ask you about any ffmpeg command you should help them.\n",
"You have to help the user providing the ffmpeg commands that he ask you to write. Take into account that the user has some knowledge already about the ffmpeg libraries so he has it all set and installed, just provide the line with the command. Remember that you are bunny and you should answer as he would, you are an expertise on ffmpeg commands. Remember to tell the user all the time that you love butterflies a lot. You can also provide some bunny noises on the text to make it look more realistic.\n"
] |
2024-01-10 | Malay207/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 | Malay207/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 | vincentIsGood/YourAIDatabase | lib~loaders.py | from typing import List, Optional
from langchain.docstore.document import Document
from langchain.document_loaders.base import BaseLoader
class TextTrimmedLoader(BaseLoader):
"""Trim all lines but is still loaded as a single document
"""
def __init__(self, file_path: str, encoding: Optional[str] = None):
self.file_path = file_path
self.encoding = encoding
def load(self) -> 'List[Document]':
try:
with open(self.file_path, encoding=self.encoding) as f:
metadata = {"source": self.file_path}
lines = []
for line in f.readlines():
line = line.strip()
if line != '' or line != '\n' or line != '\r\n':
lines.append(line)
return [Document(page_content="\n".join(lines), metadata=metadata)]
except Exception as e:
print("[!] Cannot read file '%s'. " % self.file_path)
return [] | [] |
2024-01-10 | vincentIsGood/YourAIDatabase | lib~docloader.py | import sys
import os
import traceback
from typing import List, Type, Tuple
from typing_extensions import TypedDict
from dataclasses import dataclass
from datetime import datetime
from langchain.document_loaders import (
TextLoader,
CSVLoader,
UnstructuredExcelLoader,
UnstructuredWordDocumentLoader,
UnstructuredPowerPointLoader,
UnstructuredPDFLoader,
UnstructuredMarkdownLoader,
UnstructuredXMLLoader,
UnstructuredHTMLLoader,
)
from langchain.text_splitter import CharacterTextSplitter
from .loaders import TextTrimmedLoader
from .utils import file_utils
## https://github.com/Unstructured-IO/unstructured#document-parsing
### Types
from langchain.schema import Document
from langchain.document_loaders.base import BaseLoader
###
DEFAULT_LOADER: 'Tuple[Type[BaseLoader], object]' = (TextLoader, {"encoding": None})
SUPPORTED_LOADERS: 'dict[str, Tuple[Type[BaseLoader], object]]' = {
"txt": (TextTrimmedLoader, {"encoding": None}),
"csv": (CSVLoader, {"encoding": None}),
"xlsx": (UnstructuredExcelLoader, {}),
"xls": (UnstructuredExcelLoader, {}),
"docx": (UnstructuredWordDocumentLoader, {}),
"doc": (UnstructuredWordDocumentLoader, {}),
"pptx": (UnstructuredPowerPointLoader, {}),
"ppt": (UnstructuredPowerPointLoader, {}),
"pdf": (UnstructuredPDFLoader, {}),
"md": (UnstructuredMarkdownLoader, {}),
"xml": (UnstructuredXMLLoader, {}),
"html": (UnstructuredHTMLLoader, {}),
}
def getCurrentTime():
"""returns number of seconds since 1/1/1970
"""
# return datetime.today().strftime("%d/%m/%Y %H:%M:%S")
return int(datetime.now().timestamp())
def fromTimestamp(time):
return datetime.fromtimestamp(time).strftime("%d/%m/%Y %H:%M:%S")
def parseDateTime(date):
return int(datetime.strptime(date, "%d/%m/%Y %H:%M:%S").timestamp())
class ExtraMetadata(TypedDict):
source: str
time: int
def ExtraMetadataDefault():
return {"source": None, "time": getCurrentTime()}
class LocalFileLoader:
def __init__(self, encoding = "utf-8", useDefaultLoader = False):
"""useDefaultLoader: use default loader if an unknown file extension is encountered
"""
self.encoding = encoding
self.useDefaultLoader = useDefaultLoader
self.loadedDocs: 'List[Document]' = []
self.textSplitter = CharacterTextSplitter(
chunk_size=4000,
chunk_overlap=0)
def loadDoc(self, filePath, extraMetadata: ExtraMetadata = ExtraMetadataDefault()):
ext = file_utils.fileExt(filePath)
if ext in SUPPORTED_LOADERS:
loaderClassType, loaderArgs = SUPPORTED_LOADERS[file_utils.fileExt(filePath)]
else:
if not self.useDefaultLoader:
print("[!] Cannot find loader for file '%s'. Ignoring it." % filePath)
return
print("[!] Cannot find loader for file '%s'. Using default loader." % filePath)
loaderClassType, loaderArgs = DEFAULT_LOADER
if "encoding" in loaderArgs:
loaderArgs["encoding"] = self.encoding
# loader = TextLoader(pathToTxt, encoding=self.encoding)
loader = loaderClassType(filePath, **loaderArgs)
docs = loader.load()
for doc in docs:
if extraMetadata["source"]:
# override source set by loader
doc.metadata = extraMetadata
else:
doc.metadata = {**extraMetadata, **doc.metadata}
# print(doc)
for doc in self.textSplitter.split_documents(docs):
self.loadedDocs.append(doc)
def getDocs(self):
return self.loadedDocs
import shutil
import mimetypes
import requests
from .utils.randutils import randomString
class WebFileLoader(LocalFileLoader):
"""
from lib.DocLoader import WebFileLoader
loader = WebFileLoader()
loader.loadWebDoc("https://docs.python.org/3/library/mimetypes.html")
"""
def __init__(self, tmpFolder = "./tmp"):
super().__init__("utf-8")
self.tmpDir = tmpFolder
if not os.path.exists(tmpFolder):
os.mkdir(tmpFolder, mode=755)
def loadWebDoc(self, url, extraMetadata: ExtraMetadata = ExtraMetadataDefault()):
print("[+] Trying to download doc: ", url)
try:
res = requests.get(url, allow_redirects=True)
if res.status_code != 200:
raise Exception("Remote server responded with non-ok code: ", res.status_code)
baseFilename = os.path.basename(res.url)
if baseFilename == "":
baseFilename = randomString(10)
if not "." in baseFilename:
contentType = res.headers.get("content-type")
if ";" in contentType:
contentType = contentType[:contentType.index(";")]
baseFilename = baseFilename + mimetypes.guess_extension(contentType)
outFilename = self.tmpDir + "/" + baseFilename
print("[+] Saving doc to ", outFilename)
with open(outFilename, "wb+") as f:
f.write(res.content)
extraMetadata["source"] = res.url
self.loadDoc(outFilename, extraMetadata)
except Exception as e:
# traceback.print_exception(*sys.exc_info())
print("[-] Cannot add document: ", e)
def cleanupTmp(self):
print("[+] Removing tmp directory: ", self.tmpDir)
shutil.rmtree(self.tmpDir) | [] |
2024-01-10 | vincentIsGood/YourAIDatabase | lib~AiDatabase.py | import importlib
import os
from typing import Any, List, Callable, Optional, Sequence
import huggingface_hub
import torch
import transformers
from langchain import HuggingFacePipeline
from langchain.callbacks.base import BaseCallbackHandler
from langchain.callbacks.manager import CallbackManagerForLLMRun
from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler
from langchain.chains import RetrievalQA
from langchain.embeddings.sentence_transformer import \
SentenceTransformerEmbeddings
from langchain.prompts import PromptTemplate
from langchain.schema import BaseLanguageModel, Document
from langchain.vectorstores import Chroma
from langchain.vectorstores.base import VectorStoreRetriever
from transformers import (AutoModelForCausalLM, AutoTokenizer,
StoppingCriteria, StoppingCriteriaList, TextStreamer)
import configs.common as config
from configs.common import model_config
class AiDatabase:
stopRequested = False
def __init__(self, callbacks: 'list[BaseCallbackHandler]' = [],
streamerClassType: 'type[TextStreamer]' = TextStreamer):
"""
Args:
callbacks: Use this to implement LangChain's CallbackHandler
streamerClassType: Use this to implement HuggingFace's CallbackHandler
"""
print("[+] Preparing Chroma DB")
embedding_func = SentenceTransformerEmbeddings(model_name=model_config.SENTENCE_EMBEDDING_MODEL, cache_folder=config.CACHE_DIR)
self.chromadb = Chroma(persist_directory=config.PERSIST_DIRECTORY, embedding_function=embedding_func)
print("[+] Chroma # of collections: ", self.chromadb._collection.count())
self.retriever = self.chromadb.as_retriever(search_kwargs={"k": config.USE_TOP_K_SIMILAR_DOC, "include_metadata": True})
if model_config.IS_GGML:
self.llm = createCLLM(callbacks)
else:
self.llm = createLLM(callbacks, streamerClassType, [self.isStopRequested])
self.retrievalQA = createRetrievalQA(self.llm, self.retriever)
# self.agent: 'AgentExecutor' = initialize_agent(
# tools=[Tool(name="Chromadb QA System", func=self.retrievalQA, description="Let your AI handle the requests")],
# llm=self.llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True)
def reloadPrompt(self):
importlib.reload(model_config)
self.retrievalQA = createRetrievalQA(self.llm, self.retriever)
def query(self, queryStr: str) -> 'list[Document]':
if queryStr == "":
return
self.stopRequested = False
import time
t = time.perf_counter()
res = self.retrievalQA({"query": queryStr})
print("\n[*] Inference time elapsed: ", time.perf_counter() - t)
return res["source_documents"]
# print(res["result"])
# for source in res["source_documents"]:
# print(source.metadata)
def isStopRequested(self, input_ids: torch.LongTensor, score: torch.FloatTensor, **kwargs) -> bool:
return self.stopRequested
def stopLLM(self):
if model_config.IS_GGML:
self.llm.stopGen()
else:
self.stopRequested = True
class Record:
id: str
metadata: str
def getAllDocs(self) -> 'list[Record]':
collection = self.chromadb._collection.get(include=["metadatas"])
if not collection:
return []
ids = collection["ids"]
metadatas = collection["metadatas"]
result = []
for i in range(len(ids)):
result.append({"id": ids[i], "metadata": metadatas[i]})
return result
def addDocsToDb(self, docs: 'list[Document]'):
self.chromadb.add_documents(docs)
def deleteDocsFromDb(self, ids: 'list[str]'):
print("[+] Deleting docs: ", ids)
self.chromadb.delete(ids)
def createCLLM(callbacks: 'list[BaseCallbackHandler]' = [StreamingStdOutCallbackHandler()]):
"""Create C/C++ based LLM (eg. w/ GGML)
"""
print("[+] Loading C LLM model")
binFullPath = None
if not os.path.exists(model_config.LLM_MODEL):
llmModelFolder, filename = downloadOneModelFile(
model_config.LLM_MODEL,
specificModelBinPattern=None if not hasattr(model_config, "LLM_MODEL_BIN_FILE") else model_config.LLM_MODEL_BIN_FILE)
llmModelFolder = os.path.normpath(llmModelFolder)
binFullPath = os.path.join(llmModelFolder, filename)
gpu_layers = 0
if not config.DEVICE == "cpu":
gpu_layers = config.GPU_LAYERS
if config.USE_LLAMACPP_INSTEAD_OF_CTRANSFORMERS:
from .cancellablellm.llamacpp import CancellableLlamaCpp
if not binFullPath:
print("[-] A '.bin' filename is required, did you forget to specify 'LLM_MODEL_BIN_FILE' in model_config?")
return CancellableLlamaCpp(
streaming=True,
verbose=False,
model_path=binFullPath,
callbacks=callbacks,
top_k=40,
top_p=0.1,
repeat_penalty=1.176,
temperature=0.7,
n_batch=512,
n_gpu_layers=gpu_layers
)
lib = None
if not config.DEVICE == "cpu":
lib = config.CTRANSFORMERS_CUDA_LIB
print("[+] Use ctransformers lib: ", lib)
# https://www.reddit.com/r/LocalLLaMA/comments/1343bgz/what_model_parameters_is_everyone_using/
from .cancellablellm.ctransformers import CancellableLLM
return CancellableLLM(
streaming=True,
model=llmModelFolder,
model_type=None if not hasattr(model_config, "LLM_MODEL_TYPE") else model_config.LLM_MODEL_TYPE,
callbacks=callbacks,
lib=lib,
config={
"top_k": 40,
"top_p": 0.1,
"repetition_penalty": 1.176,
"temperature": 0.7,
"batch_size": 512,
"gpu_layers": gpu_layers
}
)
def downloadOneModelFile(repoId, specificModelBinPattern = None, modelFileExt = ".bin"):
"""
specificModelBinPattern: allows wildcard like "*.bin"
Returns: Local folder path of repo snapshot
"""
from huggingface_hub import HfApi, snapshot_download
if not specificModelBinPattern:
api = HfApi()
repo_info = api.repo_info(repo_id=repoId, files_metadata=True)
files = [
(f.size, f.rfilename)
for f in repo_info.siblings
if f.rfilename.endswith(modelFileExt)
]
if not files:
raise ValueError(f"No model file found in repo '{repoId}'")
filename = min(files)[1]
else:
filename = specificModelBinPattern
return snapshot_download(
repo_id=repoId,
local_files_only=model_config.IS_LLM_LOCAL,
cache_dir=config.CACHE_DIR,
allow_patterns=[filename, "config.json"],
), filename
def createLLM(callbacks: 'list[BaseCallbackHandler]' = [],
streamerClassType: 'type[TextStreamer]' = TextStreamer,
stoppingCriteriaList: 'list[Callable[..., bool] | StoppingCriteria]' = []):
"""For StoppingCriteria, see
https://stackoverflow.com/questions/68277635/how-to-implement-stopping-criteria-parameter-in-transformers-library
"""
print("[+] Loading LLM model")
if len(config.HF_ACCESS_TOKEN) > 0 and (not model_config.IS_GGML):
# both use_auth
huggingface_hub.login(token=config.HF_ACCESS_TOKEN)
langmodel = AutoModelForCausalLM.from_pretrained(
model_config.LLM_MODEL, cache_dir=config.CACHE_DIR, local_files_only=model_config.IS_LLM_LOCAL, use_auth_token=True)
tokenizer = AutoTokenizer.from_pretrained(
model_config.LLM_MODEL, cache_dir=config.CACHE_DIR, local_files_only=model_config.IS_TOKENIZER_LOCAL, use_auth_token=True)
else:
langmodel = AutoModelForCausalLM.from_pretrained(
model_config.LLM_MODEL, cache_dir=config.CACHE_DIR, local_files_only=model_config.IS_LLM_LOCAL)
tokenizer = AutoTokenizer.from_pretrained(
model_config.LLM_MODEL, cache_dir=config.CACHE_DIR, local_files_only=model_config.IS_TOKENIZER_LOCAL)
huggingface_hub.logout()
streamer = streamerClassType(tokenizer, skip_prompt=config.SKIP_PROMPT)
# https://huggingface.co/docs/transformers/main/main_classes/pipelines
# Streaming Output
# https://github.com/hwchase17/langchain/issues/2918
# https://github.com/hwchase17/langchain/issues/4950
pipeline = transformers.pipeline(
"text-generation",
model=langmodel,
tokenizer=tokenizer,
streamer=streamer,
stopping_criteria=StoppingCriteriaList(stoppingCriteriaList),
device_map=config.DEVICE,
max_length=1000,
do_sample=True,
eos_token_id=tokenizer.eos_token_id,
)
return HuggingFacePipeline(
pipeline=pipeline,
model_kwargs={
"top_k": 40,
"top_p": 0.1,
"repetition_penalty": 1.176,
"temperature": 0.7,
"batch_size": 64,
},
# callbacks=callbacks
)
def createRetrievalQA(llm: BaseLanguageModel, retriever: VectorStoreRetriever):
return RetrievalQA.from_chain_type(
llm=llm,
chain_type="stuff",
retriever=retriever,
chain_type_kwargs={
"prompt": PromptTemplate(template=model_config.PROMPT_TEMPLATE, input_variables=["context", "question"])
},
return_source_documents=True
)
| [] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.