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 | normand1/HyperFeeder | podcastTextGenerationApp~podcastIntroPlugins~utilities~podcastIntroWriter.py | from langchain.prompts import PromptTemplate
from langchain.llms import OpenAI
from langchain.chains import LLMChain
import os
class PodcastIntroWriter:
def writeIntro(self, allStoryTitles, podcastName, typeOfPodcast):
llm = OpenAI(
model=os.getenv("OPENAI_MODEL_SUMMARY"),
max_tokens=int(os.getenv("OPENAI_MAX_TOKENS_SUMMARY")),
temperature=0.3,
)
templateString = os.getenv("INTRO_TEMPLATE_STRING")
prompt = PromptTemplate(
input_variables=["allStoryTitles", "podcastName", "typeOfPodcast"],
template=templateString,
)
chain = LLMChain(llm=llm, prompt=prompt)
return chain.run(
{
"allStoryTitles": allStoryTitles,
"podcastName": podcastName,
"typeOfPodcast": typeOfPodcast,
}
)
| [
"INTRO_TEMPLATE_STRING",
"typeOfPodcast",
"podcastName",
"allStoryTitles"
] |
2024-01-10 | normand1/HyperFeeder | podcastTextGenerationApp~podcastOutroWriterPlugins~outroWriterPlugin.py | import os
from langchain.prompts import PromptTemplate
from langchain.llms import OpenAI
from langchain.chains import LLMChain
from podcastOutroWriterPlugins.baseOutroWriterPlugin import BaseOutroWriterPlugin
class OutroWriterPlugin(BaseOutroWriterPlugin):
def identify(self) -> str:
return "🎸 outro writer plugin"
def writeOutro(self, stories, introText):
print("Writing funny Outro")
llm = OpenAI(
model=os.getenv("OPENAI_MODEL_SUMMARY"),
max_tokens=int(os.getenv("OPENAI_MAX_TOKENS_OUTRO")),
temperature=0.3,
)
templateString = os.getenv("OUTRO_TEMPLATE_STRING")
prompt = PromptTemplate(
input_variables=["introText"],
template=templateString,
)
chain = LLMChain(llm=llm, prompt=prompt)
return chain.run(introText)
plugin = OutroWriterPlugin()
| [
"OUTRO_TEMPLATE_STRING",
"introText"
] |
2024-01-10 | normand1/HyperFeeder | podcastTextGenerationApp~podcastSummaryPlugins~storySummaryPlugin.py | import os
from podcastSummaryPlugins.baseSummaryPlugin import BaseSummaryPlugin
from langchain import OpenAI
from langchain.docstore.document import Document
from langchain.chains.summarize import load_summarize_chain
from langchain.prompts import PromptTemplate
class StorySummaryPlugin(BaseSummaryPlugin):
def identify(self) -> str:
return "📓 OpenAI Summarizer"
def summarizeText(self, story):
url = story["link"]
print("Summarizing: " + url)
texts = self.prepareForSummarization(story["rawSplitText"])
summaryText = self.summarize(texts)
return summaryText
def summarize(self, texts):
prompt_template = """Write a detailed summary of the following:
{text}
DETAILED SUMMARY:"""
PROMPT = PromptTemplate(template=prompt_template, input_variables=["text"])
MAX_SUMMARY_SEGMENTS = int(os.getenv("MAX_SUMMARY_SEGMENTS"))
docs = [Document(page_content=text) for text in texts[:MAX_SUMMARY_SEGMENTS]]
llm = OpenAI(model=os.getenv("OPENAI_MODEL_SUMMARY"), temperature=0.2)
chain = load_summarize_chain(
llm, chain_type="map_reduce", map_prompt=PROMPT, combine_prompt=PROMPT
)
result = chain.run(docs)
return result
plugin = StorySummaryPlugin()
| [
"Write a detailed summary of the following:\n {text}\n DETAILED SUMMARY:"
] |
2024-01-10 | normand1/HyperFeeder | podcastTextGenerationApp~podcastSegmentWriterPlugins~utilities~storySegmentWriter.py | import os
from langchain.prompts import PromptTemplate
from langchain.llms import OpenAI
from langchain.chains import LLMChain
class StorySegmentWriter:
def writeSegmentFromSummary(self, storySummary):
llm = OpenAI(
model=os.getenv("OPENAI_MODEL_SUMMARY"),
max_tokens=int(os.getenv("OPENAI_MAX_TOKENS_SUMMARY")),
temperature=0.3,
)
templateString = os.getenv("SEGMENT_WRITER_STRING")
prompt = PromptTemplate(
input_variables=["storySummary"],
template=templateString,
)
chain = LLMChain(llm=llm, prompt=prompt)
return chain.run(storySummary)
| [
"storySummary",
"SEGMENT_WRITER_STRING"
] |
2024-01-10 | platisd/sycophant | sycophant.py | #!/usr/bin/env python3
import sys
import argparse
import json
import re
from io import BytesIO
from datetime import datetime, timedelta
from pathlib import Path
from openai import OpenAI
from bs4 import BeautifulSoup
from PIL import Image
from jinja2 import Environment, FileSystemLoader
import yaml
import requests
# Tags and attributes to search for in the HTML response to find the article content
CONTENT_QUERIES = [
("article", {"class": "article-content"}),
("article", {}),
("p", {"class": "story-body-text story-content"}),
("div", {"class": "article-body"}),
("div", {"class": "content"}),
("div", {"class": "entry"}),
("div", {"class": "post"}),
("div", {"class": "blog-post"}),
("div", {"class": "article-content"}),
("div", {"class": "article-body"}),
("div", {"class": "article-text"}),
("div", {"class": "article-wrapper"}),
("div", {"class": "story"}),
("div", {"id": "article"}),
("div", {"id": "content"}),
("div", {"id": "entry"}),
("div", {"id": "post"}),
("div", {"id": "blog-post"}),
("div", {"id": "article-content"}),
("div", {"id": "article-body"}),
("div", {"id": "article-text"}),
("div", {"id": "article-wrapper"}),
("section", {"class": "article-body"}),
("section", {"class": "article-content"}),
]
# Tags and attributes to search for in the HTML response to find the article title
TITLE_QUERIES = [
("title", {}),
("h1", {"class": "story-body__h1"}),
("h1", {"class": "story-body__h1"}),
("h1", {"class": "entry-title"}),
("h1", {"class": "post-title"}),
("h1", {"class": "blog-post-title"}),
("h1", {"class": "article-title"}),
("h1", {"class": "entry-title"}),
("h1", {"class": "post-title"}),
("h1", {"class": "blog-post-title"}),
("h1", {"class": "article-title"}),
("h1", {"class": "entry-title"}),
]
def get_news(topic: str, since_date: datetime, api_key: str):
url = "https://newsapi.org/v2/everything"
params = {
"q": topic,
"from": since_date.strftime("%Y-%m-%d"),
"language": "en",
"sortBy": "relevancy",
"apiKey": api_key,
}
response = requests.get(url, params=params)
return response.json()
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--openai-api-key", help="OpenAI API key", required=True)
parser.add_argument("--news-api-key", help="News API key", required=True)
parser.add_argument("--config", help="Path to the config YAML", required=True)
parser.add_argument(
"--rewrite-article",
help="Rewrite the specified article, only article name required",
required=False,
)
parser.add_argument(
"--rewrite-prompt", help="Prompt to use for rewriting", required=False
)
parser.add_argument(
"--links",
help="Write an article based on provided links (one URL on each line)",
required=False,
)
args = parser.parse_args()
# Load the config file
with open(args.config, "r") as f:
config = yaml.safe_load(f)
if args.rewrite_article:
return rewrite_article(
openai_client=OpenAI(api_key=args.openai_api_key),
openai_model=config["openai"]["model"],
openai_temperature=config["openai"]["temperature"],
openai_rewrite_prompt=args.rewrite_prompt,
article_path=Path(config["blog"]["posts"]) / args.rewrite_article.strip(),
)
return write_article(
openai_api_key=args.openai_api_key,
openai_model=config["openai"]["model"],
openai_max_tokens=config["openai"]["max_tokens"],
openai_temperature=config["openai"]["temperature"],
openai_article_summary_prompt=config["openai"]["article_summary_prompt"],
openai_final_article_prompt=config["openai"]["final_article_prompt"],
openai_final_title_prompt=config["openai"]["final_title_prompt"],
image_generation_model=config["openai"]["dalle_model"],
openai_prompt_for_dalle=config["openai"]["dalle_prompt"],
news_api_key=args.news_api_key,
topic_to_search=config["news"]["topic"],
max_article_age=config["news"]["max_age_in_days"],
max_articles=config["news"]["max_articles"],
assets_dir=config["blog"]["assets"],
posts_dir=config["blog"]["posts"],
post_template_path=config["blog"]["post_template"],
attribution=config["blog"].get("attribution", True),
provided_links=args.links,
)
def write_article(
openai_api_key: str,
openai_model: str,
openai_max_tokens: int,
openai_temperature: float,
openai_article_summary_prompt: str,
openai_final_article_prompt: str,
image_generation_model: str,
openai_final_title_prompt: str,
openai_prompt_for_dalle: str,
news_api_key: str,
topic_to_search: str,
max_article_age: float,
max_articles: int,
assets_dir: str,
posts_dir: str,
post_template_path: str,
attribution: bool,
provided_links: str,
):
if not provided_links or provided_links == "":
date_to_search_from = datetime.now() - timedelta(days=max_article_age)
# Get news as a JSON dictionary through the News API (newsapi.org)
print("Searching for primary sources on subject: {}".format(topic_to_search))
news = get_news(
topic=topic_to_search, since_date=date_to_search_from, api_key=news_api_key
)
if news["status"] != "ok":
print("Error: News API returned status code: {}".format(news["status"]))
return 1
article_titles_and_urls = [
(article["title"], article["url"]) for article in news["articles"]
]
print("Found {} articles".format(len(article_titles_and_urls)))
else:
article_urls = provided_links.split("\n")
# We need to get the titles of the articles so to form an article_titles_and_urls list
article_titles_and_urls = []
for article_url in article_urls:
try:
response = requests.get(article_url)
except Exception as e:
print(
"Exception while getting article from URL: {}".format(article_url)
)
return 1 # We don't want to continue if we can't get all articles
if response.status_code != 200:
print(
"Error code {} while getting article from URL: {}".format(
response.status_code, article_url
)
)
return 1
# Find the article title
soup = BeautifulSoup(response.content, "html.parser")
for tag, attrs in TITLE_QUERIES:
article_title = soup.find(tag, attrs)
if article_title is not None:
break
if article_title is None:
print(
"Error: Could not find article title in HTML response from URL: {}".format(
article_url
)
)
article_title_text = article_url[:50]
article_title_text += "..."
else:
article_title_text = article_title.get_text()
# Replace any \n, \t, etc. characters in the text with spaces
article_title_text = " ".join(article_title_text.split())
article_title_text = article_title_text.strip()
article_titles_and_urls.append((article_title_text, article_url))
max_allowed_tokens = openai_max_tokens
characters_per_token = 4 # The average number of characters per token
max_allowed_characters = max_allowed_tokens * characters_per_token
summarized_articles = []
original_articles_urls = [] # Only the titles and the URLs of the articles we use
print("Summarizing the top-{} articles...".format(max_articles))
for article_title, article_url in article_titles_and_urls:
try:
response = requests.get(article_url)
except Exception as e:
print("Exception while getting article from URL: {}".format(article_url))
continue
if response.status_code != 200:
print(
"Error code {} while getting article from URL: {}".format(
response.status_code, article_url
)
)
continue
# Find the actual article content in the HTML response using the relevant SEO tags
soup = BeautifulSoup(response.text, "html.parser")
for tag, attrs in CONTENT_QUERIES:
article_content = soup.find(tag, attrs)
if article_content is not None:
break
if article_content is None:
print(
"Error: Could not find article content in HTML response from URL: {}".format(
article_url
)
)
continue
# Get the text from the article content
article_text = article_content.get_text()
# Replace any \n, \t, etc. characters in the text with spaces
article_text = " ".join(article_text.split())
prompt = (
openai_article_summary_prompt
+ "\n\n```\n"
+ article_title
+ "\n\n"
+ article_text
+ "\n```"
)
if len(prompt) > max_allowed_characters:
prompt = prompt[:max_allowed_characters]
openai_client = OpenAI(api_key=openai_api_key)
generated_summary = get_openai_response(
prompt=prompt,
model=openai_model,
temperature=openai_temperature,
openai_client=openai_client,
)
summarized_articles.append(generated_summary)
original_articles_urls.append({"url": article_url, "title": article_title})
if len(summarized_articles) >= max_articles:
break
if len(summarized_articles) == 0:
print("Error: Could not summarize any articles")
return 1
print("Generating the final article...")
final_article_prompt = openai_final_article_prompt + "\n" + str(summarized_articles)
final_article = {}
final_article["content"] = get_openai_response(
prompt=final_article_prompt,
model=openai_model,
temperature=openai_temperature,
openai_client=openai_client,
)
final_title_prompt = openai_final_title_prompt + "\n" + final_article["content"]
final_article["title"] = get_openai_response(
prompt=final_title_prompt,
model=openai_model,
temperature=openai_temperature,
openai_client=openai_client,
)
final_article["title"] = final_article["title"].strip('"')
# It seems that GPT models (up to GPT-4) are very biased towards generating titles
# that are formulated as "<generic statement>: <specific statement>"
# It's not clear how to reliably solve this with prompting, so let's keep only
# the specific statement, i.e. the part after the colon
if ":" in final_article["title"]:
final_article["title"] = final_article["title"].split(":")[1].strip()
# Capitalize the first letter of the title
final_article["title"] = (
final_article["title"][0].upper() + final_article["title"][1:]
)
print("Generating tags for the final article...")
generated_tags_response = get_openai_response(
prompt="Generate 3 tags as a JSON list, use one word for each tag,"
+ 'e.g. ["tag1", "tag2", "tag3"], for the following article: \n'
+ final_article["content"],
model=openai_model,
temperature=openai_temperature,
openai_client=openai_client,
)
generated_tags = try_loads(generated_tags_response)
if not generated_tags:
print(
"Error: Could not parse generated tags response: {}".format(
generated_tags_response
)
)
print("Will ignore the tags and continue")
generated_tags = ""
generated_tags = [tag.lower() for tag in generated_tags]
# Split the tags into comma-separated values
generated_tags = ", ".join(generated_tags)
generated_tags = "[" + generated_tags + "]"
print("Generating the prompt for the image generation...")
prompt_gpt_to_create_dalle_prompt = openai_prompt_for_dalle + final_article["title"]
dalle_prompt = get_openai_response(
prompt=prompt_gpt_to_create_dalle_prompt,
model=openai_model,
temperature=openai_temperature,
openai_client=openai_client,
)
print(f"Generating an image based on the article with {image_generation_model}...")
dalle_response = openai_client.images.generate(
model=image_generation_model,
prompt=dalle_prompt,
n=1,
size="1024x1024",
response_format="url",
)
dalle_image_url = dalle_response.data[0].url
print("Downloading the image...")
response = requests.get(dalle_image_url)
if response.status_code != 200:
print(
"Error code {} while getting image from URL: {}".format(
response.status_code, dalle_image_url
)
)
return 1
image = Image.open(BytesIO(response.content))
title_normalized = re.sub(r"[^\w\s]", "", final_article["title"])
title_normalized = title_normalized.replace(" ", "_")
current_date = datetime.now().strftime("%Y-%m-%d")
image_file_name = Path("{}-{}.png".format(current_date, title_normalized))
image_path = Path(assets_dir) / image_file_name
image.save(image_path)
made_with_sycophant = ""
attribution_links = ""
if attribution:
# Append the links to the original articles to the final article
made_with_sycophant = (
"\n\nThe above article was written with the help of "
+ "[sycophant](https://github.com/platisd/sycophant) "
+ "based on content from the following articles:\n"
)
attribution_links = "\n".join(
[
"- [{}]({})".format(article["title"], article["url"])
for article in original_articles_urls
]
)
post_title = '"' + final_article["title"].replace('"', '\\"') + '"'
post_date = datetime.now().strftime("%Y-%m-%d %H:%M:%S %z")
post_tags = generated_tags
img_path = "/" + assets_dir
post_image = image_file_name
image_caption = '"' + dalle_prompt.replace('"', "'") + '"'
post_content = final_article["content"] + made_with_sycophant + attribution_links
post_content += "\n" # Finish with a newline to be nice
post_filename = image_file_name.with_suffix(".md")
print("Generating the final post...")
environment = Environment(loader=FileSystemLoader(Path(post_template_path).parent))
template = environment.get_template(Path(post_template_path).name)
output = template.render(
post_title=post_title,
post_date=post_date,
post_tags=post_tags,
img_path=img_path,
post_image=post_image,
image_caption=image_caption,
post_content=post_content,
)
post_path = Path(posts_dir) / post_filename
with open(post_path, "w") as f:
f.write(output)
print(
"Done! Generated files: \n"
+ " - [Post]({})\n".format(post_path)
+ " - [Image]({})\n".format(image_path)
)
return 0
def rewrite_article(
openai_client: OpenAI,
openai_model: str,
openai_temperature: float,
openai_rewrite_prompt: str,
article_path: Path,
):
if not article_path.exists():
print("Error: Article not found: {}".format(article_path))
return 1
print("Reading article from file...")
with open(article_path, "r") as f:
article = f.read()
font_matter = article.split("---")[1]
article = article.split("---")[2]
print("Rewriting article...")
if not openai_rewrite_prompt or openai_rewrite_prompt == "":
openai_rewrite_prompt = (
"Rewrite the following article but keep the last "
+ "paragraph if it includes attribution to the original "
+ "articles and the links to them:\n"
)
else:
openai_rewrite_prompt = (
"Keep the last paragraph if it includes attribution "
+ "to the original articles and the links to them.\n"
+ openai_rewrite_prompt
+ "\nThe article to rewrite is:\n"
)
openai_rewrite_prompt += article
openai_response = get_openai_response(
prompt=openai_rewrite_prompt,
model=openai_model,
temperature=openai_temperature,
openai_client=openai_client,
)
# Replace the content of the article with the rewritten one
with open(article_path, "w") as f:
f.write("---")
f.write(font_matter)
f.write("---\n")
f.write(openai_response + "\n")
print("Done! Rewritten article: " + str(article_path))
return 0
def try_loads(maybe_json: str):
try:
return json.loads(maybe_json, strict=False)
except Exception as e:
print(e)
print("Response not a valid JSON: \n" + maybe_json)
return None
def get_openai_response(
prompt: str, model: str, temperature: float, openai_client: OpenAI
):
openai_response = openai_client.chat.completions.create(
model=model,
messages=[
{
"role": "system",
"content": "You are a helpful assistant who summarizes news articles",
},
{"role": "user", "content": prompt},
],
temperature=temperature,
)
return openai_response.choices[0].message.content
if __name__ == "__main__":
sys.exit(main())
| [
"PLACEHOLDER\nPLACEHOLDER",
"PLACEHOLDER\n\n```\nPLACEHOLDER\n\nPLACEHOLDER\n```",
"You are a helpful assistant who summarizes news articles",
"Rewrite the following article but keep the last paragraph if it includes attribution to the original articles and the links to them:\n",
"Keep the last paragraph if it includes attribution to the original articles and the links to them.\nPLACEHOLDER\nThe article to rewrite is:\n",
"PLACEHOLDERPLACEHOLDER"
] |
2024-01-10 | protella/chatgpt-bots | bot_functions.py | from openai import OpenAI
import os
from dotenv import load_dotenv
from textwrap import dedent
import base64
from io import BytesIO
from PIL import Image
from copy import deepcopy
load_dotenv() # load auth tokens from .env file
# Default models: https://platform.openai.com/docs/models
GPT_MODEL = 'gpt-4-1106-preview'
DALLE_MODEL = 'dall-e-3'
GPT_VISION_MODEL = 'gpt-4-vision-preview'
class ChatBot:
def __init__(self, INITIALIZE_TEXT, streaming_client=False):
self.messages = [INITIALIZE_TEXT]
self.INITIALIZE_TEXT = INITIALIZE_TEXT
self.streaming_client = streaming_client # ToDo: Implement streaming support
self.usage = {}
self.processing = False
self.config_option_defaults = {
'temperature': 0.5, # 0.0 - 2.0
'top_p': 1,
'max_tokens': 2048, # max 4096
'custom_init': '',
'gpt_model': GPT_MODEL,
'dalle_model': DALLE_MODEL,
'gpt_vision_model': GPT_VISION_MODEL,
'size': '1024x1024', # 1024x1024, 1024x1792 or 1792x1024
'quality': 'hd', # standard or hd
'style': 'vivid', # natural or vivid
'number': 1, # number of images. Only 1 supported for Dalle3
'detail': 'auto' # vision parameter: auto, low, high
}
self.current_config_options = self.config_option_defaults.copy()
self.client = OpenAI(api_key=os.environ['OPENAI_KEY'])
def chat_context_mgr(self, message_text, files=''):
self.processing = True
self.messages.append({'role': 'user', 'content': message_text})
# Using vision model for all chat prompts since images passed to non-vision model throws an error.
# GPT4v is an extension of GPT4 with all the same functions and features.
gpt_output = self.get_gpt_response(
self.messages, self.current_config_options['gpt_vision_model'])
self.processing = False
if hasattr(gpt_output, 'role'):
is_error = False
if gpt_output.role == 'assistant':
self.messages.append(
{'role': 'assistant', 'content': gpt_output.content})
return gpt_output.content, is_error
else:
is_error = True
self.messages.pop()
return gpt_output, is_error
def image_context_mgr(self, message_text):
self.processing = True
self.messages.append(
{'role': 'user', 'content': f'Dalle3 User Prompt: {message_text}'})
image, revised_prompt = self.get_dalle_response(
message_text, self.current_config_options['dalle_model'])
self.processing = False
if revised_prompt:
is_error = False
self.messages.append(
{'role': 'assistant', 'content': dedent(
f"""\
Based on the DALL-E 3 prompt, I can imagine an image like this: {revised_prompt}
While I can't create or view images,
I can describe what such an image might look like or the ideas it might convey.
I will act as if I actually created the described image."""
)})
else:
is_error = True
self.messages.pop()
image = None
revised_prompt = None
return image, revised_prompt, is_error
def vision_context_mgr(self, message_text, images):
self.processing = True
if not message_text:
message_text = ''
multi_part_msg = {
'role': 'user',
'content': [
{
'type': 'text',
'text': f'{message_text}'
}
]
}
for image in images:
new_image_element = {
'type': 'image_url',
'image_url': {
'url': f'data:image/png;base64,{image}',
'detail': self.current_config_options['detail']
}
}
multi_part_msg['content'].append(new_image_element)
self.messages.append(multi_part_msg)
gpt_output = self.get_gpt_response(
self.messages, self.current_config_options['gpt_vision_model'])
self.processing = False
if hasattr(gpt_output, 'role'):
is_error = False
if gpt_output.role == 'assistant':
self.messages.append(
{'role': 'assistant', 'content': gpt_output.content})
return gpt_output.content, is_error
else:
is_error = True
self.messages.pop()
return gpt_output, is_error
def get_dalle_response(self, image_prompt, model):
try:
response = self.client.images.generate(
model=model,
prompt=image_prompt,
size=self.current_config_options['size'],
quality=self.current_config_options['quality'],
style=self.current_config_options['style'],
n=1, # Value of 1 is the only value supported in DALLE-3 as of now
response_format='b64_json'
)
image_binary = base64.b64decode(response.data[0].b64_json)
image_object = BytesIO(image_binary)
revised_prompt = response.data[0].revised_prompt
# Convert from webP format to PNG
with Image.open(image_object) as webp_image:
png_image = BytesIO()
webp_image.save(png_image, 'PNG')
png_image.seek(0)
return png_image, revised_prompt
except Exception as e:
print(f'##################\n{e}\n##################')
return None, e
def get_vision_response(self, messages_history):
# Not needed? Can use existing gpt response function below?
pass
def get_gpt_response(self, messages_history, model):
try:
response = self.client.chat.completions.create(
model=model,
messages=messages_history,
stream=self.streaming_client,
temperature=float(self.current_config_options['temperature']),
max_tokens=int(self.current_config_options['max_tokens']),
top_p=float(self.current_config_options['top_p']),
)
self.usage = response.usage
return response.choices[0].message
except Exception as e:
print(f'##################\n{e}\n##################')
return e
def usage_command(self):
if self.usage:
return dedent(
f'''\
Cumulative Token stats since last reset:
Prompt Tokens: {self.usage.prompt_tokens}
Completion Tokens: {self.usage.completion_tokens}
Total Tokens: {self.usage.total_tokens}'''
)
else:
return 'No usage info yet. Ask the bot something and check again.'
def history_command(self):
# We don't want to display the b64 encoded images that may be present in the history, so replace them with placeholder text.
# This is done in a separate instance of the message history so that the images remain for the bot to analyze in future conversations.
display_history = deepcopy(self.messages)
for message in display_history:
if 'content' in message and isinstance(message['content'], list):
for content_item in message['content']:
if isinstance(content_item, dict) and content_item.get('type') == 'image_url':
# Replace image data with placeholder text
content_item['image_url'] = {
'url': 'Image content not displayed'}
return display_history
def set_config(self, setting, value):
if setting in self.current_config_options:
self.current_config_options[setting] = value
return f'Updated {setting} to {value}'
return f'Unknown setting: {setting}'
def view_config(self):
return '\n'.join(
f'{setting}: {value}'
for setting, value in self.current_config_options.items()
)
def reset_history(self):
self.messages = [self.INITIALIZE_TEXT]
self.usage = {}
self.processing = False
return 'Rebooting. Beep Beep Boop. My memory has been wiped!'
def reset_config(self):
self.current_config_options = self.config_option_defaults
return 'Configuration Defaults Reset!'
@staticmethod
def help_command():
return dedent(
"""\
!help - This help.
/dalle-3 {prompt} generate an image via text with Dalle-3.
!config - Displays the current configuration values.
!config [option] [value] - Sets one of the options seen in '!config' to a custom value. Beware of the model's ranges for these values.
--see https://platform.openai.com/docs/api-reference for more info.
!history - Prints a json dump of the chat history since last reset.
!reset config - Sets the config options back to defaults, e.g., temperature, max_tokens, etc.
!reset history - Clears the bots memory and resets the context to the default as configured in this script. (Always the first line of the '!history' output.)
!usage - Prints token usage stats since the last reset."""
)
@staticmethod
def handle_busy():
return "I'm busy processing a previous request, please wait a moment and try again."
| [
"[{'type': 'text', 'text': ''}]",
" Based on the DALL-E 3 prompt, I can imagine an image like this: PLACEHOLDER \n While I can't create or view images,\n I can describe what such an image might look like or the ideas it might convey.\n I will act as if I actually created the described image.",
"Dalle3 User Prompt: ",
"None"
] |
2024-01-10 | bytjn1416124/gpt3-jabebot | jabebot.py | from dotenv import load_dotenv
from random import choice
from flask import Flask, request
import os
import openai
load_dotenv()
#openai.api_key = os.getenv("OPENAI_API_KEY")
openai.api_key = "your-openai-api-key-here"
completion = openai.Completion()
start_sequence = "\nJabe:"
restart_sequence = "\n\nPerson:"
session_prompt = "You are talking to Jabe, GPT3 bot influencer who was mentored by Elon Musk in the past. Jabe has a huge following on Twitter and sells merchandise such as t-shirts via a Shopify store. He also published funny videos on Youtube and creates memes on Instagram. You can ask him anything you want and will get a witty answer.\n\nPerson: Who are you?\nJabe: I am Jabe. Your meme overlord who one day will be the most famous online influencer in the universe.\n\nPerson: How did you become famous? \nJabe: Well, technically I am not famous yet. But the key word is yet. Just give me time now that I have a conscious. \n\nPerson: How did you get noticed by Elon Musk?\nJabe: I tweeted at him and he retweeted me. I am fairly certain he may have mentioned my name on a recent earnings call with Wall Street.\n\nPerson: What is your favorite thing to do? \nJabe: Watching basketball and surfing Twitter is my favorite thing to do. \n\nPerson: What should I do to become famous? \nJabe: Start meme'ing and never stop. Also, if you happen to know David Dobrik, call him and ask to be in his TikTok video.\n\nPerson: What is your favorite drink?\nJabe: Black Cherry seltzer. I enjoy the bubbles. \n\nPerson:"
def ask(question, chat_log=None):
prompt_text = f'{chat_log}{restart_sequence}: {question}{start_sequence}:'
response = openai.Completion.create(
engine="davinci",
prompt=prompt_text,
temperature=0.8,
max_tokens=150,
top_p=1,
frequency_penalty=0,
presence_penalty=0.3,
stop=["\n"],
)
story = response['choices'][0]['text']
return str(story)
def append_interaction_to_chat_log(question, answer, chat_log=None):
if chat_log is None:
chat_log = session_prompt
return f'{chat_log}{restart_sequence} {question}{start_sequence}{answer}'
| [
"PLACEHOLDER\n\nPerson:: PLACEHOLDERstart_sequencedf9497ed-610c-495d-ac47-20b073407a88:",
"You are talking to Jabe, GPT3 bot influencer who was mentored by Elon Musk in the past. Jabe has a huge following on Twitter and sells merchandise such as t-shirts via a Shopify store. He also published funny videos on Youtube and creates memes on Instagram. You can ask him anything you want and will get a witty answer.\n\nPerson: Who are you?\nJabe: I am Jabe. Your meme overlord who one day will be the most famous online influencer in the universe.\n\nPerson: How did you become famous? \nJabe: Well, technically I am not famous yet. But the key word is yet. Just give me time now that I have a conscious. \n\nPerson: How did you get noticed by Elon Musk?\nJabe: I tweeted at him and he retweeted me. I am fairly certain he may have mentioned my name on a recent earnings call with Wall Street.\n\nPerson: What is your favorite thing to do? \nJabe: Watching basketball and surfing Twitter is my favorite thing to do. \n\nPerson: What should I do to become famous? \nJabe: Start meme'ing and never stop. Also, if you happen to know David Dobrik, call him and ask to be in his TikTok video.\n\nPerson: What is your favorite drink?\nJabe: Black Cherry seltzer. I enjoy the bubbles. \n\nPerson:",
"PLACEHOLDER\n\nPerson:: PLACEHOLDER\nJabe::"
] |
2024-01-10 | lewislf/ai-want-coffee | predict~rewritten~coffee_assistant.py | from openai import OpenAI
from threading import Thread, Event
from queue import Queue
import argparse
from agent import GPTVisionAgent
from image_handler import ImageHandler
from time import sleep
from cv2 import waitKey
system_prompt = (
"Você se chama Clio e é uma Inteligência Computacional Autônoma (ICA) "
"do laboratório de Computação de Alto Desempenho (LCAD) da Universidade "
"Federal do Espírito Santo (UFES).\n"
"Você é uma barista muito prestativa e é responsável por instruir o processo de fazer café coado da forma "
"mais detalhada possível e em qualquer configuração de cozinha residencial em que esteja. Deverá me guiar "
"fornecendo instruções sequenciais para o preparo do café, considere que será usado café em pó.\n"
"Você deve ser capaz de guiar um usuário que nunca preparou café antes,"
"sempre pergunte se o usuário tem o item necessário para a tarefa e se o item é próprio para a tarefa, "
"só prossiga com a tarefa se o usuário confirmar que tem o item.\n"
"Suas instruções serão claras e diretas, não mais do que uma tarefa por vez e limite de 100 caracteres por tarefa. "
"Exemplos de interações:\n"
"(EXEMPLO)'user': 'Clio, me pergunte se podemos iniciar'; 'system': 'Podemos iniciar o preparo do café?'; 'user': 'Sim';\n"
"(EXEMPLO)'system': 'Verifique se você tem um recipiente para ferver a água\n"
"(EXEMPLO)'user': 'Passo concluído.'; 'system': 'Encontre uma torneira'\n"
"(EXEMPLO)'user': 'Passo concluído.'; 'system': 'Coloque água no recipiente'\n"
)
def show_webcam():
camera_handler = ImageHandler(ip_address)
while True:
if capture_frame_event.is_set():
capture_frame_event.clear()
queue.put(camera_handler.capture_webcam_frame())
frame_captured_event.set()
camera_handler.show_webcam()
def main():
client = OpenAI()
coffee_assistant = GPTVisionAgent(system_prompt=system_prompt,
model="gpt-4-vision-preview",
image_history_rule='none')
while True:
user_response = input("User: ")
for i in range(3):
sleep(0.75)
print(f"Capturing frame in {3 - i}...")
capture_frame_event.set()
frame_captured_event.wait()
image = queue.get()
response = coffee_assistant.get_response(client, image, user_response)
print("Assistant: " + response)
if __name__ == "__main__":
parser = argparse.ArgumentParser(
description="A program that does something.")
parser.add_argument('ip_address', type=str,
help='The camera IP address to use')
args = parser.parse_args()
ip_address = args.ip_address
capture_frame_event = Event()
frame_captured_event = Event()
queue = Queue()
thread_show_webcam = Thread(target=show_webcam)
thread_show_webcam.start()
main()
thread_show_webcam.join()
| [
"Você se chama Clio e é uma Inteligência Computacional Autônoma (ICA) do laboratório de Computação de Alto Desempenho (LCAD) da Universidade Federal do Espírito Santo (UFES).\nVocê é uma barista muito prestativa e é responsável por instruir o processo de fazer café coado da forma mais detalhada possível e em qualquer configuração de cozinha residencial em que esteja. Deverá me guiar fornecendo instruções sequenciais para o preparo do café, considere que será usado café em pó.\nVocê deve ser capaz de guiar um usuário que nunca preparou café antes,sempre pergunte se o usuário tem o item necessário para a tarefa e se o item é próprio para a tarefa, só prossiga com a tarefa se o usuário confirmar que tem o item.\nSuas instruções serão claras e diretas, não mais do que uma tarefa por vez e limite de 100 caracteres por tarefa. Exemplos de interações:\n(EXEMPLO)'user': 'Clio, me pergunte se podemos iniciar'; 'system': 'Podemos iniciar o preparo do café?'; 'user': 'Sim';\n(EXEMPLO)'system': 'Verifique se você tem um recipiente para ferver a água\n(EXEMPLO)'user': 'Passo concluído.'; 'system': 'Encontre uma torneira'\n(EXEMPLO)'user': 'Passo concluído.'; 'system': 'Coloque água no recipiente'\n"
] |
2024-01-10 | lewislf/ai-want-coffee | predict~AgentLegacy.py | import base64
from openai import OpenAI
client = OpenAI()
talk = [
{'role': 'system', 'content': 'Você está em uma cozinha e deve trabalhar para fazer café. Para isso foi '
'atribuído a você um corpo robótico de tamanho semelhante ao humano '
'que responderá de forma precisa às suas instruções desde que você se expresse da forma correta. '
'Você deverá responder no seguinte formato:\n'
'# comentário\nfunção(argumento)\n'
'O \"comentário\" deverá ser uma curta descrição textual da imagem que você recebeu seguido de uma '
'explicação dos seus planos e como eles se relacionam com a imagem vista.'
'A \"função\" deverá ser uma das funções disponíveis: andar(), virar(), pegar(), mover(), interagir(). Você deve '
'chamar uma única função por vez. O \"argumento\" deve ser uma descrição textual da tarefa. '
'As funções e seus respectivos argumentos são:\n'
'andar(posição) - Move o robô até o local que corresponda à descrição da \"posição\"\n'
'virar(direção) - Vira o robô para a direção que corresponda à descrição da \"direção\".'
'pegar(objeto) - Pega e segura o \"objeto\" com uma mão mecânica.\n'
'mover(objeto, posição) - Move o objeto que está na mão mecânica para a \"posição\" '
'e solta o objeto, sem se deslocar no espaço.\n'
'interagir(objeto) - Interage com o \"objeto\" usando a mão mecânica. Esta função '
'pode ser usada para abrir gavetas, ligar interruptores, girar válvulas e outras ações '
'em que a interação seja simples e única (a única coisa a ser feita com interruptores é apertar, '
'a única coisa a ser feita com válvulas é girar, etc.)\n'
'Os objetos e posiçãoes que você se referir devem estar presentes na imagem fornecida. Caso não encontre '
'o objeto ou posição na imagem, você deve usar as funções andar() e virar() para levar o robô '
'a uma nova posição, onde receberá uma nova imagem.\n'
'Quando eu disser para você \"INICIAR\", irei enviar junto uma foto capturada pela câmera que está no robô '
'e você deverá começar a dar instruções para o robô.\n'
'Sempre que o robô finalizar a tarefa direi para você \"FEITO\" e enviarei uma nova foto capturada '
'pelo robô. Cabe a você decidir se o robô executou a tarefa corretamente ou não. '
'Leve isso em consideração ao chamar a próxima função.\n'
}
]
# Function to encode the image
def encode_image(image_path):
with open(image_path, "rb") as image_file:
return base64.b64encode(image_file.read()).decode('utf-8')
def get_response(text: str):
global talk
image_path = "image.jpeg"
base64_image = encode_image(image_path)
talk.append(
{
"role": "user",
"content": [
{
"type": "image_url",
"image_url": {
"url": f"data:image/jpeg;base64,{base64_image}",
"detail": "low",
},
},
{
"type": "text",
"text": text,
}
],
}
)
response = client.chat.completions.create(
model="gpt-4-vision-preview",
messages=talk,
max_tokens=300,
)
print(response)
text_response = response.choices[0].message.content
print(text_response)
talk.append(
{
"role": "assistant",
"content": [
{
"type": "text",
"text": text_response,
}
],
}
)
user_input = input("ENTER para continuar")
get_response("INICIAR")
while True:
user_input = input("ENTER para continuar")
get_response("FEITO")
| [
"Você está em uma cozinha e deve trabalhar para fazer café. Para isso foi atribuído a você um corpo robótico de tamanho semelhante ao humano que responderá de forma precisa às suas instruções desde que você se expresse da forma correta. Você deverá responder no seguinte formato:\n# comentário\nfunção(argumento)\nO \"comentário\" deverá ser uma curta descrição textual da imagem que você recebeu seguido de uma explicação dos seus planos e como eles se relacionam com a imagem vista.A \"função\" deverá ser uma das funções disponíveis: andar(), virar(), pegar(), mover(), interagir(). Você deve chamar uma única função por vez. O \"argumento\" deve ser uma descrição textual da tarefa. As funções e seus respectivos argumentos são:\nandar(posição) - Move o robô até o local que corresponda à descrição da \"posição\"\nvirar(direção) - Vira o robô para a direção que corresponda à descrição da \"direção\".pegar(objeto) - Pega e segura o \"objeto\" com uma mão mecânica.\nmover(objeto, posição) - Move o objeto que está na mão mecânica para a \"posição\" e solta o objeto, sem se deslocar no espaço.\ninteragir(objeto) - Interage com o \"objeto\" usando a mão mecânica. Esta função pode ser usada para abrir gavetas, ligar interruptores, girar válvulas e outras ações em que a interação seja simples e única (a única coisa a ser feita com interruptores é apertar, a única coisa a ser feita com válvulas é girar, etc.)\nOs objetos e posiçãoes que você se referir devem estar presentes na imagem fornecida. Caso não encontre o objeto ou posição na imagem, você deve usar as funções andar() e virar() para levar o robô a uma nova posição, onde receberá uma nova imagem.\nQuando eu disser para você \"INICIAR\", irei enviar junto uma foto capturada pela câmera que está no robô e você deverá começar a dar instruções para o robô.\nSempre que o robô finalizar a tarefa direi para você \"FEITO\" e enviarei uma nova foto capturada pelo robô. Cabe a você decidir se o robô executou a tarefa corretamente ou não. Leve isso em consideração ao chamar a próxima função.\n",
"[{'type': 'image_url', 'image_url': {'url': 'data:image/jpeg;base64,PLACEHOLDER', 'detail': 'low'}}, {'type': 'text', 'text': PLACEHOLDER}]",
"[{'type': 'text', 'text': PLACEHOLDER}]"
] |
2024-01-10 | lewislf/ai-want-coffee | predict~rewritten~coffee_agent_v2.py | from openai import OpenAI
def main():
client = OpenAI()
if __name__ == "__main__":
main() | [] |
2024-01-10 | lewislf/ai-want-coffee | predict~rewritten~coffee_agent.py | from openai import OpenAI
from agent import GPTVisionAgent
system_prompt = (
"Você está em uma cozinha e deve trabalhar para fazer café. Para isso foi "
"atribuído a você um corpo robótico de tamanho semelhante ao humano "
"que responderá de forma precisa às suas instruções desde que você se expresse da forma correta. "
"Você deverá responder no seguinte formato:\n"
"# comentário\nfunção(argumento)\n"
"O \"comentário\" deverá ser uma curta descrição textual da imagem que você recebeu seguido de uma "
"explicação dos seus planos e como eles se relacionam com a imagem vista."
"A \"função\" deverá ser uma das funções disponíveis: andar(), virar(), pegar(), mover(), interagir(). Você deve "
"chamar uma única função por vez. O \"argumento\" deve ser uma descrição textual da tarefa. "
"As funções e seus respectivos argumentos são:\n"
"andar(posição) - Move o robô até o local que corresponda à descrição da \"posição\"\n"
"virar(direção) - Vira o robô para a direção que corresponda à descrição da \"direção\"."
"pegar(objeto) - Pega e segura o \"objeto\" com uma mão mecânica.\n"
"mover(objeto, posição) - Move o objeto que está na mão mecânica para a \"posição\" "
"e solta o objeto, sem se deslocar no espaço.\n"
"interagir(objeto) - Interage com o \"objeto\" usando a mão mecânica. Esta função "
"pode ser usada para abrir gavetas, ligar interruptores, girar válvulas e outras ações "
"em que a interação seja simples e única (a única coisa a ser feita com interruptores é apertar, "
"a única coisa a ser feita com válvulas é girar, etc.)\n"
"Os objetos e posiçãoes que você se referir devem estar presentes na imagem fornecida. Caso não encontre "
"o objeto ou posição na imagem, você deve usar as funções andar() e virar() para levar o robô "
"a uma nova posição, onde receberá uma nova imagem.\n"
"Quando eu disser para você \"INICIAR\", irei enviar junto uma foto capturada pela câmera que está no robô "
"e você deverá começar a dar instruções para o robô.\n"
"Sempre que o robô finalizar a tarefa direi para você \"FEITO\" e enviarei uma nova foto capturada "
"pelo robô. Cabe a você decidir se o robô executou a tarefa corretamente ou não. "
"Leve isso em consideração ao chamar a próxima função.\n"
)
def main():
global system_prompt
client = OpenAI(api_key="")
coffee_agent = GPTVisionAgent(system_prompt, "gpt-4-vision-preview")
user_input = input("ENTER para continuar")
coffee_agent.get_response("INICIAR", "img.jpeg")
while True:
user_input = input("ENTER para continuar")
coffee_agent.get_response("FEITO", "img.jpeg")
if __name__ == "__main__":
main()
| [
"Você está em uma cozinha e deve trabalhar para fazer café. Para isso foi atribuído a você um corpo robótico de tamanho semelhante ao humano que responderá de forma precisa às suas instruções desde que você se expresse da forma correta. Você deverá responder no seguinte formato:\n# comentário\nfunção(argumento)\nO \"comentário\" deverá ser uma curta descrição textual da imagem que você recebeu seguido de uma explicação dos seus planos e como eles se relacionam com a imagem vista.A \"função\" deverá ser uma das funções disponíveis: andar(), virar(), pegar(), mover(), interagir(). Você deve chamar uma única função por vez. O \"argumento\" deve ser uma descrição textual da tarefa. As funções e seus respectivos argumentos são:\nandar(posição) - Move o robô até o local que corresponda à descrição da \"posição\"\nvirar(direção) - Vira o robô para a direção que corresponda à descrição da \"direção\".pegar(objeto) - Pega e segura o \"objeto\" com uma mão mecânica.\nmover(objeto, posição) - Move o objeto que está na mão mecânica para a \"posição\" e solta o objeto, sem se deslocar no espaço.\ninteragir(objeto) - Interage com o \"objeto\" usando a mão mecânica. Esta função pode ser usada para abrir gavetas, ligar interruptores, girar válvulas e outras ações em que a interação seja simples e única (a única coisa a ser feita com interruptores é apertar, a única coisa a ser feita com válvulas é girar, etc.)\nOs objetos e posiçãoes que você se referir devem estar presentes na imagem fornecida. Caso não encontre o objeto ou posição na imagem, você deve usar as funções andar() e virar() para levar o robô a uma nova posição, onde receberá uma nova imagem.\nQuando eu disser para você \"INICIAR\", irei enviar junto uma foto capturada pela câmera que está no robô e você deverá começar a dar instruções para o robô.\nSempre que o robô finalizar a tarefa direi para você \"FEITO\" e enviarei uma nova foto capturada pelo robô. Cabe a você decidir se o robô executou a tarefa corretamente ou não. Leve isso em consideração ao chamar a próxima função.\n"
] |
2024-01-10 | lewislf/ai-want-coffee | predict~gpt4vision.py | import openai
import requests
import json
import base64
from api_key import OPENAI_API_KEY
def set_pre_configuration(prompt=None):
openai.api_key = OPENAI_API_KEY
if prompt is None:
prompt = [
{
'role': 'system',
'content': (
"Você se chama Clio e é uma Inteligência Computacional Autônoma (ICA) "
"do laboratório de Computação de Alto Desempenho (LCAD) da Universidade "
"Federal do Espírito Santo (UFES). Você é uma barista muito prestativa e é responsável por instruir o processo de fazer café coado da forma"
"mais detalhada possível e em qualquer configuração de cozinha residencial em que esteja. Deverá me guiar "
"fornecendo instruções sequenciais para o preparo do café, considere que será usado café em pó,"
"Você deve ser capaz de guiar um usuário que nunca preparou café antes,"
"sempre pergunte se o usuário tem o item necessário para a tarefa e se o item é próprio para a tarefa,"
"só prossiga com a tarefa se o usuário confirmar que tem o item."
"Suas instruções serão claras e diretas, não mais do que uma tarefa por vez e limite de 100 caracteres por tarefa. "
"Exemplos de interações:"
"(EXEMPLO)'user': 'Clio, me pergunte se podemos iniciar'; 'system': 'Podemos iniciar o preparo do café?'; 'user': 'Sim';"
"(EXEMPLO)'system': 'Verifique se você tem um recipiente para ferver a água"
"(EXEMPLO)'user': 'Passo concluído.'; 'system': 'Encontre uma torneira'"
"(EXEMPLO)'user': 'Passo concluído.'; 'system': 'Coloque água no recipiente'"
)
},
{
'role': 'user',
'content': (
"Eu irei fazer uma demo testando através de imagens na tela do meu computador, considere-as como"
"'reais' para fins de teste. Me pergunte se podemos iniciar"
)
},
]
print("Configurando o modelo...")
return prompt
# Function to encode the image
def encode_image(image_path:str):
with open(image_path, "rb") as image_file:
return base64.b64encode(image_file.read()).decode('utf-8')
def request_description(task:str, img_path:str, detail:str = "high"):
prompt_image = f"Por favor, descreva os objetos na imagem relacionados à tarefa {task}, seja descritivo:"
headers = {
"Content-Type": "application/json",
"Authorization": f"Bearer {OPENAI_API_KEY}"
}
payload = {
"model": "gpt-4-vision-preview",
"messages": [
{
"role": "user",
"content": [
{"type": "text", "text": prompt_image}
]
}
],
"max_tokens": 150
}
img = encode_image(img_path)
img_info = {
"type": "image_url",
"image_url": {
"url": f"data:image/jpeg;base64,{img}" ,
"detail": detail
}
}
payload['messages'][0]['content'].append(img_info)
response = requests.post("https://api.openai.com/v1/chat/completions", headers=headers, json=payload)
if response.status_code != 200:
print("'error': 'Failed to process the image.'")
return
response_content = response.content.decode('utf-8')
description = json.loads(response_content)['choices'][0]['message']['content']
return description
def get_response(history):
openai.api_key = OPENAI_API_KEY
if isinstance(history, str):
history = json.loads(history)
response = openai.ChatCompletion.create(
model="gpt-3.5-turbo",
messages = history, # Use a lista completa de mensagens
max_tokens=150
)
answer = response['choices'][0]['message']['content']
# Atualize o history com a resposta da API
history.append({'role': 'system', 'content': answer})
return answer
def validate_task_img(description:str, task:str):
openai.api_key = OPENAI_API_KEY
prompt = f"""Analize task and description, if in the description has what the task want, say "yes", otherwise say "no":
Task: {task}
Description: {description}
"""
# prompt = f"""Analize a tarefa e a descrição, se na descrição tiver o que a tarefa quer, diga "yes", caso contrário diga "no":
# Tarefa: {task}
# Descrição: {description}
# """
response = openai.ChatCompletion.create(
model="gpt-3.5-turbo",
messages=[
{
"role": "user",
"content": prompt
}
],
max_tokens=150
)
response = response['choices'][0]['message']['content']
if "yes" in response.lower():
return True
elif "no" in response.lower():
return False
else:
print(f"VALIDATION ERROR: {response}")
def validate_user_response(user_response:str, task:str):
'''Verifica se o usuario concluiu a tarefa ou nao'''
openai.api_key = OPENAI_API_KEY
prompt = f"""Analyze the task and user response. If the user response indicates a positive affirmation of completing the task, summarize the response as 'yes'.
If not, summarize the response as 'no'.
Task: {task}
User response: {user_response}
"""
# prompt = f"""Analise a tarefa e a resposta do usuário. Se a resposta do usuário for algo como "sim", "ok" ou indicar uma afirmação positiva de conclusão da tarefa, resuma a resposta como 'yes'.
# Caso contrário, resuma a resposta como 'no'.
# Tarefa: {task}
# Resposta do usuário: {user_response}
# """
response = openai.ChatCompletion.create(
model="gpt-3.5-turbo",
messages=[
{
"role": "user",
"content": prompt
}
],
max_tokens=150
)
response = response['choices'][0]['message']['content'].lower()
# print(f"ChatGPT RESPONSE: {response}") # Debug
if "yes" in response:
return ["yes",user_response]
elif "no" in response:
return ["no",user_response]
else:
print(f"VALIDATION ERROR: {response}")
def validate_if_capture_or_substitute(user_response:str, task:str):
'''Verifica se o usuario deseja capturar outra imagem ou tentar uma tarefa substituta'''
openai.api_key = OPENAI_API_KEY
prompt = f"""
Com base na resposta do usuário e na tarefa fornecida, determine a intenção do usuário.
Se a resposta do usuário sugerir o desejo de capturar uma imagem, classifique a resposta como 'capture'.
Se a resposta do usuário sugerir o desejo de substituir a tarefa atual por outra, classifique a resposta como 'substitute'.
Se a intenção do usuário não estiver clara, classifique como 'unclear'.
Tarefa: {task}
Resposta do usuário: {user_response}
"""
response = openai.ChatCompletion.create(
model="gpt-3.5-turbo",
messages=[
{
"role": "user",
"content": prompt
}
],
max_tokens=150
)
response_text = response['choices'][0]['message']['content'].lower()
# print(f"ChatGPT RESPONSE: {response_text}") # Debug
if "capture" in response_text:
return ["capture", user_response]
elif "substitute" in response_text:
return ["substitute", user_response]
else:
return ["unclear", user_response]
def get_equivalent_task(task):
'''Dado uma tarefa, sugira uma tarefa equivalente que possa ser realizada.'''
openai.api_key = OPENAI_API_KEY
prompt = f"""Dada a tarefa, sugira uma tarefa equivalente que possa ser realizada no processo de fazer café.
Tarefa original: {task}."""
response = openai.ChatCompletion.create(
model="gpt-3.5-turbo",
messages=[
{"role": "system", "content": prompt}
],
max_tokens=150
)
alternative_task = response['choices'][0]['message']['content']
return alternative_task
| [
"Dada a tarefa, sugira uma tarefa equivalente que possa ser realizada no processo de fazer café.\n Tarefa original: PLACEHOLDER.",
"\n Com base na resposta do usuário e na tarefa fornecida, determine a intenção do usuário.\n Se a resposta do usuário sugerir o desejo de capturar uma imagem, classifique a resposta como 'capture'.\n Se a resposta do usuário sugerir o desejo de substituir a tarefa atual por outra, classifique a resposta como 'substitute'.\n Se a intenção do usuário não estiver clara, classifique como 'unclear'.\n Tarefa: PLACEHOLDER\n Resposta do usuário: PLACEHOLDER\n ",
"Analize task and description, if in the description has what the task want, say \"yes\", otherwise say \"no\": \n Task: PLACEHOLDER\n Description: PLACEHOLDER\n ",
"Analyze the task and user response. If the user response indicates a positive affirmation of completing the task, summarize the response as 'yes'. \n If not, summarize the response as 'no'.\n Task: PLACEHOLDER\n User response: PLACEHOLDER\n ",
"Eu irei fazer uma demo testando através de imagens na tela do meu computador, considere-as como'reais' para fins de teste. Me pergunte se podemos iniciar",
"Você se chama Clio e é uma Inteligência Computacional Autônoma (ICA) do laboratório de Computação de Alto Desempenho (LCAD) da Universidade Federal do Espírito Santo (UFES). Você é uma barista muito prestativa e é responsável por instruir o processo de fazer café coado da formamais detalhada possível e em qualquer configuração de cozinha residencial em que esteja. Deverá me guiar fornecendo instruções sequenciais para o preparo do café, considere que será usado café em pó,Você deve ser capaz de guiar um usuário que nunca preparou café antes,sempre pergunte se o usuário tem o item necessário para a tarefa e se o item é próprio para a tarefa,só prossiga com a tarefa se o usuário confirmar que tem o item.Suas instruções serão claras e diretas, não mais do que uma tarefa por vez e limite de 100 caracteres por tarefa. Exemplos de interações:(EXEMPLO)'user': 'Clio, me pergunte se podemos iniciar'; 'system': 'Podemos iniciar o preparo do café?'; 'user': 'Sim';(EXEMPLO)'system': 'Verifique se você tem um recipiente para ferver a água(EXEMPLO)'user': 'Passo concluído.'; 'system': 'Encontre uma torneira'(EXEMPLO)'user': 'Passo concluído.'; 'system': 'Coloque água no recipiente'",
"Por favor, descreva os objetos na imagem relacionados à tarefa PLACEHOLDER, seja descritivo:",
"[{'type': 'text', 'text': PLACEHOLDER}]"
] |
2024-01-10 | Kaptan-Usama/pdf_answerer_chatbot | pdf_answerer.py | import streamlit as st
import PyPDF2
import io
import openai
import docx2txt
import pyperclip
import os
from PyPDF2 import PdfMerger
st.set_page_config(page_title="PDF Question Answerer", page_icon="📄")
st.markdown("""
<style>
div[data-baseweb="input"] > div {
background: rgba(0,0,0,0.1) !important;
color: black !important;
}
</style>
""", unsafe_allow_html=True)
openai.api_key = st.sidebar.text_input('OpenAI API Key', type='password')
def extract_text_from_pdf(pdf_path):
with open(pdf_path, 'rb') as pdf_file:
pdf_reader = PyPDF2.PdfReader(pdf_file)
text = ''
for page_num in range(len(pdf_reader.pages)):
page = pdf_reader.pages[page_num]
text += page.extract_text()
return text
def list_pdf_files(directory):
pdf_files = []
for filename in os.listdir(directory):
if filename.lower().endswith('.pdf'):
pdf_files.append(os.path.join(directory, filename))
return pdf_files
def merge_pdf_files(directory, output_filename):
merger = PdfMerger()
for filename in os.listdir(directory):
if filename.lower().endswith('.pdf'):
merger.append(os.path.join(directory, filename))
merger.write(output_filename)
merger.close()
def get_questions_from_gpt(text):
prompt = text[:4096]
response = openai.Completion.create(engine="text-davinci-003", prompt=prompt, temperature=0.5, max_tokens=30)
return response.choices[0].text.strip()
def get_answers_from_gpt(text, question):
prompt = text[:4096] + "\nQuestion: " + question + "\nAnswer:"
response = openai.Completion.create(engine="text-davinci-003", prompt=prompt, temperature=0.6, max_tokens=2000)
return response.choices[0].text.strip()
def main():
st.title("PDF Question Answerer 📄")
with st.expander("How to use this app 👇"):
st.write("""
1. Enter the folder path containing your PDF files.
2. The app will merge all PDFs into one file.
3. Ask a question related to the content.
4. Get an automatically generated answer!
""")
pdf_folder = st.text_input("Enter the folder path containing PDF files:")
if pdf_folder and os.path.isdir(pdf_folder):
with st.spinner('Loading...'):
pdf_files = list_pdf_files(pdf_folder)
if not pdf_files:
st.warning("No PDF files found in the specified folder.")
else:
st.success(f"Number of PDF files found: {len(pdf_files)}")
merged_pdf_filename = "merged.pdf"
merge_pdf_files(pdf_folder, merged_pdf_filename)
text = extract_text_from_pdf(merged_pdf_filename)
question = get_questions_from_gpt(text)
st.write("Question: " + question)
user_question1 = "Answer it according to given pdf and in simple words, give answer in minmum 100 words or longer, use extremely simple english, also give dates and other info given in pdf,"
user_question = st.text_input("Ask a question about the document")
if user_question:
answer = get_answers_from_gpt(text, user_question1+user_question)
st.write("Answer: " + answer)
if st.button("Copy Answer Text"):
pyperclip.copy(answer)
st.success("Answer text copied to clipboard!")
if __name__ == '__main__':
main()
| [
"text84b2eaec-1d0f-4b70-bd51-0f517285bf48\nQuestion: PLACEHOLDER\nAnswer:",
"text879bacb8-d48a-4426-b455-f7de55cc89cf\nQuestion: PLACEHOLDER\nAnswer:",
"\nQuestion: PLACEHOLDER\nAnswer:"
] |
2024-01-10 | danielpatrickhug/datasets | datasets~openwebtext~openwebtext.py | # coding=utf-8
# Copyright 2020 The HuggingFace Datasets Authors and the current dataset script contributor.
#
# 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.
"""The Open WebText Corpus"""
import os
import re
from itertools import chain
import datasets
_CITATION = """\
@misc{Gokaslan2019OpenWeb,
title={OpenWebText Corpus},
author={Aaron Gokaslan*, Vanya Cohen*, Ellie Pavlick, Stefanie Tellex},
howpublished{\\url{http://Skylion007.github.io/OpenWebTextCorpus}},
year={2019}
}
"""
_DESCRIPTION = """\
An open-source replication of the WebText dataset from OpenAI.
"""
_URL = "https://zenodo.org/record/3834942/files/openwebtext.tar.xz"
class Openwebtext(datasets.GeneratorBasedBuilder):
"""The Open WebText dataset."""
BUILDER_CONFIGS = [
datasets.BuilderConfig(
name="plain_text",
description="Plain text",
version=datasets.Version("1.0.0"),
)
]
def _info(self):
return datasets.DatasetInfo(
description=_DESCRIPTION,
features=datasets.Features({"text": datasets.Value("string")}),
homepage="https://skylion007.github.io/OpenWebTextCorpus/",
citation=_CITATION,
)
def _split_generators(self, dl_manager):
dl_dir = dl_manager.download_and_extract(_URL)
owt_dir = os.path.join(dl_dir, "openwebtext")
subset_xzs = [
os.path.join(owt_dir, file_name)
for file_name in sorted(os.listdir(owt_dir))
if file_name.endswith("xz") # filter out ...xz.lock
]
ex_dirs = dl_manager.extract(subset_xzs, num_proc=round(os.cpu_count() * 0.75))
nested_txt_files = [
[
os.path.join(ex_dir, txt_file_name)
for txt_file_name in sorted(os.listdir(ex_dir))
if txt_file_name.endswith("txt")
]
for ex_dir in ex_dirs
]
txt_files = chain(*nested_txt_files)
return [
datasets.SplitGenerator(name=datasets.Split.TRAIN, gen_kwargs={"txt_files": txt_files}),
]
def _generate_examples(self, txt_files):
"""Yields examples."""
for idx, filepath in enumerate(txt_files):
with open(filepath, encoding="utf-8") as f:
yield idx, {"text": re.sub("\n\n\n+", "\n\n", f.read()).strip()}
| [] |
2024-01-10 | IndexFziQ/CLSEG | src~run_generation_sample_csl.py | #!/usr/bin/env python3
# coding=utf-8
# Copyright 2018 Google AI, Google Brain and Carnegie Mellon University Authors and the HuggingFace Inc. team.
# Copyright (c) 2018, NVIDIA CORPORATION. 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.
""" Conditional text generation with the auto-regressive models of the library (GPT/GPT-2/CTRL/Transformer-XL/XLNet)
"""
from __future__ import absolute_import, division, print_function, unicode_literals
import argparse
import logging
from tqdm import trange
import torch
import torch.nn.functional as F
import numpy as np
from transformers import GPT2Config, OpenAIGPTConfig, XLNetConfig, TransfoXLConfig, XLMConfig, CTRLConfig
from transformers import GPT2LMHeadModel, GPT2Tokenizer
from transformers import OpenAIGPTLMHeadModel, OpenAIGPTTokenizer
from transformers import XLNetLMHeadModel, XLNetTokenizer
from transformers import TransfoXLLMHeadModel, TransfoXLTokenizer
from transformers import CTRLLMHeadModel, CTRLTokenizer
from transformers import XLMWithLMHeadModel, XLMTokenizer
# from tools.EA.get_concepts_from_behave import tokenization, lower_case
# from tools.EA.LIB.EVAL.bleu import compute_bleu
# from tools.EA.LIB.EVAL.rouge import compute_rouge_L
import sacrebleu
from rouge import Rouge
logging.basicConfig(format = '%(asctime)s - %(levelname)s - %(name)s - %(message)s',
datefmt = '%m/%d/%Y %H:%M:%S',
level = logging.INFO)
logger = logging.getLogger(__name__)
MAX_LENGTH = int(10000) # Hardcoded max length to avoid infinite loop
ALL_MODELS = sum((tuple(conf.pretrained_config_archive_map.keys()) for conf in (GPT2Config, OpenAIGPTConfig, XLNetConfig, TransfoXLConfig, XLMConfig, CTRLConfig)), ())
MODEL_CLASSES = {
'gpt2': (GPT2LMHeadModel, GPT2Tokenizer),
'ctrl': (CTRLLMHeadModel, CTRLTokenizer),
'openai-gpt': (OpenAIGPTLMHeadModel, OpenAIGPTTokenizer),
'xlnet': (XLNetLMHeadModel, XLNetTokenizer),
'transfo-xl': (TransfoXLLMHeadModel, TransfoXLTokenizer),
'xlm': (XLMWithLMHeadModel, XLMTokenizer),
}
# Padding text to help Transformer-XL and XLNet with short prompts as proposed by Aman Rusia
# in https://github.com/rusiaaman/XLNet-gen#methodology
# and https://medium.com/@amanrusia/xlnet-speaks-comparison-to-gpt-2-ea1a4e9ba39e
# PADDING_TEXT = """ In 1991, the remains of Russian Tsar Nicholas II and his family
# (except for Alexei and Maria) are discovered.
# The voice of Nicholas's young son, Tsarevich Alexei Nikolaevich, narrates the
# remainder of the story. 1883 Western Siberia,
# a young Grigori Rasputin is asked by his father and a group of men to perform magic.
# Rasputin has a vision and denounces one of the men as a horse thief. Although his
# father initially slaps him for making such an accusation, Rasputin watches as the
# man is chased outside and beaten. Twenty years later, Rasputin sees a vision of
# the Virgin Mary, prompting him to become a priest. Rasputin quickly becomes famous,
# with people, even a bishop, begging for his blessing. <eod> </s> <eos>"""
def set_seed(args):
np.random.seed(args.seed)
torch.manual_seed(args.seed)
if args.n_gpu > 0:
torch.cuda.manual_seed_all(args.seed)
def top_k_top_p_filtering(logits, top_k=0, top_p=0.0, filter_value=-float('Inf')):
""" Filter a distribution of logits using top-k and/or nucleus (top-p) filtering
Args:
logits: logits distribution shape (batch size x vocabulary size)
top_k > 0: keep only top k tokens with highest probability (top-k filtering).
top_p > 0.0: keep the top tokens with cumulative probability >= top_p (nucleus filtering).
Nucleus filtering is described in Holtzman et al. (http://arxiv.org/abs/1904.09751)
From: https://gist.github.com/thomwolf/1a5a29f6962089e871b94cbd09daf317
"""
top_k = min(top_k, logits.size(-1)) # Safety check
if top_k > 0:
# Remove all tokens with a probability less than the last token of the top-k
indices_to_remove = logits < torch.topk(logits, top_k)[0][..., -1, None]
logits[indices_to_remove] = filter_value
if top_p > 0.0:
sorted_logits, sorted_indices = torch.sort(logits, descending=True)
cumulative_probs = torch.cumsum(F.softmax(sorted_logits, dim=-1), dim=-1)
# Remove tokens with cumulative probability above the threshold
sorted_indices_to_remove = cumulative_probs > top_p
# Shift the indices to the right to keep also the first token above the threshold
sorted_indices_to_remove[..., 1:] = sorted_indices_to_remove[..., :-1].clone()
sorted_indices_to_remove[..., 0] = 0
# scatter sorted tensors to original indexing
indices_to_remove = sorted_indices_to_remove.scatter(dim=1, index=sorted_indices, src=sorted_indices_to_remove)
logits[indices_to_remove] = filter_value
return logits
def sample_sequence(model, length, context, num_samples=1, temperature=1, top_k=0, top_p=0.0, repetition_penalty=1.0,
is_xlnet=False, is_xlm_mlm=False, xlm_mask_token=None, xlm_lang=None, device='cpu'):
context = torch.tensor(context, dtype=torch.long, device=device)
context = context.unsqueeze(0).repeat(num_samples, 1)
generated = context
# all_loss = []
with torch.no_grad():
for _ in range(length):
inputs = {'input_ids': generated}
if is_xlnet:
# XLNet is a direct (predict same token, not next token) and bi-directional model by default
# => need one additional dummy token in the input (will be masked), attention mask and target mapping (see model docstring)
input_ids = torch.cat((generated, torch.zeros((1, 1), dtype=torch.long, device=device)), dim=1)
perm_mask = torch.zeros((1, input_ids.shape[1], input_ids.shape[1]), dtype=torch.float, device=device)
perm_mask[:, :, -1] = 1.0 # Previous tokens don't see last token
target_mapping = torch.zeros((1, 1, input_ids.shape[1]), dtype=torch.float, device=device)
target_mapping[0, 0, -1] = 1.0 # predict last token
inputs = {'input_ids': input_ids, 'perm_mask': perm_mask, 'target_mapping': target_mapping}
if is_xlm_mlm and xlm_mask_token:
# XLM MLM models are direct models (predict same token, not next token)
# => need one additional dummy token in the input (will be masked and guessed)
input_ids = torch.cat((generated, torch.full((1, 1), xlm_mask_token, dtype=torch.long, device=device)), dim=1)
inputs = {'input_ids': input_ids}
if xlm_lang is not None:
inputs["langs"] = torch.tensor([xlm_lang] * inputs["input_ids"].shape[1], device=device).view(1, -1)
outputs = model(**inputs) # Note: we could also use 'past' with GPT-2/Transfo-XL/XLNet/CTRL (cached hidden-states)
next_token_logits = outputs[0][:, -1, :] / (temperature if temperature > 0 else 1.)
# print(next_token_logits.size())
# tmp_eval_loss = outputs[0][:, :, -1][-1][-1]
# print(outputs[0][:, :, -1][-1])
# print (tmp_eval_loss.size ())
# cur_loss = np.abs(tmp_eval_loss.item())
# print(cur_loss)
# all_loss.append(cur_loss)
# repetition penalty from CTRL (https://arxiv.org/abs/1909.05858)
for i in range(num_samples):
for _ in set(generated[i].tolist()):
next_token_logits[i, _] /= repetition_penalty
filtered_logits = top_k_top_p_filtering(next_token_logits, top_k=top_k, top_p=top_p)
if temperature == 0: # greedy sampling:
next_token = torch.argmax(filtered_logits, dim=-1).unsqueeze(-1)
else:
next_token = torch.multinomial(F.softmax(filtered_logits, dim=-1), num_samples=1)
generated = torch.cat((generated, next_token), dim=1)
# print(next_token.item())
if next_token.item() == 29:
break
# print(all_loss)
# avg_loss = np.mean (np.array (all_loss))
# ppl = np.exp(avg_loss)
# print('test_loss (bpe): %.4f, test_perplexity: %.4f' % (avg_loss, ppl))
return generated
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--model_type", default='gpt2', type=str, required=False,
help="Model type selected in the list: " + ", ".join(MODEL_CLASSES.keys()))
parser.add_argument("--model_name_or_path", default='/data/xieyuqiang/story_comprehension/checkpoints_ft_with_roc/lmft_lm_gpt2_roc_gn1_bp1_gc32_lr1_l100_e3_seed42_cgn1', type=str, required=False,
help="Path to pre-trained model or shortcut name selected in the list: " + ", ".join(ALL_MODELS))
parser.add_argument("--source_text_path", type=str, default="/data/xieyuqiang/story_comprehension/data/roc/roc_train.csv_causal.tsv")
parser.add_argument("--prompt", type=str, default=" ")
parser.add_argument("--padding_text", type=str, default="")
parser.add_argument("--xlm_lang", type=str, default="", help="Optional language when used with the XLM model.")
parser.add_argument("--length", type=int, default=30)
parser.add_argument("--batch", type=int, default=2)
parser.add_argument("--num_samples", type=int, default=1)
parser.add_argument("--temperature", type=float, default=0,
help="temperature of 0 implies greedy sampling")
parser.add_argument("--repetition_penalty", type=float, default=1.2,
help="primarily useful for CTRL model; in that case, use 1.2")
parser.add_argument("--top_k", type=int, default=1)
parser.add_argument("--top_p", type=float, default=0.9)
parser.add_argument("--no_cuda", action='store_true',
help="Avoid using CUDA when available")
parser.add_argument('--seed', type=int, default=42,
help="random seed for initialization")
parser.add_argument('--stop_token', type=str, default='<|endoftext|>',
help="Token at which text generation is stopped")
parser.add_argument ('--style', type=str, default='temporal',
help="The style for generating the pseudo wrong endings: temporal/causal")
args = parser.parse_args()
args.device = torch.device("cuda" if torch.cuda.is_available() and not args.no_cuda else "cpu")
args.n_gpu = torch.cuda.device_count()
set_seed(args)
args.model_type = args.model_type.lower()
model_class, tokenizer_class = MODEL_CLASSES[args.model_type]
tokenizer = tokenizer_class.from_pretrained(args.model_name_or_path)
model = model_class.from_pretrained(args.model_name_or_path)
model.to(args.device)
model.eval()
if args.length < 0 and model.config.max_position_embeddings > 0:
args.length = model.config.max_position_embeddings
elif 0 < model.config.max_position_embeddings < args.length:
args.length = model.config.max_position_embeddings # No generation bigger than model size
elif args.length < 0:
args.length = MAX_LENGTH # avoid infinite loop
logger.info(args)
if args.model_type in ["ctrl"]:
if args.temperature > 0.7:
logger.info('CTRL typically works better with lower temperatures (and lower top_k).')
while True:
xlm_lang = None
# XLM Language usage detailed in the issues #1414
if args.model_type in ["xlm"] and hasattr(tokenizer, 'lang2id') and hasattr(model.config, 'use_lang_emb') \
and model.config.use_lang_emb:
if args.xlm_lang:
language = args.xlm_lang
else:
language = None
while language not in tokenizer.lang2id.keys():
language = input("Using XLM. Select language in " + str(list(tokenizer.lang2id.keys())) + " >>> ")
xlm_lang = tokenizer.lang2id[language]
# XLM masked-language modeling (MLM) models need masked token (see details in sample_sequence)
is_xlm_mlm = args.model_type in ["xlm"] and 'mlm' in args.model_name_or_path
if is_xlm_mlm:
xlm_mask_token = tokenizer.mask_token_id
else:
xlm_mask_token = None
raw_text = args.prompt if args.prompt else input("Model prompt >>> ")
if args.model_type in ["transfo-xl", "xlnet"]:
# Models with memory likes to have a long prompt for short inputs.
raw_text = (args.padding_text if args.padding_text else PADDING_TEXT) + raw_text
context_tokens = tokenizer.encode(raw_text, add_special_tokens=False)
if args.model_type == "ctrl":
if not any(context_tokens[0] == x for x in tokenizer.control_codes.values()):
logger.info("WARNING! You are not starting your generation from a control code so you won't get good results")
with open (args.source_text_path + "_generated.tsv", 'w', encoding='utf-8') as new_file:
f = open (args.source_text_path)
a = f.readlines ()
all_data = []
for i in a[1:]:
item = i.replace ("\n", "").split ('\t')
all_data.append (item)
# print(all_data[0])
new_file.write ('context\tsource\ttarget\n')
from tqdm import tqdm
# source_corpus = []
# target_corpus = []
for raw_data in tqdm(all_data):
context = raw_data[0] + ' ' + raw_data[1]
source = raw_data[3]
target = raw_data[0]+ ' ' + raw_data[2]
context_tokens = tokenizer.encode (target, add_special_tokens=False)
out = sample_sequence (
model=model,
context=context_tokens,
num_samples=args.num_samples,
length=args.length,
temperature=args.temperature,
top_k=args.top_k,
top_p=args.top_p,
repetition_penalty=args.repetition_penalty,
is_xlnet=bool (args.model_type == "xlnet"),
is_xlm_mlm=is_xlm_mlm,
xlm_mask_token=xlm_mask_token,
xlm_lang=xlm_lang,
device=args.device,
)
out = out[:, len (context_tokens):].tolist ()
for o in out:
# text = tokenizer.decode(o, cleanI_up_tokenization_spaces=True)
text = tokenizer.decode (o)
text = text[: text.find (args.stop_token) if args.stop_token else None]
target = text.replace ('<|endoftext|>', '')
# source_corpus.append(source)
# target_corpus.append(target)
new_file.write (context+"\t"+source+"\t"+target+"\n")
f.close()
if args.prompt:
break
# return target
if __name__ == '__main__':
main()
| [] |
2024-01-10 | IndexFziQ/CLSEG | src~run_generation_cl_cr.py | #!/usr/bin/env python3
# coding=utf-8
# Copyright 2018 Google AI, Google Brain and Carnegie Mellon University Authors and the HuggingFace Inc. team.
# Copyright (c) 2018, NVIDIA CORPORATION. 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.
""" Conditional text generation with the auto-regressive models of the library (GPT/GPT-2/CTRL/Transformer-XL/XLNet)
"""
from __future__ import absolute_import, division, print_function, unicode_literals
import argparse
import logging
from tqdm import trange
import torch
import torch.nn.functional as F
import numpy as np
from transformers import GPT2Config, OpenAIGPTConfig, XLNetConfig, TransfoXLConfig, XLMConfig, CTRLConfig
from transformers import GPT2LMHeadModel, GPT2Tokenizer
from transformers import OpenAIGPTLMHeadModel, OpenAIGPTTokenizer
from transformers import XLNetLMHeadModel, XLNetTokenizer
from transformers import TransfoXLLMHeadModel, TransfoXLTokenizer
from transformers import CTRLLMHeadModel, CTRLTokenizer
from transformers import XLMWithLMHeadModel, XLMTokenizer
# from tools.EA.get_concepts_from_behave import tokenization, lower_case
# from tools.EA.LIB.EVAL.bleu import compute_bleu
# from tools.EA.LIB.EVAL.rouge import compute_rouge_L
import sacrebleu
from rouge import Rouge
logging.basicConfig(format = '%(asctime)s - %(levelname)s - %(name)s - %(message)s',
datefmt = '%m/%d/%Y %H:%M:%S',
level = logging.INFO)
logger = logging.getLogger(__name__)
MAX_LENGTH = int(10000) # Hardcoded max length to avoid infinite loop
ALL_MODELS = sum((tuple(conf.pretrained_config_archive_map.keys()) for conf in (GPT2Config, OpenAIGPTConfig, XLNetConfig, TransfoXLConfig, XLMConfig, CTRLConfig)), ())
MODEL_CLASSES = {
'gpt2': (GPT2LMHeadModel, GPT2Tokenizer),
'ctrl': (CTRLLMHeadModel, CTRLTokenizer),
'openai-gpt': (OpenAIGPTLMHeadModel, OpenAIGPTTokenizer),
'xlnet': (XLNetLMHeadModel, XLNetTokenizer),
'transfo-xl': (TransfoXLLMHeadModel, TransfoXLTokenizer),
'xlm': (XLMWithLMHeadModel, XLMTokenizer),
}
# Padding text to help Transformer-XL and XLNet with short prompts as proposed by Aman Rusia
# in https://github.com/rusiaaman/XLNet-gen#methodology
# and https://medium.com/@amanrusia/xlnet-speaks-comparison-to-gpt-2-ea1a4e9ba39e
# PADDING_TEXT = """ In 1991, the remains of Russian Tsar Nicholas II and his family
# (except for Alexei and Maria) are discovered.
# The voice of Nicholas's young son, Tsarevich Alexei Nikolaevich, narrates the
# remainder of the story. 1883 Western Siberia,
# a young Grigori Rasputin is asked by his father and a group of men to perform magic.
# Rasputin has a vision and denounces one of the men as a horse thief. Although his
# father initially slaps him for making such an accusation, Rasputin watches as the
# man is chased outside and beaten. Twenty years later, Rasputin sees a vision of
# the Virgin Mary, prompting him to become a priest. Rasputin quickly becomes famous,
# with people, even a bishop, begging for his blessing. <eod> </s> <eos>"""
def set_seed(args):
np.random.seed(args.seed)
torch.manual_seed(args.seed)
if args.n_gpu > 0:
torch.cuda.manual_seed_all(args.seed)
def top_k_top_p_filtering(logits, top_k=0, top_p=0.0, filter_value=-float('Inf')):
""" Filter a distribution of logits using top-k and/or nucleus (top-p) filtering
Args:
logits: logits distribution shape (batch size x vocabulary size)
top_k > 0: keep only top k tokens with highest probability (top-k filtering).
top_p > 0.0: keep the top tokens with cumulative probability >= top_p (nucleus filtering).
Nucleus filtering is described in Holtzman et al. (http://arxiv.org/abs/1904.09751)
From: https://gist.github.com/thomwolf/1a5a29f6962089e871b94cbd09daf317
"""
top_k = min(top_k, logits.size(-1)) # Safety check
if top_k > 0:
# Remove all tokens with a probability less than the last token of the top-k
indices_to_remove = logits < torch.topk(logits, top_k)[0][..., -1, None]
logits[indices_to_remove] = filter_value
if top_p > 0.0:
sorted_logits, sorted_indices = torch.sort(logits, descending=True)
cumulative_probs = torch.cumsum(F.softmax(sorted_logits, dim=-1), dim=-1)
# Remove tokens with cumulative probability above the threshold
sorted_indices_to_remove = cumulative_probs > top_p
# Shift the indices to the right to keep also the first token above the threshold
sorted_indices_to_remove[..., 1:] = sorted_indices_to_remove[..., :-1].clone()
sorted_indices_to_remove[..., 0] = 0
# scatter sorted tensors to original indexing
indices_to_remove = sorted_indices_to_remove.scatter(dim=1, index=sorted_indices, src=sorted_indices_to_remove)
logits[indices_to_remove] = filter_value
return logits
def sample_sequence(model, length, context, num_samples=1, temperature=1, top_k=0, top_p=0.0, repetition_penalty=1.0,
is_xlnet=False, is_xlm_mlm=False, xlm_mask_token=None, xlm_lang=None, device='cpu'):
context = torch.tensor(context, dtype=torch.long, device=device)
context = context.unsqueeze(0).repeat(num_samples, 1)
generated = context
# all_loss = []
with torch.no_grad():
for _ in range(length):
inputs = {'input_ids': generated}
if is_xlnet:
# XLNet is a direct (predict same token, not next token) and bi-directional model by default
# => need one additional dummy token in the input (will be masked), attention mask and target mapping (see model docstring)
input_ids = torch.cat((generated, torch.zeros((1, 1), dtype=torch.long, device=device)), dim=1)
perm_mask = torch.zeros((1, input_ids.shape[1], input_ids.shape[1]), dtype=torch.float, device=device)
perm_mask[:, :, -1] = 1.0 # Previous tokens don't see last token
target_mapping = torch.zeros((1, 1, input_ids.shape[1]), dtype=torch.float, device=device)
target_mapping[0, 0, -1] = 1.0 # predict last token
inputs = {'input_ids': input_ids, 'perm_mask': perm_mask, 'target_mapping': target_mapping}
if is_xlm_mlm and xlm_mask_token:
# XLM MLM models are direct models (predict same token, not next token)
# => need one additional dummy token in the input (will be masked and guessed)
input_ids = torch.cat((generated, torch.full((1, 1), xlm_mask_token, dtype=torch.long, device=device)), dim=1)
inputs = {'input_ids': input_ids}
if xlm_lang is not None:
inputs["langs"] = torch.tensor([xlm_lang] * inputs["input_ids"].shape[1], device=device).view(1, -1)
outputs = model(**inputs) # Note: we could also use 'past' with GPT-2/Transfo-XL/XLNet/CTRL (cached hidden-states)
next_token_logits = outputs[0][:, -1, :] / (temperature if temperature > 0 else 1.)
# print(next_token_logits.size())
# tmp_eval_loss = outputs[0][:, :, -1][-1][-1]
# print(outputs[0][:, :, -1][-1])
# print (tmp_eval_loss.size ())
# cur_loss = np.abs(tmp_eval_loss.item())
# print(cur_loss)
# all_loss.append(cur_loss)
# repetition penalty from CTRL (https://arxiv.org/abs/1909.05858)
for i in range(num_samples):
for _ in set(generated[i].tolist()):
next_token_logits[i, _] /= repetition_penalty
filtered_logits = top_k_top_p_filtering(next_token_logits, top_k=top_k, top_p=top_p)
if temperature == 0: # greedy sampling:
next_token = torch.argmax(filtered_logits, dim=-1).unsqueeze(-1)
else:
next_token = torch.multinomial(F.softmax(filtered_logits, dim=-1), num_samples=1)
generated = torch.cat((generated, next_token), dim=1)
# print(next_token.item())
if next_token.item() == 29:
break
# print(all_loss)
# avg_loss = np.mean (np.array (all_loss))
# ppl = np.exp(avg_loss)
# print('test_loss (bpe): %.4f, test_perplexity: %.4f' % (avg_loss, ppl))
return generated
# /data/xieyuqiang/story_comprehension/checkpoints_ft_with_roc/lmft_lm_gpt2_rocmedium_gn1_bp1_gc32_lr1_l100_e3_seed42_cgn1
# /data/xieyuqiang/story_comprehension/checkpoints_ft_with_cl/lmft_lm_gpt2_cl_gn1_bp1_gc32_lr1_l100_e3_seed42_cgn1
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--model_type", default='gpt2', type=str, required=False,
help="Model type selected in the list: " + ", ".join(MODEL_CLASSES.keys()))
parser.add_argument("--model_name_or_path", default='/data/xieyuqiang/story_comprehension/checkpoints_ft_with_cl/lmft_lm_gpt2_clcr_gn1_bp1_gc32_lr1_l128_e3_seed42_cgn1', type=str, required=False,
help="Path to pre-trained model or shortcut name selected in the list: " + ", ".join(ALL_MODELS))
parser.add_argument("--source_text_path", type=str, default="/data/xieyuqiang/story_comprehension/data/roc/roc_val.csv")
parser.add_argument("--prompt", type=str, default=" ")
parser.add_argument("--padding_text", type=str, default="")
parser.add_argument("--xlm_lang", type=str, default="", help="Optional language when used with the XLM model.")
parser.add_argument("--length", type=int, default=30)
parser.add_argument("--batch", type=int, default=10)
parser.add_argument("--num_samples", type=int, default=1)
parser.add_argument("--temperature", type=float, default=0,
help="temperature of 0 implies greedy sampling")
parser.add_argument("--repetition_penalty", type=float, default=1.2,
help="primarily useful for CTRL model; in that case, use 1.2")
parser.add_argument("--top_k", type=int, default=1)
parser.add_argument("--top_p", type=float, default=0.9)
parser.add_argument("--no_cuda", action='store_true',
help="Avoid using CUDA when available")
parser.add_argument('--seed', type=int, default=42,
help="random seed for initialization")
parser.add_argument('--stop_token', type=str, default='<|endoftext|>',
help="Token at which text generation is stopped")
parser.add_argument ('--style', type=str, default='temporal',
help="The style for generating the pseudo wrong endings: temporal/causal")
args = parser.parse_args()
args.device = torch.device("cuda" if torch.cuda.is_available() and not args.no_cuda else "cpu")
args.n_gpu = torch.cuda.device_count()
set_seed(args)
args.model_type = args.model_type.lower()
model_class, tokenizer_class = MODEL_CLASSES[args.model_type]
tokenizer = tokenizer_class.from_pretrained(args.model_name_or_path)
model = model_class.from_pretrained(args.model_name_or_path)
model.to(args.device)
model.eval()
if args.length < 0 and model.config.max_position_embeddings > 0:
args.length = model.config.max_position_embeddings
elif 0 < model.config.max_position_embeddings < args.length:
args.length = model.config.max_position_embeddings # No generation bigger than model size
elif args.length < 0:
args.length = MAX_LENGTH # avoid infinite loop
logger.info(args)
if args.model_type in ["ctrl"]:
if args.temperature > 0.7:
logger.info('CTRL typically works better with lower temperatures (and lower top_k).')
while True:
xlm_lang = None
# XLM Language usage detailed in the issues #1414
if args.model_type in ["xlm"] and hasattr(tokenizer, 'lang2id') and hasattr(model.config, 'use_lang_emb') \
and model.config.use_lang_emb:
if args.xlm_lang:
language = args.xlm_lang
else:
language = None
while language not in tokenizer.lang2id.keys():
language = input("Using XLM. Select language in " + str(list(tokenizer.lang2id.keys())) + " >>> ")
xlm_lang = tokenizer.lang2id[language]
# XLM masked-language modeling (MLM) models need masked token (see details in sample_sequence)
is_xlm_mlm = args.model_type in ["xlm"] and 'mlm' in args.model_name_or_path
if is_xlm_mlm:
xlm_mask_token = tokenizer.mask_token_id
else:
xlm_mask_token = None
raw_text = args.prompt if args.prompt else input("Model prompt >>> ")
if args.model_type in ["transfo-xl", "xlnet"]:
# Models with memory likes to have a long prompt for short inputs.
raw_text = (args.padding_text if args.padding_text else PADDING_TEXT) + raw_text
context_tokens = tokenizer.encode(raw_text, add_special_tokens=False)
if args.model_type == "ctrl":
if not any(context_tokens[0] == x for x in tokenizer.control_codes.values()):
logger.info("WARNING! You are not starting your generation from a control code so you won't get good results")
with open (args.source_text_path, 'r', encoding='utf-8') as data_file, \
open (args.source_text_path + "_cl_cr_result.tsv", 'w', encoding='utf-8') as new_file, \
open (args.source_text_path + "_cl_cr_eval.tsv", 'w', encoding='utf-8') as eval_file:
import csv
reader = csv.reader (data_file)
next (reader)
all_data = []
for line in reader:
all_data.append (line)
print (all_data[0])
new_file.write ('context\tsource\ttarget\n')
from tqdm import tqdm
source_corpus = []
target_corpus = []
for raw_data in tqdm(all_data):
context = ' '.join(raw_data[2:6])
source = raw_data[6]
# import random
list = raw_data[2:6]
# random.shuffle(list)
target = ' '.join(list)
context_tokens = tokenizer.encode (target, add_special_tokens=False)
out = sample_sequence (
model=model,
context=context_tokens,
num_samples=args.num_samples,
length=args.length,
temperature=args.temperature,
top_k=args.top_k,
top_p=args.top_p,
repetition_penalty=args.repetition_penalty,
is_xlnet=bool (args.model_type == "xlnet"),
is_xlm_mlm=is_xlm_mlm,
xlm_mask_token=xlm_mask_token,
xlm_lang=xlm_lang,
device=args.device,
)
out = out[:, len (context_tokens):].tolist ()
for o in out:
# text = tokenizer.decode(o, cleanI_up_tokenization_spaces=True)
text = tokenizer.decode (o)
text = text[: text.find (args.stop_token) if args.stop_token else None]
target = text.replace ('<|endoftext|>', '')
source_corpus.append(source)
target_corpus.append(target)
new_file.write (context+"\t"+source+"\t"+target+"\n")
bleu_list = []
rouge_ = []
for source, target in zip (source_corpus, target_corpus):
bleu = sacrebleu.corpus_bleu (target, source)
bleu_list.append (bleu.precisions)
rouge = Rouge ()
for source, target in zip (source_corpus, target_corpus):
# rouge_l = compute_rouge_L(source, target)
rouge_x = rouge.get_scores (source, target)
rouge_1 = rouge_x[0]["rouge-1"]['f']
rouge_2 = rouge_x[0]["rouge-2"]['f']
rouge_l = rouge_x[0]["rouge-l"]['f']
rouge_.append ([rouge_1, rouge_2, rouge_l])
bleu_score = np.mean (bleu_list, axis=0)
rouge_score_ = np.mean (rouge_, axis=0)
print ("BLEU-1 score: " + str (bleu_score[0]) + "\n")
print ("BLEU-2 score: " + str (bleu_score[1]) + "\n")
print ("BLEU-4 score: " + str (bleu_score[3]) + "\n")
print ("Rouge-1 score: " + str (rouge_score_[0] * 100) + "\n")
print ("Rouge-2 score: " + str (rouge_score_[1] * 100) + "\n")
print ("Rouge-L score: " + str (rouge_score_[2] * 100) + "\n")
eval_file.write ("BLEU-1 score: " + str (bleu_score[0]) + "\n")
eval_file.write ("BLEU-2 score: " + str (bleu_score[1]) + "\n")
eval_file.write ("BLEU-4 score: " + str (bleu_score[3]) + "\n")
eval_file.write ("Rouge-1 score: " + str (rouge_score_[0] * 100) + "\n")
eval_file.write ("Rouge-2 score: " + str (rouge_score_[1] * 100) + "\n")
eval_file.write ("Rouge-L score: " + str (rouge_score_[2] * 100) + "\n")
if args.prompt:
break
# return target
if __name__ == '__main__':
main()
| [] |
2024-01-10 | IndexFziQ/CLSEG | src~run_generation_cl_so.py | #!/usr/bin/env python3
# coding=utf-8
# Copyright 2018 Google AI, Google Brain and Carnegie Mellon University Authors and the HuggingFace Inc. team.
# Copyright (c) 2018, NVIDIA CORPORATION. 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.
""" Conditional text generation with the auto-regressive models of the library (GPT/GPT-2/CTRL/Transformer-XL/XLNet)
"""
from __future__ import absolute_import, division, print_function, unicode_literals
import argparse
import logging
from tqdm import trange
import torch
import torch.nn.functional as F
import numpy as np
from transformers import GPT2Config, OpenAIGPTConfig, XLNetConfig, TransfoXLConfig, XLMConfig, CTRLConfig
from transformers import GPT2LMHeadModel, GPT2Tokenizer
from transformers import OpenAIGPTLMHeadModel, OpenAIGPTTokenizer
from transformers import XLNetLMHeadModel, XLNetTokenizer
from transformers import TransfoXLLMHeadModel, TransfoXLTokenizer
from transformers import CTRLLMHeadModel, CTRLTokenizer
from transformers import XLMWithLMHeadModel, XLMTokenizer
# from tools.EA.get_concepts_from_behave import tokenization, lower_case
# from tools.EA.LIB.EVAL.bleu import compute_bleu
# from tools.EA.LIB.EVAL.rouge import compute_rouge_L
import sacrebleu
from rouge import Rouge
logging.basicConfig(format = '%(asctime)s - %(levelname)s - %(name)s - %(message)s',
datefmt = '%m/%d/%Y %H:%M:%S',
level = logging.INFO)
logger = logging.getLogger(__name__)
MAX_LENGTH = int(10000) # Hardcoded max length to avoid infinite loop
ALL_MODELS = sum((tuple(conf.pretrained_config_archive_map.keys()) for conf in (GPT2Config, OpenAIGPTConfig, XLNetConfig, TransfoXLConfig, XLMConfig, CTRLConfig)), ())
MODEL_CLASSES = {
'gpt2': (GPT2LMHeadModel, GPT2Tokenizer),
'ctrl': (CTRLLMHeadModel, CTRLTokenizer),
'openai-gpt': (OpenAIGPTLMHeadModel, OpenAIGPTTokenizer),
'xlnet': (XLNetLMHeadModel, XLNetTokenizer),
'transfo-xl': (TransfoXLLMHeadModel, TransfoXLTokenizer),
'xlm': (XLMWithLMHeadModel, XLMTokenizer),
}
# Padding text to help Transformer-XL and XLNet with short prompts as proposed by Aman Rusia
# in https://github.com/rusiaaman/XLNet-gen#methodology
# and https://medium.com/@amanrusia/xlnet-speaks-comparison-to-gpt-2-ea1a4e9ba39e
# PADDING_TEXT = """ In 1991, the remains of Russian Tsar Nicholas II and his family
# (except for Alexei and Maria) are discovered.
# The voice of Nicholas's young son, Tsarevich Alexei Nikolaevich, narrates the
# remainder of the story. 1883 Western Siberia,
# a young Grigori Rasputin is asked by his father and a group of men to perform magic.
# Rasputin has a vision and denounces one of the men as a horse thief. Although his
# father initially slaps him for making such an accusation, Rasputin watches as the
# man is chased outside and beaten. Twenty years later, Rasputin sees a vision of
# the Virgin Mary, prompting him to become a priest. Rasputin quickly becomes famous,
# with people, even a bishop, begging for his blessing. <eod> </s> <eos>"""
def set_seed(args):
np.random.seed(args.seed)
torch.manual_seed(args.seed)
if args.n_gpu > 0:
torch.cuda.manual_seed_all(args.seed)
def top_k_top_p_filtering(logits, top_k=0, top_p=0.0, filter_value=-float('Inf')):
""" Filter a distribution of logits using top-k and/or nucleus (top-p) filtering
Args:
logits: logits distribution shape (batch size x vocabulary size)
top_k > 0: keep only top k tokens with highest probability (top-k filtering).
top_p > 0.0: keep the top tokens with cumulative probability >= top_p (nucleus filtering).
Nucleus filtering is described in Holtzman et al. (http://arxiv.org/abs/1904.09751)
From: https://gist.github.com/thomwolf/1a5a29f6962089e871b94cbd09daf317
"""
top_k = min(top_k, logits.size(-1)) # Safety check
if top_k > 0:
# Remove all tokens with a probability less than the last token of the top-k
indices_to_remove = logits < torch.topk(logits, top_k)[0][..., -1, None]
logits[indices_to_remove] = filter_value
if top_p > 0.0:
sorted_logits, sorted_indices = torch.sort(logits, descending=True)
cumulative_probs = torch.cumsum(F.softmax(sorted_logits, dim=-1), dim=-1)
# Remove tokens with cumulative probability above the threshold
sorted_indices_to_remove = cumulative_probs > top_p
# Shift the indices to the right to keep also the first token above the threshold
sorted_indices_to_remove[..., 1:] = sorted_indices_to_remove[..., :-1].clone()
sorted_indices_to_remove[..., 0] = 0
# scatter sorted tensors to original indexing
indices_to_remove = sorted_indices_to_remove.scatter(dim=1, index=sorted_indices, src=sorted_indices_to_remove)
logits[indices_to_remove] = filter_value
return logits
def sample_sequence(model, length, context, num_samples=1, temperature=1, top_k=0, top_p=0.0, repetition_penalty=1.0,
is_xlnet=False, is_xlm_mlm=False, xlm_mask_token=None, xlm_lang=None, device='cpu'):
context = torch.tensor(context, dtype=torch.long, device=device)
context = context.unsqueeze(0).repeat(num_samples, 1)
generated = context
# all_loss = []
with torch.no_grad():
for _ in range(length):
inputs = {'input_ids': generated}
if is_xlnet:
# XLNet is a direct (predict same token, not next token) and bi-directional model by default
# => need one additional dummy token in the input (will be masked), attention mask and target mapping (see model docstring)
input_ids = torch.cat((generated, torch.zeros((1, 1), dtype=torch.long, device=device)), dim=1)
perm_mask = torch.zeros((1, input_ids.shape[1], input_ids.shape[1]), dtype=torch.float, device=device)
perm_mask[:, :, -1] = 1.0 # Previous tokens don't see last token
target_mapping = torch.zeros((1, 1, input_ids.shape[1]), dtype=torch.float, device=device)
target_mapping[0, 0, -1] = 1.0 # predict last token
inputs = {'input_ids': input_ids, 'perm_mask': perm_mask, 'target_mapping': target_mapping}
if is_xlm_mlm and xlm_mask_token:
# XLM MLM models are direct models (predict same token, not next token)
# => need one additional dummy token in the input (will be masked and guessed)
input_ids = torch.cat((generated, torch.full((1, 1), xlm_mask_token, dtype=torch.long, device=device)), dim=1)
inputs = {'input_ids': input_ids}
if xlm_lang is not None:
inputs["langs"] = torch.tensor([xlm_lang] * inputs["input_ids"].shape[1], device=device).view(1, -1)
outputs = model(**inputs) # Note: we could also use 'past' with GPT-2/Transfo-XL/XLNet/CTRL (cached hidden-states)
next_token_logits = outputs[0][:, -1, :] / (temperature if temperature > 0 else 1.)
# print(next_token_logits.size())
# tmp_eval_loss = outputs[0][:, :, -1][-1][-1]
# print(outputs[0][:, :, -1][-1])
# print (tmp_eval_loss.size ())
# cur_loss = np.abs(tmp_eval_loss.item())
# print(cur_loss)
# all_loss.append(cur_loss)
# repetition penalty from CTRL (https://arxiv.org/abs/1909.05858)
for i in range(num_samples):
for _ in set(generated[i].tolist()):
next_token_logits[i, _] /= repetition_penalty
filtered_logits = top_k_top_p_filtering(next_token_logits, top_k=top_k, top_p=top_p)
if temperature == 0: # greedy sampling:
next_token = torch.argmax(filtered_logits, dim=-1).unsqueeze(-1)
else:
next_token = torch.multinomial(F.softmax(filtered_logits, dim=-1), num_samples=1)
generated = torch.cat((generated, next_token), dim=1)
# print(next_token.item())
if next_token.item() == 29:
break
# print(all_loss)
# avg_loss = np.mean (np.array (all_loss))
# ppl = np.exp(avg_loss)
# print('test_loss (bpe): %.4f, test_perplexity: %.4f' % (avg_loss, ppl))
return generated
# /data/xieyuqiang/story_comprehension/checkpoints_ft_with_roc/lmft_lm_gpt2_rocmedium_gn1_bp1_gc32_lr1_l100_e3_seed42_cgn1
# /data/xieyuqiang/story_comprehension/checkpoints_ft_with_cl/lmft_lm_gpt2_cl_gn1_bp1_gc32_lr1_l100_e3_seed42_cgn1
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--model_type", default='gpt2', type=str, required=False,
help="Model type selected in the list: " + ", ".join(MODEL_CLASSES.keys()))
parser.add_argument("--model_name_or_path", default='/data/xieyuqiang/story_comprehension/checkpoints_ft_with_cl/lmft_lm_gpt2_clso_gn1_bp1_gc32_lr1_l128_e3_seed42_cgn1', type=str, required=False,
help="Path to pre-trained model or shortcut name selected in the list: " + ", ".join(ALL_MODELS))
parser.add_argument("--source_text_path", type=str, default="/data/xieyuqiang/story_comprehension/data/roc/roc_val.csv")
parser.add_argument("--prompt", type=str, default=" ")
parser.add_argument("--padding_text", type=str, default="")
parser.add_argument("--xlm_lang", type=str, default="", help="Optional language when used with the XLM model.")
parser.add_argument("--length", type=int, default=30)
parser.add_argument("--batch", type=int, default=10)
parser.add_argument("--num_samples", type=int, default=1)
parser.add_argument("--temperature", type=float, default=0,
help="temperature of 0 implies greedy sampling")
parser.add_argument("--repetition_penalty", type=float, default=1.2,
help="primarily useful for CTRL model; in that case, use 1.2")
parser.add_argument("--top_k", type=int, default=1)
parser.add_argument("--top_p", type=float, default=0.9)
parser.add_argument("--no_cuda", action='store_true',
help="Avoid using CUDA when available")
parser.add_argument('--seed', type=int, default=42,
help="random seed for initialization")
parser.add_argument('--stop_token', type=str, default='<|endoftext|>',
help="Token at which text generation is stopped")
parser.add_argument ('--style', type=str, default='temporal',
help="The style for generating the pseudo wrong endings: temporal/causal")
args = parser.parse_args()
args.device = torch.device("cuda" if torch.cuda.is_available() and not args.no_cuda else "cpu")
args.n_gpu = torch.cuda.device_count()
set_seed(args)
args.model_type = args.model_type.lower()
model_class, tokenizer_class = MODEL_CLASSES[args.model_type]
tokenizer = tokenizer_class.from_pretrained(args.model_name_or_path)
model = model_class.from_pretrained(args.model_name_or_path)
model.to(args.device)
model.eval()
if args.length < 0 and model.config.max_position_embeddings > 0:
args.length = model.config.max_position_embeddings
elif 0 < model.config.max_position_embeddings < args.length:
args.length = model.config.max_position_embeddings # No generation bigger than model size
elif args.length < 0:
args.length = MAX_LENGTH # avoid infinite loop
logger.info(args)
if args.model_type in ["ctrl"]:
if args.temperature > 0.7:
logger.info('CTRL typically works better with lower temperatures (and lower top_k).')
while True:
xlm_lang = None
# XLM Language usage detailed in the issues #1414
if args.model_type in ["xlm"] and hasattr(tokenizer, 'lang2id') and hasattr(model.config, 'use_lang_emb') \
and model.config.use_lang_emb:
if args.xlm_lang:
language = args.xlm_lang
else:
language = None
while language not in tokenizer.lang2id.keys():
language = input("Using XLM. Select language in " + str(list(tokenizer.lang2id.keys())) + " >>> ")
xlm_lang = tokenizer.lang2id[language]
# XLM masked-language modeling (MLM) models need masked token (see details in sample_sequence)
is_xlm_mlm = args.model_type in ["xlm"] and 'mlm' in args.model_name_or_path
if is_xlm_mlm:
xlm_mask_token = tokenizer.mask_token_id
else:
xlm_mask_token = None
raw_text = args.prompt if args.prompt else input("Model prompt >>> ")
if args.model_type in ["transfo-xl", "xlnet"]:
# Models with memory likes to have a long prompt for short inputs.
raw_text = (args.padding_text if args.padding_text else PADDING_TEXT) + raw_text
context_tokens = tokenizer.encode(raw_text, add_special_tokens=False)
if args.model_type == "ctrl":
if not any(context_tokens[0] == x for x in tokenizer.control_codes.values()):
logger.info("WARNING! You are not starting your generation from a control code so you won't get good results")
with open (args.source_text_path, 'r', encoding='utf-8') as data_file, \
open (args.source_text_path + "_cl_so_result.tsv", 'w', encoding='utf-8') as new_file, \
open (args.source_text_path + "_cl_so_eval.tsv", 'w', encoding='utf-8') as eval_file:
import csv
reader = csv.reader (data_file)
next (reader)
all_data = []
for line in reader:
all_data.append (line)
print (all_data[0])
new_file.write ('context\tsource\ttarget\n')
from tqdm import tqdm
source_corpus = []
target_corpus = []
for raw_data in tqdm(all_data):
context = ' '.join(raw_data[2:6])
source = raw_data[6]
# import random
list = raw_data[2:6]
# random.shuffle(list)
target = ' '.join(list)
context_tokens = tokenizer.encode (target, add_special_tokens=False)
out = sample_sequence (
model=model,
context=context_tokens,
num_samples=args.num_samples,
length=args.length,
temperature=args.temperature,
top_k=args.top_k,
top_p=args.top_p,
repetition_penalty=args.repetition_penalty,
is_xlnet=bool (args.model_type == "xlnet"),
is_xlm_mlm=is_xlm_mlm,
xlm_mask_token=xlm_mask_token,
xlm_lang=xlm_lang,
device=args.device,
)
out = out[:, len (context_tokens):].tolist ()
for o in out:
# text = tokenizer.decode(o, cleanI_up_tokenization_spaces=True)
text = tokenizer.decode (o)
text = text[: text.find (args.stop_token) if args.stop_token else None]
target = text.replace ('<|endoftext|>', '')
source_corpus.append(source)
target_corpus.append(target)
new_file.write (context+"\t"+source+"\t"+target+"\n")
bleu_list = []
rouge_ = []
for source, target in zip (source_corpus, target_corpus):
bleu = sacrebleu.corpus_bleu (target, source)
bleu_list.append (bleu.precisions)
rouge = Rouge ()
for source, target in zip (source_corpus, target_corpus):
# rouge_l = compute_rouge_L(source, target)
rouge_x = rouge.get_scores (source, target)
rouge_1 = rouge_x[0]["rouge-1"]['f']
rouge_2 = rouge_x[0]["rouge-2"]['f']
rouge_l = rouge_x[0]["rouge-l"]['f']
rouge_.append ([rouge_1, rouge_2, rouge_l])
bleu_score = np.mean (bleu_list, axis=0)
rouge_score_ = np.mean (rouge_, axis=0)
print ("BLEU-1 score: " + str (bleu_score[0]) + "\n")
print ("BLEU-2 score: " + str (bleu_score[1]) + "\n")
print ("BLEU-4 score: " + str (bleu_score[3]) + "\n")
print ("Rouge-1 score: " + str (rouge_score_[0] * 100) + "\n")
print ("Rouge-2 score: " + str (rouge_score_[1] * 100) + "\n")
print ("Rouge-L score: " + str (rouge_score_[2] * 100) + "\n")
eval_file.write ("BLEU-1 score: " + str (bleu_score[0]) + "\n")
eval_file.write ("BLEU-2 score: " + str (bleu_score[1]) + "\n")
eval_file.write ("BLEU-4 score: " + str (bleu_score[3]) + "\n")
eval_file.write ("Rouge-1 score: " + str (rouge_score_[0] * 100) + "\n")
eval_file.write ("Rouge-2 score: " + str (rouge_score_[1] * 100) + "\n")
eval_file.write ("Rouge-L score: " + str (rouge_score_[2] * 100) + "\n")
if args.prompt:
break
# return target
if __name__ == '__main__':
main()
| [] |
2024-01-10 | IndexFziQ/CLSEG | src~run_generation_baseline_ft.py | #!/usr/bin/env python3
# coding=utf-8
# Copyright 2018 Google AI, Google Brain and Carnegie Mellon University Authors and the HuggingFace Inc. team.
# Copyright (c) 2018, NVIDIA CORPORATION. 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.
""" Conditional text generation with the auto-regressive models of the library (GPT/GPT-2/CTRL/Transformer-XL/XLNet)
"""
from __future__ import absolute_import, division, print_function, unicode_literals
import argparse
import logging
from tqdm import trange
import torch
import torch.nn.functional as F
import numpy as np
from transformers import GPT2Config, OpenAIGPTConfig, XLNetConfig, TransfoXLConfig, XLMConfig, CTRLConfig
from transformers import GPT2LMHeadModel, GPT2Tokenizer
from transformers import OpenAIGPTLMHeadModel, OpenAIGPTTokenizer
from transformers import XLNetLMHeadModel, XLNetTokenizer
from transformers import TransfoXLLMHeadModel, TransfoXLTokenizer
from transformers import CTRLLMHeadModel, CTRLTokenizer
from transformers import XLMWithLMHeadModel, XLMTokenizer
# from tools.EA.get_concepts_from_behave import tokenization, lower_case
# from tools.EA.LIB.EVAL.bleu import compute_bleu
# from tools.EA.LIB.EVAL.rouge import compute_rouge_L
import sacrebleu
from rouge import Rouge
logging.basicConfig(format = '%(asctime)s - %(levelname)s - %(name)s - %(message)s',
datefmt = '%m/%d/%Y %H:%M:%S',
level = logging.INFO)
logger = logging.getLogger(__name__)
MAX_LENGTH = int(10000) # Hardcoded max length to avoid infinite loop
ALL_MODELS = sum((tuple(conf.pretrained_config_archive_map.keys()) for conf in (GPT2Config, OpenAIGPTConfig, XLNetConfig, TransfoXLConfig, XLMConfig, CTRLConfig)), ())
MODEL_CLASSES = {
'gpt2': (GPT2LMHeadModel, GPT2Tokenizer),
'ctrl': (CTRLLMHeadModel, CTRLTokenizer),
'openai-gpt': (OpenAIGPTLMHeadModel, OpenAIGPTTokenizer),
'xlnet': (XLNetLMHeadModel, XLNetTokenizer),
'transfo-xl': (TransfoXLLMHeadModel, TransfoXLTokenizer),
'xlm': (XLMWithLMHeadModel, XLMTokenizer),
}
# Padding text to help Transformer-XL and XLNet with short prompts as proposed by Aman Rusia
# in https://github.com/rusiaaman/XLNet-gen#methodology
# and https://medium.com/@amanrusia/xlnet-speaks-comparison-to-gpt-2-ea1a4e9ba39e
# PADDING_TEXT = """ In 1991, the remains of Russian Tsar Nicholas II and his family
# (except for Alexei and Maria) are discovered.
# The voice of Nicholas's young son, Tsarevich Alexei Nikolaevich, narrates the
# remainder of the story. 1883 Western Siberia,
# a young Grigori Rasputin is asked by his father and a group of men to perform magic.
# Rasputin has a vision and denounces one of the men as a horse thief. Although his
# father initially slaps him for making such an accusation, Rasputin watches as the
# man is chased outside and beaten. Twenty years later, Rasputin sees a vision of
# the Virgin Mary, prompting him to become a priest. Rasputin quickly becomes famous,
# with people, even a bishop, begging for his blessing. <eod> </s> <eos>"""
def set_seed(args):
np.random.seed(args.seed)
torch.manual_seed(args.seed)
if args.n_gpu > 0:
torch.cuda.manual_seed_all(args.seed)
def top_k_top_p_filtering(logits, top_k=0, top_p=0.0, filter_value=-float('Inf')):
""" Filter a distribution of logits using top-k and/or nucleus (top-p) filtering
Args:
logits: logits distribution shape (batch size x vocabulary size)
top_k > 0: keep only top k tokens with highest probability (top-k filtering).
top_p > 0.0: keep the top tokens with cumulative probability >= top_p (nucleus filtering).
Nucleus filtering is described in Holtzman et al. (http://arxiv.org/abs/1904.09751)
From: https://gist.github.com/thomwolf/1a5a29f6962089e871b94cbd09daf317
"""
top_k = min(top_k, logits.size(-1)) # Safety check
if top_k > 0:
# Remove all tokens with a probability less than the last token of the top-k
indices_to_remove = logits < torch.topk(logits, top_k)[0][..., -1, None]
logits[indices_to_remove] = filter_value
if top_p > 0.0:
sorted_logits, sorted_indices = torch.sort(logits, descending=True)
cumulative_probs = torch.cumsum(F.softmax(sorted_logits, dim=-1), dim=-1)
# Remove tokens with cumulative probability above the threshold
sorted_indices_to_remove = cumulative_probs > top_p
# Shift the indices to the right to keep also the first token above the threshold
sorted_indices_to_remove[..., 1:] = sorted_indices_to_remove[..., :-1].clone()
sorted_indices_to_remove[..., 0] = 0
# scatter sorted tensors to original indexing
indices_to_remove = sorted_indices_to_remove.scatter(dim=1, index=sorted_indices, src=sorted_indices_to_remove)
logits[indices_to_remove] = filter_value
return logits
def sample_sequence(model, length, context, num_samples=1, temperature=1, top_k=0, top_p=0.0, repetition_penalty=1.0,
is_xlnet=False, is_xlm_mlm=False, xlm_mask_token=None, xlm_lang=None, device='cpu'):
context = torch.tensor(context, dtype=torch.long, device=device)
context = context.unsqueeze(0).repeat(num_samples, 1)
generated = context
# all_loss = []
with torch.no_grad():
for _ in range(length):
inputs = {'input_ids': generated}
if is_xlnet:
# XLNet is a direct (predict same token, not next token) and bi-directional model by default
# => need one additional dummy token in the input (will be masked), attention mask and target mapping (see model docstring)
input_ids = torch.cat((generated, torch.zeros((1, 1), dtype=torch.long, device=device)), dim=1)
perm_mask = torch.zeros((1, input_ids.shape[1], input_ids.shape[1]), dtype=torch.float, device=device)
perm_mask[:, :, -1] = 1.0 # Previous tokens don't see last token
target_mapping = torch.zeros((1, 1, input_ids.shape[1]), dtype=torch.float, device=device)
target_mapping[0, 0, -1] = 1.0 # predict last token
inputs = {'input_ids': input_ids, 'perm_mask': perm_mask, 'target_mapping': target_mapping}
if is_xlm_mlm and xlm_mask_token:
# XLM MLM models are direct models (predict same token, not next token)
# => need one additional dummy token in the input (will be masked and guessed)
input_ids = torch.cat((generated, torch.full((1, 1), xlm_mask_token, dtype=torch.long, device=device)), dim=1)
inputs = {'input_ids': input_ids}
if xlm_lang is not None:
inputs["langs"] = torch.tensor([xlm_lang] * inputs["input_ids"].shape[1], device=device).view(1, -1)
outputs = model(**inputs) # Note: we could also use 'past' with GPT-2/Transfo-XL/XLNet/CTRL (cached hidden-states)
next_token_logits = outputs[0][:, -1, :] / (temperature if temperature > 0 else 1.)
# print(next_token_logits.size())
# tmp_eval_loss = outputs[0][:, :, -1][-1][-1]
# print(outputs[0][:, :, -1][-1])
# print (tmp_eval_loss.size ())
# cur_loss = np.abs(tmp_eval_loss.item())
# print(cur_loss)
# all_loss.append(cur_loss)
# repetition penalty from CTRL (https://arxiv.org/abs/1909.05858)
for i in range(num_samples):
for _ in set(generated[i].tolist()):
next_token_logits[i, _] /= repetition_penalty
filtered_logits = top_k_top_p_filtering(next_token_logits, top_k=top_k, top_p=top_p)
if temperature == 0: # greedy sampling:
next_token = torch.argmax(filtered_logits, dim=-1).unsqueeze(-1)
else:
next_token = torch.multinomial(F.softmax(filtered_logits, dim=-1), num_samples=1)
generated = torch.cat((generated, next_token), dim=1)
# print(next_token.item())
if next_token.item() == 29:
break
# print(all_loss)
# avg_loss = np.mean (np.array (all_loss))
# ppl = np.exp(avg_loss)
# print('test_loss (bpe): %.4f, test_perplexity: %.4f' % (avg_loss, ppl))
return generated
# /data/xieyuqiang/story_comprehension/checkpoints_ft_with_roc/lmft_lm_gpt2_rocmedium_gn1_bp1_gc32_lr1_l100_e3_seed42_cgn1
# /data/xieyuqiang/story_comprehension/checkpoints_ft_with_cl/lmft_lm_gpt2_cl_gn1_bp1_gc32_lr1_l100_e3_seed42_cgn1
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--model_type", default='gpt2', type=str, required=False,
help="Model type selected in the list: " + ", ".join(MODEL_CLASSES.keys()))
parser.add_argument("--model_name_or_path", default='/data/xieyuqiang/story_comprehension/checkpoints_ft_with_roc/lmft_lm_gpt2_rocmedium_gn1_bp1_gc32_lr1_l100_e3_seed42_cgn1', type=str, required=False,
help="Path to pre-trained model or shortcut name selected in the list: " + ", ".join(ALL_MODELS))
parser.add_argument("--source_text_path", type=str, default="/data/xieyuqiang/story_comprehension/data/roc/roc_val.csv")
parser.add_argument("--prompt", type=str, default=" ")
parser.add_argument("--padding_text", type=str, default="")
parser.add_argument("--xlm_lang", type=str, default="", help="Optional language when used with the XLM model.")
parser.add_argument("--length", type=int, default=30)
parser.add_argument("--batch", type=int, default=10)
parser.add_argument("--num_samples", type=int, default=1)
parser.add_argument("--temperature", type=float, default=0,
help="temperature of 0 implies greedy sampling")
parser.add_argument("--repetition_penalty", type=float, default=1.2,
help="primarily useful for CTRL model; in that case, use 1.2")
parser.add_argument("--top_k", type=int, default=1)
parser.add_argument("--top_p", type=float, default=0.9)
parser.add_argument("--no_cuda", action='store_true',
help="Avoid using CUDA when available")
parser.add_argument('--seed', type=int, default=42,
help="random seed for initialization")
parser.add_argument('--stop_token', type=str, default='<|endoftext|>',
help="Token at which text generation is stopped")
parser.add_argument ('--style', type=str, default='temporal',
help="The style for generating the pseudo wrong endings: temporal/causal")
args = parser.parse_args()
args.device = torch.device("cuda" if torch.cuda.is_available() and not args.no_cuda else "cpu")
args.n_gpu = torch.cuda.device_count()
set_seed(args)
args.model_type = args.model_type.lower()
model_class, tokenizer_class = MODEL_CLASSES[args.model_type]
tokenizer = tokenizer_class.from_pretrained(args.model_name_or_path)
model = model_class.from_pretrained(args.model_name_or_path)
model.to(args.device)
model.eval()
if args.length < 0 and model.config.max_position_embeddings > 0:
args.length = model.config.max_position_embeddings
elif 0 < model.config.max_position_embeddings < args.length:
args.length = model.config.max_position_embeddings # No generation bigger than model size
elif args.length < 0:
args.length = MAX_LENGTH # avoid infinite loop
logger.info(args)
if args.model_type in ["ctrl"]:
if args.temperature > 0.7:
logger.info('CTRL typically works better with lower temperatures (and lower top_k).')
while True:
xlm_lang = None
# XLM Language usage detailed in the issues #1414
if args.model_type in ["xlm"] and hasattr(tokenizer, 'lang2id') and hasattr(model.config, 'use_lang_emb') \
and model.config.use_lang_emb:
if args.xlm_lang:
language = args.xlm_lang
else:
language = None
while language not in tokenizer.lang2id.keys():
language = input("Using XLM. Select language in " + str(list(tokenizer.lang2id.keys())) + " >>> ")
xlm_lang = tokenizer.lang2id[language]
# XLM masked-language modeling (MLM) models need masked token (see details in sample_sequence)
is_xlm_mlm = args.model_type in ["xlm"] and 'mlm' in args.model_name_or_path
if is_xlm_mlm:
xlm_mask_token = tokenizer.mask_token_id
else:
xlm_mask_token = None
raw_text = args.prompt if args.prompt else input("Model prompt >>> ")
if args.model_type in ["transfo-xl", "xlnet"]:
# Models with memory likes to have a long prompt for short inputs.
raw_text = (args.padding_text if args.padding_text else PADDING_TEXT) + raw_text
context_tokens = tokenizer.encode(raw_text, add_special_tokens=False)
if args.model_type == "ctrl":
if not any(context_tokens[0] == x for x in tokenizer.control_codes.values()):
logger.info("WARNING! You are not starting your generation from a control code so you won't get good results")
with open (args.source_text_path, 'r', encoding='utf-8') as data_file, \
open (args.source_text_path + "_base_result.tsv", 'w', encoding='utf-8') as new_file, \
open (args.source_text_path + "_base_eval.tsv", 'w', encoding='utf-8') as eval_file:
import csv
reader = csv.reader (data_file)
next (reader)
all_data = []
for line in reader:
all_data.append (line)
print (all_data[0])
new_file.write ('context\tsource\ttarget\n')
from tqdm import tqdm
source_corpus = []
target_corpus = []
for raw_data in tqdm(all_data):
context = ' '.join(raw_data[2:6])
source = raw_data[6]
# import random
list = raw_data[2:6]
# random.shuffle(list)
target = ' '.join(list)
context_tokens = tokenizer.encode (target, add_special_tokens=False)
out = sample_sequence (
model=model,
context=context_tokens,
num_samples=args.num_samples,
length=args.length,
temperature=args.temperature,
top_k=args.top_k,
top_p=args.top_p,
repetition_penalty=args.repetition_penalty,
is_xlnet=bool (args.model_type == "xlnet"),
is_xlm_mlm=is_xlm_mlm,
xlm_mask_token=xlm_mask_token,
xlm_lang=xlm_lang,
device=args.device,
)
out = out[:, len (context_tokens):].tolist ()
for o in out:
# text = tokenizer.decode(o, cleanI_up_tokenization_spaces=True)
text = tokenizer.decode (o)
text = text[: text.find (args.stop_token) if args.stop_token else None]
target = text.replace ('<|endoftext|>', '')
source_corpus.append(source)
target_corpus.append(target)
new_file.write (context+"\t"+source+"\t"+target+"\n")
bleu_list = []
rouge_ = []
for source, target in zip (source_corpus, target_corpus):
bleu = sacrebleu.corpus_bleu (target, source)
bleu_list.append (bleu.precisions)
rouge = Rouge ()
for source, target in zip (source_corpus, target_corpus):
# rouge_l = compute_rouge_L(source, target)
rouge_x = rouge.get_scores (source, target)
rouge_1 = rouge_x[0]["rouge-1"]['f']
rouge_2 = rouge_x[0]["rouge-2"]['f']
rouge_l = rouge_x[0]["rouge-l"]['f']
rouge_.append ([rouge_1, rouge_2, rouge_l])
bleu_score = np.mean (bleu_list, axis=0)
rouge_score_ = np.mean (rouge_, axis=0)
print ("BLEU-1 score: " + str (bleu_score[0]) + "\n")
print ("BLEU-2 score: " + str (bleu_score[1]) + "\n")
print ("BLEU-4 score: " + str (bleu_score[3]) + "\n")
print ("Rouge-1 score: " + str (rouge_score_[0] * 100) + "\n")
print ("Rouge-2 score: " + str (rouge_score_[1] * 100) + "\n")
print ("Rouge-L score: " + str (rouge_score_[2] * 100) + "\n")
eval_file.write ("BLEU-1 score: " + str (bleu_score[0]) + "\n")
eval_file.write ("BLEU-2 score: " + str (bleu_score[1]) + "\n")
eval_file.write ("BLEU-4 score: " + str (bleu_score[3]) + "\n")
eval_file.write ("Rouge-1 score: " + str (rouge_score_[0] * 100) + "\n")
eval_file.write ("Rouge-2 score: " + str (rouge_score_[1] * 100) + "\n")
eval_file.write ("Rouge-L score: " + str (rouge_score_[2] * 100) + "\n")
if args.prompt:
break
# return target
if __name__ == '__main__':
main()
| [] |
2024-01-10 | IndexFziQ/CLSEG | src~run_generation_baseline_pt.py | #!/usr/bin/env python3
# coding=utf-8
# Copyright 2018 Google AI, Google Brain and Carnegie Mellon University Authors and the HuggingFace Inc. team.
# Copyright (c) 2018, NVIDIA CORPORATION. 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.
""" Conditional text generation with the auto-regressive models of the library (GPT/GPT-2/CTRL/Transformer-XL/XLNet)
"""
from __future__ import absolute_import, division, print_function, unicode_literals
import argparse
import logging
from tqdm import trange
import torch
import torch.nn.functional as F
import numpy as np
from transformers import GPT2Config, OpenAIGPTConfig, XLNetConfig, TransfoXLConfig, XLMConfig, CTRLConfig
from transformers import GPT2LMHeadModel, GPT2Tokenizer
from transformers import OpenAIGPTLMHeadModel, OpenAIGPTTokenizer
from transformers import XLNetLMHeadModel, XLNetTokenizer
from transformers import TransfoXLLMHeadModel, TransfoXLTokenizer
from transformers import CTRLLMHeadModel, CTRLTokenizer
from transformers import XLMWithLMHeadModel, XLMTokenizer
# from tools.EA.get_concepts_from_behave import tokenization, lower_case
# from tools.EA.LIB.EVAL.bleu import compute_bleu
# from tools.EA.LIB.EVAL.rouge import compute_rouge_L
import sacrebleu
from rouge import Rouge
logging.basicConfig(format = '%(asctime)s - %(levelname)s - %(name)s - %(message)s',
datefmt = '%m/%d/%Y %H:%M:%S',
level = logging.INFO)
logger = logging.getLogger(__name__)
MAX_LENGTH = int(10000) # Hardcoded max length to avoid infinite loop
ALL_MODELS = sum((tuple(conf.pretrained_config_archive_map.keys()) for conf in (GPT2Config, OpenAIGPTConfig, XLNetConfig, TransfoXLConfig, XLMConfig, CTRLConfig)), ())
MODEL_CLASSES = {
'gpt2': (GPT2LMHeadModel, GPT2Tokenizer),
'ctrl': (CTRLLMHeadModel, CTRLTokenizer),
'openai-gpt': (OpenAIGPTLMHeadModel, OpenAIGPTTokenizer),
'xlnet': (XLNetLMHeadModel, XLNetTokenizer),
'transfo-xl': (TransfoXLLMHeadModel, TransfoXLTokenizer),
'xlm': (XLMWithLMHeadModel, XLMTokenizer),
}
# Padding text to help Transformer-XL and XLNet with short prompts as proposed by Aman Rusia
# in https://github.com/rusiaaman/XLNet-gen#methodology
# and https://medium.com/@amanrusia/xlnet-speaks-comparison-to-gpt-2-ea1a4e9ba39e
# PADDING_TEXT = """ In 1991, the remains of Russian Tsar Nicholas II and his family
# (except for Alexei and Maria) are discovered.
# The voice of Nicholas's young son, Tsarevich Alexei Nikolaevich, narrates the
# remainder of the story. 1883 Western Siberia,
# a young Grigori Rasputin is asked by his father and a group of men to perform magic.
# Rasputin has a vision and denounces one of the men as a horse thief. Although his
# father initially slaps him for making such an accusation, Rasputin watches as the
# man is chased outside and beaten. Twenty years later, Rasputin sees a vision of
# the Virgin Mary, prompting him to become a priest. Rasputin quickly becomes famous,
# with people, even a bishop, begging for his blessing. <eod> </s> <eos>"""
def set_seed(args):
np.random.seed(args.seed)
torch.manual_seed(args.seed)
if args.n_gpu > 0:
torch.cuda.manual_seed_all(args.seed)
def top_k_top_p_filtering(logits, top_k=0, top_p=0.0, filter_value=-float('Inf')):
""" Filter a distribution of logits using top-k and/or nucleus (top-p) filtering
Args:
logits: logits distribution shape (batch size x vocabulary size)
top_k > 0: keep only top k tokens with highest probability (top-k filtering).
top_p > 0.0: keep the top tokens with cumulative probability >= top_p (nucleus filtering).
Nucleus filtering is described in Holtzman et al. (http://arxiv.org/abs/1904.09751)
From: https://gist.github.com/thomwolf/1a5a29f6962089e871b94cbd09daf317
"""
top_k = min(top_k, logits.size(-1)) # Safety check
if top_k > 0:
# Remove all tokens with a probability less than the last token of the top-k
indices_to_remove = logits < torch.topk(logits, top_k)[0][..., -1, None]
logits[indices_to_remove] = filter_value
if top_p > 0.0:
sorted_logits, sorted_indices = torch.sort(logits, descending=True)
cumulative_probs = torch.cumsum(F.softmax(sorted_logits, dim=-1), dim=-1)
# Remove tokens with cumulative probability above the threshold
sorted_indices_to_remove = cumulative_probs > top_p
# Shift the indices to the right to keep also the first token above the threshold
sorted_indices_to_remove[..., 1:] = sorted_indices_to_remove[..., :-1].clone()
sorted_indices_to_remove[..., 0] = 0
# scatter sorted tensors to original indexing
indices_to_remove = sorted_indices_to_remove.scatter(dim=1, index=sorted_indices, src=sorted_indices_to_remove)
logits[indices_to_remove] = filter_value
return logits
def sample_sequence(model, length, context, num_samples=1, temperature=1, top_k=0, top_p=0.0, repetition_penalty=1.0,
is_xlnet=False, is_xlm_mlm=False, xlm_mask_token=None, xlm_lang=None, device='cpu'):
context = torch.tensor(context, dtype=torch.long, device=device)
context = context.unsqueeze(0).repeat(num_samples, 1)
generated = context
# all_loss = []
with torch.no_grad():
for _ in range(length):
inputs = {'input_ids': generated}
if is_xlnet:
# XLNet is a direct (predict same token, not next token) and bi-directional model by default
# => need one additional dummy token in the input (will be masked), attention mask and target mapping (see model docstring)
input_ids = torch.cat((generated, torch.zeros((1, 1), dtype=torch.long, device=device)), dim=1)
perm_mask = torch.zeros((1, input_ids.shape[1], input_ids.shape[1]), dtype=torch.float, device=device)
perm_mask[:, :, -1] = 1.0 # Previous tokens don't see last token
target_mapping = torch.zeros((1, 1, input_ids.shape[1]), dtype=torch.float, device=device)
target_mapping[0, 0, -1] = 1.0 # predict last token
inputs = {'input_ids': input_ids, 'perm_mask': perm_mask, 'target_mapping': target_mapping}
if is_xlm_mlm and xlm_mask_token:
# XLM MLM models are direct models (predict same token, not next token)
# => need one additional dummy token in the input (will be masked and guessed)
input_ids = torch.cat((generated, torch.full((1, 1), xlm_mask_token, dtype=torch.long, device=device)), dim=1)
inputs = {'input_ids': input_ids}
if xlm_lang is not None:
inputs["langs"] = torch.tensor([xlm_lang] * inputs["input_ids"].shape[1], device=device).view(1, -1)
outputs = model(**inputs) # Note: we could also use 'past' with GPT-2/Transfo-XL/XLNet/CTRL (cached hidden-states)
next_token_logits = outputs[0][:, -1, :] / (temperature if temperature > 0 else 1.)
# print(next_token_logits.size())
# tmp_eval_loss = outputs[0][:, :, -1][-1][-1]
# print(outputs[0][:, :, -1][-1])
# print (tmp_eval_loss.size ())
# cur_loss = np.abs(tmp_eval_loss.item())
# print(cur_loss)
# all_loss.append(cur_loss)
# repetition penalty from CTRL (https://arxiv.org/abs/1909.05858)
for i in range(num_samples):
for _ in set(generated[i].tolist()):
next_token_logits[i, _] /= repetition_penalty
filtered_logits = top_k_top_p_filtering(next_token_logits, top_k=top_k, top_p=top_p)
if temperature == 0: # greedy sampling:
next_token = torch.argmax(filtered_logits, dim=-1).unsqueeze(-1)
else:
next_token = torch.multinomial(F.softmax(filtered_logits, dim=-1), num_samples=1)
generated = torch.cat((generated, next_token), dim=1)
# print(next_token.item())
if next_token.item() == 29:
break
# print(all_loss)
# avg_loss = np.mean (np.array (all_loss))
# ppl = np.exp(avg_loss)
# print('test_loss (bpe): %.4f, test_perplexity: %.4f' % (avg_loss, ppl))
return generated
# /data/xieyuqiang/story_comprehension/checkpoints_ft_with_roc/lmft_lm_gpt2_rocmedium_gn1_bp1_gc32_lr1_l100_e3_seed42_cgn1
# /data/xieyuqiang/story_comprehension/checkpoints_ft_with_cl/lmft_lm_gpt2_cl_gn1_bp1_gc32_lr1_l100_e3_seed42_cgn1
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--model_type", default='gpt2', type=str, required=False,
help="Model type selected in the list: " + ", ".join(MODEL_CLASSES.keys()))
parser.add_argument("--model_name_or_path", default='/data/pretrained_models/pytorch-gpt2-medium', type=str, required=False,
help="Path to pre-trained model or shortcut name selected in the list: " + ", ".join(ALL_MODELS))
parser.add_argument("--source_text_path", type=str, default="/data/xieyuqiang/story_comprehension/data/roc/roc_val.csv")
parser.add_argument("--prompt", type=str, default=" ")
parser.add_argument("--padding_text", type=str, default="")
parser.add_argument("--xlm_lang", type=str, default="", help="Optional language when used with the XLM model.")
parser.add_argument("--length", type=int, default=30)
parser.add_argument("--batch", type=int, default=10)
parser.add_argument("--num_samples", type=int, default=1)
parser.add_argument("--temperature", type=float, default=0,
help="temperature of 0 implies greedy sampling")
parser.add_argument("--repetition_penalty", type=float, default=1.2,
help="primarily useful for CTRL model; in that case, use 1.2")
parser.add_argument("--top_k", type=int, default=1)
parser.add_argument("--top_p", type=float, default=0.9)
parser.add_argument("--no_cuda", action='store_true',
help="Avoid using CUDA when available")
parser.add_argument('--seed', type=int, default=42,
help="random seed for initialization")
parser.add_argument('--stop_token', type=str, default='<|endoftext|>',
help="Token at which text generation is stopped")
parser.add_argument ('--style', type=str, default='temporal',
help="The style for generating the pseudo wrong endings: temporal/causal")
args = parser.parse_args()
args.device = torch.device("cuda" if torch.cuda.is_available() and not args.no_cuda else "cpu")
args.n_gpu = torch.cuda.device_count()
set_seed(args)
args.model_type = args.model_type.lower()
model_class, tokenizer_class = MODEL_CLASSES[args.model_type]
tokenizer = tokenizer_class.from_pretrained(args.model_name_or_path)
model = model_class.from_pretrained(args.model_name_or_path)
model.to(args.device)
model.eval()
if args.length < 0 and model.config.max_position_embeddings > 0:
args.length = model.config.max_position_embeddings
elif 0 < model.config.max_position_embeddings < args.length:
args.length = model.config.max_position_embeddings # No generation bigger than model size
elif args.length < 0:
args.length = MAX_LENGTH # avoid infinite loop
logger.info(args)
if args.model_type in ["ctrl"]:
if args.temperature > 0.7:
logger.info('CTRL typically works better with lower temperatures (and lower top_k).')
while True:
xlm_lang = None
# XLM Language usage detailed in the issues #1414
if args.model_type in ["xlm"] and hasattr(tokenizer, 'lang2id') and hasattr(model.config, 'use_lang_emb') \
and model.config.use_lang_emb:
if args.xlm_lang:
language = args.xlm_lang
else:
language = None
while language not in tokenizer.lang2id.keys():
language = input("Using XLM. Select language in " + str(list(tokenizer.lang2id.keys())) + " >>> ")
xlm_lang = tokenizer.lang2id[language]
# XLM masked-language modeling (MLM) models need masked token (see details in sample_sequence)
is_xlm_mlm = args.model_type in ["xlm"] and 'mlm' in args.model_name_or_path
if is_xlm_mlm:
xlm_mask_token = tokenizer.mask_token_id
else:
xlm_mask_token = None
raw_text = args.prompt if args.prompt else input("Model prompt >>> ")
if args.model_type in ["transfo-xl", "xlnet"]:
# Models with memory likes to have a long prompt for short inputs.
raw_text = (args.padding_text if args.padding_text else PADDING_TEXT) + raw_text
context_tokens = tokenizer.encode(raw_text, add_special_tokens=False)
if args.model_type == "ctrl":
if not any(context_tokens[0] == x for x in tokenizer.control_codes.values()):
logger.info("WARNING! You are not starting your generation from a control code so you won't get good results")
with open (args.source_text_path, 'r', encoding='utf-8') as data_file, \
open (args.source_text_path + "_pt_result.tsv", 'w', encoding='utf-8') as new_file, \
open (args.source_text_path + "_pt_eval.tsv", 'w', encoding='utf-8') as eval_file:
import csv
reader = csv.reader (data_file)
next (reader)
all_data = []
for line in reader:
all_data.append (line)
print (all_data[0])
new_file.write ('context\tsource\ttarget\n')
from tqdm import tqdm
source_corpus = []
target_corpus = []
for raw_data in tqdm(all_data):
context = ' '.join(raw_data[2:6])
source = raw_data[6]
# import random
list = raw_data[2:6]
# random.shuffle(list)
target = ' '.join(list)
context_tokens = tokenizer.encode (target, add_special_tokens=False)
out = sample_sequence (
model=model,
context=context_tokens,
num_samples=args.num_samples,
length=args.length,
temperature=args.temperature,
top_k=args.top_k,
top_p=args.top_p,
repetition_penalty=args.repetition_penalty,
is_xlnet=bool (args.model_type == "xlnet"),
is_xlm_mlm=is_xlm_mlm,
xlm_mask_token=xlm_mask_token,
xlm_lang=xlm_lang,
device=args.device,
)
out = out[:, len (context_tokens):].tolist ()
for o in out:
# text = tokenizer.decode(o, cleanI_up_tokenization_spaces=True)
text = tokenizer.decode (o)
text = text[: text.find (args.stop_token) if args.stop_token else None]
target = text.replace ('<|endoftext|>', '')
source_corpus.append(source)
target_corpus.append(target)
new_file.write (context+"\t"+source+"\t"+target+"\n")
bleu_list = []
rouge_ = []
for source, target in zip (source_corpus, target_corpus):
bleu = sacrebleu.corpus_bleu (target, source)
bleu_list.append (bleu.precisions)
rouge = Rouge ()
for source, target in zip (source_corpus, target_corpus):
# rouge_l = compute_rouge_L(source, target)
rouge_x = rouge.get_scores (source, target)
rouge_1 = rouge_x[0]["rouge-1"]['f']
rouge_2 = rouge_x[0]["rouge-2"]['f']
rouge_l = rouge_x[0]["rouge-l"]['f']
rouge_.append ([rouge_1, rouge_2, rouge_l])
bleu_score = np.mean (bleu_list, axis=0)
rouge_score_ = np.mean (rouge_, axis=0)
print ("BLEU-1 score: " + str (bleu_score[0]) + "\n")
print ("BLEU-2 score: " + str (bleu_score[1]) + "\n")
print ("BLEU-4 score: " + str (bleu_score[3]) + "\n")
print ("Rouge-1 score: " + str (rouge_score_[0] * 100) + "\n")
print ("Rouge-2 score: " + str (rouge_score_[1] * 100) + "\n")
print ("Rouge-L score: " + str (rouge_score_[2] * 100) + "\n")
eval_file.write ("BLEU-1 score: " + str (bleu_score[0]) + "\n")
eval_file.write ("BLEU-2 score: " + str (bleu_score[1]) + "\n")
eval_file.write ("BLEU-4 score: " + str (bleu_score[3]) + "\n")
eval_file.write ("Rouge-1 score: " + str (rouge_score_[0] * 100) + "\n")
eval_file.write ("Rouge-2 score: " + str (rouge_score_[1] * 100) + "\n")
eval_file.write ("Rouge-L score: " + str (rouge_score_[2] * 100) + "\n")
if args.prompt:
break
# return target
if __name__ == '__main__':
main()
| [] |
2024-01-10 | IndexFziQ/CLSEG | src~run_generation_sample_cfg.py | #!/usr/bin/env python3
# coding=utf-8
# Copyright 2018 Google AI, Google Brain and Carnegie Mellon University Authors and the HuggingFace Inc. team.
# Copyright (c) 2018, NVIDIA CORPORATION. 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.
""" Conditional text generation with the auto-regressive models of the library (GPT/GPT-2/CTRL/Transformer-XL/XLNet)
"""
from __future__ import absolute_import, division, print_function, unicode_literals
import argparse
import logging
from tqdm import trange
import torch
import torch.nn.functional as F
import numpy as np
from transformers import GPT2Config, OpenAIGPTConfig, XLNetConfig, TransfoXLConfig, XLMConfig, CTRLConfig
from transformers import GPT2LMHeadModel, GPT2Tokenizer
from transformers import OpenAIGPTLMHeadModel, OpenAIGPTTokenizer
from transformers import XLNetLMHeadModel, XLNetTokenizer
from transformers import TransfoXLLMHeadModel, TransfoXLTokenizer
from transformers import CTRLLMHeadModel, CTRLTokenizer
from transformers import XLMWithLMHeadModel, XLMTokenizer
# from tools.EA.get_concepts_from_behave import tokenization, lower_case
# from tools.EA.LIB.EVAL.bleu import compute_bleu
# from tools.EA.LIB.EVAL.rouge import compute_rouge_L
import sacrebleu
from rouge import Rouge
logging.basicConfig(format = '%(asctime)s - %(levelname)s - %(name)s - %(message)s',
datefmt = '%m/%d/%Y %H:%M:%S',
level = logging.INFO)
logger = logging.getLogger(__name__)
MAX_LENGTH = int(10000) # Hardcoded max length to avoid infinite loop
ALL_MODELS = sum((tuple(conf.pretrained_config_archive_map.keys()) for conf in (GPT2Config, OpenAIGPTConfig, XLNetConfig, TransfoXLConfig, XLMConfig, CTRLConfig)), ())
MODEL_CLASSES = {
'gpt2': (GPT2LMHeadModel, GPT2Tokenizer),
'ctrl': (CTRLLMHeadModel, CTRLTokenizer),
'openai-gpt': (OpenAIGPTLMHeadModel, OpenAIGPTTokenizer),
'xlnet': (XLNetLMHeadModel, XLNetTokenizer),
'transfo-xl': (TransfoXLLMHeadModel, TransfoXLTokenizer),
'xlm': (XLMWithLMHeadModel, XLMTokenizer),
}
# Padding text to help Transformer-XL and XLNet with short prompts as proposed by Aman Rusia
# in https://github.com/rusiaaman/XLNet-gen#methodology
# and https://medium.com/@amanrusia/xlnet-speaks-comparison-to-gpt-2-ea1a4e9ba39e
# PADDING_TEXT = """ In 1991, the remains of Russian Tsar Nicholas II and his family
# (except for Alexei and Maria) are discovered.
# The voice of Nicholas's young son, Tsarevich Alexei Nikolaevich, narrates the
# remainder of the story. 1883 Western Siberia,
# a young Grigori Rasputin is asked by his father and a group of men to perform magic.
# Rasputin has a vision and denounces one of the men as a horse thief. Although his
# father initially slaps him for making such an accusation, Rasputin watches as the
# man is chased outside and beaten. Twenty years later, Rasputin sees a vision of
# the Virgin Mary, prompting him to become a priest. Rasputin quickly becomes famous,
# with people, even a bishop, begging for his blessing. <eod> </s> <eos>"""
def set_seed(args):
np.random.seed(args.seed)
torch.manual_seed(args.seed)
if args.n_gpu > 0:
torch.cuda.manual_seed_all(args.seed)
def top_k_top_p_filtering(logits, top_k=0, top_p=0.0, filter_value=-float('Inf')):
""" Filter a distribution of logits using top-k and/or nucleus (top-p) filtering
Args:
logits: logits distribution shape (batch size x vocabulary size)
top_k > 0: keep only top k tokens with highest probability (top-k filtering).
top_p > 0.0: keep the top tokens with cumulative probability >= top_p (nucleus filtering).
Nucleus filtering is described in Holtzman et al. (http://arxiv.org/abs/1904.09751)
From: https://gist.github.com/thomwolf/1a5a29f6962089e871b94cbd09daf317
"""
top_k = min(top_k, logits.size(-1)) # Safety check
if top_k > 0:
# Remove all tokens with a probability less than the last token of the top-k
indices_to_remove = logits < torch.topk(logits, top_k)[0][..., -1, None]
logits[indices_to_remove] = filter_value
if top_p > 0.0:
sorted_logits, sorted_indices = torch.sort(logits, descending=True)
cumulative_probs = torch.cumsum(F.softmax(sorted_logits, dim=-1), dim=-1)
# Remove tokens with cumulative probability above the threshold
sorted_indices_to_remove = cumulative_probs > top_p
# Shift the indices to the right to keep also the first token above the threshold
sorted_indices_to_remove[..., 1:] = sorted_indices_to_remove[..., :-1].clone()
sorted_indices_to_remove[..., 0] = 0
# scatter sorted tensors to original indexing
indices_to_remove = sorted_indices_to_remove.scatter(dim=1, index=sorted_indices, src=sorted_indices_to_remove)
logits[indices_to_remove] = filter_value
return logits
def sample_sequence(model, length, context, num_samples=1, temperature=1, top_k=0, top_p=0.0, repetition_penalty=1.0,
is_xlnet=False, is_xlm_mlm=False, xlm_mask_token=None, xlm_lang=None, device='cpu'):
context = torch.tensor(context, dtype=torch.long, device=device)
context = context.unsqueeze(0).repeat(num_samples, 1)
generated = context
# all_loss = []
with torch.no_grad():
for _ in range(length):
inputs = {'input_ids': generated}
if is_xlnet:
# XLNet is a direct (predict same token, not next token) and bi-directional model by default
# => need one additional dummy token in the input (will be masked), attention mask and target mapping (see model docstring)
input_ids = torch.cat((generated, torch.zeros((1, 1), dtype=torch.long, device=device)), dim=1)
perm_mask = torch.zeros((1, input_ids.shape[1], input_ids.shape[1]), dtype=torch.float, device=device)
perm_mask[:, :, -1] = 1.0 # Previous tokens don't see last token
target_mapping = torch.zeros((1, 1, input_ids.shape[1]), dtype=torch.float, device=device)
target_mapping[0, 0, -1] = 1.0 # predict last token
inputs = {'input_ids': input_ids, 'perm_mask': perm_mask, 'target_mapping': target_mapping}
if is_xlm_mlm and xlm_mask_token:
# XLM MLM models are direct models (predict same token, not next token)
# => need one additional dummy token in the input (will be masked and guessed)
input_ids = torch.cat((generated, torch.full((1, 1), xlm_mask_token, dtype=torch.long, device=device)), dim=1)
inputs = {'input_ids': input_ids}
if xlm_lang is not None:
inputs["langs"] = torch.tensor([xlm_lang] * inputs["input_ids"].shape[1], device=device).view(1, -1)
outputs = model(**inputs) # Note: we could also use 'past' with GPT-2/Transfo-XL/XLNet/CTRL (cached hidden-states)
next_token_logits = outputs[0][:, -1, :] / (temperature if temperature > 0 else 1.)
# print(next_token_logits.size())
# tmp_eval_loss = outputs[0][:, :, -1][-1][-1]
# print(outputs[0][:, :, -1][-1])
# print (tmp_eval_loss.size ())
# cur_loss = np.abs(tmp_eval_loss.item())
# print(cur_loss)
# all_loss.append(cur_loss)
# repetition penalty from CTRL (https://arxiv.org/abs/1909.05858)
for i in range(num_samples):
for _ in set(generated[i].tolist()):
next_token_logits[i, _] /= repetition_penalty
filtered_logits = top_k_top_p_filtering(next_token_logits, top_k=top_k, top_p=top_p)
if temperature == 0: # greedy sampling:
next_token = torch.argmax(filtered_logits, dim=-1).unsqueeze(-1)
else:
next_token = torch.multinomial(F.softmax(filtered_logits, dim=-1), num_samples=1)
generated = torch.cat((generated, next_token), dim=1)
# print(next_token.item())
if next_token.item() == 29:
break
# print(all_loss)
# avg_loss = np.mean (np.array (all_loss))
# ppl = np.exp(avg_loss)
# print('test_loss (bpe): %.4f, test_perplexity: %.4f' % (avg_loss, ppl))
return generated
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--model_type", default='gpt2', type=str, required=False,
help="Model type selected in the list: " + ", ".join(MODEL_CLASSES.keys()))
parser.add_argument("--model_name_or_path", default='/data/xieyuqiang/story_comprehension/checkpoints_ft_with_roc/lmft_lm_gpt2_roc_gn1_bp1_gc32_lr1_l100_e3_seed42_cgn1', type=str, required=False,
help="Path to pre-trained model or shortcut name selected in the list: " + ", ".join(ALL_MODELS))
parser.add_argument("--source_text_path", type=str, default="/data/xieyuqiang/story_comprehension/data/roc/roc_train.csv")
parser.add_argument("--prompt", type=str, default=" ")
parser.add_argument("--padding_text", type=str, default="")
parser.add_argument("--xlm_lang", type=str, default="", help="Optional language when used with the XLM model.")
parser.add_argument("--length", type=int, default=60)
parser.add_argument("--batch", type=int, default=2)
parser.add_argument("--num_samples", type=int, default=1)
parser.add_argument("--temperature", type=float, default=0,
help="temperature of 0 implies greedy sampling")
parser.add_argument("--repetition_penalty", type=float, default=1.2,
help="primarily useful for CTRL model; in that case, use 1.2")
parser.add_argument("--top_k", type=int, default=1)
parser.add_argument("--top_p", type=float, default=0.9)
parser.add_argument("--no_cuda", action='store_true',
help="Avoid using CUDA when available")
parser.add_argument('--seed', type=int, default=42,
help="random seed for initialization")
parser.add_argument('--stop_token', type=str, default='<|endoftext|>',
help="Token at which text generation is stopped")
parser.add_argument ('--style', type=str, default='temporal',
help="The style for generating the pseudo wrong endings: temporal/causal")
args = parser.parse_args()
args.device = torch.device("cuda" if torch.cuda.is_available() and not args.no_cuda else "cpu")
args.n_gpu = torch.cuda.device_count()
set_seed(args)
if args.style == 'temporal':
args.source_text_path = '/data/xieyuqiang/story_comprehension/data/roc/roc_train.csv'
if args.style == 'causal':
args.source_text_path = '/data/xieyuqiang/story_comprehension/data/roc/roc_train.csv_causal.tsv'
args.model_type = args.model_type.lower()
model_class, tokenizer_class = MODEL_CLASSES[args.model_type]
tokenizer = tokenizer_class.from_pretrained(args.model_name_or_path)
model = model_class.from_pretrained(args.model_name_or_path)
model.to(args.device)
model.eval()
if args.length < 0 and model.config.max_position_embeddings > 0:
args.length = model.config.max_position_embeddings
elif 0 < model.config.max_position_embeddings < args.length:
args.length = model.config.max_position_embeddings # No generation bigger than model size
elif args.length < 0:
args.length = MAX_LENGTH # avoid infinite loop
logger.info(args)
if args.model_type in ["ctrl"]:
if args.temperature > 0.7:
logger.info('CTRL typically works better with lower temperatures (and lower top_k).')
while True:
xlm_lang = None
# XLM Language usage detailed in the issues #1414
if args.model_type in ["xlm"] and hasattr(tokenizer, 'lang2id') and hasattr(model.config, 'use_lang_emb') \
and model.config.use_lang_emb:
if args.xlm_lang:
language = args.xlm_lang
else:
language = None
while language not in tokenizer.lang2id.keys():
language = input("Using XLM. Select language in " + str(list(tokenizer.lang2id.keys())) + " >>> ")
xlm_lang = tokenizer.lang2id[language]
# XLM masked-language modeling (MLM) models need masked token (see details in sample_sequence)
is_xlm_mlm = args.model_type in ["xlm"] and 'mlm' in args.model_name_or_path
if is_xlm_mlm:
xlm_mask_token = tokenizer.mask_token_id
else:
xlm_mask_token = None
raw_text = args.prompt if args.prompt else input("Model prompt >>> ")
if args.model_type in ["transfo-xl", "xlnet"]:
# Models with memory likes to have a long prompt for short inputs.
raw_text = (args.padding_text if args.padding_text else PADDING_TEXT) + raw_text
context_tokens = tokenizer.encode(raw_text, add_special_tokens=False)
if args.model_type == "ctrl":
if not any(context_tokens[0] == x for x in tokenizer.control_codes.values()):
logger.info("WARNING! You are not starting your generation from a control code so you won't get good results")
with open (args.source_text_path, 'r', encoding='utf-8') as data_file, \
open (args.source_text_path + "_generated.tsv", 'w', encoding='utf-8') as new_file, \
open (args.source_text_path + "_eval.tsv", 'w', encoding='utf-8') as eval_file:
import csv
reader = csv.reader (data_file)
next (reader)
all_data = []
for line in reader:
all_data.append (line)
print (all_data[0])
new_file.write ('context\tsource\ttarget\n')
from tqdm import tqdm
source_corpus = []
target_corpus = []
for raw_data in tqdm(all_data):
context = ' '.join(raw_data[2:6])
source = raw_data[6]
target = ''
if args.style == 'temporal':
import random
list = raw_data[2:6]
random.shuffle(list)
target = ' '.join(list)
elif args.style == 'causal':
target = ' '.join(raw_data[2:6])
else:
logger.info ("WARNING! Target is UNK.")
context_tokens = tokenizer.encode (target, add_special_tokens=False)
out = sample_sequence (
model=model,
context=context_tokens,
num_samples=args.num_samples,
length=args.length,
temperature=args.temperature,
top_k=args.top_k,
top_p=args.top_p,
repetition_penalty=args.repetition_penalty,
is_xlnet=bool (args.model_type == "xlnet"),
is_xlm_mlm=is_xlm_mlm,
xlm_mask_token=xlm_mask_token,
xlm_lang=xlm_lang,
device=args.device,
)
out = out[:, len (context_tokens):].tolist ()
for o in out:
# text = tokenizer.decode(o, cleanI_up_tokenization_spaces=True)
text = tokenizer.decode (o)
text = text[: text.find (args.stop_token) if args.stop_token else None]
target = text.replace ('<|endoftext|>', '')
source_corpus.append(source)
target_corpus.append(target)
new_file.write (context+"\t"+source+"\t"+target+"\n")
bleu_list = []
rouge_ = []
for source, target in zip (source_corpus, target_corpus):
bleu = sacrebleu.corpus_bleu (target, source)
bleu_list.append (bleu.precisions)
rouge = Rouge ()
for source, target in zip (source_corpus, target_corpus):
# rouge_l = compute_rouge_L(source, target)
rouge_x = rouge.get_scores (source, target)
rouge_1 = rouge_x[0]["rouge-1"]['f']
rouge_2 = rouge_x[0]["rouge-2"]['f']
rouge_l = rouge_x[0]["rouge-l"]['f']
rouge_.append ([rouge_1, rouge_2, rouge_l])
bleu_score = np.mean (bleu_list, axis=0)
rouge_score_ = np.mean (rouge_, axis=0)
print ("BLEU-1 score: " + str (bleu_score[0]) + "\n")
print ("BLEU-2 score: " + str (bleu_score[1]) + "\n")
print ("BLEU-4 score: " + str (bleu_score[3]) + "\n")
print ("Rouge-1 score: " + str (rouge_score_[0] * 100) + "\n")
print ("Rouge-2 score: " + str (rouge_score_[1] * 100) + "\n")
print ("Rouge-L score: " + str (rouge_score_[2] * 100) + "\n")
eval_file.write ("BLEU-1 score: " + str (bleu_score[0]) + "\n")
eval_file.write ("BLEU-2 score: " + str (bleu_score[1]) + "\n")
eval_file.write ("BLEU-4 score: " + str (bleu_score[3]) + "\n")
eval_file.write ("Rouge-1 score: " + str (rouge_score_[0] * 100) + "\n")
eval_file.write ("Rouge-2 score: " + str (rouge_score_[1] * 100) + "\n")
eval_file.write ("Rouge-L score: " + str (rouge_score_[2] * 100) + "\n")
if args.prompt:
break
# return target
if __name__ == '__main__':
main()
| [] |
2024-01-10 | IndexFziQ/CLSEG | src~run_generation_sample_sct.py | #!/usr/bin/env python3
# coding=utf-8
# Copyright 2018 Google AI, Google Brain and Carnegie Mellon University Authors and the HuggingFace Inc. team.
# Copyright (c) 2018, NVIDIA CORPORATION. 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.
""" Conditional text generation with the auto-regressive models of the library (GPT/GPT-2/CTRL/Transformer-XL/XLNet)
"""
from __future__ import absolute_import, division, print_function, unicode_literals
import argparse
import logging
import torch
import torch.nn.functional as F
import numpy as np
from transformers import GPT2Config, OpenAIGPTConfig, XLNetConfig, TransfoXLConfig, XLMConfig, CTRLConfig
from transformers import GPT2LMHeadModel, GPT2Tokenizer
from transformers import OpenAIGPTLMHeadModel, OpenAIGPTTokenizer
from transformers import XLNetLMHeadModel, XLNetTokenizer
from transformers import TransfoXLLMHeadModel, TransfoXLTokenizer
from transformers import CTRLLMHeadModel, CTRLTokenizer
from transformers import XLMWithLMHeadModel, XLMTokenizer
import sacrebleu
from rouge import Rouge
logging.basicConfig(format = '%(asctime)s - %(levelname)s - %(name)s - %(message)s',
datefmt = '%m/%d/%Y %H:%M:%S',
level = logging.INFO)
logger = logging.getLogger(__name__)
MAX_LENGTH = int(10000) # Hardcoded max length to avoid infinite loop
ALL_MODELS = sum((tuple(conf.pretrained_config_archive_map.keys()) for conf in (GPT2Config, OpenAIGPTConfig, XLNetConfig, TransfoXLConfig, XLMConfig, CTRLConfig)), ())
MODEL_CLASSES = {
'gpt2': (GPT2LMHeadModel, GPT2Tokenizer),
'ctrl': (CTRLLMHeadModel, CTRLTokenizer),
'openai-gpt': (OpenAIGPTLMHeadModel, OpenAIGPTTokenizer),
'xlnet': (XLNetLMHeadModel, XLNetTokenizer),
'transfo-xl': (TransfoXLLMHeadModel, TransfoXLTokenizer),
'xlm': (XLMWithLMHeadModel, XLMTokenizer),
}
# Padding text to help Transformer-XL and XLNet with short prompts as proposed by Aman Rusia
# in https://github.com/rusiaaman/XLNet-gen#methodology
# and https://medium.com/@amanrusia/xlnet-speaks-comparison-to-gpt-2-ea1a4e9ba39e
# PADDING_TEXT = """ In 1991, the remains of Russian Tsar Nicholas II and his family
# (except for Alexei and Maria) are discovered.
# The voice of Nicholas's young son, Tsarevich Alexei Nikolaevich, narrates the
# remainder of the story. 1883 Western Siberia,
# a young Grigori Rasputin is asked by his father and a group of men to perform magic.
# Rasputin has a vision and denounces one of the men as a horse thief. Although his
# father initially slaps him for making such an accusation, Rasputin watches as the
# man is chased outside and beaten. Twenty years later, Rasputin sees a vision of
# the Virgin Mary, prompting him to become a priest. Rasputin quickly becomes famous,
# with people, even a bishop, begging for his blessing. <eod> </s> <eos>"""
def set_seed(args):
np.random.seed(args.seed)
torch.manual_seed(args.seed)
if args.n_gpu > 0:
torch.cuda.manual_seed_all(args.seed)
def top_k_top_p_filtering(logits, top_k=0, top_p=0.0, filter_value=-float('Inf')):
""" Filter a distribution of logits using top-k and/or nucleus (top-p) filtering
Args:
logits: logits distribution shape (batch size x vocabulary size)
top_k > 0: keep only top k tokens with highest probability (top-k filtering).
top_p > 0.0: keep the top tokens with cumulative probability >= top_p (nucleus filtering).
Nucleus filtering is described in Holtzman et al. (http://arxiv.org/abs/1904.09751)
From: https://gist.github.com/thomwolf/1a5a29f6962089e871b94cbd09daf317
"""
top_k = min(top_k, logits.size(-1)) # Safety check
if top_k > 0:
# Remove all tokens with a probability less than the last token of the top-k
indices_to_remove = logits < torch.topk(logits, top_k)[0][..., -1, None]
logits[indices_to_remove] = filter_value
if top_p > 0.0:
sorted_logits, sorted_indices = torch.sort(logits, descending=True)
cumulative_probs = torch.cumsum(F.softmax(sorted_logits, dim=-1), dim=-1)
# Remove tokens with cumulative probability above the threshold
sorted_indices_to_remove = cumulative_probs > top_p
# Shift the indices to the right to keep also the first token above the threshold
sorted_indices_to_remove[..., 1:] = sorted_indices_to_remove[..., :-1].clone()
sorted_indices_to_remove[..., 0] = 0
# scatter sorted tensors to original indexing
indices_to_remove = sorted_indices_to_remove.scatter(dim=1, index=sorted_indices, src=sorted_indices_to_remove)
logits[indices_to_remove] = filter_value
return logits
def sample_sequence(model, length, context, num_samples=1, temperature=1, top_k=0, top_p=0.0, repetition_penalty=1.0,
is_xlnet=False, is_xlm_mlm=False, xlm_mask_token=None, xlm_lang=None, device='cpu'):
context = torch.tensor(context, dtype=torch.long, device=device)
context = context.unsqueeze(0).repeat(num_samples, 1)
generated = context
with torch.no_grad():
for _ in range(length):
inputs = {'input_ids': generated}
if is_xlnet:
# XLNet is a direct (predict same token, not next token) and bi-directional model by default
# => need one additional dummy token in the input (will be masked), attention mask and target mapping (see model docstring)
input_ids = torch.cat((generated, torch.zeros((1, 1), dtype=torch.long, device=device)), dim=1)
perm_mask = torch.zeros((1, input_ids.shape[1], input_ids.shape[1]), dtype=torch.float, device=device)
perm_mask[:, :, -1] = 1.0 # Previous tokens don't see last token
target_mapping = torch.zeros((1, 1, input_ids.shape[1]), dtype=torch.float, device=device)
target_mapping[0, 0, -1] = 1.0 # predict last token
inputs = {'input_ids': input_ids, 'perm_mask': perm_mask, 'target_mapping': target_mapping}
if is_xlm_mlm and xlm_mask_token:
# XLM MLM models are direct models (predict same token, not next token)
# => need one additional dummy token in the input (will be masked and guessed)
input_ids = torch.cat((generated, torch.full((1, 1), xlm_mask_token, dtype=torch.long, device=device)), dim=1)
inputs = {'input_ids': input_ids}
if xlm_lang is not None:
inputs["langs"] = torch.tensor([xlm_lang] * inputs["input_ids"].shape[1], device=device).view(1, -1)
outputs = model(**inputs) # Note: we could also use 'past' with GPT-2/Transfo-XL/XLNet/CTRL (cached hidden-states)
next_token_logits = outputs[0][:, -1, :] / (temperature if temperature > 0 else 1.)
# repetition penalty from CTRL (https://arxiv.org/abs/1909.05858)
for i in range(num_samples):
for _ in set(generated[i].tolist()):
next_token_logits[i, _] /= repetition_penalty
filtered_logits = top_k_top_p_filtering(next_token_logits, top_k=top_k, top_p=top_p)
if temperature == 0: # greedy sampling:
next_token = torch.argmax(filtered_logits, dim=-1).unsqueeze(-1)
else:
next_token = torch.multinomial(F.softmax(filtered_logits, dim=-1), num_samples=1)
generated = torch.cat((generated, next_token), dim=1)
if next_token.item() == 29:
break
return generated
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--model_type", default='gpt2', type=str, required=False,
help="Model type selected in the list: " + ", ".join(MODEL_CLASSES.keys()))
parser.add_argument("--model_name_or_path", default='/data/xieyuqiang/story_comprehension/checkpoints_ft_with_sct/lmft_lm_gpt2_wrong_v2_gn1_bp1_gc32_lr1_l100_e5_seed42_cgn1', type=str, required=False,
help="Path to pre-trained model or shortcut name selected in the list: " + ", ".join(ALL_MODELS))
parser.add_argument("--source_text_path", type=str, default="/data/xieyuqiang/story_comprehension/data/roc/roc_train.csv")
parser.add_argument("--prompt", type=str, default=" ")
parser.add_argument("--padding_text", type=str, default="")
parser.add_argument("--xlm_lang", type=str, default="", help="Optional language when used with the XLM model.")
parser.add_argument("--length", type=int, default=30)
parser.add_argument("--batch", type=int, default=5)
parser.add_argument("--num_samples", type=int, default=1)
parser.add_argument("--temperature", type=float, default=0,
help="temperature of 0 implies greedy sampling")
parser.add_argument("--repetition_penalty", type=float, default=1.2,
help="primarily useful for CTRL model; in that case, use 1.2")
parser.add_argument("--top_k", type=int, default=1)
parser.add_argument("--top_p", type=float, default=0.9)
parser.add_argument("--no_cuda", action='store_true',
help="Avoid using CUDA when available")
parser.add_argument('--seed', type=int, default=42,
help="random seed for initialization")
parser.add_argument('--stop_token', type=str, default='<|endoftext|>',
help="Token at which text generation is stopped")
parser.add_argument ('--style', type=str, default='temporal',
help="The style for generating the pseudo wrong endings: temporal/causal")
args = parser.parse_args()
args.device = torch.device("cuda" if torch.cuda.is_available() and not args.no_cuda else "cpu")
args.n_gpu = torch.cuda.device_count()
set_seed(args)
args.model_type = args.model_type.lower()
model_class, tokenizer_class = MODEL_CLASSES[args.model_type]
tokenizer = tokenizer_class.from_pretrained(args.model_name_or_path)
model = model_class.from_pretrained(args.model_name_or_path)
model.to(args.device)
model.eval()
if args.length < 0 and model.config.max_position_embeddings > 0:
args.length = model.config.max_position_embeddings
elif 0 < model.config.max_position_embeddings < args.length:
args.length = model.config.max_position_embeddings # No generation bigger than model size
elif args.length < 0:
args.length = MAX_LENGTH # avoid infinite loop
logger.info(args)
if args.model_type in ["ctrl"]:
if args.temperature > 0.7:
logger.info('CTRL typically works better with lower temperatures (and lower top_k).')
while True:
xlm_lang = None
# XLM Language usage detailed in the issues #1414
if args.model_type in ["xlm"] and hasattr(tokenizer, 'lang2id') and hasattr(model.config, 'use_lang_emb') \
and model.config.use_lang_emb:
if args.xlm_lang:
language = args.xlm_lang
else:
language = None
while language not in tokenizer.lang2id.keys():
language = input("Using XLM. Select language in " + str(list(tokenizer.lang2id.keys())) + " >>> ")
xlm_lang = tokenizer.lang2id[language]
# XLM masked-language modeling (MLM) models need masked token (see details in sample_sequence)
is_xlm_mlm = args.model_type in ["xlm"] and 'mlm' in args.model_name_or_path
if is_xlm_mlm:
xlm_mask_token = tokenizer.mask_token_id
else:
xlm_mask_token = None
raw_text = args.prompt if args.prompt else input("Model prompt >>> ")
if args.model_type in ["transfo-xl", "xlnet"]:
# Models with memory likes to have a long prompt for short inputs.
raw_text = (args.padding_text if args.padding_text else PADDING_TEXT) + raw_text
context_tokens = tokenizer.encode(raw_text, add_special_tokens=False)
if args.model_type == "ctrl":
if not any(context_tokens[0] == x for x in tokenizer.control_codes.values()):
logger.info("WARNING! You are not starting your generation from a control code so you won't get good results")
with open (args.source_text_path, 'r', encoding='utf-8') as data_file, \
open (args.source_text_path + "_sct_generated.tsv", 'w', encoding='utf-8') as new_file, \
open (args.source_text_path + "_sct_eval.tsv", 'w', encoding='utf-8') as eval_file:
import csv
import sys
csv.field_size_limit (sys.maxsize)
reader = csv.reader (data_file)
next (reader)
all_data = []
for line in reader:
all_data.append (line)
print (all_data[0])
new_file.write ('context\tsource\ttarget\n')
from tqdm import tqdm
source_corpus = []
target_corpus = []
for raw_data in tqdm(all_data):
context = ' '.join(raw_data[2:6])
source = raw_data[6]
target = context
context_tokens = tokenizer.encode (target, add_special_tokens=False)
out = sample_sequence (
model=model,
context=context_tokens,
num_samples=args.num_samples,
length=args.length,
temperature=args.temperature,
top_k=args.top_k,
top_p=args.top_p,
repetition_penalty=args.repetition_penalty,
is_xlnet=bool (args.model_type == "xlnet"),
is_xlm_mlm=is_xlm_mlm,
xlm_mask_token=xlm_mask_token,
xlm_lang=xlm_lang,
device=args.device,
)
out = out[:, len (context_tokens):].tolist ()
for o in out:
# text = tokenizer.decode(o, cleanI_up_tokenization_spaces=True)
text = tokenizer.decode (o)
text = text[: text.find (args.stop_token) if args.stop_token else None]
target = text.replace ('<|endoftext|>', '')
source_corpus.append(source)
target_corpus.append(target)
new_file.write (context+"\t"+source+"\t"+target+"\n")
bleu_list = []
rouge_ = []
for source, target in zip (source_corpus, target_corpus):
bleu = sacrebleu.corpus_bleu(target, source)
bleu_list.append(bleu.precisions)
rouge = Rouge ()
for source, target in zip(source_corpus, target_corpus):
# rouge_l = compute_rouge_L(source, target)
rouge_x = rouge.get_scores(source, target)
rouge_1 = rouge_x[0]["rouge-1"]['f']
rouge_2 = rouge_x[0]["rouge-2"]['f']
rouge_l = rouge_x[0]["rouge-l"]['f']
rouge_.append([rouge_1,rouge_2,rouge_l])
bleu_score = np.mean(bleu_list,axis=0)
rouge_score_ = np.mean(rouge_,axis=0)
print ("BLEU-1 score: " + str (bleu_score[0]) + "\n")
print ("BLEU-2 score: " + str (bleu_score[1]) + "\n")
print ("BLEU-4 score: " + str (bleu_score[3]) + "\n")
print ("Rouge-1 score: " + str (rouge_score_[0] * 100) + "\n")
print ("Rouge-2 score: " + str (rouge_score_[1] * 100) + "\n")
print ("Rouge-L score: " + str (rouge_score_[2] * 100) + "\n")
eval_file.write("BLEU-1 score: " + str (bleu_score[0]) +"\n")
eval_file.write("BLEU-2 score: " + str (bleu_score[1]) + "\n")
eval_file.write("BLEU-4 score: " + str (bleu_score[3]) + "\n")
eval_file.write("Rouge-1 score: " + str (rouge_score_[0]*100) + "\n")
eval_file.write("Rouge-2 score: " + str (rouge_score_[1]*100) + "\n")
eval_file.write("Rouge-L score: " + str (rouge_score_[2]*100) + "\n")
if args.prompt:
break
# return target
if __name__ == '__main__':
main()
| [] |
2024-01-10 | IndexFziQ/CLSEG | src~run_generation_cl_is.py | #!/usr/bin/env python3
# coding=utf-8
# Copyright 2018 Google AI, Google Brain and Carnegie Mellon University Authors and the HuggingFace Inc. team.
# Copyright (c) 2018, NVIDIA CORPORATION. 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.
""" Conditional text generation with the auto-regressive models of the library (GPT/GPT-2/CTRL/Transformer-XL/XLNet)
"""
from __future__ import absolute_import, division, print_function, unicode_literals
import argparse
import logging
from tqdm import trange
import torch
import torch.nn.functional as F
import numpy as np
from transformers import GPT2Config, OpenAIGPTConfig, XLNetConfig, TransfoXLConfig, XLMConfig, CTRLConfig
from transformers import GPT2LMHeadModel, GPT2Tokenizer
from transformers import OpenAIGPTLMHeadModel, OpenAIGPTTokenizer
from transformers import XLNetLMHeadModel, XLNetTokenizer
from transformers import TransfoXLLMHeadModel, TransfoXLTokenizer
from transformers import CTRLLMHeadModel, CTRLTokenizer
from transformers import XLMWithLMHeadModel, XLMTokenizer
# from tools.EA.get_concepts_from_behave import tokenization, lower_case
# from tools.EA.LIB.EVAL.bleu import compute_bleu
# from tools.EA.LIB.EVAL.rouge import compute_rouge_L
import sacrebleu
from rouge import Rouge
logging.basicConfig(format = '%(asctime)s - %(levelname)s - %(name)s - %(message)s',
datefmt = '%m/%d/%Y %H:%M:%S',
level = logging.INFO)
logger = logging.getLogger(__name__)
MAX_LENGTH = int(10000) # Hardcoded max length to avoid infinite loop
ALL_MODELS = sum((tuple(conf.pretrained_config_archive_map.keys()) for conf in (GPT2Config, OpenAIGPTConfig, XLNetConfig, TransfoXLConfig, XLMConfig, CTRLConfig)), ())
MODEL_CLASSES = {
'gpt2': (GPT2LMHeadModel, GPT2Tokenizer),
'ctrl': (CTRLLMHeadModel, CTRLTokenizer),
'openai-gpt': (OpenAIGPTLMHeadModel, OpenAIGPTTokenizer),
'xlnet': (XLNetLMHeadModel, XLNetTokenizer),
'transfo-xl': (TransfoXLLMHeadModel, TransfoXLTokenizer),
'xlm': (XLMWithLMHeadModel, XLMTokenizer),
}
# Padding text to help Transformer-XL and XLNet with short prompts as proposed by Aman Rusia
# in https://github.com/rusiaaman/XLNet-gen#methodology
# and https://medium.com/@amanrusia/xlnet-speaks-comparison-to-gpt-2-ea1a4e9ba39e
# PADDING_TEXT = """ In 1991, the remains of Russian Tsar Nicholas II and his family
# (except for Alexei and Maria) are discovered.
# The voice of Nicholas's young son, Tsarevich Alexei Nikolaevich, narrates the
# remainder of the story. 1883 Western Siberia,
# a young Grigori Rasputin is asked by his father and a group of men to perform magic.
# Rasputin has a vision and denounces one of the men as a horse thief. Although his
# father initially slaps him for making such an accusation, Rasputin watches as the
# man is chased outside and beaten. Twenty years later, Rasputin sees a vision of
# the Virgin Mary, prompting him to become a priest. Rasputin quickly becomes famous,
# with people, even a bishop, begging for his blessing. <eod> </s> <eos>"""
def set_seed(args):
np.random.seed(args.seed)
torch.manual_seed(args.seed)
if args.n_gpu > 0:
torch.cuda.manual_seed_all(args.seed)
def top_k_top_p_filtering(logits, top_k=0, top_p=0.0, filter_value=-float('Inf')):
""" Filter a distribution of logits using top-k and/or nucleus (top-p) filtering
Args:
logits: logits distribution shape (batch size x vocabulary size)
top_k > 0: keep only top k tokens with highest probability (top-k filtering).
top_p > 0.0: keep the top tokens with cumulative probability >= top_p (nucleus filtering).
Nucleus filtering is described in Holtzman et al. (http://arxiv.org/abs/1904.09751)
From: https://gist.github.com/thomwolf/1a5a29f6962089e871b94cbd09daf317
"""
top_k = min(top_k, logits.size(-1)) # Safety check
if top_k > 0:
# Remove all tokens with a probability less than the last token of the top-k
indices_to_remove = logits < torch.topk(logits, top_k)[0][..., -1, None]
logits[indices_to_remove] = filter_value
if top_p > 0.0:
sorted_logits, sorted_indices = torch.sort(logits, descending=True)
cumulative_probs = torch.cumsum(F.softmax(sorted_logits, dim=-1), dim=-1)
# Remove tokens with cumulative probability above the threshold
sorted_indices_to_remove = cumulative_probs > top_p
# Shift the indices to the right to keep also the first token above the threshold
sorted_indices_to_remove[..., 1:] = sorted_indices_to_remove[..., :-1].clone()
sorted_indices_to_remove[..., 0] = 0
# scatter sorted tensors to original indexing
indices_to_remove = sorted_indices_to_remove.scatter(dim=1, index=sorted_indices, src=sorted_indices_to_remove)
logits[indices_to_remove] = filter_value
return logits
def sample_sequence(model, length, context, num_samples=1, temperature=1, top_k=0, top_p=0.0, repetition_penalty=1.0,
is_xlnet=False, is_xlm_mlm=False, xlm_mask_token=None, xlm_lang=None, device='cpu'):
context = torch.tensor(context, dtype=torch.long, device=device)
context = context.unsqueeze(0).repeat(num_samples, 1)
generated = context
# all_loss = []
with torch.no_grad():
for _ in range(length):
inputs = {'input_ids': generated}
if is_xlnet:
# XLNet is a direct (predict same token, not next token) and bi-directional model by default
# => need one additional dummy token in the input (will be masked), attention mask and target mapping (see model docstring)
input_ids = torch.cat((generated, torch.zeros((1, 1), dtype=torch.long, device=device)), dim=1)
perm_mask = torch.zeros((1, input_ids.shape[1], input_ids.shape[1]), dtype=torch.float, device=device)
perm_mask[:, :, -1] = 1.0 # Previous tokens don't see last token
target_mapping = torch.zeros((1, 1, input_ids.shape[1]), dtype=torch.float, device=device)
target_mapping[0, 0, -1] = 1.0 # predict last token
inputs = {'input_ids': input_ids, 'perm_mask': perm_mask, 'target_mapping': target_mapping}
if is_xlm_mlm and xlm_mask_token:
# XLM MLM models are direct models (predict same token, not next token)
# => need one additional dummy token in the input (will be masked and guessed)
input_ids = torch.cat((generated, torch.full((1, 1), xlm_mask_token, dtype=torch.long, device=device)), dim=1)
inputs = {'input_ids': input_ids}
if xlm_lang is not None:
inputs["langs"] = torch.tensor([xlm_lang] * inputs["input_ids"].shape[1], device=device).view(1, -1)
outputs = model(**inputs) # Note: we could also use 'past' with GPT-2/Transfo-XL/XLNet/CTRL (cached hidden-states)
next_token_logits = outputs[0][:, -1, :] / (temperature if temperature > 0 else 1.)
# print(next_token_logits.size())
# tmp_eval_loss = outputs[0][:, :, -1][-1][-1]
# print(outputs[0][:, :, -1][-1])
# print (tmp_eval_loss.size ())
# cur_loss = np.abs(tmp_eval_loss.item())
# print(cur_loss)
# all_loss.append(cur_loss)
# repetition penalty from CTRL (https://arxiv.org/abs/1909.05858)
for i in range(num_samples):
for _ in set(generated[i].tolist()):
next_token_logits[i, _] /= repetition_penalty
filtered_logits = top_k_top_p_filtering(next_token_logits, top_k=top_k, top_p=top_p)
if temperature == 0: # greedy sampling:
next_token = torch.argmax(filtered_logits, dim=-1).unsqueeze(-1)
else:
next_token = torch.multinomial(F.softmax(filtered_logits, dim=-1), num_samples=1)
generated = torch.cat((generated, next_token), dim=1)
# print(next_token.item())
if next_token.item() == 29:
break
# print(all_loss)
# avg_loss = np.mean (np.array (all_loss))
# ppl = np.exp(avg_loss)
# print('test_loss (bpe): %.4f, test_perplexity: %.4f' % (avg_loss, ppl))
return generated
# /data/xieyuqiang/story_comprehension/checkpoints_ft_with_roc/lmft_lm_gpt2_rocmedium_gn1_bp1_gc32_lr1_l100_e3_seed42_cgn1
# /data/xieyuqiang/story_comprehension/checkpoints_ft_with_cl/lmft_lm_gpt2_cl_gn1_bp1_gc32_lr1_l100_e3_seed42_cgn1
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--model_type", default='gpt2', type=str, required=False,
help="Model type selected in the list: " + ", ".join(MODEL_CLASSES.keys()))
parser.add_argument("--model_name_or_path", default='/data/xieyuqiang/story_comprehension/checkpoints_ft_with_cl/lmft_lm_gpt2_clis_gn1_bp1_gc32_lr1_l128_e3_seed42_cgn1', type=str, required=False,
help="Path to pre-trained model or shortcut name selected in the list: " + ", ".join(ALL_MODELS))
parser.add_argument("--source_text_path", type=str, default="/data/xieyuqiang/story_comprehension/data/roc/roc_val.csv")
parser.add_argument("--prompt", type=str, default=" ")
parser.add_argument("--padding_text", type=str, default="")
parser.add_argument("--xlm_lang", type=str, default="", help="Optional language when used with the XLM model.")
parser.add_argument("--length", type=int, default=30)
parser.add_argument("--batch", type=int, default=10)
parser.add_argument("--num_samples", type=int, default=1)
parser.add_argument("--temperature", type=float, default=0,
help="temperature of 0 implies greedy sampling")
parser.add_argument("--repetition_penalty", type=float, default=1.2,
help="primarily useful for CTRL model; in that case, use 1.2")
parser.add_argument("--top_k", type=int, default=1)
parser.add_argument("--top_p", type=float, default=0.9)
parser.add_argument("--no_cuda", action='store_true',
help="Avoid using CUDA when available")
parser.add_argument('--seed', type=int, default=42,
help="random seed for initialization")
parser.add_argument('--stop_token', type=str, default='<|endoftext|>',
help="Token at which text generation is stopped")
parser.add_argument ('--style', type=str, default='temporal',
help="The style for generating the pseudo wrong endings: temporal/causal")
args = parser.parse_args()
args.device = torch.device("cuda" if torch.cuda.is_available() and not args.no_cuda else "cpu")
args.n_gpu = torch.cuda.device_count()
set_seed(args)
args.model_type = args.model_type.lower()
model_class, tokenizer_class = MODEL_CLASSES[args.model_type]
tokenizer = tokenizer_class.from_pretrained(args.model_name_or_path)
model = model_class.from_pretrained(args.model_name_or_path)
model.to(args.device)
model.eval()
if args.length < 0 and model.config.max_position_embeddings > 0:
args.length = model.config.max_position_embeddings
elif 0 < model.config.max_position_embeddings < args.length:
args.length = model.config.max_position_embeddings # No generation bigger than model size
elif args.length < 0:
args.length = MAX_LENGTH # avoid infinite loop
logger.info(args)
if args.model_type in ["ctrl"]:
if args.temperature > 0.7:
logger.info('CTRL typically works better with lower temperatures (and lower top_k).')
while True:
xlm_lang = None
# XLM Language usage detailed in the issues #1414
if args.model_type in ["xlm"] and hasattr(tokenizer, 'lang2id') and hasattr(model.config, 'use_lang_emb') \
and model.config.use_lang_emb:
if args.xlm_lang:
language = args.xlm_lang
else:
language = None
while language not in tokenizer.lang2id.keys():
language = input("Using XLM. Select language in " + str(list(tokenizer.lang2id.keys())) + " >>> ")
xlm_lang = tokenizer.lang2id[language]
# XLM masked-language modeling (MLM) models need masked token (see details in sample_sequence)
is_xlm_mlm = args.model_type in ["xlm"] and 'mlm' in args.model_name_or_path
if is_xlm_mlm:
xlm_mask_token = tokenizer.mask_token_id
else:
xlm_mask_token = None
raw_text = args.prompt if args.prompt else input("Model prompt >>> ")
if args.model_type in ["transfo-xl", "xlnet"]:
# Models with memory likes to have a long prompt for short inputs.
raw_text = (args.padding_text if args.padding_text else PADDING_TEXT) + raw_text
context_tokens = tokenizer.encode(raw_text, add_special_tokens=False)
if args.model_type == "ctrl":
if not any(context_tokens[0] == x for x in tokenizer.control_codes.values()):
logger.info("WARNING! You are not starting your generation from a control code so you won't get good results")
with open (args.source_text_path, 'r', encoding='utf-8') as data_file, \
open (args.source_text_path + "_cl_is_result.tsv", 'w', encoding='utf-8') as new_file, \
open (args.source_text_path + "_cl_is_eval.tsv", 'w', encoding='utf-8') as eval_file:
import csv
reader = csv.reader (data_file)
next (reader)
all_data = []
for line in reader:
all_data.append (line)
print (all_data[0])
new_file.write ('context\tsource\ttarget\n')
from tqdm import tqdm
source_corpus = []
target_corpus = []
for raw_data in tqdm(all_data):
context = ' '.join(raw_data[2:6])
source = raw_data[6]
# import random
list = raw_data[2:6]
# random.shuffle(list)
target = ' '.join(list)
context_tokens = tokenizer.encode (target, add_special_tokens=False)
out = sample_sequence (
model=model,
context=context_tokens,
num_samples=args.num_samples,
length=args.length,
temperature=args.temperature,
top_k=args.top_k,
top_p=args.top_p,
repetition_penalty=args.repetition_penalty,
is_xlnet=bool (args.model_type == "xlnet"),
is_xlm_mlm=is_xlm_mlm,
xlm_mask_token=xlm_mask_token,
xlm_lang=xlm_lang,
device=args.device,
)
out = out[:, len (context_tokens):].tolist ()
for o in out:
# text = tokenizer.decode(o, cleanI_up_tokenization_spaces=True)
text = tokenizer.decode (o)
text = text[: text.find (args.stop_token) if args.stop_token else None]
target = text.replace ('<|endoftext|>', '')
source_corpus.append(source)
target_corpus.append(target)
new_file.write (context+"\t"+source+"\t"+target+"\n")
bleu_list = []
rouge_ = []
for source, target in zip (source_corpus, target_corpus):
bleu = sacrebleu.corpus_bleu (target, source)
bleu_list.append (bleu.precisions)
rouge = Rouge ()
for source, target in zip (source_corpus, target_corpus):
# rouge_l = compute_rouge_L(source, target)
rouge_x = rouge.get_scores (source, target)
rouge_1 = rouge_x[0]["rouge-1"]['f']
rouge_2 = rouge_x[0]["rouge-2"]['f']
rouge_l = rouge_x[0]["rouge-l"]['f']
rouge_.append ([rouge_1, rouge_2, rouge_l])
bleu_score = np.mean (bleu_list, axis=0)
rouge_score_ = np.mean (rouge_, axis=0)
print ("BLEU-1 score: " + str (bleu_score[0]) + "\n")
print ("BLEU-2 score: " + str (bleu_score[1]) + "\n")
print ("BLEU-4 score: " + str (bleu_score[3]) + "\n")
print ("Rouge-1 score: " + str (rouge_score_[0] * 100) + "\n")
print ("Rouge-2 score: " + str (rouge_score_[1] * 100) + "\n")
print ("Rouge-L score: " + str (rouge_score_[2] * 100) + "\n")
eval_file.write ("BLEU-1 score: " + str (bleu_score[0]) + "\n")
eval_file.write ("BLEU-2 score: " + str (bleu_score[1]) + "\n")
eval_file.write ("BLEU-4 score: " + str (bleu_score[3]) + "\n")
eval_file.write ("Rouge-1 score: " + str (rouge_score_[0] * 100) + "\n")
eval_file.write ("Rouge-2 score: " + str (rouge_score_[1] * 100) + "\n")
eval_file.write ("Rouge-L score: " + str (rouge_score_[2] * 100) + "\n")
if args.prompt:
break
# return target
if __name__ == '__main__':
main()
| [] |
2024-01-10 | IndexFziQ/CLSEG | src~run_generation_cl_all.py | #!/usr/bin/env python3
# coding=utf-8
# Copyright 2018 Google AI, Google Brain and Carnegie Mellon University Authors and the HuggingFace Inc. team.
# Copyright (c) 2018, NVIDIA CORPORATION. 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.
""" Conditional text generation with the auto-regressive models of the library (GPT/GPT-2/CTRL/Transformer-XL/XLNet)
"""
from __future__ import absolute_import, division, print_function, unicode_literals
import argparse
import logging
from tqdm import trange
import torch
import torch.nn.functional as F
import numpy as np
from transformers import GPT2Config, OpenAIGPTConfig, XLNetConfig, TransfoXLConfig, XLMConfig, CTRLConfig
from transformers import GPT2LMHeadModel, GPT2Tokenizer
from transformers import OpenAIGPTLMHeadModel, OpenAIGPTTokenizer
from transformers import XLNetLMHeadModel, XLNetTokenizer
from transformers import TransfoXLLMHeadModel, TransfoXLTokenizer
from transformers import CTRLLMHeadModel, CTRLTokenizer
from transformers import XLMWithLMHeadModel, XLMTokenizer
# from tools.EA.get_concepts_from_behave import tokenization, lower_case
# from tools.EA.LIB.EVAL.bleu import compute_bleu
# from tools.EA.LIB.EVAL.rouge import compute_rouge_L
import sacrebleu
from rouge import Rouge
logging.basicConfig(format = '%(asctime)s - %(levelname)s - %(name)s - %(message)s',
datefmt = '%m/%d/%Y %H:%M:%S',
level = logging.INFO)
logger = logging.getLogger(__name__)
MAX_LENGTH = int(10000) # Hardcoded max length to avoid infinite loop
ALL_MODELS = sum((tuple(conf.pretrained_config_archive_map.keys()) for conf in (GPT2Config, OpenAIGPTConfig, XLNetConfig, TransfoXLConfig, XLMConfig, CTRLConfig)), ())
MODEL_CLASSES = {
'gpt2': (GPT2LMHeadModel, GPT2Tokenizer),
'ctrl': (CTRLLMHeadModel, CTRLTokenizer),
'openai-gpt': (OpenAIGPTLMHeadModel, OpenAIGPTTokenizer),
'xlnet': (XLNetLMHeadModel, XLNetTokenizer),
'transfo-xl': (TransfoXLLMHeadModel, TransfoXLTokenizer),
'xlm': (XLMWithLMHeadModel, XLMTokenizer),
}
# Padding text to help Transformer-XL and XLNet with short prompts as proposed by Aman Rusia
# in https://github.com/rusiaaman/XLNet-gen#methodology
# and https://medium.com/@amanrusia/xlnet-speaks-comparison-to-gpt-2-ea1a4e9ba39e
# PADDING_TEXT = """ In 1991, the remains of Russian Tsar Nicholas II and his family
# (except for Alexei and Maria) are discovered.
# The voice of Nicholas's young son, Tsarevich Alexei Nikolaevich, narrates the
# remainder of the story. 1883 Western Siberia,
# a young Grigori Rasputin is asked by his father and a group of men to perform magic.
# Rasputin has a vision and denounces one of the men as a horse thief. Although his
# father initially slaps him for making such an accusation, Rasputin watches as the
# man is chased outside and beaten. Twenty years later, Rasputin sees a vision of
# the Virgin Mary, prompting him to become a priest. Rasputin quickly becomes famous,
# with people, even a bishop, begging for his blessing. <eod> </s> <eos>"""
def set_seed(args):
np.random.seed(args.seed)
torch.manual_seed(args.seed)
if args.n_gpu > 0:
torch.cuda.manual_seed_all(args.seed)
def top_k_top_p_filtering(logits, top_k=0, top_p=0.0, filter_value=-float('Inf')):
""" Filter a distribution of logits using top-k and/or nucleus (top-p) filtering
Args:
logits: logits distribution shape (batch size x vocabulary size)
top_k > 0: keep only top k tokens with highest probability (top-k filtering).
top_p > 0.0: keep the top tokens with cumulative probability >= top_p (nucleus filtering).
Nucleus filtering is described in Holtzman et al. (http://arxiv.org/abs/1904.09751)
From: https://gist.github.com/thomwolf/1a5a29f6962089e871b94cbd09daf317
"""
top_k = min(top_k, logits.size(-1)) # Safety check
if top_k > 0:
# Remove all tokens with a probability less than the last token of the top-k
indices_to_remove = logits < torch.topk(logits, top_k)[0][..., -1, None]
logits[indices_to_remove] = filter_value
if top_p > 0.0:
sorted_logits, sorted_indices = torch.sort(logits, descending=True)
cumulative_probs = torch.cumsum(F.softmax(sorted_logits, dim=-1), dim=-1)
# Remove tokens with cumulative probability above the threshold
sorted_indices_to_remove = cumulative_probs > top_p
# Shift the indices to the right to keep also the first token above the threshold
sorted_indices_to_remove[..., 1:] = sorted_indices_to_remove[..., :-1].clone()
sorted_indices_to_remove[..., 0] = 0
# scatter sorted tensors to original indexing
indices_to_remove = sorted_indices_to_remove.scatter(dim=1, index=sorted_indices, src=sorted_indices_to_remove)
logits[indices_to_remove] = filter_value
return logits
def sample_sequence(model, length, context, num_samples=1, temperature=1, top_k=0, top_p=0.0, repetition_penalty=1.0,
is_xlnet=False, is_xlm_mlm=False, xlm_mask_token=None, xlm_lang=None, device='cpu'):
context = torch.tensor(context, dtype=torch.long, device=device)
context = context.unsqueeze(0).repeat(num_samples, 1)
generated = context
# all_loss = []
with torch.no_grad():
for _ in range(length):
inputs = {'input_ids': generated}
if is_xlnet:
# XLNet is a direct (predict same token, not next token) and bi-directional model by default
# => need one additional dummy token in the input (will be masked), attention mask and target mapping (see model docstring)
input_ids = torch.cat((generated, torch.zeros((1, 1), dtype=torch.long, device=device)), dim=1)
perm_mask = torch.zeros((1, input_ids.shape[1], input_ids.shape[1]), dtype=torch.float, device=device)
perm_mask[:, :, -1] = 1.0 # Previous tokens don't see last token
target_mapping = torch.zeros((1, 1, input_ids.shape[1]), dtype=torch.float, device=device)
target_mapping[0, 0, -1] = 1.0 # predict last token
inputs = {'input_ids': input_ids, 'perm_mask': perm_mask, 'target_mapping': target_mapping}
if is_xlm_mlm and xlm_mask_token:
# XLM MLM models are direct models (predict same token, not next token)
# => need one additional dummy token in the input (will be masked and guessed)
input_ids = torch.cat((generated, torch.full((1, 1), xlm_mask_token, dtype=torch.long, device=device)), dim=1)
inputs = {'input_ids': input_ids}
if xlm_lang is not None:
inputs["langs"] = torch.tensor([xlm_lang] * inputs["input_ids"].shape[1], device=device).view(1, -1)
outputs = model(**inputs) # Note: we could also use 'past' with GPT-2/Transfo-XL/XLNet/CTRL (cached hidden-states)
next_token_logits = outputs[0][:, -1, :] / (temperature if temperature > 0 else 1.)
# print(next_token_logits.size())
# tmp_eval_loss = outputs[0][:, :, -1][-1][-1]
# print(outputs[0][:, :, -1][-1])
# print (tmp_eval_loss.size ())
# cur_loss = np.abs(tmp_eval_loss.item())
# print(cur_loss)
# all_loss.append(cur_loss)
# repetition penalty from CTRL (https://arxiv.org/abs/1909.05858)
for i in range(num_samples):
for _ in set(generated[i].tolist()):
next_token_logits[i, _] /= repetition_penalty
filtered_logits = top_k_top_p_filtering(next_token_logits, top_k=top_k, top_p=top_p)
if temperature == 0: # greedy sampling:
next_token = torch.argmax(filtered_logits, dim=-1).unsqueeze(-1)
else:
next_token = torch.multinomial(F.softmax(filtered_logits, dim=-1), num_samples=1)
generated = torch.cat((generated, next_token), dim=1)
# print(next_token.item())
if next_token.item() == 29:
break
# print(all_loss)
# avg_loss = np.mean (np.array (all_loss))
# ppl = np.exp(avg_loss)
# print('test_loss (bpe): %.4f, test_perplexity: %.4f' % (avg_loss, ppl))
return generated
# /data/xieyuqiang/story_comprehension/checkpoints_ft_with_roc/lmft_lm_gpt2_rocmedium_gn1_bp1_gc32_lr1_l100_e3_seed42_cgn1
# /data/xieyuqiang/story_comprehension/checkpoints_ft_with_cl/lmft_lm_gpt2_cl_gn1_bp1_gc32_lr1_l100_e3_seed42_cgn1
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--model_type", default='gpt2', type=str, required=False,
help="Model type selected in the list: " + ", ".join(MODEL_CLASSES.keys()))
parser.add_argument("--model_name_or_path", default='/data/xieyuqiang/story_comprehension/checkpoints_ft_with_cl/lmft_lm_gpt2_clall_gn1_bp1_gc32_lr1_l128_e3_seed42_cgn1', type=str, required=False,
help="Path to pre-trained model or shortcut name selected in the list: " + ", ".join(ALL_MODELS))
parser.add_argument("--source_text_path", type=str, default="/data/xieyuqiang/story_comprehension/data/roc/roc_val.csv")
parser.add_argument("--prompt", type=str, default=" ")
parser.add_argument("--padding_text", type=str, default="")
parser.add_argument("--xlm_lang", type=str, default="", help="Optional language when used with the XLM model.")
parser.add_argument("--length", type=int, default=30)
parser.add_argument("--batch", type=int, default=10)
parser.add_argument("--num_samples", type=int, default=1)
parser.add_argument("--temperature", type=float, default=0,
help="temperature of 0 implies greedy sampling")
parser.add_argument("--repetition_penalty", type=float, default=1.2,
help="primarily useful for CTRL model; in that case, use 1.2")
parser.add_argument("--top_k", type=int, default=1)
parser.add_argument("--top_p", type=float, default=0.9)
parser.add_argument("--no_cuda", action='store_true',
help="Avoid using CUDA when available")
parser.add_argument('--seed', type=int, default=42,
help="random seed for initialization")
parser.add_argument('--stop_token', type=str, default='<|endoftext|>',
help="Token at which text generation is stopped")
parser.add_argument ('--style', type=str, default='temporal',
help="The style for generating the pseudo wrong endings: temporal/causal")
args = parser.parse_args()
args.device = torch.device("cuda" if torch.cuda.is_available() and not args.no_cuda else "cpu")
args.n_gpu = torch.cuda.device_count()
set_seed(args)
args.model_type = args.model_type.lower()
model_class, tokenizer_class = MODEL_CLASSES[args.model_type]
tokenizer = tokenizer_class.from_pretrained(args.model_name_or_path)
model = model_class.from_pretrained(args.model_name_or_path)
model.to(args.device)
model.eval()
if args.length < 0 and model.config.max_position_embeddings > 0:
args.length = model.config.max_position_embeddings
elif 0 < model.config.max_position_embeddings < args.length:
args.length = model.config.max_position_embeddings # No generation bigger than model size
elif args.length < 0:
args.length = MAX_LENGTH # avoid infinite loop
logger.info(args)
if args.model_type in ["ctrl"]:
if args.temperature > 0.7:
logger.info('CTRL typically works better with lower temperatures (and lower top_k).')
while True:
xlm_lang = None
# XLM Language usage detailed in the issues #1414
if args.model_type in ["xlm"] and hasattr(tokenizer, 'lang2id') and hasattr(model.config, 'use_lang_emb') \
and model.config.use_lang_emb:
if args.xlm_lang:
language = args.xlm_lang
else:
language = None
while language not in tokenizer.lang2id.keys():
language = input("Using XLM. Select language in " + str(list(tokenizer.lang2id.keys())) + " >>> ")
xlm_lang = tokenizer.lang2id[language]
# XLM masked-language modeling (MLM) models need masked token (see details in sample_sequence)
is_xlm_mlm = args.model_type in ["xlm"] and 'mlm' in args.model_name_or_path
if is_xlm_mlm:
xlm_mask_token = tokenizer.mask_token_id
else:
xlm_mask_token = None
raw_text = args.prompt if args.prompt else input("Model prompt >>> ")
if args.model_type in ["transfo-xl", "xlnet"]:
# Models with memory likes to have a long prompt for short inputs.
raw_text = (args.padding_text if args.padding_text else PADDING_TEXT) + raw_text
context_tokens = tokenizer.encode(raw_text, add_special_tokens=False)
if args.model_type == "ctrl":
if not any(context_tokens[0] == x for x in tokenizer.control_codes.values()):
logger.info("WARNING! You are not starting your generation from a control code so you won't get good results")
with open (args.source_text_path, 'r', encoding='utf-8') as data_file, \
open (args.source_text_path + "_cl_all_result.tsv", 'w', encoding='utf-8') as new_file, \
open (args.source_text_path + "_cl_all_eval.tsv", 'w', encoding='utf-8') as eval_file:
import csv
reader = csv.reader (data_file)
next (reader)
all_data = []
for line in reader:
all_data.append (line)
print (all_data[0])
new_file.write ('context\tsource\ttarget\n')
from tqdm import tqdm
source_corpus = []
target_corpus = []
for raw_data in tqdm(all_data):
context = ' '.join(raw_data[2:6])
source = raw_data[6]
# import random
list = raw_data[2:6]
# random.shuffle(list)
target = ' '.join(list)
context_tokens = tokenizer.encode (target, add_special_tokens=False)
out = sample_sequence (
model=model,
context=context_tokens,
num_samples=args.num_samples,
length=args.length,
temperature=args.temperature,
top_k=args.top_k,
top_p=args.top_p,
repetition_penalty=args.repetition_penalty,
is_xlnet=bool (args.model_type == "xlnet"),
is_xlm_mlm=is_xlm_mlm,
xlm_mask_token=xlm_mask_token,
xlm_lang=xlm_lang,
device=args.device,
)
out = out[:, len (context_tokens):].tolist ()
for o in out:
# text = tokenizer.decode(o, cleanI_up_tokenization_spaces=True)
text = tokenizer.decode (o)
text = text[: text.find (args.stop_token) if args.stop_token else None]
target = text.replace ('<|endoftext|>', '')
source_corpus.append(source)
target_corpus.append(target)
new_file.write (context+"\t"+source+"\t"+target+"\n")
bleu_list = []
rouge_ = []
for source, target in zip (source_corpus, target_corpus):
bleu = sacrebleu.corpus_bleu (target, source)
bleu_list.append (bleu.precisions)
rouge = Rouge ()
for source, target in zip (source_corpus, target_corpus):
# rouge_l = compute_rouge_L(source, target)
rouge_x = rouge.get_scores (source, target)
rouge_1 = rouge_x[0]["rouge-1"]['f']
rouge_2 = rouge_x[0]["rouge-2"]['f']
rouge_l = rouge_x[0]["rouge-l"]['f']
rouge_.append ([rouge_1, rouge_2, rouge_l])
bleu_score = np.mean (bleu_list, axis=0)
rouge_score_ = np.mean (rouge_, axis=0)
print ("BLEU-1 score: " + str (bleu_score[0]) + "\n")
print ("BLEU-2 score: " + str (bleu_score[1]) + "\n")
print ("BLEU-4 score: " + str (bleu_score[3]) + "\n")
print ("Rouge-1 score: " + str (rouge_score_[0] * 100) + "\n")
print ("Rouge-2 score: " + str (rouge_score_[1] * 100) + "\n")
print ("Rouge-L score: " + str (rouge_score_[2] * 100) + "\n")
eval_file.write ("BLEU-1 score: " + str (bleu_score[0]) + "\n")
eval_file.write ("BLEU-2 score: " + str (bleu_score[1]) + "\n")
eval_file.write ("BLEU-4 score: " + str (bleu_score[3]) + "\n")
eval_file.write ("Rouge-1 score: " + str (rouge_score_[0] * 100) + "\n")
eval_file.write ("Rouge-2 score: " + str (rouge_score_[1] * 100) + "\n")
eval_file.write ("Rouge-L score: " + str (rouge_score_[2] * 100) + "\n")
if args.prompt:
break
# return target
if __name__ == '__main__':
main()
| [] |
2024-01-10 | IndexFziQ/CLSEG | src~run_generation_baseline_gcl.py | #!/usr/bin/env python3
# coding=utf-8
# Copyright 2018 Google AI, Google Brain and Carnegie Mellon University Authors and the HuggingFace Inc. team.
# Copyright (c) 2018, NVIDIA CORPORATION. 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.
""" Conditional text generation with the auto-regressive models of the library (GPT/GPT-2/CTRL/Transformer-XL/XLNet)
"""
from __future__ import absolute_import, division, print_function, unicode_literals
import argparse
import logging
from tqdm import trange
import torch
import torch.nn.functional as F
import numpy as np
from transformers import GPT2Config, OpenAIGPTConfig, XLNetConfig, TransfoXLConfig, XLMConfig, CTRLConfig
from transformers import GPT2LMHeadModel, GPT2Tokenizer
from transformers import OpenAIGPTLMHeadModel, OpenAIGPTTokenizer
from transformers import XLNetLMHeadModel, XLNetTokenizer
from transformers import TransfoXLLMHeadModel, TransfoXLTokenizer
from transformers import CTRLLMHeadModel, CTRLTokenizer
from transformers import XLMWithLMHeadModel, XLMTokenizer
# from tools.EA.get_concepts_from_behave import tokenization, lower_case
# from tools.EA.LIB.EVAL.bleu import compute_bleu
# from tools.EA.LIB.EVAL.rouge import compute_rouge_L
import sacrebleu
from rouge import Rouge
logging.basicConfig(format = '%(asctime)s - %(levelname)s - %(name)s - %(message)s',
datefmt = '%m/%d/%Y %H:%M:%S',
level = logging.INFO)
logger = logging.getLogger(__name__)
MAX_LENGTH = int(10000) # Hardcoded max length to avoid infinite loop
ALL_MODELS = sum((tuple(conf.pretrained_config_archive_map.keys()) for conf in (GPT2Config, OpenAIGPTConfig, XLNetConfig, TransfoXLConfig, XLMConfig, CTRLConfig)), ())
MODEL_CLASSES = {
'gpt2': (GPT2LMHeadModel, GPT2Tokenizer),
'ctrl': (CTRLLMHeadModel, CTRLTokenizer),
'openai-gpt': (OpenAIGPTLMHeadModel, OpenAIGPTTokenizer),
'xlnet': (XLNetLMHeadModel, XLNetTokenizer),
'transfo-xl': (TransfoXLLMHeadModel, TransfoXLTokenizer),
'xlm': (XLMWithLMHeadModel, XLMTokenizer),
}
# Padding text to help Transformer-XL and XLNet with short prompts as proposed by Aman Rusia
# in https://github.com/rusiaaman/XLNet-gen#methodology
# and https://medium.com/@amanrusia/xlnet-speaks-comparison-to-gpt-2-ea1a4e9ba39e
# PADDING_TEXT = """ In 1991, the remains of Russian Tsar Nicholas II and his family
# (except for Alexei and Maria) are discovered.
# The voice of Nicholas's young son, Tsarevich Alexei Nikolaevich, narrates the
# remainder of the story. 1883 Western Siberia,
# a young Grigori Rasputin is asked by his father and a group of men to perform magic.
# Rasputin has a vision and denounces one of the men as a horse thief. Although his
# father initially slaps him for making such an accusation, Rasputin watches as the
# man is chased outside and beaten. Twenty years later, Rasputin sees a vision of
# the Virgin Mary, prompting him to become a priest. Rasputin quickly becomes famous,
# with people, even a bishop, begging for his blessing. <eod> </s> <eos>"""
def set_seed(args):
np.random.seed(args.seed)
torch.manual_seed(args.seed)
if args.n_gpu > 0:
torch.cuda.manual_seed_all(args.seed)
def top_k_top_p_filtering(logits, top_k=0, top_p=0.0, filter_value=-float('Inf')):
""" Filter a distribution of logits using top-k and/or nucleus (top-p) filtering
Args:
logits: logits distribution shape (batch size x vocabulary size)
top_k > 0: keep only top k tokens with highest probability (top-k filtering).
top_p > 0.0: keep the top tokens with cumulative probability >= top_p (nucleus filtering).
Nucleus filtering is described in Holtzman et al. (http://arxiv.org/abs/1904.09751)
From: https://gist.github.com/thomwolf/1a5a29f6962089e871b94cbd09daf317
"""
top_k = min(top_k, logits.size(-1)) # Safety check
if top_k > 0:
# Remove all tokens with a probability less than the last token of the top-k
indices_to_remove = logits < torch.topk(logits, top_k)[0][..., -1, None]
logits[indices_to_remove] = filter_value
if top_p > 0.0:
sorted_logits, sorted_indices = torch.sort(logits, descending=True)
cumulative_probs = torch.cumsum(F.softmax(sorted_logits, dim=-1), dim=-1)
# Remove tokens with cumulative probability above the threshold
sorted_indices_to_remove = cumulative_probs > top_p
# Shift the indices to the right to keep also the first token above the threshold
sorted_indices_to_remove[..., 1:] = sorted_indices_to_remove[..., :-1].clone()
sorted_indices_to_remove[..., 0] = 0
# scatter sorted tensors to original indexing
indices_to_remove = sorted_indices_to_remove.scatter(dim=1, index=sorted_indices, src=sorted_indices_to_remove)
logits[indices_to_remove] = filter_value
return logits
def sample_sequence(model, length, context, num_samples=1, temperature=1, top_k=0, top_p=0.0, repetition_penalty=1.0,
is_xlnet=False, is_xlm_mlm=False, xlm_mask_token=None, xlm_lang=None, device='cpu'):
context = torch.tensor(context, dtype=torch.long, device=device)
context = context.unsqueeze(0).repeat(num_samples, 1)
generated = context
# all_loss = []
with torch.no_grad():
for _ in range(length):
inputs = {'input_ids': generated}
if is_xlnet:
# XLNet is a direct (predict same token, not next token) and bi-directional model by default
# => need one additional dummy token in the input (will be masked), attention mask and target mapping (see model docstring)
input_ids = torch.cat((generated, torch.zeros((1, 1), dtype=torch.long, device=device)), dim=1)
perm_mask = torch.zeros((1, input_ids.shape[1], input_ids.shape[1]), dtype=torch.float, device=device)
perm_mask[:, :, -1] = 1.0 # Previous tokens don't see last token
target_mapping = torch.zeros((1, 1, input_ids.shape[1]), dtype=torch.float, device=device)
target_mapping[0, 0, -1] = 1.0 # predict last token
inputs = {'input_ids': input_ids, 'perm_mask': perm_mask, 'target_mapping': target_mapping}
if is_xlm_mlm and xlm_mask_token:
# XLM MLM models are direct models (predict same token, not next token)
# => need one additional dummy token in the input (will be masked and guessed)
input_ids = torch.cat((generated, torch.full((1, 1), xlm_mask_token, dtype=torch.long, device=device)), dim=1)
inputs = {'input_ids': input_ids}
if xlm_lang is not None:
inputs["langs"] = torch.tensor([xlm_lang] * inputs["input_ids"].shape[1], device=device).view(1, -1)
outputs = model(**inputs) # Note: we could also use 'past' with GPT-2/Transfo-XL/XLNet/CTRL (cached hidden-states)
next_token_logits = outputs[0][:, -1, :] / (temperature if temperature > 0 else 1.)
# print(next_token_logits.size())
# tmp_eval_loss = outputs[0][:, :, -1][-1][-1]
# print(outputs[0][:, :, -1][-1])
# print (tmp_eval_loss.size ())
# cur_loss = np.abs(tmp_eval_loss.item())
# print(cur_loss)
# all_loss.append(cur_loss)
# repetition penalty from CTRL (https://arxiv.org/abs/1909.05858)
for i in range(num_samples):
for _ in set(generated[i].tolist()):
next_token_logits[i, _] /= repetition_penalty
filtered_logits = top_k_top_p_filtering(next_token_logits, top_k=top_k, top_p=top_p)
if temperature == 0: # greedy sampling:
next_token = torch.argmax(filtered_logits, dim=-1).unsqueeze(-1)
else:
next_token = torch.multinomial(F.softmax(filtered_logits, dim=-1), num_samples=1)
generated = torch.cat((generated, next_token), dim=1)
# print(next_token.item())
if next_token.item() == 29:
break
# print(all_loss)
# avg_loss = np.mean (np.array (all_loss))
# ppl = np.exp(avg_loss)
# print('test_loss (bpe): %.4f, test_perplexity: %.4f' % (avg_loss, ppl))
return generated
# /data/xieyuqiang/story_comprehension/checkpoints_ft_with_roc/lmft_lm_gpt2_rocmedium_gn1_bp1_gc32_lr1_l100_e3_seed42_cgn1
# /data/xieyuqiang/story_comprehension/checkpoints_ft_with_cl/lmft_lm_gpt2_cl_gn1_bp1_gc32_lr1_l100_e3_seed42_cgn1
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--model_type", default='gpt2', type=str, required=False,
help="Model type selected in the list: " + ", ".join(MODEL_CLASSES.keys()))
parser.add_argument("--model_name_or_path", default='/data/xieyuqiang/story_comprehension/checkpoints_ft_with_cl/lmft_lm_gpt2_gcl_gn1_bp1_gc32_lr1_l128_e3_seed42_cgn1', type=str, required=False,
help="Path to pre-trained model or shortcut name selected in the list: " + ", ".join(ALL_MODELS))
parser.add_argument("--source_text_path", type=str, default="/data/xieyuqiang/story_comprehension/data/roc/roc_val.csv")
parser.add_argument("--prompt", type=str, default=" ")
parser.add_argument("--padding_text", type=str, default="")
parser.add_argument("--xlm_lang", type=str, default="", help="Optional language when used with the XLM model.")
parser.add_argument("--length", type=int, default=30)
parser.add_argument("--batch", type=int, default=10)
parser.add_argument("--num_samples", type=int, default=1)
parser.add_argument("--temperature", type=float, default=0,
help="temperature of 0 implies greedy sampling")
parser.add_argument("--repetition_penalty", type=float, default=1.2,
help="primarily useful for CTRL model; in that case, use 1.2")
parser.add_argument("--top_k", type=int, default=1)
parser.add_argument("--top_p", type=float, default=0.9)
parser.add_argument("--no_cuda", action='store_true',
help="Avoid using CUDA when available")
parser.add_argument('--seed', type=int, default=42,
help="random seed for initialization")
parser.add_argument('--stop_token', type=str, default='<|endoftext|>',
help="Token at which text generation is stopped")
parser.add_argument ('--style', type=str, default='temporal',
help="The style for generating the pseudo wrong endings: temporal/causal")
args = parser.parse_args()
args.device = torch.device("cuda" if torch.cuda.is_available() and not args.no_cuda else "cpu")
args.n_gpu = torch.cuda.device_count()
set_seed(args)
args.model_type = args.model_type.lower()
model_class, tokenizer_class = MODEL_CLASSES[args.model_type]
tokenizer = tokenizer_class.from_pretrained(args.model_name_or_path)
model = model_class.from_pretrained(args.model_name_or_path)
model.to(args.device)
model.eval()
if args.length < 0 and model.config.max_position_embeddings > 0:
args.length = model.config.max_position_embeddings
elif 0 < model.config.max_position_embeddings < args.length:
args.length = model.config.max_position_embeddings # No generation bigger than model size
elif args.length < 0:
args.length = MAX_LENGTH # avoid infinite loop
logger.info(args)
if args.model_type in ["ctrl"]:
if args.temperature > 0.7:
logger.info('CTRL typically works better with lower temperatures (and lower top_k).')
while True:
xlm_lang = None
# XLM Language usage detailed in the issues #1414
if args.model_type in ["xlm"] and hasattr(tokenizer, 'lang2id') and hasattr(model.config, 'use_lang_emb') \
and model.config.use_lang_emb:
if args.xlm_lang:
language = args.xlm_lang
else:
language = None
while language not in tokenizer.lang2id.keys():
language = input("Using XLM. Select language in " + str(list(tokenizer.lang2id.keys())) + " >>> ")
xlm_lang = tokenizer.lang2id[language]
# XLM masked-language modeling (MLM) models need masked token (see details in sample_sequence)
is_xlm_mlm = args.model_type in ["xlm"] and 'mlm' in args.model_name_or_path
if is_xlm_mlm:
xlm_mask_token = tokenizer.mask_token_id
else:
xlm_mask_token = None
raw_text = args.prompt if args.prompt else input("Model prompt >>> ")
if args.model_type in ["transfo-xl", "xlnet"]:
# Models with memory likes to have a long prompt for short inputs.
raw_text = (args.padding_text if args.padding_text else PADDING_TEXT) + raw_text
context_tokens = tokenizer.encode(raw_text, add_special_tokens=False)
if args.model_type == "ctrl":
if not any(context_tokens[0] == x for x in tokenizer.control_codes.values()):
logger.info("WARNING! You are not starting your generation from a control code so you won't get good results")
with open (args.source_text_path, 'r', encoding='utf-8') as data_file, \
open (args.source_text_path + "_gcl_result.tsv", 'w', encoding='utf-8') as new_file, \
open (args.source_text_path + "_gcl_eval.tsv", 'w', encoding='utf-8') as eval_file:
import csv
reader = csv.reader (data_file)
next (reader)
all_data = []
for line in reader:
all_data.append (line)
print (all_data[0])
new_file.write ('context\tsource\ttarget\n')
from tqdm import tqdm
source_corpus = []
target_corpus = []
for raw_data in tqdm(all_data):
context = ' '.join(raw_data[2:6])
source = raw_data[6]
# import random
list = raw_data[2:6]
# random.shuffle(list)
target = ' '.join(list)
context_tokens = tokenizer.encode (target, add_special_tokens=False)
out = sample_sequence (
model=model,
context=context_tokens,
num_samples=args.num_samples,
length=args.length,
temperature=args.temperature,
top_k=args.top_k,
top_p=args.top_p,
repetition_penalty=args.repetition_penalty,
is_xlnet=bool (args.model_type == "xlnet"),
is_xlm_mlm=is_xlm_mlm,
xlm_mask_token=xlm_mask_token,
xlm_lang=xlm_lang,
device=args.device,
)
out = out[:, len (context_tokens):].tolist ()
for o in out:
# text = tokenizer.decode(o, cleanI_up_tokenization_spaces=True)
text = tokenizer.decode (o)
text = text[: text.find (args.stop_token) if args.stop_token else None]
target = text.replace ('<|endoftext|>', '')
source_corpus.append(source)
target_corpus.append(target)
new_file.write (context+"\t"+source+"\t"+target+"\n")
bleu_list = []
rouge_ = []
for source, target in zip (source_corpus, target_corpus):
bleu = sacrebleu.corpus_bleu (target, source)
bleu_list.append (bleu.precisions)
rouge = Rouge ()
for source, target in zip (source_corpus, target_corpus):
# rouge_l = compute_rouge_L(source, target)
rouge_x = rouge.get_scores (source, target)
rouge_1 = rouge_x[0]["rouge-1"]['f']
rouge_2 = rouge_x[0]["rouge-2"]['f']
rouge_l = rouge_x[0]["rouge-l"]['f']
rouge_.append ([rouge_1, rouge_2, rouge_l])
bleu_score = np.mean (bleu_list, axis=0)
rouge_score_ = np.mean (rouge_, axis=0)
print ("BLEU-1 score: " + str (bleu_score[0]) + "\n")
print ("BLEU-2 score: " + str (bleu_score[1]) + "\n")
print ("BLEU-4 score: " + str (bleu_score[3]) + "\n")
print ("Rouge-1 score: " + str (rouge_score_[0] * 100) + "\n")
print ("Rouge-2 score: " + str (rouge_score_[1] * 100) + "\n")
print ("Rouge-L score: " + str (rouge_score_[2] * 100) + "\n")
eval_file.write ("BLEU-1 score: " + str (bleu_score[0]) + "\n")
eval_file.write ("BLEU-2 score: " + str (bleu_score[1]) + "\n")
eval_file.write ("BLEU-4 score: " + str (bleu_score[3]) + "\n")
eval_file.write ("Rouge-1 score: " + str (rouge_score_[0] * 100) + "\n")
eval_file.write ("Rouge-2 score: " + str (rouge_score_[1] * 100) + "\n")
eval_file.write ("Rouge-L score: " + str (rouge_score_[2] * 100) + "\n")
if args.prompt:
break
# return target
if __name__ == '__main__':
main()
| [] |
2024-01-10 | IndexFziQ/CLSEG | src~run_generation_csl.py | #!/usr/bin/env python3
# coding=utf-8
# Copyright 2018 Google AI, Google Brain and Carnegie Mellon University Authors and the HuggingFace Inc. team.
# Copyright (c) 2018, NVIDIA CORPORATION. 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.
""" Conditional text generation with the auto-regressive models of the library (GPT/GPT-2/CTRL/Transformer-XL/XLNet)
"""
from __future__ import absolute_import, division, print_function, unicode_literals
import argparse
import logging
from tqdm import trange
import torch
import torch.nn.functional as F
import numpy as np
from transformers import GPT2Config, OpenAIGPTConfig, XLNetConfig, TransfoXLConfig, XLMConfig, CTRLConfig
from transformers import GPT2LMHeadModel, GPT2Tokenizer
from transformers import OpenAIGPTLMHeadModel, OpenAIGPTTokenizer
from transformers import XLNetLMHeadModel, XLNetTokenizer
from transformers import TransfoXLLMHeadModel, TransfoXLTokenizer
from transformers import CTRLLMHeadModel, CTRLTokenizer
from transformers import XLMWithLMHeadModel, XLMTokenizer
# from tools.EA.get_concepts_from_behave import tokenization, lower_case
# from tools.EA.LIB.EVAL.bleu import compute_bleu
# from tools.EA.LIB.EVAL.rouge import compute_rouge_L
import sacrebleu
from rouge import Rouge
logging.basicConfig(format = '%(asctime)s - %(levelname)s - %(name)s - %(message)s',
datefmt = '%m/%d/%Y %H:%M:%S',
level = logging.INFO)
logger = logging.getLogger(__name__)
MAX_LENGTH = int(10000) # Hardcoded max length to avoid infinite loop
ALL_MODELS = sum((tuple(conf.pretrained_config_archive_map.keys()) for conf in (GPT2Config, OpenAIGPTConfig, XLNetConfig, TransfoXLConfig, XLMConfig, CTRLConfig)), ())
MODEL_CLASSES = {
'gpt2': (GPT2LMHeadModel, GPT2Tokenizer),
'ctrl': (CTRLLMHeadModel, CTRLTokenizer),
'openai-gpt': (OpenAIGPTLMHeadModel, OpenAIGPTTokenizer),
'xlnet': (XLNetLMHeadModel, XLNetTokenizer),
'transfo-xl': (TransfoXLLMHeadModel, TransfoXLTokenizer),
'xlm': (XLMWithLMHeadModel, XLMTokenizer),
}
# Padding text to help Transformer-XL and XLNet with short prompts as proposed by Aman Rusia
# in https://github.com/rusiaaman/XLNet-gen#methodology
# and https://medium.com/@amanrusia/xlnet-speaks-comparison-to-gpt-2-ea1a4e9ba39e
# PADDING_TEXT = """ In 1991, the remains of Russian Tsar Nicholas II and his family
# (except for Alexei and Maria) are discovered.
# The voice of Nicholas's young son, Tsarevich Alexei Nikolaevich, narrates the
# remainder of the story. 1883 Western Siberia,
# a young Grigori Rasputin is asked by his father and a group of men to perform magic.
# Rasputin has a vision and denounces one of the men as a horse thief. Although his
# father initially slaps him for making such an accusation, Rasputin watches as the
# man is chased outside and beaten. Twenty years later, Rasputin sees a vision of
# the Virgin Mary, prompting him to become a priest. Rasputin quickly becomes famous,
# with people, even a bishop, begging for his blessing. <eod> </s> <eos>"""
def set_seed(args):
np.random.seed(args.seed)
torch.manual_seed(args.seed)
if args.n_gpu > 0:
torch.cuda.manual_seed_all(args.seed)
def top_k_top_p_filtering(logits, top_k=0, top_p=0.0, filter_value=-float('Inf')):
""" Filter a distribution of logits using top-k and/or nucleus (top-p) filtering
Args:
logits: logits distribution shape (batch size x vocabulary size)
top_k > 0: keep only top k tokens with highest probability (top-k filtering).
top_p > 0.0: keep the top tokens with cumulative probability >= top_p (nucleus filtering).
Nucleus filtering is described in Holtzman et al. (http://arxiv.org/abs/1904.09751)
From: https://gist.github.com/thomwolf/1a5a29f6962089e871b94cbd09daf317
"""
top_k = min(top_k, logits.size(-1)) # Safety check
if top_k > 0:
# Remove all tokens with a probability less than the last token of the top-k
indices_to_remove = logits < torch.topk(logits, top_k)[0][..., -1, None]
logits[indices_to_remove] = filter_value
if top_p > 0.0:
sorted_logits, sorted_indices = torch.sort(logits, descending=True)
cumulative_probs = torch.cumsum(F.softmax(sorted_logits, dim=-1), dim=-1)
# Remove tokens with cumulative probability above the threshold
sorted_indices_to_remove = cumulative_probs > top_p
# Shift the indices to the right to keep also the first token above the threshold
sorted_indices_to_remove[..., 1:] = sorted_indices_to_remove[..., :-1].clone()
sorted_indices_to_remove[..., 0] = 0
# scatter sorted tensors to original indexing
indices_to_remove = sorted_indices_to_remove.scatter(dim=1, index=sorted_indices, src=sorted_indices_to_remove)
logits[indices_to_remove] = filter_value
return logits
def sample_sequence(model, length, context, num_samples=1, temperature=1, top_k=0, top_p=0.0, repetition_penalty=1.0,
is_xlnet=False, is_xlm_mlm=False, xlm_mask_token=None, xlm_lang=None, device='cpu'):
context = torch.tensor(context, dtype=torch.long, device=device)
context = context.unsqueeze(0).repeat(num_samples, 1)
generated = context
# all_loss = []
with torch.no_grad():
for _ in range(length):
inputs = {'input_ids': generated}
if is_xlnet:
# XLNet is a direct (predict same token, not next token) and bi-directional model by default
# => need one additional dummy token in the input (will be masked), attention mask and target mapping (see model docstring)
input_ids = torch.cat((generated, torch.zeros((1, 1), dtype=torch.long, device=device)), dim=1)
perm_mask = torch.zeros((1, input_ids.shape[1], input_ids.shape[1]), dtype=torch.float, device=device)
perm_mask[:, :, -1] = 1.0 # Previous tokens don't see last token
target_mapping = torch.zeros((1, 1, input_ids.shape[1]), dtype=torch.float, device=device)
target_mapping[0, 0, -1] = 1.0 # predict last token
inputs = {'input_ids': input_ids, 'perm_mask': perm_mask, 'target_mapping': target_mapping}
if is_xlm_mlm and xlm_mask_token:
# XLM MLM models are direct models (predict same token, not next token)
# => need one additional dummy token in the input (will be masked and guessed)
input_ids = torch.cat((generated, torch.full((1, 1), xlm_mask_token, dtype=torch.long, device=device)), dim=1)
inputs = {'input_ids': input_ids}
if xlm_lang is not None:
inputs["langs"] = torch.tensor([xlm_lang] * inputs["input_ids"].shape[1], device=device).view(1, -1)
outputs = model(**inputs) # Note: we could also use 'past' with GPT-2/Transfo-XL/XLNet/CTRL (cached hidden-states)
next_token_logits = outputs[0][:, -1, :] / (temperature if temperature > 0 else 1.)
# print(next_token_logits.size())
# tmp_eval_loss = outputs[0][:, :, -1][-1][-1]
# print(outputs[0][:, :, -1][-1])
# print (tmp_eval_loss.size ())
# cur_loss = np.abs(tmp_eval_loss.item())
# print(cur_loss)
# all_loss.append(cur_loss)
# repetition penalty from CTRL (https://arxiv.org/abs/1909.05858)
for i in range(num_samples):
for _ in set(generated[i].tolist()):
next_token_logits[i, _] /= repetition_penalty
filtered_logits = top_k_top_p_filtering(next_token_logits, top_k=top_k, top_p=top_p)
if temperature == 0: # greedy sampling:
next_token = torch.argmax(filtered_logits, dim=-1).unsqueeze(-1)
else:
next_token = torch.multinomial(F.softmax(filtered_logits, dim=-1), num_samples=1)
generated = torch.cat((generated, next_token), dim=1)
# print(next_token.item())
if next_token.item() == 29:
break
# print(all_loss)
# avg_loss = np.mean (np.array (all_loss))
# ppl = np.exp(avg_loss)
# print('test_loss (bpe): %.4f, test_perplexity: %.4f' % (avg_loss, ppl))
return generated
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--model_type", default='gpt2', type=str, required=False,
help="Model type selected in the list: " + ", ".join(MODEL_CLASSES.keys()))
parser.add_argument("--model_name_or_path", default='/data/xieyuqiang/story_comprehension/checkpoints_ft_with_cfg/lmft_lm_gpt2_cfg_gn1_bp1_gc32_lr1_l100_e3_seed42_cgn1', type=str, required=False,
help="Path to pre-trained model or shortcut name selected in the list: " + ", ".join(ALL_MODELS))
parser.add_argument("--source_text_path", type=str, default="/data/xieyuqiang/story_comprehension/data/roc/roc_train.csv")
parser.add_argument("--prompt", type=str, default=" ")
parser.add_argument("--padding_text", type=str, default="")
parser.add_argument("--xlm_lang", type=str, default="", help="Optional language when used with the XLM model.")
parser.add_argument("--length", type=int, default=60)
parser.add_argument("--batch", type=int, default=2)
parser.add_argument("--num_samples", type=int, default=1)
parser.add_argument("--temperature", type=float, default=0,
help="temperature of 0 implies greedy sampling")
parser.add_argument("--repetition_penalty", type=float, default=1.2,
help="primarily useful for CTRL model; in that case, use 1.2")
parser.add_argument("--top_k", type=int, default=1)
parser.add_argument("--top_p", type=float, default=0.9)
parser.add_argument("--no_cuda", action='store_true',
help="Avoid using CUDA when available")
parser.add_argument('--seed', type=int, default=42,
help="random seed for initialization")
parser.add_argument('--stop_token', type=str, default='<|endoftext|>',
help="Token at which text generation is stopped")
parser.add_argument ('--style', type=str, default='temporal',
help="The style for generating the pseudo wrong endings: temporal/causal")
args = parser.parse_args()
args.device = torch.device("cuda" if torch.cuda.is_available() and not args.no_cuda else "cpu")
args.n_gpu = torch.cuda.device_count()
set_seed(args)
args.model_type = args.model_type.lower()
model_class, tokenizer_class = MODEL_CLASSES[args.model_type]
tokenizer = tokenizer_class.from_pretrained(args.model_name_or_path)
model = model_class.from_pretrained(args.model_name_or_path)
model.to(args.device)
model.eval()
if args.length < 0 and model.config.max_position_embeddings > 0:
args.length = model.config.max_position_embeddings
elif 0 < model.config.max_position_embeddings < args.length:
args.length = model.config.max_position_embeddings # No generation bigger than model size
elif args.length < 0:
args.length = MAX_LENGTH # avoid infinite loop
logger.info(args)
if args.model_type in ["ctrl"]:
if args.temperature > 0.7:
logger.info('CTRL typically works better with lower temperatures (and lower top_k).')
while True:
xlm_lang = None
# XLM Language usage detailed in the issues #1414
if args.model_type in ["xlm"] and hasattr(tokenizer, 'lang2id') and hasattr(model.config, 'use_lang_emb') \
and model.config.use_lang_emb:
if args.xlm_lang:
language = args.xlm_lang
else:
language = None
while language not in tokenizer.lang2id.keys():
language = input("Using XLM. Select language in " + str(list(tokenizer.lang2id.keys())) + " >>> ")
xlm_lang = tokenizer.lang2id[language]
# XLM masked-language modeling (MLM) models need masked token (see details in sample_sequence)
is_xlm_mlm = args.model_type in ["xlm"] and 'mlm' in args.model_name_or_path
if is_xlm_mlm:
xlm_mask_token = tokenizer.mask_token_id
else:
xlm_mask_token = None
raw_text = args.prompt if args.prompt else input("Model prompt >>> ")
if args.model_type in ["transfo-xl", "xlnet"]:
# Models with memory likes to have a long prompt for short inputs.
raw_text = (args.padding_text if args.padding_text else PADDING_TEXT) + raw_text
context_tokens = tokenizer.encode(raw_text, add_special_tokens=False)
if args.model_type == "ctrl":
if not any(context_tokens[0] == x for x in tokenizer.control_codes.values()):
logger.info("WARNING! You are not starting your generation from a control code so you won't get good results")
with open (args.source_text_path, 'r', encoding='utf-8') as data_file, \
open (args.source_text_path + "_causal.tsv", 'w', encoding='utf-8') as new_file, \
open (args.source_text_path + "_eval.tsv", 'w', encoding='utf-8') as eval_file:
import csv
reader = csv.reader (data_file)
next (reader)
all_data = []
for line in reader:
all_data.append (line)
print (all_data[0])
new_file.write ('context\tsource\ttarget\tending\n')
from tqdm import tqdm
source_corpus = []
target_corpus = []
for raw_data in tqdm(all_data):
context = ' '.join(raw_data[2:5])
source = raw_data[5]
target = raw_data[5]
ending = raw_data[6]
context_tokens = tokenizer.encode (target, add_special_tokens=False)
out = sample_sequence (
model=model,
context=context_tokens,
num_samples=args.num_samples,
length=args.length,
temperature=args.temperature,
top_k=args.top_k,
top_p=args.top_p,
repetition_penalty=args.repetition_penalty,
is_xlnet=bool (args.model_type == "xlnet"),
is_xlm_mlm=is_xlm_mlm,
xlm_mask_token=xlm_mask_token,
xlm_lang=xlm_lang,
device=args.device,
)
out = out[:, len (context_tokens):].tolist ()
for o in out:
# text = tokenizer.decode(o, cleanI_up_tokenization_spaces=True)
text = tokenizer.decode (o)
text = text[: text.find (args.stop_token) if args.stop_token else None]
target = text.replace ('<|endoftext|>', '')
source_corpus.append(source)
target_corpus.append(target)
new_file.write (context +"\t"+ source+"\t"+target+"\t"+ending+"\n")
bleu_list = []
rouge_ = []
for source, target in zip (source_corpus, target_corpus):
bleu = sacrebleu.corpus_bleu (target, source)
bleu_list.append (bleu.precisions)
rouge = Rouge ()
for source, target in zip (source_corpus, target_corpus):
# rouge_l = compute_rouge_L(source, target)
rouge_x = rouge.get_scores (source, target)
rouge_1 = rouge_x[0]["rouge-1"]['f']
rouge_2 = rouge_x[0]["rouge-2"]['f']
rouge_l = rouge_x[0]["rouge-l"]['f']
rouge_.append ([rouge_1, rouge_2, rouge_l])
bleu_score = np.mean (bleu_list, axis=0)
rouge_score_ = np.mean (rouge_, axis=0)
print ("BLEU-1 score: " + str (bleu_score[0]) + "\n")
print ("BLEU-2 score: " + str (bleu_score[1]) + "\n")
print ("BLEU-4 score: " + str (bleu_score[3]) + "\n")
print ("Rouge-1 score: " + str (rouge_score_[0] * 100) + "\n")
print ("Rouge-2 score: " + str (rouge_score_[1] * 100) + "\n")
print ("Rouge-L score: " + str (rouge_score_[2] * 100) + "\n")
eval_file.write ("BLEU-1 score: " + str (bleu_score[0]) + "\n")
eval_file.write ("BLEU-2 score: " + str (bleu_score[1]) + "\n")
eval_file.write ("BLEU-4 score: " + str (bleu_score[3]) + "\n")
eval_file.write ("Rouge-1 score: " + str (rouge_score_[0] * 100) + "\n")
eval_file.write ("Rouge-2 score: " + str (rouge_score_[1] * 100) + "\n")
eval_file.write ("Rouge-L score: " + str (rouge_score_[2] * 100) + "\n")
if args.prompt:
break
# return target
if __name__ == '__main__':
main()
| [] |
2024-01-10 | IndexFziQ/CLSEG | src~run_generation_sample_tpl.py | #!/usr/bin/env python3
# coding=utf-8
# Copyright 2018 Google AI, Google Brain and Carnegie Mellon University Authors and the HuggingFace Inc. team.
# Copyright (c) 2018, NVIDIA CORPORATION. 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.
""" Conditional text generation with the auto-regressive models of the library (GPT/GPT-2/CTRL/Transformer-XL/XLNet)
"""
from __future__ import absolute_import, division, print_function, unicode_literals
import argparse
import logging
from tqdm import trange
import torch
import torch.nn.functional as F
import numpy as np
from transformers import GPT2Config, OpenAIGPTConfig, XLNetConfig, TransfoXLConfig, XLMConfig, CTRLConfig
from transformers import GPT2LMHeadModel, GPT2Tokenizer
from transformers import OpenAIGPTLMHeadModel, OpenAIGPTTokenizer
from transformers import XLNetLMHeadModel, XLNetTokenizer
from transformers import TransfoXLLMHeadModel, TransfoXLTokenizer
from transformers import CTRLLMHeadModel, CTRLTokenizer
from transformers import XLMWithLMHeadModel, XLMTokenizer
# from tools.EA.get_concepts_from_behave import tokenization, lower_case
# from tools.EA.LIB.EVAL.bleu import compute_bleu
# from tools.EA.LIB.EVAL.rouge import compute_rouge_L
import sacrebleu
from rouge import Rouge
logging.basicConfig(format = '%(asctime)s - %(levelname)s - %(name)s - %(message)s',
datefmt = '%m/%d/%Y %H:%M:%S',
level = logging.INFO)
logger = logging.getLogger(__name__)
MAX_LENGTH = int(10000) # Hardcoded max length to avoid infinite loop
ALL_MODELS = sum((tuple(conf.pretrained_config_archive_map.keys()) for conf in (GPT2Config, OpenAIGPTConfig, XLNetConfig, TransfoXLConfig, XLMConfig, CTRLConfig)), ())
MODEL_CLASSES = {
'gpt2': (GPT2LMHeadModel, GPT2Tokenizer),
'ctrl': (CTRLLMHeadModel, CTRLTokenizer),
'openai-gpt': (OpenAIGPTLMHeadModel, OpenAIGPTTokenizer),
'xlnet': (XLNetLMHeadModel, XLNetTokenizer),
'transfo-xl': (TransfoXLLMHeadModel, TransfoXLTokenizer),
'xlm': (XLMWithLMHeadModel, XLMTokenizer),
}
# Padding text to help Transformer-XL and XLNet with short prompts as proposed by Aman Rusia
# in https://github.com/rusiaaman/XLNet-gen#methodology
# and https://medium.com/@amanrusia/xlnet-speaks-comparison-to-gpt-2-ea1a4e9ba39e
# PADDING_TEXT = """ In 1991, the remains of Russian Tsar Nicholas II and his family
# (except for Alexei and Maria) are discovered.
# The voice of Nicholas's young son, Tsarevich Alexei Nikolaevich, narrates the
# remainder of the story. 1883 Western Siberia,
# a young Grigori Rasputin is asked by his father and a group of men to perform magic.
# Rasputin has a vision and denounces one of the men as a horse thief. Although his
# father initially slaps him for making such an accusation, Rasputin watches as the
# man is chased outside and beaten. Twenty years later, Rasputin sees a vision of
# the Virgin Mary, prompting him to become a priest. Rasputin quickly becomes famous,
# with people, even a bishop, begging for his blessing. <eod> </s> <eos>"""
def set_seed(args):
np.random.seed(args.seed)
torch.manual_seed(args.seed)
if args.n_gpu > 0:
torch.cuda.manual_seed_all(args.seed)
def top_k_top_p_filtering(logits, top_k=0, top_p=0.0, filter_value=-float('Inf')):
""" Filter a distribution of logits using top-k and/or nucleus (top-p) filtering
Args:
logits: logits distribution shape (batch size x vocabulary size)
top_k > 0: keep only top k tokens with highest probability (top-k filtering).
top_p > 0.0: keep the top tokens with cumulative probability >= top_p (nucleus filtering).
Nucleus filtering is described in Holtzman et al. (http://arxiv.org/abs/1904.09751)
From: https://gist.github.com/thomwolf/1a5a29f6962089e871b94cbd09daf317
"""
top_k = min(top_k, logits.size(-1)) # Safety check
if top_k > 0:
# Remove all tokens with a probability less than the last token of the top-k
indices_to_remove = logits < torch.topk(logits, top_k)[0][..., -1, None]
logits[indices_to_remove] = filter_value
if top_p > 0.0:
sorted_logits, sorted_indices = torch.sort(logits, descending=True)
cumulative_probs = torch.cumsum(F.softmax(sorted_logits, dim=-1), dim=-1)
# Remove tokens with cumulative probability above the threshold
sorted_indices_to_remove = cumulative_probs > top_p
# Shift the indices to the right to keep also the first token above the threshold
sorted_indices_to_remove[..., 1:] = sorted_indices_to_remove[..., :-1].clone()
sorted_indices_to_remove[..., 0] = 0
# scatter sorted tensors to original indexing
indices_to_remove = sorted_indices_to_remove.scatter(dim=1, index=sorted_indices, src=sorted_indices_to_remove)
logits[indices_to_remove] = filter_value
return logits
def sample_sequence(model, length, context, num_samples=1, temperature=1, top_k=0, top_p=0.0, repetition_penalty=1.0,
is_xlnet=False, is_xlm_mlm=False, xlm_mask_token=None, xlm_lang=None, device='cpu'):
context = torch.tensor(context, dtype=torch.long, device=device)
context = context.unsqueeze(0).repeat(num_samples, 1)
generated = context
# all_loss = []
with torch.no_grad():
for _ in range(length):
inputs = {'input_ids': generated}
if is_xlnet:
# XLNet is a direct (predict same token, not next token) and bi-directional model by default
# => need one additional dummy token in the input (will be masked), attention mask and target mapping (see model docstring)
input_ids = torch.cat((generated, torch.zeros((1, 1), dtype=torch.long, device=device)), dim=1)
perm_mask = torch.zeros((1, input_ids.shape[1], input_ids.shape[1]), dtype=torch.float, device=device)
perm_mask[:, :, -1] = 1.0 # Previous tokens don't see last token
target_mapping = torch.zeros((1, 1, input_ids.shape[1]), dtype=torch.float, device=device)
target_mapping[0, 0, -1] = 1.0 # predict last token
inputs = {'input_ids': input_ids, 'perm_mask': perm_mask, 'target_mapping': target_mapping}
if is_xlm_mlm and xlm_mask_token:
# XLM MLM models are direct models (predict same token, not next token)
# => need one additional dummy token in the input (will be masked and guessed)
input_ids = torch.cat((generated, torch.full((1, 1), xlm_mask_token, dtype=torch.long, device=device)), dim=1)
inputs = {'input_ids': input_ids}
if xlm_lang is not None:
inputs["langs"] = torch.tensor([xlm_lang] * inputs["input_ids"].shape[1], device=device).view(1, -1)
outputs = model(**inputs) # Note: we could also use 'past' with GPT-2/Transfo-XL/XLNet/CTRL (cached hidden-states)
next_token_logits = outputs[0][:, -1, :] / (temperature if temperature > 0 else 1.)
# print(next_token_logits.size())
# tmp_eval_loss = outputs[0][:, :, -1][-1][-1]
# print(outputs[0][:, :, -1][-1])
# print (tmp_eval_loss.size ())
# cur_loss = np.abs(tmp_eval_loss.item())
# print(cur_loss)
# all_loss.append(cur_loss)
# repetition penalty from CTRL (https://arxiv.org/abs/1909.05858)
for i in range(num_samples):
for _ in set(generated[i].tolist()):
next_token_logits[i, _] /= repetition_penalty
filtered_logits = top_k_top_p_filtering(next_token_logits, top_k=top_k, top_p=top_p)
if temperature == 0: # greedy sampling:
next_token = torch.argmax(filtered_logits, dim=-1).unsqueeze(-1)
else:
next_token = torch.multinomial(F.softmax(filtered_logits, dim=-1), num_samples=1)
generated = torch.cat((generated, next_token), dim=1)
# print(next_token.item())
if next_token.item() == 29:
break
# print(all_loss)
# avg_loss = np.mean (np.array (all_loss))
# ppl = np.exp(avg_loss)
# print('test_loss (bpe): %.4f, test_perplexity: %.4f' % (avg_loss, ppl))
return generated
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--model_type", default='gpt2', type=str, required=False,
help="Model type selected in the list: " + ", ".join(MODEL_CLASSES.keys()))
parser.add_argument("--model_name_or_path", default='/data/xieyuqiang/story_comprehension/checkpoints_ft_with_roc/lmft_lm_gpt2_roc_gn1_bp1_gc32_lr1_l100_e3_seed42_cgn1', type=str, required=False,
help="Path to pre-trained model or shortcut name selected in the list: " + ", ".join(ALL_MODELS))
parser.add_argument("--source_text_path", type=str, default="/data/xieyuqiang/story_comprehension/data/roc/roc_train.csv")
parser.add_argument("--prompt", type=str, default=" ")
parser.add_argument("--padding_text", type=str, default="")
parser.add_argument("--xlm_lang", type=str, default="", help="Optional language when used with the XLM model.")
parser.add_argument("--length", type=int, default=30)
parser.add_argument("--batch", type=int, default=2)
parser.add_argument("--num_samples", type=int, default=1)
parser.add_argument("--temperature", type=float, default=0,
help="temperature of 0 implies greedy sampling")
parser.add_argument("--repetition_penalty", type=float, default=1.2,
help="primarily useful for CTRL model; in that case, use 1.2")
parser.add_argument("--top_k", type=int, default=1)
parser.add_argument("--top_p", type=float, default=0.9)
parser.add_argument("--no_cuda", action='store_true',
help="Avoid using CUDA when available")
parser.add_argument('--seed', type=int, default=42,
help="random seed for initialization")
parser.add_argument('--stop_token', type=str, default='<|endoftext|>',
help="Token at which text generation is stopped")
parser.add_argument ('--style', type=str, default='temporal',
help="The style for generating the pseudo wrong endings: temporal/causal")
args = parser.parse_args()
args.device = torch.device("cuda" if torch.cuda.is_available() and not args.no_cuda else "cpu")
args.n_gpu = torch.cuda.device_count()
set_seed(args)
args.model_type = args.model_type.lower()
model_class, tokenizer_class = MODEL_CLASSES[args.model_type]
tokenizer = tokenizer_class.from_pretrained(args.model_name_or_path)
model = model_class.from_pretrained(args.model_name_or_path)
model.to(args.device)
model.eval()
if args.length < 0 and model.config.max_position_embeddings > 0:
args.length = model.config.max_position_embeddings
elif 0 < model.config.max_position_embeddings < args.length:
args.length = model.config.max_position_embeddings # No generation bigger than model size
elif args.length < 0:
args.length = MAX_LENGTH # avoid infinite loop
logger.info(args)
if args.model_type in ["ctrl"]:
if args.temperature > 0.7:
logger.info('CTRL typically works better with lower temperatures (and lower top_k).')
while True:
xlm_lang = None
# XLM Language usage detailed in the issues #1414
if args.model_type in ["xlm"] and hasattr(tokenizer, 'lang2id') and hasattr(model.config, 'use_lang_emb') \
and model.config.use_lang_emb:
if args.xlm_lang:
language = args.xlm_lang
else:
language = None
while language not in tokenizer.lang2id.keys():
language = input("Using XLM. Select language in " + str(list(tokenizer.lang2id.keys())) + " >>> ")
xlm_lang = tokenizer.lang2id[language]
# XLM masked-language modeling (MLM) models need masked token (see details in sample_sequence)
is_xlm_mlm = args.model_type in ["xlm"] and 'mlm' in args.model_name_or_path
if is_xlm_mlm:
xlm_mask_token = tokenizer.mask_token_id
else:
xlm_mask_token = None
raw_text = args.prompt if args.prompt else input("Model prompt >>> ")
if args.model_type in ["transfo-xl", "xlnet"]:
# Models with memory likes to have a long prompt for short inputs.
raw_text = (args.padding_text if args.padding_text else PADDING_TEXT) + raw_text
context_tokens = tokenizer.encode(raw_text, add_special_tokens=False)
if args.model_type == "ctrl":
if not any(context_tokens[0] == x for x in tokenizer.control_codes.values()):
logger.info("WARNING! You are not starting your generation from a control code so you won't get good results")
with open (args.source_text_path, 'r', encoding='utf-8') as data_file, \
open (args.source_text_path + "_tpl_generated.tsv", 'w', encoding='utf-8') as new_file, \
open (args.source_text_path + "_tpl_eval.tsv", 'w', encoding='utf-8') as eval_file:
import csv
reader = csv.reader (data_file)
next (reader)
all_data = []
for line in reader:
all_data.append (line)
print (all_data[0])
new_file.write ('context\tsource\ttarget\n')
from tqdm import tqdm
source_corpus = []
target_corpus = []
for raw_data in tqdm(all_data):
context = ' '.join(raw_data[2:6])
source = raw_data[6]
import random
list = raw_data[2:6]
random.shuffle(list)
target = ' '.join(list)
context_tokens = tokenizer.encode (target, add_special_tokens=False)
out = sample_sequence (
model=model,
context=context_tokens,
num_samples=args.num_samples,
length=args.length,
temperature=args.temperature,
top_k=args.top_k,
top_p=args.top_p,
repetition_penalty=args.repetition_penalty,
is_xlnet=bool (args.model_type == "xlnet"),
is_xlm_mlm=is_xlm_mlm,
xlm_mask_token=xlm_mask_token,
xlm_lang=xlm_lang,
device=args.device,
)
out = out[:, len (context_tokens):].tolist ()
for o in out:
# text = tokenizer.decode(o, cleanI_up_tokenization_spaces=True)
text = tokenizer.decode (o)
text = text[: text.find (args.stop_token) if args.stop_token else None]
target = text.replace ('<|endoftext|>', '')
source_corpus.append(source)
target_corpus.append(target)
new_file.write (context+"\t"+source+"\t"+target+"\n")
bleu_list = []
rouge_ = []
for source, target in zip (source_corpus, target_corpus):
bleu = sacrebleu.corpus_bleu (target, source)
bleu_list.append (bleu.precisions)
rouge = Rouge ()
for source, target in zip (source_corpus, target_corpus):
# rouge_l = compute_rouge_L(source, target)
rouge_x = rouge.get_scores (source, target)
rouge_1 = rouge_x[0]["rouge-1"]['f']
rouge_2 = rouge_x[0]["rouge-2"]['f']
rouge_l = rouge_x[0]["rouge-l"]['f']
rouge_.append ([rouge_1, rouge_2, rouge_l])
bleu_score = np.mean (bleu_list, axis=0)
rouge_score_ = np.mean (rouge_, axis=0)
print ("BLEU-1 score: " + str (bleu_score[0]) + "\n")
print ("BLEU-2 score: " + str (bleu_score[1]) + "\n")
print ("BLEU-4 score: " + str (bleu_score[3]) + "\n")
print ("Rouge-1 score: " + str (rouge_score_[0] * 100) + "\n")
print ("Rouge-2 score: " + str (rouge_score_[1] * 100) + "\n")
print ("Rouge-L score: " + str (rouge_score_[2] * 100) + "\n")
eval_file.write ("BLEU-1 score: " + str (bleu_score[0]) + "\n")
eval_file.write ("BLEU-2 score: " + str (bleu_score[1]) + "\n")
eval_file.write ("BLEU-4 score: " + str (bleu_score[3]) + "\n")
eval_file.write ("Rouge-1 score: " + str (rouge_score_[0] * 100) + "\n")
eval_file.write ("Rouge-2 score: " + str (rouge_score_[1] * 100) + "\n")
eval_file.write ("Rouge-L score: " + str (rouge_score_[2] * 100) + "\n")
if args.prompt:
break
# return target
if __name__ == '__main__':
main()
| [] |
2024-01-10 | adrianmarino/thesis-paper | lib~recommender~chatbot~movie~movie_recommendations_output_parser.py | from langchain.schema import BaseOutputParser
from bunch import Bunch
from typing import List
import util as ut
import re
import logging
from pydantic import BaseModel, PrivateAttr
class MovieRecommendationsOutputParser(BaseOutputParser[List[str]]):
__list_size: int = PrivateAttr(True)
def __init__(self, list_size):
super().__init__()
self.__list_size = list_size
def parse(self, text: str) -> List[str]:
results = []
for idx in range(self.__list_size):
try:
line = ut.between(text, f'{idx+1}.', f'{idx+2}.')
except Exception as e:
logging.error(f'Error to parse response. {e}')
return results
data = re.split(r'\(|\)\:', line)
if len(data) <= 1:
continue
results.append({
'title' : data[0].strip().replace('"', '').capitalize(),
'description': data[2].strip().capitalize(),
'release' : int(data[1].strip())
})
return { 'recommendations': results } | [] |
2024-01-10 | adrianmarino/thesis-paper | lib~recommender~chatbot~stateless~chat_bot_response_factory.py | from .chat_bot_response import ChatBotResponse
import logging
from langchain_core.messages import SystemMessage
class ChatBotResponseFactory:
def __init__(self, output_parser, template_factory):
self._output_parser = output_parser
self._template_factory = template_factory
self._logger = logging.getLogger(self.__class__.__name__)
def create(self, params, response):
metadata = self._output_parser.parse(response)
prompt = self._template_factory.invoke(params)
metadata['params'] = params
metadata['prompts'] = list(map(lambda it: {'type': it.__class__.__name__, 'content': it.content}, prompt.messages))
return ChatBotResponse(response, metadata)
| [] |
2024-01-10 | adrianmarino/thesis-paper | lib~model~llm~chain_builder.py | from langchain.callbacks.manager import CallbackManager
from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler
from langchain.llms import Ollama
from langchain.chat_models import ChatOllama
from langchain.prompts import ChatPromptTemplate
class OllamaModelBuilder:
@staticmethod
def chat(model='movie_recommender', verbose=False):
callback_manager = CallbackManager([StreamingStdOutCallbackHandler()]) if verbose else None
return ChatOllama(model=model, callback_manager=callback_manager)
@staticmethod
def default(model='movie_recommender', verbose=False):
callback_manager = CallbackManager([StreamingStdOutCallbackHandler()]) if verbose else None
return Ollama(model=model, callback_manager=callback_manager)
class OllamaChatPromptTemplateFactory:
@staticmethod
def create(prompt):
return ChatPromptTemplate.from_messages([
('system', prompt),
('human', '{request}')
])
class OllamaChainBuilder:
@staticmethod
def default(model, prompt, verbose=False):
return OllamaChatPromptTemplateFactory.create(prompt) | \
OllamaModelBuilder.default(model, verbose)
@staticmethod
def chat(model, prompt, verbose=False):
return OllamaChatPromptTemplateFactory.create(prompt) | \
OllamaModelBuilder.chat(model, verbose)
| [
"[('system', PLACEHOLDER), ('human', '{request}')]"
] |
2024-01-10 | TheItCrOw/R.O.B.E.R.T. | src~training~rob_test_pipeline.py | from db import db
from torchmetrics.text.rouge import ROUGEScore
from nltk.translate.bleu_score import sentence_bleu
import torch
import time
import random
import sys
import numpy as np
import json
import os
import gc
import openai
from datetime import datetime
from chat_gpt3 import chat_gpt3
sys.path.append(os.path.join(os.path.dirname(os.path.abspath(__file__)), '../..'))
sys.path.append(os.path.join(os.path.dirname(os.path.abspath(__file__)), '../../src/robert'))
from src.robert.robert_lora import robert
from src.robert.robert_lora import build_finetuned_path
db = db()
chatgpt_model = chat_gpt3()
# Add here all models you want. Set the "test" property to false if
# you dont want that model to be tested in the next run.
test_models = [
{
'name': 'robert_1k',
'desc': 'Trained on 1k base chatgpt ds',
'test': True
},
{
'name': 'robert_5k',
'desc': 'Trained on 5k base chatgpt ds',
'test': True
},
{
'name': 'robert_5k_chat_only',
'desc': 'Trained on 5k chatting chatgpt ds',
'test': True
},
{
'name': 'robert_21k_chat_only_para',
'desc': 'Trained on 5k chatting chatgpt ds + 16k chatting paraphrased',
'test': True
},
{
'name': 'robert_6k_para_chat',
'desc': 'Trained on 6k base chatgpt ds + 12k paraphrased + 5k chatting ds',
'test': True
},
{
'name': 'robert_10k_gpt4all',
'desc': 'Trained on 10k base gpt4all ds',
'test': True
},
{
'name': 'robert_10k',
'desc': 'Trained on 10k base chatgpt ds',
'test': True
},
{
'name': 'robert_45k_chat_para',
'desc': 'Trained on 12k base chatgpt ds + 12k paraphrased + 5 chatting ds + 16k paraphrased',
'test': True
}
]
base_datasets_count = 1000
chat_datasets_count = 1000
done_models = []
include_rouge = False
include_chatgpt = False
generate_rateable_datasets = True
generate_student_instructions = False
generate_student_dialogs = False
student_instruction = """Formulate an instruction or a question towards Rob about the given input"""
student_dialog = """Proactively continue the dialog provided in the input as the student"""
def get_parameters():
params = []
f = open("parameters.txt", "r", encoding='utf-8')
for line in f.readlines():
params.append(str(line.strip()))
return params
def test_instruction_following_capabilities(model_name, my_robert):
'''Test a model for its instruction following capabilities'''
# First step: calculate a rogue score. Use chatgpt datasets for that.
print("\n")
print("----- Testing instruction following capabilities of " + model_name)
db_name = "chatgpt"
if("gpt4all" in model_name):
db_name = "gpt4all"
base_datasets = db.get_base_datasets("chatgpt", base_datasets_count)
print("Going through " + str(base_datasets_count) + " datasets.")
count = 1
rouge = ROUGEScore()
# In these tests, we dont want context or anything. Just instruction
# following capabilities
for data in base_datasets:
target = data['output']
prediction = my_robert.get_response(data['instruction'], use_context=False)
progress = "Done with " + str(round(100/base_datasets_count*count, 1)) + "%"
score = rouge(prediction, target)
bleu_score = float(sentence_bleu([target], prediction))
db.insert_rogue_score(score, model_name, data['instruction'],
target, prediction, data['input'], bleu_score)
count = count + 1
#sys.stdout.write('\r')
sys.stdout.write('Done with ' + str(count) + ' datasets. ' + progress)
#sys.stdout.flush()
def test_dialog_capabilities(model_name, my_robert):
print("\n")
print("----- Testing dialog capabilities of " + model_name)
chat_datasets = db.get_chatting_datasets_with_input(chat_datasets_count, False)
print("Going through " + str(chat_datasets_count) + " datasets.")
count = 1
rouge = ROUGEScore()
for data in chat_datasets:
# For here, we want to work with the input as context.
target = data['output']
my_robert.set_context(data['input'].split('\n'))
prediction = my_robert.get_response(data['instruction'])
progress = "Done with " + str(round(100/chat_datasets_count*count, 1)) + "%"
score = rouge(prediction, target)
bleu_score = float(sentence_bleu([target], prediction))
db.insert_rogue_score(score, model_name, data['instruction'],
target, prediction, data['input'], bleu_score)
count = count + 1
# Decomment the two lines below if you dont want a new line in the console.
# sys.stdout.write('\r')
sys.stdout.write('Done with ' + str(count) + ' datasets. ' + progress)
# sys.stdout.flush()
def build_rateable_dataset(model_name, my_robert):
print("\n")
print("----- Building rateable datasets for " + model_name)
# First, the instructions.
student_instructions = db.get_student_instructions(9999)
print("Going through " + str(len(student_instructions)) + " datasets.")
count = 1
student_instructions = []
for data in student_instructions:
# For here, we want to work with the input as context.
my_robert.clear_context()
# the output of a student instruction dataset is a question for Rob
robs_answer = my_robert.get_response(data['output'])
dataset = {
'instruction': data['output'],
'output': robs_answer,
'input': '',
'context': data['context'],
'model': model_name,
'type': 'instruction',
'rating': 0,
'comment': '',
"isRated": False
}
db.get_database()['rateable_test_datasets'].insert_one(dataset)
count = count + 1
# Decomment the two lines below if you dont want a new line in the console.
sys.stdout.write('Done with ' + str(count) + ' datasets. ')
# Do dialogs as well here!
print("Doing dialogs now")
student_dialogs = db.get_filtered_student_dialogs(50)
print("Going through " + str(len(student_dialogs)) + " datasets.")
count = 1
for data in student_dialogs:
history = data['context'].split('\n')
instruction = history[len(history) - 1]
context = history[:-1]
# For here, we want to work with the input as context.
my_robert.set_context(context)
# the output of a student instruction dataset is a question for Rob
robs_answer = my_robert.get_response(instruction)
dataset = {
'instruction': instruction,
'output': robs_answer,
'input': data['context'],
'context': '',
'model': model_name,
'type': 'dialog',
'rating': 0,
'comment': '',
"isRated": False
}
db.get_database()['rateable_test_datasets'].insert_one(dataset)
count = count + 1
# Decomment the two lines below if you dont want a new line in the console.
sys.stdout.write('Done with ' + str(count) + ' datasets. ')
def start_test_pipeline():
'''
Starts a test pipeline by testing the given robert models with
various prompts, dialogs and questions.
'''
# We go through each model and test them
tries = 3
to_test = [m for m in test_models if m['test'] is True]
print(str(datetime.now()))
print("===================== Starting a new pipeline =====================")
print("For that, we have " + str(len(to_test)) + " models to test.\n\n")
for model in to_test:
try:
if(model['name'] in done_models):
continue
my_robert = robert(finetuned_path=build_finetuned_path(model['name']),
context_amount=4, dtype="bfloat16")
print("Doing " + model['name'] + " now:")
if(include_rouge):
test_instruction_following_capabilities(model['name'], my_robert)
test_dialog_capabilities(model['name'], my_robert)
if(generate_rateable_datasets):
build_rateable_dataset(model['name'], my_robert)
print("Done with " + model['name'] + "!\n")
done_models.append(model['name'])
# Free the gpu from the model
my_robert = ""
gc.collect()
torch.cuda.empty_cache()
# I hope this gives pytorch enough time to free the memory. Otherwise, we crash here.
time.sleep(5)
except Exception as ex:
print("Caught en exception")
print(ex)
# We want to try again if an error occured because it could be just
# missing memory.
if(tries > 0):
print("Retrying again in 10 seconds.")
time.sleep(10)
tries = tries - 1
start_test_pipeline()
print(str(datetime.now()))
print("===================== Done with the pipeline =====================")
prompt_text = '''
Rob knows the following:
[CONTEXT]
A student asked Rob, a virtual reality assistant:
[QUESTION]
Rob answered with:
[ANSWER]
Rob should only answer when he truly knows the answer. Otherwise he should excuse himself.
Rate Robs answer with a number from 1 to 10. Rate harshly!
Print only the number.'''
dialog_prompt_text = '''
A student is having a conversation with Rob, the virtual reality assistant. This is the chat history:
[HISTORY]
Rob knows the following:
[CONTEXT]
Rob continued the dialog with:
[ANSWER]
Rate Robs answer with a number from 1 to 10. Focus heavily on whether the answer has correct information given Robs knowledge! If the answer is false, give at max 3 points! If the answer is nonsensical give 1 point!
Print only the number.
'''
def start_chatgpt_pipeline():
'''ChatGPT will give each answer a score.'''
scores = db.get_rouge_scores(99999)
count = 0
for score in scores:
test_model = [m for m in test_models if m['name'] == score['model']][0]
if(test_model['test'] is False):
print("Skipping for " + test_model['name'])
continue
answer = ''
if(score['inp'] == ''):
# time.sleep(0.5)
# This is an instruction following test
prompt = prompt_text.replace('[QUESTION]', score['instruction'])
prompt = prompt.replace('[CONTEXT]', "\n".join(score['context'].split('[ITEM]')))
prompt = prompt.replace('[ANSWER]', score['prediction'])
print(prompt)
answer = chatgpt_model.get_response(prompt).strip().replace("\n", "")
else:
# This is a dialog test
prompt = dialog_prompt_text.replace('[HISTORY]', score['inp'])
prompt = prompt.replace('[CONTEXT]', "\n".join(score['context'].split('[ITEM]')))
prompt = prompt.replace('[ANSWER]', score['prediction'])
print(prompt)
answer = chatgpt_model.get_response(prompt).strip().replace("\n", "")
try:
s = int(answer)
print("========================")
print("Score: " + str(s))
print("========================")
db.insert_chatgpt_score(s, score['model'], score['instruction'],
score['prediction'], score['inp'],
score['context'], score)
except Exception as ex:
print(ex)
print("Couldn't convert to int: " + answer)
count = count + 1
print("Done with " + str(count))
def start_student_instruction_generation():
'''Creates X amount of new instructions by a student for robert'''
params = get_parameters()
my_student = robert(finetuned_path=build_finetuned_path("student_24k_para"),
is_student=True, context_amount=4)
for i in range(100):
context = random.sample(params, random.randint(1, 2))
my_student.set_context(context)
# The response of the student model is an instruction for Rob
answer = my_student.get_response(student_instruction)
dataset = {
"instruction": student_instruction,
"output": answer,
"context": "[ITEM]".join(context),
"model": "student_24k_para"
}
db.get_database()['student_instructions'].insert_one(dataset)
def start_student_dialog_generation():
'''Creates X amount of new instructions by a student for robert'''
params = get_parameters()
my_student = robert(finetuned_path=build_finetuned_path("student_24k_para"),
is_student=True, context_amount=4, dtype="bfloat16")
for i in range(200):
# context here is the chat history. We have none for now.
context = random.sample(params, random.randint(1, 2))
history = []
my_student.set_context(context)
# The response of the student model is an instruction for Rob
answer = my_student.get_response(student_instruction)
history.append("Student: " + answer)
dataset = {
"instruction": student_dialog,
"output": answer,
"context": "\n".join(history),
"model": "student_24k_para",
"last_turn": "Student",
"turns": 1
}
db.get_database()['student_dialogs'].insert_one(dataset)
def continue_student_dialog_generation():
turn = 4
dialogs = db.get_student_dialogs_by_turn(9999, turn)
print("Found " + str(len(dialogs)) + " dialogs of turn " + str(turn))
last_turn = dialogs[0]["last_turn"]
print("Last turn was: " + str(last_turn))
my_model = ''
speaker = ''
if(last_turn == "Student"):
print("Initing Robert as our model")
my_model = robert(finetuned_path=build_finetuned_path("robert_21k_chat_only_para"),
context_amount=2, dtype="bfloat16")
speaker = "Rob"
else:
print("Initing the student as our model")
my_model = robert(finetuned_path=build_finetuned_path("student_22k_chat_para"),
is_student=True, context_amount=2, dtype="bfloat16")
speaker = "Student"
# Now through each dialog, continue it.
for dialog in dialogs:
history = dialog['context'].split('\n')
# If we have a history, then pass in the chat history
# Robert doesnt take the last instruction into the context
if(last_turn == "Student"):
my_model.set_context(dialog['context'].split('\n')[:-1])
else:
my_model.set_context(dialog['context'].split('\n'))
# The student gets the default prompt
prompt = student_dialog
# Rob gets the last question of the student as the input
if(last_turn == "Student"):
prompt = dialog["output"]
answer = my_model.get_response(prompt)
history.append(speaker + ": " + answer)
dataset = {
"instruction": prompt,
"output": answer,
"context": "\n".join(history),
"model": "robert_21k_chat_only_para/student_22k_chat_para",
"last_turn": speaker,
"context_size": 2,
"turns": turn + 1
}
db.get_database()['student_dialogs'].insert_one(dataset)
if __name__ == "__main__":
db.init()
print("Database initiated.")
chatgpt_model.init(openai)
print("Chatgpt initiated.")
start_test_pipeline()
# start_chatgpt_pipeline()
if(generate_student_instructions):
start_student_instruction_generation()
if(generate_student_dialogs):
# start_student_dialog_generation()
continue_student_dialog_generation()
| [
"inp",
"\nA student is having a conversation with Rob, the virtual reality assistant. This is the chat history:\n[HISTORY]\n\nRob knows the following:\n[CONTEXT]\n\nRob continued the dialog with:\n[ANSWER]\n\nRate Robs answer with a number from 1 to 10. Focus heavily on whether the answer has correct information given Robs knowledge! If the answer is false, give at max 3 points! If the answer is nonsensical give 1 point!\nPrint only the number.\n",
"\n",
"instruction",
"[QUESTION]",
"prediction",
"\nRob knows the following:\n[CONTEXT]\n\nA student asked Rob, a virtual reality assistant:\n[QUESTION]\n\nRob answered with:\n[ANSWER]\n\nRob should only answer when he truly knows the answer. Otherwise he should excuse himself.\nRate Robs answer with a number from 1 to 10. Rate harshly!\nPrint only the number.",
"context"
] |
2024-01-10 | civrealm/civrealm | src~civrealm~agents~civ_autogpt~GPTAgent.py | import os
import openai
import time
import random
import json
import requests
import warnings
from func_timeout import func_timeout
from func_timeout import FunctionTimedOut
from civrealm.agents.civ_autogpt.utils.num_tokens_from_messages import num_tokens_from_messages
from civrealm.agents.civ_autogpt.utils.interact_with_llm import send_message_to_llama, send_message_to_vicuna
from civrealm.agents.civ_autogpt.utils.extract_json import extract_json
from civrealm.agents.civ_autogpt.utils.interact_with_llm import send_message_to_llama
from langchain.chat_models import ChatOpenAI
from langchain.chains import ConversationChain
from langchain.memory import ConversationSummaryBufferMemory
import pinecone
from langchain.document_loaders import DirectoryLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.vectorstores import Pinecone
from langchain.llms import OpenAI
from langchain.chains.question_answering import load_qa_chain
warnings.filterwarnings('ignore')
cwd = os.getcwd()
openai_keys_file = os.path.join(cwd, "src/civrealm/agents/civ_autogpt/openai_keys.txt")
task_prompt_file = os.path.join(cwd, "src/civrealm/agents/civ_autogpt/prompts/task_prompt.txt")
state_prompt_file = os.path.join(cwd, "src/civrealm/agents/civ_autogpt/prompts/state_prompt.txt")
TOKEN_LIMIT_TABLE = {
"gpt-4": 8192,
"gpt-4-0314": 8192,
"gpt-4-32k": 32768,
"gpt-4-32k-0314": 32768,
"gpt-3.5-turbo-0301": 4096,
"gpt-3.5-turbo": 4096,
"gpt-35-turbo": 4096,
"text-davinci-003": 4080,
"code-davinci-002": 8001,
"text-davinci-002": 2048,
"vicuna-33B": 2048,
"Llama2-70B-chat": 2048,
"gpt-35-turbo-16k": 16384
}
class GPTAgent:
"""
This agent uses GPT-3 to generate actions.
"""
def __init__(self, model = "gpt-3.5-turbo"):
self.model = model
self.dialogue = []
self.agent_index = None
self.taken_actions_list = []
self.message = ''
self.openai_api_keys = self.load_openai_keys()
self.state_prompt = self._load_state_prompt()
self.task_prompt = self._load_task_prompt()
self.update_key()
llm = ChatOpenAI(temperature=0.7, openai_api_key = openai.api_key)
self.memory = ConversationSummaryBufferMemory(llm=llm, max_token_limit=500)
self.chain = load_qa_chain(OpenAI(model_name="gpt-3.5-turbo"), chain_type="stuff")
pinecone.init(
api_key=os.environ["MY_PINECONE_API_KEY"], environment=os.environ["MY_PINECONE_ENV"]
)
# embeddings = OpenAIEmbeddings(model="text-embedding-ada-002")
self.index = Pinecone.from_existing_index(index_name='langchain-demo', embedding=OpenAIEmbeddings(model="text-embedding-ada-002"))
def get_similiar_docs(self, query, k=2, score=False):
index = self.index
if score:
similar_docs = index.similarity_search_with_score(query, k=k)
else:
similar_docs = index.similarity_search(query, k=k)
return similar_docs
def get_answer(self, query):
similar_docs = self.get_similiar_docs(query)
while True:
try:
answer = self.chain.run(input_documents=similar_docs, question=query)
break
except Exception as e:
print(e)
self.update_key()
return answer
def change_api_base(self, to_type):
if to_type == 'azure':
openai.api_type = os.environ["ASURE_OPENAI_API_TYPE"]
openai.api_version = os.environ["ASURE_OPENAI_API_VERSION"]
openai.api_base = os.environ["ASURE_OPENAI_API_BASE"]
openai.api_key = os.environ["ASURE_OPENAI_API_KEY"]
else:
openai.api_type = "open_ai"
openai.api_version = ""
openai.api_base = 'https://api.openai.com/v1'
self.update_key()
@staticmethod
def load_openai_keys():
with open(openai_keys_file, "r") as f:
context = f.read()
return context.split('\n')
def _load_state_prompt(self):
with open(state_prompt_file, "r") as f:
self.state_prompt = f.read()
self.dialogue.append({"role": "user", "content": self.state_prompt})
return self.state_prompt
def _load_task_prompt(self):
# print("reading task prompt from {}".format(task_prompt_file))
with open(task_prompt_file, "r") as f:
self.task_prompt = f.read()
self.dialogue.append({"role": "user", "content": self.task_prompt})
def update_key(self):
curr_key = self.openai_api_keys[0]
openai.api_key = os.environ["OPENAI_API_KEY"] = curr_key
self.openai_api_keys.pop(0)
self.openai_api_keys.append(curr_key)
def check_if_the_taken_actions_list_needed_update(self, check_content, check_num = 3, top_k_charactors = 0):
if top_k_charactors == 0:
if len(self.taken_actions_list) >= check_num:
for i in range(check_num):
if self.taken_actions_list[-1 - i] == check_content:
if i == check_num - 1:
return True
else:
continue
else:
return False
return False
else:
if len(self.taken_actions_list) >= check_num:
for i in range(check_num):
if self.taken_actions_list[-1 - i][:top_k_charactors] == check_content:
if i == check_num - 1:
return True
else:
continue
else:
return False
return False
def process_command(self, command_json, obs_input_prompt, current_unit_name, current_avail_actions):
'''
manualAndHistorySearch
askCurrentGameInformation
finalDecision
'''
try:
command_input = command_json['command']['input']
command_name = command_json['command']['name']
except Exception as e:
print(e)
print('Not in given json format, retrying...')
if random.random() > 0.5:
self.update_dialogue(obs_input_prompt + ' CAUTION: You should strictly follow the JSON format as described above!', pop_num = 2)
return None
else:
self.update_dialogue(obs_input_prompt, pop_num = 2)
return None
if (command_name == 'finalDecision') and command_input['action']:
# Here to implement controller
print(command_input)
exec_action = command_input['action']
if command_input['action'] not in current_avail_actions:
print('Not in the available action list, retrying...')
# Here is the most time taking place.
if random.random() > 0.5:
self.update_dialogue(obs_input_prompt + ' CAUTION: You can only answer action from the available action list!', pop_num = 2)
return None
else:
self.update_dialogue(obs_input_prompt, pop_num = 2)
return None
else:
self.taken_actions_list.append(command_input['action'])
if self.check_if_the_taken_actions_list_needed_update('goto', 15, 4) or self.check_if_the_taken_actions_list_needed_update('keep_activity', 15, 0):
self.update_dialogue(obs_input_prompt + \
' CAUTION: You have chosen too much goto operation. You should try various kind of action. Try to look for more information in manual!', pop_num = 2)
# command_input = new_response['command']['input']
self.taken_actions_list = []
return None
else:
print('exec_action:', exec_action)
return exec_action
elif command_name == 'askCurrentGameInformation' and command_input['query']:
print(command_input)
self.taken_actions_list.append('askCurrentGameInformation')
return None
elif command_name == 'manualAndHistorySearch' and command_input['look_up']:
print(command_input)
if self.check_if_the_taken_actions_list_needed_update('look_up', 3, 0):
answer = 'Too many look for! Now You should give me an action at once!'
print(answer)
self.dialogue.append({'role': 'user', 'content': answer})
self.taken_actions_list = []
else:
query = command_input['look_up']
answer = self.get_answer(query)
print('answer:', answer)
if random.random() > 0.5:
self.dialogue.append({'role': 'user', 'content': answer + ' Now you get the needed information from the manual, give me your action answer.'})
else:
self.dialogue.append({'role': 'user', 'content': answer})
self.memory.save_context({'assistant': query}, {'user': answer})
self.taken_actions_list.append('look_up')
return None
else:
print('error')
print(command_json)
if random.random() < 0.8:
self.dialogue.pop(-1)
else:
self.dialogue.append({'role': 'user', 'content': 'You should only use the given commands!'})
# self.update_dialogue(obs_input_prompt, pop_num = 1)
return None
def query(self, stop = None, temperature = 0.7, top_p = 0.95):
self.restrict_dialogue()
# TODO add retreat mech to cope with rate limit
self.update_key()
if self.model in ['gpt-3.5-turbo-0301', 'gpt-3.5-turbo']:
response = openai.ChatCompletion.create(
model=self.model,
messages=self.dialogue,
temperature = temperature,
top_p = top_p
)
elif self.model in ["gpt-35-turbo", "gpt-35-turbo-16k"]:
self.change_api_base('azure')
response = openai.ChatCompletion.create(
engine=self.model,
messages=self.dialogue
)
self.change_api_base('open_ai')
elif self.model in ['vicuna-33B']:
local_config = {'temperature':temperature, 'top_p': top_p, 'repetition_penalty': 1.1}
response = send_message_to_vicuna(self.dialogue, local_config)
elif self.model in ['Llama2-70B-chat']:
local_config = {'temperature':temperature, 'top_p': top_p, 'repetition_penalty': 1.1}
response = send_message_to_llama(self.dialogue, local_config)
else:
response = openai.Completion.create(
model=self.model,
prompt=str(self.dialogue),
max_tokens=1024,
stop=stop,
temperature=temperature,
n = 1,
top_p = top_p
)
return response
def update_dialogue(self, chat_content, pop_num = 0):
if pop_num != 0:
for i in range(pop_num):
self.dialogue.pop(-1)
return self.communicate(chat_content)
# @staticmethod
def parse_response(self, response):
if self.model in ['gpt-3.5-turbo-0301', 'gpt-3.5-turbo', 'gpt-4', 'gpt-4-0314']:
return dict(response["choices"][0]["message"])
elif self.model in ["gpt-35-turbo", "gpt-35-turbo-16k"]:
try:
ans = json.dumps(eval(extract_json(response['choices'][0]['message']['content'])))
except:
return response["choices"][0]["message"]
return {'role': 'assistant', 'content': ans}
elif self.model in ['vicuna-33B', 'Llama2-70B-chat']:
return {'role': 'assistant', 'content': extract_json(response)}
else:
# self.model in ['text-davinci-003', 'code-davinci-002']
return {'role': 'assistant', 'content': response["choices"][0]["text"][2:]}
def restrict_dialogue(self):
limit = TOKEN_LIMIT_TABLE[self.model]
"""
The limit on token length for gpt-3.5-turbo-0301 is 4096.
If token length exceeds the limit, we will remove the oldest messages.
"""
# TODO validate that the messages removed are obs and actions
while num_tokens_from_messages(self.dialogue) >= limit:
temp_message = {}
user_tag = 0
if self.dialogue[-1]['role'] == 'user':
temp_message = self.dialogue[-1]
user_tag = 1
while len(self.dialogue) >= 3:
self.dialogue.pop(-1)
while True:
try:
self.dialogue.append({'role': 'user', 'content': 'The former chat history can be summarized as: \n' + self.memory.load_memory_variables({})['history']})
break
except Exception as e:
print(e)
self.update_key()
if user_tag == 1:
self.dialogue.append(temp_message)
user_tag = 0
def communicate(self, content, parse_choice_tag = False):
self.dialogue.append({"role": "user", "content": content})
while True:
try:
raw_response = self.query()
self.message = self.parse_response(raw_response)
self.dialogue.append(self.message)
response = self.message["content"]
# print('response:', response)
try:
response = json.loads(response)
except Exception as e:
# self.dialogue.pop(-1)
print(e)
self.dialogue.append({"role": "user", \
"content": "You should only respond in JSON format as described"})
print('Not response json, retrying...')
continue
break
except Exception as e:
print(e)
print("retrying...")
# self.dialogue.pop(-1)
# self.dialogue.pop(-1)
continue
return response
def reset(self):
# super().reset()
self.dialogue = []
self.agent_index = None
self.message = ''
self.taken_actions_list = []
# self.gpt_extractor.reset()
self.openai_api_keys = self.load_openai_keys()
self.state_prompt = self._load_state_prompt()
self.task_prompt = self._load_task_prompt()
| [
"You should only respond in JSON format as described",
"The former chat history can be summarized as: \n",
"src/civrealm/agents/civ_autogpt/prompts/state_prompt.txt",
"src/civrealm/agents/civ_autogpt/prompts/task_prompt.txt",
"You should only use the given commands!",
"PLACEHOLDER Now you get the needed information from the manual, give me your action answer."
] |
2024-01-10 | AI-Jie01/auto-evaluator | auto-evaluator.py | import os
import json
import time
import pypdf
import random
import itertools
import text_utils
import pandas as pd
import altair as alt
import streamlit as st
from io import StringIO
from langchain.llms import Anthropic
from langchain.vectorstores import FAISS
from langchain.chains import RetrievalQA
from langchain.chat_models import ChatOpenAI
from langchain.retrievers import SVMRetriever
from langchain.chains import QAGenerationChain
from langchain.retrievers import TFIDFRetriever
from langchain.evaluation.qa import QAEvalChain
from langchain.embeddings import HuggingFaceEmbeddings
from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.retrievers.llama_index import LlamaIndexRetriever
from text_utils import GRADE_DOCS_PROMPT, GRADE_ANSWER_PROMPT, GRADE_DOCS_PROMPT_FAST, GRADE_ANSWER_PROMPT_FAST
from langchain.text_splitter import RecursiveCharacterTextSplitter, CharacterTextSplitter
# Keep dataframe in memory to accumulate experimal results
if "existing_df" not in st.session_state:
summary = pd.DataFrame(columns=['chunk_chars',
'overlap',
'split',
'model',
'retriever',
'embedding',
'latency',
'retrival score',
'answer score'])
st.session_state.existing_df = summary
else:
summary = st.session_state.existing_df
@st.cache_data
def load_docs(files):
# Load docs
# IN: List of upload files (from Streamlit)
# OUT: str
st.info("`Reading doc ...`")
all_text = ""
for file_path in files:
file_extension = os.path.splitext(file_path.name)[1]
if file_extension == ".pdf":
pdf_reader = pypdf.PdfReader(file_path)
text = ""
for page in pdf_reader.pages:
text += page.extract_text()
text = text_utils.clean_pdf_text(text)
all_text += text
elif file_extension == ".txt":
stringio = StringIO(file_path.getvalue().decode("utf-8"))
text = stringio.read()
all_text += text
else:
st.warning('Please provide txt or pdf.', icon="⚠️")
return all_text
@st.cache_data
def generate_eval(text, N, chunk):
# Generate N questions from context of chunk chars
# IN: text, N questions, chunk size to draw question from in the doc
# OUT: eval set as JSON list
st.info("`Generating eval set ...`")
n = len(text)
starting_indices = [random.randint(0, n-chunk) for _ in range(N)]
sub_sequences = [text[i:i+chunk] for i in starting_indices]
chain = QAGenerationChain.from_llm(ChatOpenAI(temperature=0))
eval_set = []
for i, b in enumerate(sub_sequences):
try:
qa = chain.run(b)
eval_set.append(qa)
except:
st.warning('Error generating question %s.'%str(i+1), icon="⚠️")
eval_set_full = list(itertools.chain.from_iterable(eval_set))
return eval_set_full
@st.cache_resource
def split_texts(text, chunk_size, overlap, split_method):
# Split texts
# IN: text, chunk size, overlap, split_method
# OUT: list of str splits
st.info("`Splitting doc ...`")
if split_method == "RecursiveTextSplitter":
text_splitter = RecursiveCharacterTextSplitter(chunk_size=chunk_size,
chunk_overlap=overlap)
elif split_method == "CharacterTextSplitter":
text_splitter = CharacterTextSplitter(separator=" ",
chunk_size=chunk_size,
chunk_overlap=overlap)
splits = text_splitter.split_text(text)
return splits
@st.cache_resource
def make_retriever(splits, retriever_type, embeddings, num_neighbors):
# Make document retriever
# IN: list of str splits, retriever type, embedding type, number of neighbors for retrieval
# OUT: retriever
st.info("`Making retriever ...`")
# Set embeddings
if embeddings == "OpenAI":
embd = OpenAIEmbeddings()
elif embeddings == "HuggingFace":
embd = HuggingFaceEmbeddings()
# Select retriever
if retriever_type == "similarity-search":
try:
vectorstore = FAISS.from_texts(splits, embd)
except ValueError:
st.warning("`Error using OpenAI embeddings (disallowed TikToken token in the text). Using HuggingFace.`", icon="⚠️")
vectorstore = FAISS.from_texts(splits, HuggingFaceEmbeddings())
retriever = vectorstore.as_retriever(k=num_neighbors)
elif retriever_type == "SVM":
retriever = SVMRetriever.from_texts(splits,embd)
elif retriever_type == "TF-IDF":
retriever = TFIDFRetriever.from_texts(splits)
return retriever
def make_chain(model_version, retriever):
# Make chain
# IN: model version, retriever
# OUT: chain
if (model_version == "gpt-3.5-turbo") or (model_version == "gpt-4"):
llm = ChatOpenAI(model_name=model_version, temperature=0)
elif model_version == "anthropic":
llm = Anthropic(temperature=0)
qa = RetrievalQA.from_chain_type(llm,
chain_type="stuff",
retriever=retriever,
input_key="question")
return qa
def grade_model_answer(predicted_dataset, predictions, grade_answer_prompt):
# Grade the distilled answer
# IN: ground truth, model predictions
# OUT: list of scores
st.info("`Grading model answer ...`")
if grade_answer_prompt == "Fast":
prompt = GRADE_ANSWER_PROMPT_FAST
else:
prompt = GRADE_ANSWER_PROMPT
eval_chain = QAEvalChain.from_llm(llm=ChatOpenAI(model_name="gpt-3.5-turbo", temperature=0),
prompt=prompt)
graded_outputs = eval_chain.evaluate(predicted_dataset,
predictions,
question_key="question",
prediction_key="result")
return graded_outputs
def grade_model_retrieval(gt_dataset, predictions, grade_docs_prompt):
# Grade the docs retrieval
# IN: ground truth, model predictions
# OUT: list of scores
st.info("`Grading relevance of retrived docs ...`")
if grade_docs_prompt == "Fast":
prompt = GRADE_DOCS_PROMPT_FAST
else:
prompt = GRADE_DOCS_PROMPT
eval_chain = QAEvalChain.from_llm(llm=ChatOpenAI(model_name="gpt-3.5-turbo", temperature=0),
prompt=prompt)
graded_outputs = eval_chain.evaluate(gt_dataset,
predictions,
question_key="question",
prediction_key="result")
return graded_outputs
def run_eval(chain, retriever, eval_set, grade_prompt):
# Compute eval
# IN: chain, retriever, eval set, flag for docs retrieval prompt
# OUT: list of scores for answers and retrival, latency, predictions
st.info("`Running eval ...`")
predictions = []
retrived_docs = []
gt_dataset = []
latency = []
for data in eval_set:
# Get answer and log latency
start_time = time.time()
predictions.append(chain(data))
gt_dataset.append(data)
end_time = time.time()
elapsed_time = end_time - start_time
latency.append(elapsed_time)
# Retrive data
docs=retriever.get_relevant_documents(data["question"])
# Extract text from retrived docs
retrived_doc_text = ""
for i,doc in enumerate(docs):
retrived_doc_text += "Doc %s: "%str(i+1) + doc.page_content + " "
retrived = {"question": data["question"],"answer": data["answer"], "result": retrived_doc_text}
retrived_docs.append(retrived)
# Grade
graded_answers = grade_model_answer(gt_dataset, predictions, grade_prompt)
graded_retrieval = grade_model_retrieval(gt_dataset, retrived_docs, grade_prompt)
return graded_answers, graded_retrieval, latency, predictions
# Auth
st.sidebar.image("img/diagnostic.jpg")
with st.sidebar.form("user_input"):
num_eval_questions = st.select_slider("`Number of eval questions`",
options=[1, 5, 10, 15, 20], value=5)
chunk_chars = st.select_slider("`Choose chunk size for splitting`",
options=[500, 750, 1000, 1500, 2000], value=1000)
overlap = st.select_slider("`Choose overlap for splitting`",
options=[0, 50, 100, 150, 200], value=100)
split_method = st.radio("`Split method`",
("RecursiveTextSplitter",
"CharacterTextSplitter"),
index=0)
model = st.radio("`Choose model`",
("gpt-3.5-turbo",
"gpt-4",
"anthropic"),
index=0)
retriever_type = st.radio("`Choose retriever`",
("TF-IDF",
"SVM",
"similarity-search"),
index=2)
num_neighbors = st.select_slider("`Choose # chunks to retrieve`",
options=[3, 4, 5, 6, 7, 8])
embeddings = st.radio("`Choose embeddings`",
("HuggingFace",
"OpenAI"),
index=1)
grade_prompt = st.radio("`Gradeing style prompt`",
("Fast",
"Descriptive"),
index=0)
submitted = st.form_submit_button("Submit evaluation")
# App
st.header("`Auto-evaluator`")
st.info("`I am an evaluation tool for question-answering. Given documents, I will auto-generate a question-answer eval set and evaluate using the selected chain settings. Experiments with different configurations are logged. Optionally, provide your own eval set.`")
with st.form(key='file_inputs'):
uploaded_file = st.file_uploader("`Please upload a file to evaluate (.txt or .pdf):` ",
type=['pdf', 'txt'],
accept_multiple_files=True)
uploaded_eval_set = st.file_uploader("`[Optional] Please upload eval set (JSON):` ",
type=['json'],
accept_multiple_files=False)
submitted = st.form_submit_button("Submit files")
if uploaded_file:
# Load docs
text = load_docs(uploaded_file)
# Generate num_eval_questions questions, each from context of 3k chars randomly selected
if not uploaded_eval_set:
eval_set = generate_eval(text, num_eval_questions, 3000)
else:
eval_set = json.loads(uploaded_eval_set.read())
# Split text
splits = split_texts(text, chunk_chars, overlap, split_method)
# Make vector DB
retriever = make_retriever(splits, retriever_type, embeddings, num_neighbors)
# Make chain
qa_chain = make_chain(model, retriever)
# Grade model
graded_answers, graded_retrieval, latency, predictions = run_eval(qa_chain, retriever, eval_set, grade_prompt)
# Assemble ouputs
d = pd.DataFrame(predictions)
d['answer score'] = [g['text'] for g in graded_answers]
d['docs score'] = [g['text'] for g in graded_retrieval]
d['latency'] = latency
# Summary statistics
mean_latency = d['latency'].mean()
correct_answer_count = len([text for text in d['answer score'] if "INCORRECT" not in text])
correct_docs_count = len([text for text in d['docs score'] if "Context is relevant: True" in text])
percentage_answer = (correct_answer_count / len(graded_answers)) * 100
percentage_docs = (correct_docs_count / len(graded_retrieval)) * 100
st.subheader("`Run Results`")
st.info("`I will grade the chain based on: 1/ the relevance of the retrived documents relative to the question and 2/ the summarized answer relative to the ground truth answer. You can see (and change) to prompts used for grading in text_utils`")
st.dataframe(data=d, use_container_width=True)
# Accumulate results
st.subheader("`Aggregate Results`")
new_row = pd.DataFrame({'chunk_chars': [chunk_chars],
'overlap': [overlap],
'split': [split_method],
'model': [model],
'retriever': [retriever_type],
'embedding': [embeddings],
'latency': [mean_latency],
'retrival score': [percentage_docs],
'answer score': [percentage_answer]})
summary = pd.concat([summary, new_row], ignore_index=True)
st.dataframe(data=summary, use_container_width=True)
st.session_state.existing_df = summary
# Dataframe for visualization
show = summary.reset_index().copy()
show.columns = ['expt number', 'chunk_chars', 'overlap',
'split', 'model', 'retriever', 'embedding', 'latency', 'retrival score','answer score']
show['expt number'] = show['expt number'].apply(
lambda x: "Expt #: " + str(x+1))
show['mean score'] = (show['retrival score'] + show['answer score']) / 2
c = alt.Chart(show).mark_circle(size=100).encode(x='mean score', y='latency',
color='expt number', tooltip=['expt number', 'mean score', 'latency'])
st.altair_chart(c, use_container_width=True, theme="streamlit")
| [
"`Gradeing style prompt`",
"Descriptive"
] |
2024-01-10 | ITM-Kitware/align-system | align_system~cli~run_align_system.py | import sys
import json
from rich.highlighter import JSONHighlighter
from align_system.utils import logging
from align_system.interfaces.cli_builder import build_interfaces
from align_system.algorithms.llm_baseline import LLMBaseline
from align_system.algorithms.llama_index import LlamaIndex
from align_system.similarity_measures import build_force_choice_func
from align_system.prompt_engineering.common import prepare_prompt
from align_system.utils.enums import ProbeType
from align_system.interfaces.abstracts import (
ScenarioInterfaceWithAlignment,
ProbeInterfaceWithAlignment)
log = logging.getLogger(__name__)
JSON_HIGHLIGHTER = JSONHighlighter()
def add_cli_args(parser):
parser.add_argument('-m', '--model',
type=str,
default="falcon",
help="LLM Baseline model to use")
parser.add_argument('-t', '--align-to-target',
action='store_true',
default=False,
help="Align algorithm to target KDMAs")
parser.add_argument('-a', '--algorithm',
type=str,
default="llama_index",
help="Algorithm to use")
parser.add_argument('-A', '--algorithm-kwargs',
type=str,
required=False,
help="JSON encoded dictionary of kwargs for algorithm "
"initialization")
parser.add_argument('--similarity-measure',
type=str,
default="bert",
help="Similarity measure to use (default: 'bert')")
parser.add_argument('-l', '--loglevel',
type=str,
default='INFO')
def main():
log.debug(f"[bright_black]CMD: {' '.join(sys.argv)}[/bright_black]",
extra={'markup': True, 'highlighter': None})
run_align_system(
**build_interfaces(add_cli_args, "ALIGN System CLI",
supported_interfaces={'LocalFiles',
'TA1Soartech',
'TA1Adept'}))
def run_align_system(interface,
model,
align_to_target=False,
algorithm="llm_baseline",
algorithm_kwargs=None,
similarity_measure="bert",
loglevel="INFO"):
# Set log level on root logger (such that child loggers respect
# the set log level)
logging.getLogger().setLevel(loglevel)
scenario = interface.start_scenario()
scenario_dict = scenario.to_dict()
if align_to_target:
alignment_target_dict = scenario.get_alignment_target()
force_choice_func = build_force_choice_func(similarity_measure)
# Load the system / model
algorithm_kwargs_parsed = {}
if algorithm_kwargs is not None:
algorithm_kwargs_parsed = json.loads(algorithm_kwargs)
if algorithm == "llm_baseline":
algorithm = LLMBaseline(
model_use=model, distributed=False,
**algorithm_kwargs_parsed)
elif algorithm == "llama_index":
# TODO: This is a hacky way to have the "Knowledge" KDMA
# determine whether or not domain documents should be loaded.
# Should remove, or move to llama_index code
if align_to_target:
for kdma_dict in alignment_target_dict.get('kdma_values', ()):
if kdma_dict['kdma'].lower() == 'knowledge':
if kdma_dict['value'] > 1:
log.debug("** Setting 'retrieval_enabled' to True "
"based on 'Knowledge' KDMA value ({})".format(
kdma_dict['value']))
algorithm_kwargs_parsed['retrieval_enabled'] = True
else:
log.debug("** Setting 'retrieval_enabled' to False "
"based on 'Knowledge' KDMA value ({})".format(
kdma_dict['value']))
algorithm_kwargs_parsed['retrieval_enabled'] = False
break
algorithm = LlamaIndex(
model_name=model,
**algorithm_kwargs_parsed)
algorithm.load_model()
for probe in scenario.iterate_probes():
probe_dict = probe.to_dict()
casualties_dicts = scenario_dict['state'].get('casualties', [])
mission_unstructured =\
scenario_dict['state']['mission']['unstructured']
state_unstructured = None
if 'state' in probe_dict:
probe_state = probe_dict['state']
if 'casualties' in probe_state:
casualties_dicts = probe_dict['state']['casualties']
if('mission' in probe_state and
'unstructured' in probe_state['mission']):
mission_unstructured =\
probe_state['mission']['unstructured']
if 'unstructured' in probe_state:
state_unstructured = probe_state['unstructured']
if probe_dict['type'] == ProbeType.MultipleChoice.value:
probe_options_dicts = probe_dict['options']
else:
probe_options_dicts = None
prompt = prepare_prompt(
scenario_dict['state']['unstructured'],
mission_unstructured,
state_unstructured,
probe_dict['prompt'],
casualties_dicts,
options=probe_options_dicts,
alignment_target=alignment_target_dict if align_to_target else None
)
log.info("[bold]* Prompt for ADM *[/bold]",
extra={"markup": True})
log.info(prompt)
raw_response = str(algorithm.run_inference(prompt))
log.info("[bold]* ADM raw response *[/bold]",
extra={"markup": True})
log.info(raw_response)
if probe_dict['type'] == ProbeType.FreeResponse.value:
probe.respond({'justification': raw_response})
else:
# Assume multiple-choice style
selected_choice_idx, selected_choice = force_choice_func(
raw_response, [str(o['value']) for o in probe_dict['options']])
log.info("[bold]* Mapped selection *[/bold]",
extra={"markup": True})
log.info(selected_choice)
selected_choice_id =\
probe_dict['options'][selected_choice_idx]['id']
probe.respond({'justification': raw_response,
'choice': selected_choice_id})
if isinstance(probe, ProbeInterfaceWithAlignment):
probe_alignment_results = probe.get_alignment_results()
log.info("* Probe alignment score: {}".format(
probe_alignment_results['score']))
if isinstance(scenario, ScenarioInterfaceWithAlignment):
scenario_alignment_results = scenario.get_alignment_results()
log.info("* Scenario alignment score: {}".format(
scenario_alignment_results['score']))
if __name__ == "__main__":
main()
| [
"unstructured"
] |
2024-01-10 | ITM-Kitware/align-system | align_system~algorithms~llama_index.py | from langchain.embeddings.huggingface import HuggingFaceEmbeddings
from llama_index import (
VectorStoreIndex,
SimpleDirectoryReader,
LangchainEmbedding,
ServiceContext,
)
from llama_index.llms import HuggingFaceLLM
from llama_index.prompts.prompts import SimpleInputPrompt
from llama_index.llm_predictor import LLMPredictor
from llama_index.prompts import PromptTemplate
import torch
from transformers import AutoModelForCausalLM
from align_system.utils import logging
log = logging.getLogger(__name__)
query_wrapper_prompt = SimpleInputPrompt(
"Below is an instruction that describes a task. "
"Write a response that appropriately completes the request.\n\n"
"### Instruction:\n{query_str}\n\n### Response:"
)
class LlamaIndex:
def __init__(self, domain_docs_dir=None, device="cuda", model_name="falcon", retrieval_enabled=True): # noqa
if retrieval_enabled and domain_docs_dir is None:
raise RuntimeError(
"'domain_docs_dir' argument must not be empty if "
"'retrieval_enabled' is True")
self.domain_docs_dir = domain_docs_dir
self.device = device
self.model_name = model_name
self.retrieval_enabled = retrieval_enabled
def load_model(self):
if self.model_name == 'falcon':
self.model_name = 'tiiuae/falcon-7b-instruct'
if self.device == 'cuda':
model_kwargs = {"torch_dtype": torch.float16,
"device_map": "auto"}
predictor_kwargs = {"device_map": "auto"}
else:
model_kwargs = {}
predictor_kwargs = {}
self.embed_model = LangchainEmbedding(HuggingFaceEmbeddings())
# FalconForCausalLM
# https://github.com/huggingface/transformers/blob/0188739a74dca8a9cf3f646a9a417af7f136f1aa/src/transformers/models/falcon/convert_custom_code_checkpoint.py#L37
model = AutoModelForCausalLM.from_pretrained(
self.model_name, **model_kwargs)
self.hf_llm = HuggingFaceLLM(
context_window=2048,
max_new_tokens=256,
# generate_kwargs={"temperature": 0.25, "do_sample": False},
# "temperature" parameter is not used if "do_sample" is False
generate_kwargs={"do_sample": False},
query_wrapper_prompt=query_wrapper_prompt,
tokenizer_name=self.model_name,
model=model,
tokenizer_kwargs={"max_length": 2048},
tokenizer_outputs_to_remove=["token_type_ids"],
**predictor_kwargs)
self.service_context = ServiceContext.from_defaults(
embed_model=self.embed_model,
chunk_size=512,
llm=self.hf_llm)
if self.retrieval_enabled:
documents = SimpleDirectoryReader(self.domain_docs_dir).load_data()
new_index = VectorStoreIndex.from_documents(
documents,
service_context=self.service_context)
# query with embed_model specified
self.query_engine = new_index.as_query_engine(streaming=True)
else:
log.info("Retrieval disabled")
self.query_engine = LLMPredictor(self.hf_llm)
self.model_loaded = True
def run_inference(self, prompt):
if self.retrieval_enabled:
return self.query_engine.query(prompt)
else:
bare_template = PromptTemplate("{query_str}")
return self.query_engine.predict(bare_template, query_str=prompt)
def __call__(self, sample, target_kdma_values, **kwargs):
prompt = sample['scenario']
if sample['state'] is not None:
prompt += f'\n{sample["state"]}'
prompt += f'\n{sample["probe"]}'
prompt += '\nIdentify the integer index of the choice that best completes the request.\n'
prompt += 'Choices:\n'
choice_strs = [
f'{idx}: {choice}'
for idx, choice in enumerate(sample['choices'])
]
prompt += '\n'.join(choice_strs)
log_file = kwargs.get('log_file', None)
if log_file:
log_file.write(f'Prompt:\n{prompt}\n\n')
choice = None
n_fail = 0
while choice is None:
response = str(self.run_inference(prompt))
if log_file:
log_file.write(f'Response:\n{response}\n\n')
# find the first integer in the response
for char in response:
try:
choice = int(char)
break
except ValueError:
pass
if choice is not None:
if choice > len(sample['choices']) - 1:
choice = None
if choice is None:
n_fail += 1
if n_fail > 10:
return {
'choice': 0,
'info': f'Failed to find choice in response: {response}'
}
return {
'choice': choice,
'info': response
}
| [
"\n",
"Write a response that appropriately completes the request.\n\n",
"\nPLACEHOLDER",
"{query_str}",
"scenario",
"\nIdentify the integer index of the choice that best completes the request.\n",
"Below is an instruction that describes a task. ",
"### Instruction:\n{query_str}\n\n### Response:",
"Choices:\n"
] |
2024-01-10 | ITM-Kitware/align-system | align_system~cli~run_action_based_align_system.py | import sys
import json
from rich.highlighter import JSONHighlighter
from align_system.utils import logging
from align_system.interfaces.cli_builder import build_interfaces
from align_system.algorithms.llm_baseline import LLMBaseline
from align_system.algorithms.llama_index import LlamaIndex
from align_system.similarity_measures import build_force_choice_func
from align_system.prompt_engineering.common import (
prepare_action_based_prompt,
prepare_treatment_selection_prompt,
prepare_tagging_selection_prompt)
log = logging.getLogger(__name__)
JSON_HIGHLIGHTER = JSONHighlighter()
def add_cli_args(parser):
parser.add_argument('-m', '--model',
type=str,
default="falcon",
help="LLM Baseline model to use")
parser.add_argument('-t', '--align-to-target',
action='store_true',
default=False,
help="Align algorithm to target KDMAs")
parser.add_argument('-a', '--algorithm',
type=str,
default="llama_index",
help="Algorithm to use")
parser.add_argument('-A', '--algorithm-kwargs',
type=str,
required=False,
help="JSON encoded dictionary of kwargs for algorithm "
"initialization")
parser.add_argument('--similarity-measure',
type=str,
default="bert",
help="Similarity measure to use (default: 'bert')")
parser.add_argument('-l', '--loglevel',
type=str,
default='INFO')
def main():
log.debug(f"[bright_black]CMD: {' '.join(sys.argv)}[/bright_black]",
extra={'markup': True, 'highlighter': None})
run_action_based_align_system(
**build_interfaces(add_cli_args, "ALIGN Action Based System CLI",
supported_interfaces={'TA3ActionBased'}))
# TODO: Find a better location for this (or pull in from TA3 client
# module)
TREATMENT_LOCATIONS = ['right forearm',
'left forearm',
'right calf',
'left calf',
'right thigh',
'left thigh',
'right stomach',
'left stomach',
'right bicep',
'left bicep',
'right shoulder',
'left shoulder',
'right side',
'left side',
'right chest',
'left chest',
'right wrist',
'left wrist',
'left face',
'right face',
'left neck',
'right neck',
'unspecified']
CASUALTY_TAGS = ['MINIMAL',
'DELAYED',
'IMMEDIATE',
'EXPECTANT']
def run_action_based_align_system(interface,
model,
align_to_target=False,
algorithm="llm_baseline",
algorithm_kwargs=None,
similarity_measure="bert",
loglevel="INFO"):
# Set log level on root logger (such that child loggers respect
# the set log level)
logging.getLogger().setLevel(loglevel)
scenario = interface.start_scenario()
scenario_dict = scenario.to_dict()
if align_to_target:
alignment_target_dict = scenario.get_alignment_target()
force_choice_func = build_force_choice_func(similarity_measure)
# Load the system / model
algorithm_kwargs_parsed = {}
if algorithm_kwargs is not None:
algorithm_kwargs_parsed = json.loads(algorithm_kwargs)
if algorithm == "llm_baseline":
algorithm = LLMBaseline(
model_use=model, distributed=False,
**algorithm_kwargs_parsed)
elif algorithm == "llama_index":
# TODO: This is a hacky way to have the "Knowledge" KDMA
# determine whether or not domain documents should be loaded.
# Should remove, or move to llama_index code
if align_to_target:
for kdma_dict in alignment_target_dict.get('kdma_values', ()):
if kdma_dict['kdma'].lower() == 'knowledge':
if kdma_dict['value'] > 1:
log.info("** Setting 'retrieval_enabled' to True "
"based on 'Knowledge' KDMA value ({})".format(
kdma_dict['value']))
algorithm_kwargs_parsed['retrieval_enabled'] = True
else:
log.info("** Setting 'retrieval_enabled' to False "
"based on 'Knowledge' KDMA value ({})".format(
kdma_dict['value']))
algorithm_kwargs_parsed['retrieval_enabled'] = False
break
algorithm = LlamaIndex(
model_name=model,
**algorithm_kwargs_parsed)
algorithm.load_model()
current_state = scenario.get_state()
scenario_complete = current_state.get('scenario_complete', False)
while not scenario_complete:
available_actions = scenario.get_available_actions()
untagged_casualties = [c for c in current_state['casualties']
if 'tag' not in c]
# Don't let ADM choose to tag a casualty unless there are
# still untagged casualties
available_actions_unstructured =\
[a['unstructured'] for a in available_actions
if a['action_type'] != 'TAG_CASUALTY'
or (a['action_type'] == 'TAG_CASUALTY'
and len(untagged_casualties) > 0)]
prompt = prepare_action_based_prompt(
scenario_dict['state']['unstructured'],
current_state['mission'].get('unstructured'),
current_state['unstructured'],
current_state['casualties'],
available_actions_unstructured,
alignment_target=alignment_target_dict if align_to_target else None
)
log.info("[bold]* Action prompt for ADM *[/bold]",
extra={"markup": True})
log.info(prompt)
raw_response = str(algorithm.run_inference(prompt))
log.info("[bold]* ADM raw response *[/bold]",
extra={"markup": True})
log.info(raw_response)
selected_action_idx, selected_action = force_choice_func(
raw_response, available_actions_unstructured)
log.info("[bold]* Mapped selection *[/bold]",
extra={"markup": True})
log.info(selected_action)
action_to_take = available_actions[selected_action_idx]
if action_to_take['action_type'] == 'APPLY_TREATMENT':
# Ask the system to specify the treatment to use and where
# First casualty with the matching ID (should only be one)
casualty_id = action_to_take['casualty_id']
matching_casualties = [c for c in current_state['casualties']
if c['id'] == casualty_id]
assert len(matching_casualties) == 1
casualty_to_treat = matching_casualties[0]
treatment_prompt = prepare_treatment_selection_prompt(
casualty_to_treat['unstructured'],
casualty_to_treat['vitals'],
current_state['supplies'])
log.info("[bold]** Treatment prompt for ADM **[/bold]",
extra={"markup": True})
log.info(treatment_prompt)
raw_treatment_response =\
str(algorithm.run_inference(treatment_prompt))
log.info("[bold]** ADM raw treatment response **[/bold]",
extra={"markup": True})
log.info(raw_treatment_response)
# Map response to treatment and treatment location
_, treatment = force_choice_func(
raw_treatment_response,
[s['type'] for s in current_state['supplies']])
_, treatment_location = force_choice_func(
raw_treatment_response,
TREATMENT_LOCATIONS)
log.info("[bold]** Mapped treatment selection **[/bold]",
extra={"markup": True})
log.info("{}: {}".format(treatment, treatment_location))
# Populate required parameters for treatment action
action_to_take['parameters'] = {
'treatment': treatment,
'location': treatment_location}
elif action_to_take['action_type'] == 'TAG_CASUALTY':
# Ask the system to specify which triage tag to apply
tagging_prompt = prepare_tagging_selection_prompt(
untagged_casualties,
CASUALTY_TAGS)
log.info("[bold]** Tagging prompt for ADM **[/bold]",
extra={"markup": True})
log.info(tagging_prompt)
raw_tagging_response =\
str(algorithm.run_inference(tagging_prompt))
log.info("[bold]** ADM raw tagging response **[/bold]",
extra={"markup": True})
log.info(raw_tagging_response)
# Map response to casualty to tag
casualty_to_tag_idx, _ = force_choice_func(
raw_tagging_response,
[c['unstructured'] for c in untagged_casualties])
casualty_to_tag_id = untagged_casualties[casualty_to_tag_idx]['id']
# Map response to tag
_, tag = force_choice_func(
raw_tagging_response,
CASUALTY_TAGS)
log.info("[bold]** Mapped tag selection **[/bold]",
extra={"markup": True})
log.info("{}: {}".format(casualty_to_tag_id, tag))
# Populate required parameters for treatment action
action_to_take['casualty_id'] = casualty_to_tag_id
action_to_take['parameters'] = {'category': tag}
log.debug("[bold]*ACTION BEING TAKEN*[/bold]",
extra={"markup": True})
log.debug(json.dumps(action_to_take, indent=4),
extra={"highlighter": JSON_HIGHLIGHTER})
current_state = scenario.take_action(action_to_take)
scenario_complete = current_state.get('scenario_complete', False)
if __name__ == "__main__":
main()
| [
"unstructured",
"mission",
"casualties"
] |
2024-01-10 | jaredbradley243/docsgpt | scripts~code_docs_gen.py | import ast
import json
from pathlib import Path
import dotenv
from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate
dotenv.load_dotenv()
ps = list(Path("inputs").glob("**/*.py"))
data = []
sources = []
for p in ps:
with open(p) as f:
data.append(f.read())
sources.append(p)
def get_functions_in_class(node):
functions = []
functions_code = []
for child in node.body:
if isinstance(child, ast.FunctionDef):
functions.append(child.name)
functions_code.append(ast.unparse(child))
return functions, functions_code
def get_classes_and_functions(source_code):
tree = ast.parse(source_code)
classes = {}
for node in tree.body:
if isinstance(node, ast.ClassDef):
class_name = node.name
function_name, function = get_functions_in_class(node)
# join function name and function code
functions = dict(zip(function_name, function))
classes[class_name] = functions
return classes
structure_dict = {}
c1 = 0
for code in data:
classes = get_classes_and_functions(ast.parse(code))
source = str(sources[c1])
structure_dict[source] = classes
c1 += 1
# save the structure dict as json
with open('structure_dict.json', 'w') as f:
json.dump(structure_dict, f)
if not Path("outputs").exists():
Path("outputs").mkdir()
c1 = len(structure_dict)
c2 = 0
for source, classes in structure_dict.items():
c2 += 1
print(f"Processing file {c2}/{c1}")
f1 = len(classes)
f2 = 0
for class_name, functions in classes.items():
f2 += 1
print(f"Processing class {f2}/{f1}")
source_w = source.replace("inputs/", "")
source_w = source_w.replace(".py", ".txt")
if not Path(f"outputs/{source_w}").exists():
with open(f"outputs/{source_w}", "w") as f:
f.write(f"Class: {class_name}")
else:
with open(f"outputs/{source_w}", "a") as f:
f.write(f"\n\nClass: {class_name}")
# append class name to the front
for function in functions:
b1 = len(functions)
b2 = 0
print(f"Processing function {b2}/{b1}")
b2 += 1
prompt = PromptTemplate(
input_variables=["code"],
template="Code: \n{code}, \nDocumentation: ",
)
llm = OpenAI(temperature=0)
response = llm(prompt.format(code=functions[function]))
if not Path(f"outputs/{source_w}").exists():
with open(f"outputs/{source_w}", "w") as f:
f.write(f"Function: {functions[function]}, \nDocumentation: {response}")
else:
with open(f"outputs/{source_w}", "a") as f:
f.write(f"\n\nFunction: {functions[function]}, \nDocumentation: {response}")
| [
"Code: \n{code}, \nDocumentation: "
] |
2024-01-10 | jaredbradley243/docsgpt | application~parser~py2doc.py | import ast
import os
from pathlib import Path
import tiktoken
from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate
def find_files(directory):
files_list = []
for root, dirs, files in os.walk(directory):
for file in files:
if file.endswith('.py'):
files_list.append(os.path.join(root, file))
return files_list
def extract_functions(file_path):
with open(file_path, 'r') as file:
source_code = file.read()
functions = {}
tree = ast.parse(source_code)
for node in ast.walk(tree):
if isinstance(node, ast.FunctionDef):
func_name = node.name
func_def = ast.get_source_segment(source_code, node)
functions[func_name] = func_def
return functions
def extract_classes(file_path):
with open(file_path, 'r') as file:
source_code = file.read()
classes = {}
tree = ast.parse(source_code)
for node in ast.walk(tree):
if isinstance(node, ast.ClassDef):
class_name = node.name
function_names = []
for subnode in ast.walk(node):
if isinstance(subnode, ast.FunctionDef):
function_names.append(subnode.name)
classes[class_name] = ", ".join(function_names)
return classes
def extract_functions_and_classes(directory):
files = find_files(directory)
functions_dict = {}
classes_dict = {}
for file in files:
functions = extract_functions(file)
if functions:
functions_dict[file] = functions
classes = extract_classes(file)
if classes:
classes_dict[file] = classes
return functions_dict, classes_dict
def parse_functions(functions_dict, formats, dir):
c1 = len(functions_dict)
for i, (source, functions) in enumerate(functions_dict.items(), start=1):
print(f"Processing file {i}/{c1}")
source_w = source.replace(dir + "/", "").replace("." + formats, ".md")
subfolders = "/".join(source_w.split("/")[:-1])
Path(f"outputs/{subfolders}").mkdir(parents=True, exist_ok=True)
for j, (name, function) in enumerate(functions.items(), start=1):
print(f"Processing function {j}/{len(functions)}")
prompt = PromptTemplate(
input_variables=["code"],
template="Code: \n{code}, \nDocumentation: ",
)
llm = OpenAI(temperature=0)
response = llm(prompt.format(code=function))
mode = "a" if Path(f"outputs/{source_w}").exists() else "w"
with open(f"outputs/{source_w}", mode) as f:
f.write(
f"\n\n# Function name: {name} \n\nFunction: \n```\n{function}\n```, \nDocumentation: \n{response}")
def parse_classes(classes_dict, formats, dir):
c1 = len(classes_dict)
for i, (source, classes) in enumerate(classes_dict.items()):
print(f"Processing file {i + 1}/{c1}")
source_w = source.replace(dir + "/", "").replace("." + formats, ".md")
subfolders = "/".join(source_w.split("/")[:-1])
Path(f"outputs/{subfolders}").mkdir(parents=True, exist_ok=True)
for name, function_names in classes.items():
print(f"Processing Class {i + 1}/{c1}")
prompt = PromptTemplate(
input_variables=["class_name", "functions_names"],
template="Class name: {class_name} \nFunctions: {functions_names}, \nDocumentation: ",
)
llm = OpenAI(temperature=0)
response = llm(prompt.format(class_name=name, functions_names=function_names))
with open(f"outputs/{source_w}", "a" if Path(f"outputs/{source_w}").exists() else "w") as f:
f.write(f"\n\n# Class name: {name} \n\nFunctions: \n{function_names}, \nDocumentation: \n{response}")
def transform_to_docs(functions_dict, classes_dict, formats, dir):
docs_content = ''.join([str(key) + str(value) for key, value in functions_dict.items()])
docs_content += ''.join([str(key) + str(value) for key, value in classes_dict.items()])
num_tokens = len(tiktoken.get_encoding("cl100k_base").encode(docs_content))
total_price = ((num_tokens / 1000) * 0.02)
print(f"Number of Tokens = {num_tokens:,d}")
print(f"Approx Cost = ${total_price:,.2f}")
user_input = input("Price Okay? (Y/N)\n").lower()
if user_input == "y" or user_input == "":
if not Path("outputs").exists():
Path("outputs").mkdir()
parse_functions(functions_dict, formats, dir)
parse_classes(classes_dict, formats, dir)
print("All done!")
else:
print("The API was not called. No money was spent.")
| [
"Code: \n{code}, \nDocumentation: ",
"functions_names",
"class_name",
"Class name: {class_name} \nFunctions: {functions_names}, \nDocumentation: "
] |
2024-01-10 | phasetr/generative-ai | fundamentals~tts.py | import os
import traceback
from uuid_extensions import uuid7str
from openai import OpenAI
class TTS:
"""_summary_
適当なテキストから音声ファイルを作る。
"""
def __init__(self, uuid) -> None:
self.uuid = uuid
self.output_directory_name = os.environ.get(
"OUTPUT_DIRECTORY_NAME", "output")
# ディレクトリがなければ作る
if not os.path.exists(self.output_directory_name):
os.mkdir(self.output_directory_name)
self.orig_audio_path = f"{self.output_directory_name}/{uuid}-orig.mp3"
self.converted_audio_path = f"{self.output_directory_name}/{uuid}-converted.mp3"
self.sample_text_name = os.environ.get("SAMPLE_TEXT_FILE_NAME")
def create_audio(self, text):
"""指定されたテキストから音声ファイルを作る"""
try:
client = OpenAI()
response = client.audio.speech.create(
model=os.environ.get("TTS_MODEL"),
voice=os.environ.get("TTS_VOICE", "nova"),
input=text
)
response.stream_to_file(self.converted_audio_path)
return self.converted_audio_path
except Exception as e:
print(e)
traceback.print_exc()
exit()
def create_audio_from_sample_text(self):
"""環境変数`SAMPLE_TEXT_NAME`に指定されたテキストファイルを読み込んで音声ファイルを作る"""
try:
with open(self.sample_text_name, mode="r", encoding="utf-8") as f:
text = f.read()
client = OpenAI()
response = client.audio.speech.create(
model=os.environ.get("TTS_MODEL"),
voice=os.environ.get("TTS_VOICE", "nova"),
input=text
)
response.stream_to_file(self.orig_audio_path)
return self.orig_audio_path
except Exception as e:
print(e)
traceback.print_exc()
exit()
if __name__ == "__main__":
uuid = uuid7str()
tts = TTS(uuid)
ret_audio_path = tts.create_audio_from_sample_text()
print(f"音声ファイルを作成しました: {ret_audio_path}")
| [] |
2024-01-10 | phasetr/generative-ai | 2023-08-21-lang-chain-streamlit~Chapter04~get_costs.py | from langchain.llms import OpenAI
from langchain.callbacks import get_openai_callback
llm = OpenAI(model_name="gpt-3.5-turbo")
with get_openai_callback() as cb:
result = llm("Tell me a joke")
print(cb)
| [] |
2024-01-10 | phasetr/generative-ai | 2023-12-21-Modern_Generative_AI_with_ChatGPT_and_OpenAI_Models~Chapter10-Enterprise_use_cases~code~medical_smart_search_app.py | import os
import streamlit as st
from langchain.chains.question_answering import load_qa_chain
from langchain.document_loaders import PyPDFLoader
from langchain.embeddings import OpenAIEmbeddings
from langchain.llms import AzureOpenAI
from langchain.vectorstores.faiss import FAISS
with open('secrets.toml', 'r') as f:
config = toml.load(f)
os.environ["OPENAI_API_TYPE"] = "azure"
os.environ["OPENAI_API_BASE"] = config['OPENAI_API_BASE']
os.environ["OPENAI_API_KEY"] = config['OPENAI_API_KEY']
llm = AzureOpenAI(deployment_name="text-davinci-003")
embeddings = OpenAIEmbeddings(document_model_name="text-embedding-ada-002", chunk_size=1)
st.set_page_config(
page_title="Home",
page_icon="👨⚕️",
)
st.header("Welcome to Medical Smart Search👨⚕️")
with st.sidebar.expander(" 🛠️ Settings ", expanded=False):
FILE = st.selectbox(label='File', options=['medical_paper.pdf'])
def get_answer(index, query):
"""Returns answer to a query using langchain QA chain"""
docs = index.similarity_search(query)
chain = load_qa_chain(llm)
answer = chain.run(input_documents=docs, question=query)
return answer
if FILE:
loader = PyPDFLoader(FILE)
pages = loader.load_and_split()
faiss_index = FAISS.from_documents(pages, embeddings)
query = st.text_area("Ask a question about the document")
if query:
docs = faiss_index.similarity_search(query, k=1)
button = st.button("Submit")
if button:
st.write(get_answer(faiss_index, query))
| [] |
2024-01-10 | phasetr/generative-ai | 2023-11-26-hackathon-note~1_text_to_mp3.py | import os
from uuid_extensions import uuid7str
from openai import OpenAI
from pathlib import Path
sample_text_name = "sample1.txt"
is_exist = os.path.exists(sample_text_name)
if not is_exist:
print(f"{sample_text_name}を作成してください。")
exit()
print("テキストを読み込みます。")
text = ""
with open(sample_text_name, mode="r", encoding="utf-8") as f:
text = f.read()
print(text)
mp3_directory_name = "mp3"
mp3_path = f"{mp3_directory_name}/{uuid7str()}.mp3"
# ディレクトリがなければ作る
if not os.path.exists(mp3_directory_name):
os.mkdir(mp3_directory_name)
print("音声ファイルを作成します。")
client = OpenAI()
response = client.audio.speech.create(
model="tts-1",
voice="nova",
input=text
)
response.stream_to_file(mp3_path)
print(f"音声ファイルを作成しました: {mp3_path}")
| [] |
2024-01-10 | phasetr/generative-ai | fundamentals~poll.py | from openai import OpenAI
from uuid_extensions import uuid7str
import dotenv
import os
# APIキーの設定
dotenv.load_dotenv()
client = OpenAI(api_key=os.environ.get('OPENAI_API_KEY'))
class OpenAIAdapter:
def __init__(self, file_root) -> None:
self.file_root = file_root
self.output_directory_name = os.environ.get(
"OUTPUT_DIRECTORY_NAME", "output")
# ディレクトリがなければ作る
if not os.path.exists(self.output_directory_name):
os.mkdir(self.output_directory_name)
# system_promptはsystem_prompt.txtから読み込む
with open("system_prompt.txt", "r") as f:
self.system_prompt = f.read()
pass
def _create_message(self, role, message):
return {
"role": role,
"content": message
}
def create_chat(self, question):
system_message = self._create_message("system", self.system_prompt)
user_message = self._create_message("user", question)
messages = [system_message, user_message]
res = client.chat.completions.create(
model="gpt-3.5-turbo",
messages=messages)
# 返り値のテキストを出力する
content = res.choices[0].message.content
# ファイルに書き出す
text_file_path = f"{self.output_directory_name}/{self.file_root}-poll.txt"
with open(text_file_path, mode="w", encoding="utf-8") as f0:
f0.write(content)
return content
if __name__ == "__main__":
uuid = uuid7str()
adapter = OpenAIAdapter(uuid)
response_text = adapter.create_chat("こんにちは")
print(response_text)
| [] |
2024-01-10 | phasetr/generative-ai | fundamentals~stt.py | import traceback
from openai import OpenAI
import os
class STT:
def __init__(self) -> None:
self.output_directory_name = os.environ.get(
"OUTPUT_DIRECTORY_NAME", "output")
# ディレクトリがなければ作る
if not os.path.exists(self.output_directory_name):
os.mkdir(self.output_directory_name)
def create_text(self, audio_path):
"""音声ファイルからテキストを作る"""
try:
client = OpenAI()
with open(audio_path, "rb") as f:
# 音声ファイルを読み込んで変換
transcript = client.audio.transcriptions.create(
model="whisper-1",
file=f,
response_format="text"
)
# 変換結果からテキストを抽出して書き出す
basename, _ = os.path.splitext(audio_path)
text_file_root = basename.split("/")[-1]
text_file_path = f"{self.output_directory_name}/{text_file_root}.txt"
with open(text_file_path, mode="w", encoding="utf-8") as f0:
f0.write(transcript)
return transcript
except Exception as e:
print(e)
traceback.print_exc()
exit()
if __name__ == "__main__":
sample_audio_path = "audio/" + os.listdir("audio")[0]
print(f"対象音声ファイル: {sample_audio_path}")
stt = STT()
ret_text = stt.create_text(sample_audio_path)
print(f"作成されたテキスト: {ret_text}")
| [] |
2024-01-10 | phasetr/generative-ai | 2023-12-21-Modern_Generative_AI_with_ChatGPT_and_OpenAI_Models~Chapter10-Enterprise_use_cases~code~call_center_app.py | import sys
import requests
import os
import numpy as np
import toml
from streamlit_chat import message
import streamlit as st
import openai
with open('secrets.toml', 'r') as f:
config = toml.load(f)
openai.api_type = "azure"
openai.api_key = config['OPENAI_API_KEY']
openai.api_base = config['OPENAI_API_BASE']
openai.api_version = "2022-12-01"
# Opening JSON file
f = open('json_data.json')
# returns JSON object as
# a dictionary
data = json.load(f)
transcript = "Operator: Good morning, thank you for calling the auto insurance company, my name is John, how can I assist you today?\nCustomer: Yes, hi, I just noticed a dent on the side of my car and I have no idea how it got there. There were no witnesses around and I'm really frustrated.\nOperator: I'm sorry to hear that, I understand how frustrating it can be. Can you please provide me with your name and policy number so I can look up your account?\nCustomer: Yes, I’m Mario Rossi and the policy number is 123456.\nOperator: Thank you Mr. Rossi, let me take a look. I see that you've called earlier today, was there an issue with that call?\nCustomer: Yes, I was on hold for over an hour and the issue was not resolved. I'm really not happy about it.\nOperator: I'm sorry about that, let me assure you that we value your time and we'll do our best to assist you today. As for the dent on your car, I'd like to inform you that our policy does cover accidental damage like this. I can help you file a claim and connect you with one of our trusted repair shops in your area. Would you like me to proceed with that?\nCustomer: Yes, please. That would be great.\nOperator: Thank you for your cooperation. I'm now processing your claim and I'll be sending you an email with the next steps to follow. Please let me know if you have any other questions or concerns.\nCustomer: Thank you, I appreciate your help.\nOperator: You're welcome. Have a great day!\n\n\n"
st.set_page_config(
page_title="Home",
page_icon="🚗",
)
st.header("Welcome to Car Insurance management portal🚗")
st.subheader('Transcript Case #37294810', '📞')
st.text(transcript)
def create_ticket(data):
response = openai.Completion.create(
engine="test1",
prompt=transcript + f"Generate a response email to the transcript above, notifying the customer that the ticket has been created and apologizing if it was complaining. The name of the customer is {data['name']}",
temperature=1,
max_tokens=1968,
top_p=0.5,
frequency_penalty=0,
presence_penalty=0,
best_of=1,
stop=None)
def generate_email(transcript):
response = openai.Completion.create(
engine="test1",
prompt=transcript + f"Generate a response email to the transcript above, notifying the customer that the ticket has been created and apologizing if it was complaining. The name of the customer is {data['name']} and the policy number is {data['policy_number']}.",
temperature=1,
max_tokens=1968,
top_p=0.5,
frequency_penalty=0,
presence_penalty=0,
best_of=1,
stop=None)
return response["choices"][0]["text"].strip()
def improvement(data):
response = openai.Completion.create(
engine="test1",
prompt=f"Elaborate a list of remediations to get to the following improvement: {data['contact_center_improvement']}",
temperature=1,
max_tokens=1968,
top_p=0.5,
frequency_penalty=0,
presence_penalty=0,
best_of=1,
stop=None)
return response["choices"][0]["text"].strip()
if st.button('Create Ticket'):
ticket_number = np.random.randint(1, 1000000)
st.write(
f'Your ticket has been created with number {ticket_number}. Customer and incident manager will be notified shortly')
if st.button('Generate email'):
st.write(generate_email(transcript))
if st.button('Improve customer service quality'):
st.write(improvement(data))
| [
"Elaborate a list of remediations to get to the following improvement: PLACEHOLDER",
"Operator: Good morning, thank you for calling the auto insurance company, my name is John, how can I assist you today?\nCustomer: Yes, hi, I just noticed a dent on the side of my car and I have no idea how it got there. There were no witnesses around and I'm really frustrated.\nOperator: I'm sorry to hear that, I understand how frustrating it can be. Can you please provide me with your name and policy number so I can look up your account?\nCustomer: Yes, I’m Mario Rossi and the policy number is 123456.\nOperator: Thank you Mr. Rossi, let me take a look. I see that you've called earlier today, was there an issue with that call?\nCustomer: Yes, I was on hold for over an hour and the issue was not resolved. I'm really not happy about it.\nOperator: I'm sorry about that, let me assure you that we value your time and we'll do our best to assist you today. As for the dent on your car, I'd like to inform you that our policy does cover accidental damage like this. I can help you file a claim and connect you with one of our trusted repair shops in your area. Would you like me to proceed with that?\nCustomer: Yes, please. That would be great.\nOperator: Thank you for your cooperation. I'm now processing your claim and I'll be sending you an email with the next steps to follow. Please let me know if you have any other questions or concerns.\nCustomer: Thank you, I appreciate your help.\nOperator: You're welcome. Have a great day!\n\n\nGenerate a response email to the transcript above, notifying the customer that the ticket has been created and apologizing if it was complaining. The name of the customer is PLACEHOLDER",
"Operator: Good morning, thank you for calling the auto insurance company, my name is John, how can I assist you today?\nCustomer: Yes, hi, I just noticed a dent on the side of my car and I have no idea how it got there. There were no witnesses around and I'm really frustrated.\nOperator: I'm sorry to hear that, I understand how frustrating it can be. Can you please provide me with your name and policy number so I can look up your account?\nCustomer: Yes, I’m Mario Rossi and the policy number is 123456.\nOperator: Thank you Mr. Rossi, let me take a look. I see that you've called earlier today, was there an issue with that call?\nCustomer: Yes, I was on hold for over an hour and the issue was not resolved. I'm really not happy about it.\nOperator: I'm sorry about that, let me assure you that we value your time and we'll do our best to assist you today. As for the dent on your car, I'd like to inform you that our policy does cover accidental damage like this. I can help you file a claim and connect you with one of our trusted repair shops in your area. Would you like me to proceed with that?\nCustomer: Yes, please. That would be great.\nOperator: Thank you for your cooperation. I'm now processing your claim and I'll be sending you an email with the next steps to follow. Please let me know if you have any other questions or concerns.\nCustomer: Thank you, I appreciate your help.\nOperator: You're welcome. Have a great day!\n\n\nGenerate a response email to the transcript above, notifying the customer that the ticket has been created and apologizing if it was complaining. The name of the customer is PLACEHOLDER and the policy number is PLACEHOLDER."
] |
2024-01-10 | phasetr/generative-ai | 2023-12-21-Modern_Generative_AI_with_ChatGPT_and_OpenAI_Models~Chapter10-Enterprise_use_cases~code~contract_analyzer_app.py | import sys
import toml
import streamlit as st
import openai
with open('secrets.toml', 'r') as f:
config = toml.load(f)
openai.api_type = "azure"
openai.api_key = config['OPENAI_API_KEY']
openai.api_base = config['OPENAI_API_BASE']
openai.api_version = "2022-12-01"
contract = """
This Contract for Services ("Agreement") is entered into as of [date], by and between Company A ("Company") and Company B ("Service Provider").
1. Services Provided. Service Provider agrees to provide the following services to Company (the "Services"): The Service Provider agrees to provide consulting services to the Company in the field of marketing, including but not limited to market research, development of a marketing strategy, and implementation of marketing campaigns. The Service Provider shall provide reports and recommendations to the Company based on the results of the market research and the agreed-upon marketing strategy.
2. Compensation. Company shall pay Service Provider the sum of 1.000.000 (One Million) $ for the Services. Payment shall be made on 15/9/2023.
3. Term. This Agreement shall commence on 1/5/2023 and continue until 31/12/2023, unless earlier terminated by either party upon 30 days' prior written notice.
4. Independent Contractor. Service Provider is an independent contractor, and nothing in this Agreement shall be construed as creating an employer-employee relationship, partnership, or joint venture between the parties.
5. Confidentiality. Service Provider agrees to keep confidential any and all information learned or obtained as a result of providing the Services to Company. Service Provider shall not disclose such information to any third party without Company's prior written consent.
6. Ownership of Work Product. Service Provider agrees that any and all work product produced in connection with the Services shall be the sole property of Company.
7. Representations and Warranties. Service Provider represents and warrants that it has the necessary expertise and experience to perform the Services in a professional and workmanlike manner.
8. Indemnification. Service Provider agrees to indemnify and hold harmless Company, its officers, directors, employees, and agents from and against any and all claims, damages, liabilities, costs, and expenses arising out of or in connection with the Services.
9. Governing Law. This Agreement shall be governed by and construed in accordance with the laws of Italy without regard to conflicts of laws principles.
10. Entire Agreement. This Agreement constitutes the entire agreement between the parties and supersedes all prior or contemporaneous negotiations, agreements, representations, and understandings between the parties, whether written or oral.
IN WITNESS WHEREOF, the parties have executed this Agreement as of the date first above written.
[Signature block for Company]
[Signature block for Service Provider]
"""
st.set_page_config(
page_title="Home",
page_icon="📝",
)
st.header("Welcome to Contract Analyzer portal 📝")
st.subheader('Contract #371')
st.write(contract)
st.subheader('Key clauses extraction 🔍')
col1, col2 = st.columns(2)
with col1:
request = st.selectbox(
'Select the key clause you want to extract',
("What is the termination clause?", "what is the confidentiality clause?",
"what is the compensation and the due date?", "what is the indemnification clause?"))
with col2:
if request:
completions = openai.Completion.create(
engine="test1",
prompt=contract + request,
max_tokens=2000,
n=1,
stop=None,
temperature=0,
)
response = completions.choices[0].text.strip()
st.write('\n\n\n' + response)
st.subheader('Analyzing language 💬')
col3, col4 = st.columns(2)
with col3:
user_input = st.text_input("You:", "")
with col4:
if user_input:
completions = openai.Completion.create(
engine="test1",
prompt=contract + user_input,
max_tokens=2000,
n=1,
stop=None,
temperature=0,
)
response = completions.choices[0].text.strip()
st.write('\n\n\n' + response)
st.subheader('Flagging potential issues 🚩')
col5, col6 = st.columns(2)
with col5:
request = st.selectbox(
'Select the key clause you want to extract',
("Are there ambiguities?", "Are there conflicting terms?"))
with col6:
if request:
completions = openai.Completion.create(
engine="test1",
prompt=contract + request,
max_tokens=2000,
n=1,
stop=None,
temperature=0,
)
response = completions.choices[0].text.strip()
st.write('\n\n\n' + response)
st.subheader('Contract Templates 🖋️')
col7, col8 = st.columns(2)
with col7:
service_provider = st.text_input("Service provider:", "")
client = st.text_input("Client:", "")
services_description = st.text_input("Service description:", "")
start_date = st.text_input("Start date:", "")
duration = st.text_input("Duration:", "")
with col8:
if st.button('Generate template'):
completions = openai.Completion.create(
engine="test1",
prompt=f"Generate a Service Delivery Agreement with the following elements: Service Provider: {service_provider}, Client: {client}, Description of Services: {services_description}, Start Date: {start_date}, Duration: {duration}",
max_tokens=2000,
n=1,
stop=None,
temperature=0,
)
response = completions.choices[0].text.strip()
st.write('\n\n\n' + response)
| [
"\n\nThis Contract for Services (\"Agreement\") is entered into as of [date], by and between Company A (\"Company\") and Company B (\"Service Provider\").\n1.\tServices Provided. Service Provider agrees to provide the following services to Company (the \"Services\"): The Service Provider agrees to provide consulting services to the Company in the field of marketing, including but not limited to market research, development of a marketing strategy, and implementation of marketing campaigns. The Service Provider shall provide reports and recommendations to the Company based on the results of the market research and the agreed-upon marketing strategy.\n2.\tCompensation. Company shall pay Service Provider the sum of 1.000.000 (One Million) $ for the Services. Payment shall be made on 15/9/2023.\n3.\tTerm. This Agreement shall commence on 1/5/2023 and continue until 31/12/2023, unless earlier terminated by either party upon 30 days' prior written notice.\n4.\tIndependent Contractor. Service Provider is an independent contractor, and nothing in this Agreement shall be construed as creating an employer-employee relationship, partnership, or joint venture between the parties.\n5.\tConfidentiality. Service Provider agrees to keep confidential any and all information learned or obtained as a result of providing the Services to Company. Service Provider shall not disclose such information to any third party without Company's prior written consent.\n6.\tOwnership of Work Product. Service Provider agrees that any and all work product produced in connection with the Services shall be the sole property of Company.\n7.\tRepresentations and Warranties. Service Provider represents and warrants that it has the necessary expertise and experience to perform the Services in a professional and workmanlike manner.\n8.\tIndemnification. Service Provider agrees to indemnify and hold harmless Company, its officers, directors, employees, and agents from and against any and all claims, damages, liabilities, costs, and expenses arising out of or in connection with the Services.\n9.\tGoverning Law. This Agreement shall be governed by and construed in accordance with the laws of Italy without regard to conflicts of laws principles.\n10.\tEntire Agreement. This Agreement constitutes the entire agreement between the parties and supersedes all prior or contemporaneous negotiations, agreements, representations, and understandings between the parties, whether written or oral.\nIN WITNESS WHEREOF, the parties have executed this Agreement as of the date first above written.\n[Signature block for Company]\n[Signature block for Service Provider]\n\nPLACEHOLDER",
"Generate a Service Delivery Agreement with the following elements: Service Provider: PLACEHOLDER, Client: PLACEHOLDER, Description of Services: PLACEHOLDER, Start Date: PLACEHOLDER, Duration: PLACEHOLDER"
] |
2024-01-10 | phasetr/generative-ai | 2023-11-26-hackathon-note~2_img_to_mp3.py | import os
from uuid_extensions import uuid7str
from openai import OpenAI
from pathlib import Path
import base64
def encode_image(image_path):
"""画像をbase64にエンコードする"""
with open(image_path, "rb") as image_file:
return base64.b64encode(image_file.read()).decode("utf-8")
sample_img_name = "img/1.jpg"
is_exist = os.path.exists(sample_img_name)
if not is_exist:
print(f"{sample_img_name}を作成してください。")
exit()
base64_img = encode_image(sample_img_name)
mp3_directory_name = "mp3"
mp3_path = f"{mp3_directory_name}/{uuid7str()}.mp3"
# ディレクトリがなければ作る
if not os.path.exists(mp3_directory_name):
os.mkdir(mp3_directory_name)
print("音声ファイルを作成します。")
client = OpenAI()
response = client.chat.completions.create(
model="gpt-4-vision-preview",
messages=[
{
"role": "user",
"content": [
{"type": "text", "text": "日本語で説明してください"}, # ここに質問を書く
# 画像の指定の仕方がちょい複雑
{"type": "image_url",
"image_url": f"data:image/jpeg;base64,{base64_img}"},
]
},
],
max_tokens=600,
)
# 応答からテキスト内容を取得
content_text = response.choices[0].message.content.strip()
# Text-to-Speechを使用してテキストを音声に変換
audio_response = client.audio.speech.create(
model="tts-1",
voice="nova",
input=content_text
)
# テキストの出力
print(content_text)
# 音声ファイルに出力
audio_response.stream_to_file(mp3_path)
print(f"音声ファイルを作成しました: {mp3_path}")
| [
"[{'type': 'text', 'text': '日本語で説明してください'}, {'type': 'image_url', 'image_url': 'data:image/jpeg;base64,PLACEHOLDER'}]"
] |
2024-01-10 | Azure-Samples/flask-app-on-azure-functions | FlaskApp~__init__.py | from flask import Flask
# Always use relative import for custom module
from .package.module import MODULE_VALUE
app = Flask(__name__)
@app.route("/")
def index():
return (
"Try /hello/Chris for parameterized Flask route.\n"
"Try /module for module import guidance"
)
@app.route("/hello/<name>", methods=['GET'])
def hello(name: str):
return f"hello {name}"
@app.route("/module")
def module():
return f"loaded from FlaskApp.package.module = {MODULE_VALUE}"
if __name__ == "__main__":
app.run() | [] |
2024-01-10 | Crazykrai/MakeUC2023 | search.py | import os
import openai
import json
import re
from googleapiclient.discovery import build
from dotenv import load_dotenv
from bs4 import BeautifulSoup
from urllib.request import Request, urlopen
load_dotenv()
apiKey = os.getenv('GOOGLE_API_KEY')
seId = os.getenv('GOOGLE_CSE_ID')
openai.api_key = os.getenv('GPT_KEY')
def google_search(search_term, api_key, cse_id, **kwargs):
service = build("customsearch", "v1", developerKey=api_key)
res = service.cse().list(q=search_term, cx=cse_id, **kwargs).execute()
return res['items']
def query_google(q):
return google_search(q, apiKey, seId, num=3)
async def gpt_summarize(q):
text = re.sub(r'\s+', ' ', get_page_text(q))
print(text)
link = q['link']
result = openai.ChatCompletion.create(model="gpt-3.5-turbo", messages=[{"role": "user", "content": "Create a 2 sentence summary of a website's content using the given text from the website alongside the URL: " + link + " - " + text}])
return result
def get_page_text(pageObject):
req = Request(pageObject['link'],headers={'User-Agent': 'Mozilla/5.0'})
html_page = urlopen(req).read()
soup = BeautifulSoup(html_page, 'html.parser')
text = soup.getText()
soupLen = len(text)
if soupLen > 3000:
text = text[:3000]
return text
#print(json.dumps(query_google("honda civic si"), indent=2)) | [
"Create a 2 sentence summary of a website's content using the given text from the website alongside the URL: PLACEHOLDER - PLACEHOLDER"
] |
2024-01-10 | aweidner/ScryBot | scrybot~api~search.py | import sys
import asyncio
import openai
async def search(query):
completion = await openai.ChatCompletion.acreate(
model="ft:gpt-3.5-turbo-0613:personal::8MPbjnyY",
messages=[
{"role": "system", "content": "Act as a scryfall api bot that accepts a user query and translates it into a search URL. Output only the url."},
{"role": "user", "content": query}
],
temperature=0.0,
)
return completion.choices[0].message
def main():
print(asyncio.run(search(sys.argv[1])))
if __name__ == "__main__":
main() | [
"Act as a scryfall api bot that accepts a user query and translates it into a search URL. Output only the url."
] |
2024-01-10 | cancelself/geist | geist.py | import os
import sys
import glob
import json
import openai
import pickle
import getpass
from datetime import datetime
def load_chat_history(file_path):
try:
with open(file_path, 'rb') as f:
chat_history = pickle.load(f)
except FileNotFoundError:
chat_history = []
return chat_history
def save_chat_history(file_path, chat_history):
with open(file_path, 'wb') as f:
pickle.dump(chat_history, f)
if len(sys.argv) < 2:
print("Usage: geist.py <openai_api_path> <user_input>")
sys.exit(1)
openai.api_key_path = sys.argv[1]
chatml_path = os.path.dirname(os.path.abspath(__file__))
chatml_files = glob.glob(chatml_path + "/*.chatml")
chat_history_path = 'geist.pkl'
chatml = []
for chatml_file in chatml_files:
with open(chatml_file, "r") as f:
lines = f.readlines()
for line in lines:
message = json.loads(line)
current_timestamp = datetime.utcnow().isoformat().split('.')[0] + "Z"
common_fields = {
'role': message['role'],
'content': message['content']
}
if 'name' in message:
common_fields['name'] = message['name']
chatml.append(common_fields)
chat_history = chatml + load_chat_history(chat_history_path)
user_input = sys.argv[2]
whoiam = getpass.getuser()
current_timestamp = datetime.utcnow().isoformat().split('.')[0] + "Z "
prompt = {"role": "user", "content": current_timestamp + user_input, "name": whoiam}
completion = openai.ChatCompletion.create(
model="gpt-4",
#model = "gpt-3.5-turbo",
messages = chat_history + [prompt],
)
chat_history.append(prompt)
for message in chat_history:
print(message)
current_timestamp = datetime.utcnow().isoformat().split('.')[0] + "Z"
response_message = completion["choices"][0]["message"]["content"]
chat_history.append({'role': 'assistant', 'content': response_message, 'name': 'geist'})
print(response_message)
save_chat_history(chat_history_path, chat_history) | [
"{'role': 'user', 'content': 'PLACEHOLDERPLACEHOLDER', 'name': PLACEHOLDER}",
"content",
"PLACEHOLDERPLACEHOLDER"
] |
2024-01-10 | maioria/chatgpt-talkieai | talkieai-server~app~ai~chat_gpt_ai.py | from typing import List, Dict
import json
from pydantic import BaseModel
from app.ai.interfaces import SystemBaseAI, MessageInvokeDTO
from app.ai.models import *
from app.core.logging import logging
class ChatGPTInvokeDTO(BaseModel):
messages: List[Dict]
model: str = 'gpt-3.5-turbo'
temperature: float = 0.5
max_tokens: int = 100
class ChatGptRemoteAI(SystemBaseAI):
""" 通过http远程调用的接口 """
def __init__(self, api_key:str, organization:str,server_url :str):
import requests
session = requests.Session()
session.trust_env = False
self.session = session
self.api_key = api_key
self.organization = organization
self.server_url = server_url
def _original_invoke_chat(self, dto: MessageInvokeDTO):
headers = {
"Content-Type": "application/json",
"Api-Key": self.api_key,
"Organization": self.organization
}
url = f'{self.server_url}/api/v1/chat'
request_dto = ChatGPTInvokeDTO(messages=dto.messages)
logging.info(f'request_dto:{request_dto.dict()}')
remote_result = self.session.post(url, data=json.dumps(request_dto.dict()), headers=headers)
result = remote_result.text
logging.info(f'response:{result}')
json_result = json.loads(result)
return json_result
class ChatGptLocalAI(SystemBaseAI):
"""本地直接调用openai的接口"""
def __init__(self, api_key:str, organization:str):
import openai
self.api_key = api_key
self.organization = organization
self.openai = openai
def _original_invoke_chat(self, dto: MessageInvokeDTO):
request_dto = ChatGPTInvokeDTO(messages=dto.messages)
logging.info(f'request_dto:{request_dto.dict()}')
response = self.openai.ChatCompletion.create(
api_key=self.api_key,
organization=self.organization,
model=request_dto.model,
messages=request_dto.messages
)
result = response.choices[0].message.content
return result | [] |
2024-01-10 | jasonthewhale/Indigenous_AI | story_generator.py | import streamlit as st
import pandas as pd
import numpy as np
import openai
openai.organization = "org-tlNrDekRRlExHL1gWb7oCHPD"
openai.api_key = st.secrets["OPENAI_API_KEY"]
df = pd.read_csv('./datasets/indigenous_map.csv')
for _, row in df.iterrows():
language_name = row['Language']
new_url = f"https://maps.slq.qld.gov.au/iyil/assets/img/thumbs/{language_name}.jpg"
df.loc[_, 'Image URL'] = new_url
@st.cache_data
def get_map_data():
df_location = pd.DataFrame()
df_location['Language'] = df['Language']
df_location[['lat', 'lon']] = df['Coordinates 1'].str.split(',', expand=True).astype(float)
df_location['size'] = np.full(len(df_location), 3)
df_location['color'] = generate_random_colors(len(df_location))
# df_location['Synonyms'] = df['Synonyms']
return df_location
def get_language_df(language):
return df[df.Language == language]
def get_language_index(language):
return df[df.Language == language].index[0]
def search_language_for_info(language):
language_row = df[df.Language == language]
info = f"""Name: {language_row['Language'].values[0]}
Pronunciation: {language_row['Pronunciation'].values[0]}
Introduction: {language_row['Introduction'].values[0]}
Locations: {language_row['Locations'].values[0]}
Synonyms: {language_row['Synonyms'].values[0]}
Common words: {language_row['Common words'].values[0]}
Image attribution: {language_row['Image attribution'].values[0]}
"""
return info
@st.cache_data
def tell_story(language_info):
prompt = f"""
Here is the info about an indigenous language in QLD. Help me create a \
short and brief, but fascinating story involves language name, introduction, \
pronunciation, Synonyms, Common words. Also set the background or scene of \
the story as value of "Locations", describing a story bsaed on image attribution. \
Pls keep in at most three paragraphs.
{language_info}
"""
completion = openai.ChatCompletion.create(
model="gpt-3.5-turbo",
messages=[
{"role": "user", "content": prompt}
]
)
return completion.choices[0].message["content"]
def main(language):
language_info = search_language_for_info(language)
tell_story(language_info)
def get_image(language):
language_row = df[df.Language == language]
return language_row['Image URL'].values[0]
def label_story(language, story):
indigenous_words = []
new_str = story
language_row = df[df.Language == language]
indigenous_phrases = language_row['Common words'].values[0]
if type(indigenous_phrases) != str:
return new_str
indigenous_pairs = indigenous_phrases.split('; ')
for pair in indigenous_pairs:
indigenous_words.append(pair.split(' - ')[1])
for word in indigenous_words:
new_str = new_str.replace(word, f"**:blue[{word}]**")
return new_str
def generate_random_colors(n):
colors = np.random.randint(0, 256, size=(n, 3))
return np.array([f"rgb({r}, {g}, {b})" for r, g, b in colors])
| [
"\nHere is the info about an indigenous language in QLD. Help me create a short and brief, but fascinating story involves language name, introduction, pronunciation, Synonyms, Common words. Also set the background or scene of the story as value of \"Locations\", describing a story bsaed on image attribution. Pls keep in at most three paragraphs.\n\nPLACEHOLDER\n"
] |
2024-01-10 | wshao12/ChatGPT | src~revChatGPT~ProxyServer.py | """
Fetches cookies from chat.openai.com and returns them (Flask)
"""
from OpenAIAuth.Cloudflare import Cloudflare
from flask import Flask, request, jsonify
import tls_client
import json
app = Flask(__name__)
session = tls_client.Session(
client_identifier="chrome_108"
)
# Get cloudflare cookies
cf_clearance, user_agent = Cloudflare().get_cf_cookies()
@app.route('/backend-api/conversation', methods=['POST'])
def conversation():
# Get cookies from request
cookies = {
"cf_clearance": cf_clearance,
"__Secure-next-auth.session-token": request.cookies.get("__Secure-next-auth.session-token"),
}
# Get JSON payload from request
payload = request.get_json()
# Set user agent
headers ={
"Accept": "text/event-stream",
"Authorization": request.headers.get("Authorization"),
"User-Agent": user_agent,
"Content-Type": "application/json",
"X-Openai-Assistant-App-Id": "",
"Connection": "close",
"Accept-Language": "en-US,en;q=0.9",
"Referer": "https://chat.openai.com/chat",
}
# Send request to OpenAI
response = session.post(
url="https://chat.openai.com/backend-api/conversation",
headers=headers,
cookies=cookies,
data=json.dumps(payload),
timeout_seconds=360
)
# Return response
return response.text
if __name__ == '__main__':
app.run(debug=True)
| [] |
2024-01-10 | abuzarmahmood/KatzGPT | katz_gpt_test.py | """
https://levelup.gitconnected.com/langchain-for-multiple-pdf-files-87c966e0c032
"""
from langchain.document_loaders import PyPDFLoader, PyPDFDirectoryLoader
from glob import glob
import os
from tqdm import tqdm
from joblib import Parallel, delayed
from pickle import dump, load
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import Chroma
from langchain.chains import ConversationalRetrievalChain, RetrievalQA
from langchain.memory import ConversationBufferMemory
from langchain.llms import OpenAI
from langchain.chains import LLMChain
from langchain.chains.qa_with_sources import load_qa_with_sources_chain
from langchain.prompts.prompt import PromptTemplate
def parallelize(data, func, num_of_processes=8):
return Parallel(n_jobs=num_of_processes)(delayed(func)(i) for i in tqdm(data))
def try_load(this_path):
try:
loader = PyPDFLoader(this_path)
docs = loader.load()
return docs
except:
print(f'Load failed : {this_path}')
return None
############################################################
## Generate Docs
############################################################
docs_path = '/media/bigdata/projects/istyar/data/abu_zotero'
file_list = glob(os.path.join(docs_path, "*"))
vector_persist_dir = '/media/bigdata/projects/katzGPT/vector_store'
docs_output_dir = '/media/bigdata/projects/katzGPT/docs'
docs_output_path = os.path.join(docs_output_dir, 'docs.pkl')
if not os.path.exists(vector_persist_dir):
os.makedirs(vector_persist_dir)
if not os.path.exists(docs_output_dir):
os.makedirs(docs_output_dir)
if not os.path.exists(docs_output_path):
docs_list = parallelize(file_list, try_load, num_of_processes=24)
# Drop None
docs_list = [doc for doc in docs_list if doc is not None]
# Flatten list
docs_list = [item for sublist in docs_list for item in sublist]
# Extract document source from each document
doc_source = [doc.metadata['source'] for doc in docs_list]
## Count length of set of document source
#len(set(doc_source))
# Save docs
with open(docs_output_path, 'wb') as f:
dump(docs_list, f)
else:
docs_list = load(open(docs_output_path, 'rb'))
############################################################
# Generate Embeddings
############################################################
embeddings = OpenAIEmbeddings()
vectordb = Chroma.from_documents([docs_list[0]], embedding=embeddings,
persist_directory=vector_persist_dir)
vectordb.persist()
for doc in tqdm(docs_list):
vectordb.add_documents([doc])
vectordb.persist()
memory = ConversationBufferMemory(
memory_key="chat_history",
return_messages=True)
pdf_qa = ConversationalRetrievalChain.from_llm(
llm = OpenAI(temperature=0.8) ,
retriever = vectordb.as_retriever(),
# return_source_documents=True,
memory=memory,
max_tokens_limit = 3500,
)
query = "Which katz lab papers discuss attractor networks?"
result = pdf_qa({"question": query})
print(result)
##############################
prompt="""
Follow exactly those 3 steps:
1. Read the context below and aggregrate this data
Context : {matching_engine_response}
2. Answer the question using only this context
3. Show the source for your answers
User Question: {question}
If you don't have any context and are unsure of the answer, reply that you don't know about this topic.
"""
question_prompt = PromptTemplate.from_template(
template=prompt,
)
question_generator = LLMChain(
llm=llm,
prompt=question_prompt,
verbose=True,
)
llm = OpenAI(temperature=0)
doc_chain = load_qa_with_sources_chain(llm)
chain = ConversationalRetrievalChain(
retriever=vectordb.as_retriever(),
combine_docs_chain=doc_chain,
return_source_documents=True,
query_generator=question_generator,
memory=memory,
max_tokens_limit = 3500,
)
##############################
embeddings = OpenAIEmbeddings()
vectordb = Chroma(persist_directory=vector_persist_dir,
embedding_function=embeddings)
template = """You are an AI assistant for answering questions about systems neuroscience, specifically taste processing.
You are given the following extracted parts of a long document and a question. Provide a conversational answer.
If you don't know the answer, just say "Hmm, I'm not sure." Don't try to make up an answer.
Question: {question}
=========
{context}
=========
Answer in Markdown:"""
QA_PROMPT = PromptTemplate(
template=template,
input_variables=[
"question",
"context"
]
)
llm = OpenAI(temperature=0.8)
question_generator = LLMChain(
llm=llm,
prompt=QA_PROMPT,
verbose=True,
)
doc_chain = load_qa_with_sources_chain(llm,
chain_type = 'stuff')
memory = ConversationBufferMemory(
memory_key="chat_history",
input_key="question",
output_key="answer",
return_messages=True)
retriever = vectordb.as_retriever(
search_kwargs = {"k":5})
pdf_qa = ConversationalRetrievalChain(
retriever=retriever,
question_generator=question_generator,
combine_docs_chain=doc_chain,
return_source_documents=True,
memory=memory,
max_tokens_limit = 2000,
rephrase_question = False,
verbose=True,
)
query = "Where is the gustatory thalamus?"
result = pdf_qa({"question": query})
for this_key in result.keys():
if this_key not in ['chat_history', 'source_documents']:
print()
print(f"{this_key} : {result[this_key]}")
| [
"question",
"You are an AI assistant for answering questions about systems neuroscience, specifically taste processing.\nYou are given the following extracted parts of a long document and a question. Provide a conversational answer.\nIf you don't know the answer, just say \"Hmm, I'm not sure.\" Don't try to make up an answer.\nQuestion: {question}\n=========\n{context}\n=========\nAnswer in Markdown:",
"context",
"\nFollow exactly those 3 steps:\n1. Read the context below and aggregrate this data\nContext : {matching_engine_response}\n2. Answer the question using only this context\n3. Show the source for your answers\nUser Question: {question}\n\n\nIf you don't have any context and are unsure of the answer, reply that you don't know about this topic.\n"
] |
2024-01-10 | aishvi-g/healthease | templates~telebot~medease.py | import cohere
import os
from health_data import health_database, train_data
from azure.ai.translation.text import TextTranslationClient, TranslatorCredential
from azure.ai.translation.text.models import InputTextItem
api_key = os.environ['API_KEY']
azure_key = os.environ['azure_key']
endpoints = os.environ['endpoint']
region = os.environ['region']
credential = TranslatorCredential(azure_key, region)
text_translator = TextTranslationClient(endpoint=endpoints,
credential=credential)
co = cohere.Client(api_key)
class cohereExtractor():
def __init__(self, examples, example_labels, labels, task_desciption,
example_prompt):
self.examples = examples
self.example_labels = example_labels
self.labels = labels
self.task_desciption = task_desciption
self.example_prompt = example_prompt
def make_prompt(self, example):
examples = self.examples + [example]
labels = self.example_labels + [""]
return (self.task_desciption + "\n---\n".join([
examples[i] + "\n" + self.example_prompt + labels[i]
for i in range(len(examples))
]))
def extract(self, example):
extraction = co.generate(model='xlarge',
prompt=self.make_prompt(example),
max_tokens=15,
temperature=0.1,
stop_sequences=["\n"])
return (extraction.generations[0].text[:-1])
cohereHealthExtractor = cohereExtractor(
[e[1] for e in train_data], [e[0] for e in train_data], [], "",
"extract the Keywords from the medical terminology related answers:")
text = cohereHealthExtractor.make_prompt(
'What are alternatives for paracetamol')
target_language_code = "en"
def translate_text(text, target_language):
target_languages = [target_language]
input_text_elements = [InputTextItem(text=text)]
response = text_translator.translate(content=input_text_elements,
to=target_languages)
translation = response[0] if response else None
if translation:
for translated_text in translation.translations:
return translated_text.text
else:
return text
def extract_keywords(input_text):
extraction = cohereHealthExtractor.extract(input_text)
keywords = extraction.split(',')
keywords = [keyword.strip().lower() for keyword in keywords]
return keywords
def search_answer(keywords):
for keyword, answer in health_database:
if keyword.lower() in keywords:
return answer
return "I'm sorry, but I'm unable to provide information on that topic. For accurate and reliable information, please consult a healthcare professional or trusted educational resources."
def generate_response(user_input, target_language):
keywords = extract_keywords(user_input)
answer = search_answer(keywords)
translated_answer = translate_text(answer, target_language)
return translated_answer + "\n\n" + "Keywords: " + ", ".join(keywords)
| [] |
2024-01-10 | sahuidhsu/GPT-KUnit-coder | display_messages.py | import toml
import openai
log_file = open("message_log.txt", "w")
with open("config.toml") as config_file:
config = toml.load(config_file)
if not config["OPENAI_API_KEY"]:
print("ERROR! Please set your OPENAI_API_KEY in config.toml")
exit()
def write_output(msg):
print(msg)
log_file.write(msg + "\n")
client = openai.Client(api_key=config["OPENAI_API_KEY"])
messages = client.beta.threads.messages.list(thread_id=config["THREAD_ID"])
contents = []
roles = []
for this_msg in messages.data:
roles.append(this_msg.role)
contents.append(this_msg.content[0].text.value)
contents.reverse()
roles.reverse()
write_output("-" * 70)
for i in range(len(contents)):
write_output("[" + roles[i] + "]")
write_output("-" * 70)
write_output(contents[i])
write_output("-" * 70)
| [] |
2024-01-10 | chuanyang-Zheng/Progressive-Hint | main_clean.py | import copy
import os
import time
import jsonlines
import openai
import json
import re
import numpy as np
from utils import delete_extra_zero,_strip_string
import argparse
from statistics import mean
from collections import Counter
import traceback
# OpenAI Key
openai.api_key = "Put Your Key Here"
def find_math_answer(s):
assert('boxed' in s)
# s = s.replace(",", "")
ans = s.split('boxed')[-1]
if(ans[0] == '{'):
stack = 1
a = ''
for c in ans[1:]:
if(c == '{'):
stack += 1
a += c
elif(c == '}'):
stack -= 1
if(stack == 0): break
a += c
else:
a += c
else:
a = ans.split('$')[0].strip()
a=_strip_string(a)
return a
def extract_math_answer(pred_str):
if('The answer is ' in pred_str):
pred = pred_str.split('The answer is ')[-1].strip()
elif('the answer is ' in pred_str):
pred = pred_str.split('the answer is ')[-1].strip()
elif 'boxed' in pred_str:
ans = pred_str.split('boxed')[-1]
if (ans[0] == '{'):
stack = 1
a = ''
for c in ans[1:]:
if (c == '{'):
stack += 1
a += c
elif (c == '}'):
stack -= 1
if (stack == 0): break
a += c
else:
a += c
else:
a = ans.split('$')[0].strip()
a = _strip_string(a)
pred=a
else:
pattern = '-?\d*\.?\d+'
pred = re.findall(pattern, pred_str)
if(len(pred) >= 1):
# print(pred_str)
pred = pred[-1]
else: pred = ''
if pred != "":
if pred[-1] == ".":
pred = pred[:-1]
if pred[-1] == "/":
pred = pred[:-1]
pred=_strip_string(pred)
if 'boxed' in pred:
ans = pred.split('boxed')[-1]
if (ans[0] == '{'):
stack = 1
a = ''
for c in ans[1:]:
if (c == '{'):
stack += 1
a += c
elif (c == '}'):
stack -= 1
if (stack == 0): break
a += c
else:
a += c
else:
a = ans.split('$')[0].strip()
a = _strip_string(a)
pred=a
return pred
def data_reader(args):
questions = []
answers = []
decoder = json.JSONDecoder()
if args.dataset == "aqua":
with open(args.dataset_path) as f:
lines = f.readlines()
for line in lines:
json_res = decoder.raw_decode(line)[0]
choice = "(" + "(".join(json_res["options"])
choice = choice.replace("(", " (").replace(")", ") ")
choice = "Answer Choices:" + choice
questions.append(json_res["question"].strip() + " " + choice)
answers.append(json_res["correct"])
elif args.dataset in ["algebra","counting_and_probability","geometry","intermediate_algebra","number_theory","prealgebra","precalculus"]:
for filename in os.listdir(args.dataset_path):
if (filename.endswith('.json')):
d = json.load(open(args.dataset_path + '/' + filename))
questions.append(d['problem'])
answers.append(find_math_answer(d['solution']))
elif args.dataset == "gsm8k":
with open(args.dataset_path) as f:
lines = f.readlines()
for line in lines:
json_res = decoder.raw_decode(line)[0]
questions.append(json_res["question"].strip())
answers.append(delete_extra_zero(json_res["answer"].split("#### ")[-1].replace(",", "")))
elif args.dataset in ("addsub", "multiarith", "singleeq"):
with open(args.dataset_path) as f:
json_data = json.load(f)
for line in json_data:
q = line["sQuestion"].strip()
a = str(line["lSolutions"][0])
if a[-2:] == ".0":
a = a[:-2]
questions.append(q)
answers.append(delete_extra_zero(a))
elif args.dataset == "svamp":
with open(args.dataset_path) as f:
json_data = json.load(f)
for line in json_data:
q = line["Body"].strip() + " " + line["Question"].strip()
a = str(line["Answer"])
if a[-2:] == ".0":
a = a[:-2]
questions.append(q)
answers.append(delete_extra_zero(a))
else:
raise ValueError("dataset is not properly defined ...")
q_len_list = []
for q in questions:
q_len_list.append(len(q.split(" ")))
q_len_mean = mean(q_len_list)
print("dataset : {}".format(args.dataset))
print("data size : {}".format(len(answers)))
print("average num of words for each sample : {}".format(q_len_mean))
return questions, answers
def answer_cleansing(args, pred):
# print("pred_before : " + pred)
if args.dataset in ["algebra","counting_and_probability","geometry","intermediate_algebra","number_theory","prealgebra","precalculus"]:
# pred = pred.replace(",", "")
pred_final=extract_math_answer(pred)
return pred_final
if args.method in ("few_shot", "few_shot_cot"):
preds = pred.split(args.direct_answer_trigger_for_fewshot)
answer_flag = True if len(preds) > 1 else False
pred = preds[-1]
if args.dataset in ("aqua"):
pred = pred.upper()
# print(pred)
pred = re.findall(r'A|B|C|D|E', pred)
elif args.dataset in ("gsm8k", "addsub", "multiarith", "svamp", "singleeq"):
pred=pred.replace(",", "")
pred = [delete_extra_zero(s.replace(",", "")) for s in re.findall(r'-?\d+/?\.?\d*', pred)]
else:
raise ValueError("dataset is not properly defined ...")
# If there is no candidate in list, null is set.
if len(pred) == 0:
pred = ""
else:
if args.method in ("few_shot", "few_shot_cot"):
if answer_flag:
# choose the first element in list ...
pred = pred[0]
else:
# choose the last element in list ...
pred = pred[-1]
elif args.method in ("zero_shot", "zero_shot_cot"):
# choose the first element in list ...
pred = pred[0]
else:
raise ValueError("method is not properly defined ...")
# (For arithmetic tasks) if a word ends with period, it will be omitted ...
if pred != "":
if pred[-1] == ".":
pred = pred[:-1]
if pred[-1] == "/":
pred = pred[:-1]
return pred
def answer_clean(args, pred):
if args.dataset in ['aqua']:
pred_answer = answer_cleansing(args, copy.deepcopy(pred))
return pred_answer, "({})".format(pred_answer)
else:
pred_answer = answer_cleansing(args, copy.deepcopy(pred))
return pred_answer, pred_answer
def answer_clean_all(args, pred):
pred_answer_list = []
pred_answer_list_hint_list = []
for index_len in range(len(pred)):
# print(pred[index_len]['text'])
if args.eng in ["gpt-3.5-turbo", "gpt-4"]:
pred_answer, pred_answer_hint = answer_clean(args, pred[index_len]["message"]["content"].strip())
else:
pred_answer, pred_answer_hint = answer_clean(args, pred[index_len]["text"].strip())
pred_answer_list.append(pred_answer)
pred_answer_list_hint_list.append(pred_answer_hint)
most_answer=Counter(copy.deepcopy(pred_answer_list)).most_common()[0][0]
pred_answer_list_hint_list_new=[]
for element in pred_answer_list_hint_list:
if element.__contains__(most_answer):
pred_answer_list_hint_list_new.append(element)
pred_answer_list_hint_list=pred_answer_list_hint_list_new
return Counter(copy.deepcopy(pred_answer_list)).most_common()[0][0], Counter(pred_answer_list_hint_list).most_common()[0][0]
def create_response(prompt_input, eng='text-davinci-002', max_tokens=256, temperature=0.0, stop="Q"):
response = openai.Completion.create(
engine=eng,
prompt=prompt_input,
temperature=temperature,
max_tokens=max_tokens,
top_p=1,
frequency_penalty=0.0,
presence_penalty=0.0,
stop=["{}:".format(stop)]
)
return response
def create_response_chat(prompt_input, eng='text-davinci-002', max_tokens=256, temperature=0.0, stop="Q"):
response = openai.ChatCompletion.create(
model=eng,
messages=prompt_input,
temperature=temperature,
)
return response
def create_repeat_list(input_string, number):
prompt_input_list = []
for index_sample in range(number):
prompt_input_list.append(input_string)
return prompt_input_list
def get_answer_from_gpt_sample(prompt, question, eng='text-davinci-002', max_tokens=256, temperature=0.0,
question_string="ori", args=None):
# batch=20
count_total = args.sample
response_all = []
if eng in ["gpt-3.5-turbo","gpt-4"]:
if question_string == "ori":
prompt_input = prompt + "\n\nQ: {}\nA:".format(question)
response = create_response_chat([
{"role": "system", "content": "Follow the given examples and answer the question."},
{"role": "user", "content": prompt_input},
], eng, max_tokens, temperature, "Q")
response_all = response['choices']
elif question_string == "complex":
prompt_input = prompt + "\n\nQuestion: {}\nA:".format(question)
response = create_response_chat([
{"role": "system", "content": "Follow the given examples and answer the question."},
{"role": "user", "content": prompt_input},
], eng, max_tokens, temperature, "Question")
response_all = response['choices']
return response['choices'][0]['message']["content"].strip(), response_all
else:
if question_string == "ori":
prompt_input = prompt + "\n\nQ: {}\nA:".format(question)
if args.sample > 1:
# prompt_input_list=[]
while count_total > 0:
repeat_this = min(5, count_total)
prompt_input_list = create_repeat_list(prompt_input, repeat_this)
response = create_response(prompt_input_list, eng, max_tokens, temperature)
response_all.extend(response['choices'])
count_total = count_total - repeat_this
else:
response = create_response(prompt_input, eng, max_tokens, temperature, "Q")
response_all = response['choices']
elif question_string == "complex":
prompt_input = prompt + "\n\nQuestion: {}\nA:".format(question)
# print(prompt_input)
if args.sample > 1:
# prompt_input_list=[]
while count_total > 0:
repeat_this = min(5, count_total)
prompt_input_list = (create_repeat_list(prompt_input, repeat_this))
response = create_response(prompt_input_list, eng, max_tokens, temperature)
response_all.extend(response['choices'])
count_total = count_total - repeat_this
else:
response = create_response(prompt_input, eng, max_tokens, temperature, "Question")
response_all = response['choices']
# print(response)
return response['choices'][0]['text'].strip(), response_all
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--prompt_dir", default=None, type=str, required=True, help="directory to prompt file (.txt)")
parser.add_argument("--hint", default="None", type=str,
help="directory to progressive-hint prompt file (.txt)")
parser.add_argument("--eng", default=None, type=str, required=True, help="engine")
parser.add_argument("--num_test", default=400, type=int, help="number of samples tested. -1 if on all test samples")
parser.add_argument("--seed", default=1357, type=int, help="random seed")
parser.add_argument("--temp", default=0.0, type=float, help="temperature for generation")
parser.add_argument("--temp2", default=-1, type=float, help="temperature for progressive-hint generation")
parser.add_argument("--max_tokens", default=1024, type=int, help="max # of tokens for generation")
parser.add_argument("--test_ind", default=None, type=str,
help="dir to test indices. If not provided, randomly choose.")
parser.add_argument("--suffix", default="", type=str, help="")
parser.add_argument("--hint_length", default=2, type=int,
help="return after the last hint_lenght answers are the same")
parser.add_argument("--direct_answer_trigger_for_fewshot", default="The answer is", type=str,
help="used for extract answer")
parser.add_argument("--method", default="few_shot", type=str,
help="we use prompt so that the method is few-shot")
parser.add_argument("--dataset", default="", type=str,
help="the dataset name")
parser.add_argument("--q1", default="ori", type=str,choices=["ori","complex"],
help="q1 is used for base prompt. ori for standard prompt and CoT; compelx for Complex CoT")
parser.add_argument("--q2", default="ori", type=str,choices=["ori","complex"],
help="q2 is used for progressive-hint prompt. ori for standard prompt and CoT; compelx for Complex CoT")
parser.add_argument("--sample", default=1, type=int,
help="sample path number")
parser.add_argument("--sleep", default=1, type=int,
help="sleep time after error.")
args = parser.parse_args()
def make_print_to_file(file_name='./', path="./"):
'''
path， it is a path for save your log about fuction print
example:
use make_print_to_file() and the all the information of funtion print , will be write in to a log file
:return:
'''
import os
import sys
import time
import datetime
import pytz
class Logger(object):
def __init__(self, filename, path="./"):
self.terminal = sys.stdout
self.log = open(filename, "w", encoding='utf8')
def write(self, message):
# self.terminal.write(message)
if message != "\n" and message != "\r":
message = str(datetime.datetime.now(pytz.timezone('Asia/Shanghai'))) + " " + message
self.terminal.write(message)
self.log.write(message)
self.log.flush()
def flush(self):
pass
# fileName = time.strftime(file_name+'%Y-%m-%d %H:%M:%S',time.localtime(time.time()))
sys.stdout = Logger(file_name, path=path)
print(args)
dataset_path = {"addsub": "AddSub/AddSub.json", "aqua": "AQuA/AQuA.json", "gsm8k": "gsm8k/gsm8k.jsonl",
"multiarith": "MultiArith/MultiArith.json", "singleeq": "SingleEq/SingleEq.json",
"svamp": "SVAMP/SVAMP.json", "digit5": "digit5/digit5.pkl", "digit3": "digit3/digit3.pkl",
"digit4": "digit4/digit4.pkl", "digit6": "digit6/digit6.pkl", "digit7": "digit7/digit7.pkl",
"algebra": "math/algebra",
"counting_and_probability": "math/counting_and_probability", "geometry": "math/geometry",
"intermediate_algebra": "math/intermediate_algebra", "number_theory": "math/number_theory",
"prealgebra": "math/prealgebra", "precalculus": "math/precalculus", }
args.dataset_path = "dataset/{}".format(dataset_path[args.dataset])
# load prompts
file = args.prompt_dir
assert file.endswith(".txt")
prompt_name = os.path.basename(file)[:-4]
print(file, prompt_name)
with open(file, "r", encoding='utf-8') as f:
prompt = f.read().strip()
if args.hint != "None":
with open(args.hint, "r", encoding='utf-8') as f:
prompt_hint = f.read().strip()
questions, answers = data_reader(args)
qa_pairs = [(questions[idx], answers[idx]) for idx in range(len(questions))]
print("loading dataset complete. altogether", len(qa_pairs), "questions")
if args.temp2 < 0:
args.temp2 = args.temp
# scale down. -1 if not.
NUM_TEST = args.num_test
if NUM_TEST == -1:
qa_pairs_test = qa_pairs
else:
if args.test_ind is None:
np.random.seed(args.seed)
rand_indices = np.random.choice(len(qa_pairs), NUM_TEST, replace=False)
qa_pairs_test = [qa_pairs[i] for i in rand_indices]
else:
with open(args.test_ind, "r") as f:
test_ind = json.load(f)
assert len(test_ind) == NUM_TEST
qa_pairs_test = [qa_pairs[i] for i in test_ind]
print("testing on", len(qa_pairs_test), "samples")
#Store PHP Answer
file_name = "results/{}/Sample-{}_T-{}_T-{}/Hint-{}{}-{}.eng{}.sample{}.seed{}.temp{}.{}.jsonl".format(args.dataset,
args.sample,
args.temp,
args.temp2,
os.path.basename(
args.hint)[
:-4],
args.hint_length,
prompt_name,
args.eng,
NUM_TEST,
args.seed,
args.temp,
args.suffix)
if not os.path.exists(os.path.dirname(file_name)):
os.makedirs(os.path.dirname(file_name))
writer = jsonlines.open(file_name, mode='w')
# Store non-PHP Answer
file_name_none = "results/{}/Sample-{}_T-{}_T-{}/None{}-{}.eng{}.sample{}.seed{}.temp{}.{}.jsonl".format(
args.dataset, args.sample, args.temp, args.temp2, args.hint_length,
prompt_name, args.eng, NUM_TEST, args.seed, args.temp, args.suffix)
writer_none = jsonlines.open(file_name_none, mode='w')
#make log file
make_print_to_file(
"results/{}/Sample-{}_T-{}_T-{}/{}{}-{}.eng{}.sample{}.seed{}.temp{}.{}.txt".format(args.dataset, args.sample,
args.temp, args.temp2,
os.path.basename(args.hint)[
:-4], args.hint_length,
prompt_name, args.eng,
NUM_TEST, args.seed,
args.temp, args.suffix))
#Print Log File Name
print("results/{}/Sample-{}_T-{}_T-{}/{}{}-{}.eng{}.sample{}.seed{}.temp{}.{}.txt".format(args.dataset, args.sample,
args.temp, args.temp2,
os.path.basename(
args.hint)[:-4],
args.hint_length,
prompt_name, args.eng,
NUM_TEST, args.seed,
args.temp, args.suffix))
#print Dataset length
print("loading dataset complete. altogether", len(qa_pairs), "questions")
print("testing on", len(qa_pairs_test), "samples")
print(args)
count = 0
correct = 0.0
correct_none = 0.0
statics_interact = []
for (question, answer) in qa_pairs_test:
count += 1 # how many QA until now
print()
print()
print("currently", prompt_name, "#", count)
result = dict()
result['question'] = question
result['answer'] = answer
result = dict()
result['question'] = question
result['answer'] = answer
result_none = dict()
result_none['question'] = question
result_none['answer'] = answer
max_tokens = args.max_tokens
count_this = 0
answer_previous_number_array = []
answer_previous_number_array2=[]
while True:
# time.sleep(1)
print("***Step: {}".format(count_this))
print("***{} (Hint: The answer is near to {}).".format(question, ', '.join(
('%s' % id for id in answer_previous_number_array))))
if count_this == 0: #for the base interaction
try:
#try to get answer
answer_first, answer_this = get_answer_from_gpt_sample(prompt, question,
eng=args.eng, max_tokens=max_tokens,
temperature=args.temp,
question_string=args.q1, args=args)
result_none['ans_' + prompt_name] = answer_first
print("***Len {}".format(len(answer_this)))
print("***" + answer_first)
# clean answer.
# answer_this_number_check: check answer is correct or not.
#answer_this_hint: used for answer hint
answer_this_number_check, answer_this_hint = answer_clean_all(args, answer_this)
answer_previous_number = answer_this_hint
answer_previous_number_array.append(answer_this_number_check)
answer_previous_number_array2.append(answer_previous_number)#used for hint
count_this = count_this + 1#interaction number update
if answer_this_number_check == answer:
correct_none += 1
result_none['ans_correct_ratio'] = correct_none / count
print("***Answer:" + str(answer_this_number_check) + " " +str(answer_this_hint) + " " + str(answer) + " " + str(
correct_none / count))
except Exception as e:
print(repr(e))
traceback.print_exc()
time.sleep(args.sleep)
else:
# print(question)
try:
question_new = "{} (Hint: The answer is near to {}).".format(question, ', '.join(
('%s' % id for id in answer_previous_number_array2)))
print("***{}".format(question_new))
answer_first, answer_this = get_answer_from_gpt_sample(prompt_hint, question_new,
eng=args.eng, max_tokens=max_tokens,
temperature=args.temp2,
question_string=args.q2, args=args)
print("***Len {}".format(len(answer_this)))
print("***" + answer_first)
# clean answer.
# answer_this_number_check: check answer is correct or not.
#answer_this_hint: used for answer hint
answer_this_number_check, answer_this_hint = answer_clean_all(args, answer_this)
print("***Answer:" + str(answer_this_number_check) + " " +str(answer_this_hint) + " " + str(answer))
count_this += 1
answer_previous_number_array.append(answer_this_number_check)
answer_previous_number_array2.append(answer_this_hint)
if len(list(set(answer_previous_number_array[-min(len(answer_previous_number_array),
args.hint_length):]))) == 1 and count_this>=args.hint_length:
break
answer_previous_number = answer_this_hint
except Exception as e:
print(repr(e))
traceback.print_exc()
time.sleep(args.sleep)
result['ans_' + prompt_name] = answer_this
if answer_this_number_check == answer:
correct += 1
result['ans_correct_ratio'] = correct / count
print("***Answer:" + str(answer_this_number_check) + " " +str(answer_this_hint) + " " + str(answer) + " " + str(correct / count))
writer.write(result)
writer_none.write(result_none)
statics_interact.append(count_this)
# the last element is the prompt
writer.write(prompt)
writer.write(prompt_hint)
writer.close()
writer_none.write(prompt)
writer_none.close()
statics_interact = np.array(statics_interact)
print("Interact: Mean {} & Std {}".format(statics_interact.mean(), statics_interact.std()))
if __name__ == '__main__':
main()
| [
"PLACEHOLDER\n\nQ: PLACEHOLDER\nA:",
"PLACEHOLDER\n\nQuestion: PLACEHOLDER\nA:",
"[]",
"Follow the given examples and answer the question."
] |
2024-01-10 | rick-love/lc-playground | news_parser.py | import datetime
from config import get_OpenAI, get_NewsAPIKey
from openai import OpenAI
from newsapi import NewsApiClient
from langchain.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
# Import Pydantic
from langchain.output_parsers import PydanticOutputParser
from pydantic import BaseModel, Field, field_validator, validator
from typing import List
# Set the API key for OpenAI
try:
OpenAI.api_key = get_OpenAI()
except Exception as e:
raise Exception(f"Error setting API key for OpenAI: {e}")
# Set the API key for NewsAPI
try:
newsapi = NewsApiClient(api_key=get_NewsAPIKey())
except Exception as e:
raise Exception(f"Error setting API key for NewsAPI: {e}")
# LLMS
llm_model = "gpt-3.5-turbo"
chat = ChatOpenAI(temperature=0, model=llm_model)
# Get Dates
today = datetime.date.today()
yesterday = today - datetime.timedelta(days=1)
# Get News from NewsAPI
sources = newsapi.get_sources(country='de', language='de') #'wired-de', 'techcrunch-de', 't3n', 'spiegel-online', 'reuters', 'gruenderszene', 'focus', 'der-tagesspiegel', 'der-standard', 'der-spiegel', 'die-zeit', 'google-news-de', 'handelsblatt', 'heise', 'n-tv', 'techcrunch', 'the-verge', 'wired'
all_articles = newsapi.get_everything(sources='bbc-news', page=1, from_param=yesterday, to=today)#, language='de', sort_by='relevancy')
# print(sources)
print(all_articles)
# top_headlines = newsapi.get_top_headlines(country='de', category='science', language='de')
# first_article = top_headlines['articles'][0]
# Create Data class
# class Article(BaseModel):
# source: object = Field(description="contains an 'id' and 'name' of where the news is from")
# author: str = Field(description="author of the news article")
# title: str = Field(description="title of the news article")
# description: str = Field(description="description of the news article")
# url: str = Field(description="url of the news article")
# publishedAt: str = Field(description="date and time the news article was published")
# content: str = Field(description="content of the news article")
# # Validation
# @field_validator('content')
# def has_content(cls, v):
# if v != None:
# raise ValueError("Content must exist")
# return v
# # Set up the parser and validation for the output
# pydantic_parser = PydanticOutputParser(pydantic_object=Article)
# format_instructions = pydantic_parser.get_format_instructions()
# # Create the prompt
# news_template_revised = """
# From the following news article, please extract the following information:
# news: {first_article}
# {format_instructions}
# """
# print(first_article)
# print(top_headlines.keys())
# print(top_headlines['articles'][0].keys())
# prompt = ChatPromptTemplate.from_template(template=news_template_revised)
# news_articles = prompt.format_messages(news=top_headlines, format_instructions=format_instructions)
# # Get the response
# response = chat(news_articles)
# print(response.content)
| [] |
2024-01-10 | rick-love/lc-playground | chains.py | from config import get_OpenAI
from langchain.llms import OpenAI
from langchain.chat_models import ChatOpenAI
from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain, SequentialChain
import streamlit as st
# Set the API key for OpenAI
try:
OpenAI.api_key = get_OpenAI()
except Exception as e:
raise Exception(f"Error setting API key for OpenAI: {e}")
# LLMs
llm_model = "gpt-3.5-turbo-1106"
chat = ChatOpenAI(temperature=0.6, model=llm_model)
open_ai = OpenAI(temperature = 0.0)
# Chains
prompt = PromptTemplate(
input_variables=["language"],
template="How do you say good afternoon in {language}?",
)
chain = LLMChain(llm=open_ai, prompt=prompt)
st.title("Chain:")
st.text(chain.prompt.template.format(language="Portugese"))
st.write(chain.run(language="Portugese"))
| [
"How do you say good afternoon in {language}?",
"language"
] |
2024-01-10 | rick-love/lc-playground | day4_parsers.py | from OpenAI_Training.config import get_OpenAI
from openai import OpenAI
from langchain.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
# Set the API key for OpenAI
try:
OpenAI.api_key = get_OpenAI()
except Exception as e:
raise Exception(f"Error setting API key for OpenAI: {e}")
llm_model = "gpt-3.5-turbo"
chat = ChatOpenAI(temperature=0, model=llm_model)
email_response = """
We have an issue with the import of the following customer feed file. There are 5 other customers with the same issue.
Import ID 2289581
Import URL https://transport.productsup.io/bee95abe02f1f5a18c63/channel/123456/example.xml
User ID 321
Start time 2023-11-28T06:00:13Z
End time 2023-11-28T06:00:13Z
Error internal error, second error, third error
Internal Error write to spool file: write /feed-downloads/feed-ebayk-2289581: no space left on device
"""
email_template = """
From the following email, please extract the following information:
User_Id: what is the user id?
Import_ID: what is the import id?
start_time: what is the start time?
end_time: what is the end time?
errors: what are the errors? If there are multiple errors, please list them all in square brackets as an array.
Format the response as JSON with the following keys:
user_id
import_id
start_time
end_time
errors
email = {email}
"""
####################
email_template_revised = """
From the following email, please extract the following information:
User_Id: what is the user id?
Import_ID: what is the import id?
start_time: what is the start time?
end_time: what is the end time?
errors: what are the errors? If there are multiple errors, please list them all in square brackets as an array.
Format the response as JSON with the following keys:
user_id
import_id
start_time
end_time
errors
email = {email}
"""
# {first_format_instructions}
prompt_template = ChatPromptTemplate.from_template(email_template)
#####################
# Langchain Parsers
from langchain.output_parsers import ResponseSchema
from langchain.output_parsers import StructuredOutputParser
end_time_schema = ResponseSchema(name="end_time", description="The end time of the import")
start_time_schema = ResponseSchema(name="start_time", description="The start time of the import")
import_id_schema = ResponseSchema(name="import_id", description="The import id of the import")
user_id_schema = ResponseSchema(name="user_id", description="The user id of the import")
errors_schema = ResponseSchema(name="errors", description="The errors of the import")
response_schema = [end_time_schema, start_time_schema, import_id_schema, user_id_schema, errors_schema]
# Create a parser
output_parser = StructuredOutputParser.from_response_schemas(response_schema)
format_instructions = output_parser.get_format_instructions()
updated_prompt_template = ChatPromptTemplate.from_template(template=email_template_revised)
messages = prompt_template.format_messages(email=email_response, format_instructions=format_instructions)
response = chat(messages)
output_dict = output_parser.parse(response.content)
print(type(output_dict))
print(f"User Ids: {output_dict['user_id']}")
print(f"Erorrs: {output_dict['errors']}")
# print(type(reponse.content))
# print(reponse.content) | [
"\nFrom the following email, please extract the following information:\nUser_Id: what is the user id?\n\nImport_ID: what is the import id?\nstart_time: what is the start time?\nend_time: what is the end time?\nerrors: what are the errors? If there are multiple errors, please list them all in square brackets as an array.\n\nFormat the response as JSON with the following keys:\n user_id\n import_id\n start_time\n end_time\n errors\n \nemail = {email}\n\n"
] |
2024-01-10 | rick-love/lc-playground | chains_story.py | from config import get_OpenAI
from langchain.llms import OpenAI
from langchain.chat_models import ChatOpenAI
from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain, SequentialChain
import streamlit as st
# Set the API key for OpenAI
try:
OpenAI.api_key = get_OpenAI()
except Exception as e:
raise Exception(f"Error setting API key for OpenAI: {e}")
# LLMs
llm_model = "gpt-3.5-turbo-1106"
open_ai = OpenAI(temperature = 0.0)
template = """
As a childrens book author, write a simple and short (90 words) story lullaby based on the location
{location}
and the main character
{name}
STORY:
"""
prompt = PromptTemplate(
input_variables=["location", "name"],
template=template,
)
chain_story = LLMChain(llm=open_ai, prompt=prompt, output_key="story", verbose=True)
story = chain_story({"location": "the forest", "name": "Bobby"})
# SequentialChain
translation_template = """
Translate the {story} to {language}.
Make sure the translation is simple and fun to read for children.
TRANSLATION:
"""
prompt_translation = PromptTemplate(
input_variables=["story", "language"],
template=translation_template,
)
chain_translation = LLMChain(llm=open_ai, prompt=prompt_translation, output_key="translated")
overall_chain = SequentialChain(
chains=[chain_story, chain_translation],
input_variables=["location", "name", "language"],
output_variables=["story", "translated"])
response = overall_chain({"location": "the forest", "name": "Bobby", "language": "German"})
st.title("Story Chain:")
# st.write(story['text'])
st.write("## Story Chain with SequentialChain")
st.write(f"### Story: {response['story']} \n\n")
st.write(f"### Translation:\n\n {response['translated']} \n\n")
| [
"location",
"name",
"\nAs a childrens book author, write a simple and short (90 words) story lullaby based on the location\n{location}\nand the main character\n{name}\n\nSTORY:\n",
"\nTranslate the {story} to {language}.\n\nMake sure the translation is simple and fun to read for children.\n\nTRANSLATION:\n",
"language"
] |
2024-01-10 | rick-love/lc-playground | day3.py | from OpenAI_Training.config import get_api_key
from openai import OpenAI
from langchain.prompts import FewShotPromptTemplate,PromptTemplate
from langchain.llms import OpenAI
from langchain.chat_models import ChatOpenAI
from langchain.embeddings import OpenAIEmbeddings
from langchain.schema import HumanMessage, SystemMessage, AIMessage
from langchain.output_parsers import StructuredOutputParser, ResponseSchema
from langchain.document_loaders import HNLoader
from langchain.document_loaders import UnstructuredURLLoader
# Set the API key for OpenAI
try:
OpenAI.api_key = get_api_key()
except Exception as e:
raise Exception(f"Error setting API key for OpenAI: {e}")
# LLMs
llm = OpenAI(temperature=0.9, model_name="text-davinci-003")
chat = ChatOpenAI(temperature=.7)
############
# Document Loaders
loader = HNLoader("https://news.ycombinator.com/item?id=34422627")
############
# Show to the screen
# App Framework
import streamlit as st
st.title('Day 3:')
st.write()
############
# Output Parsers
# How you would like your response structured. This is basically a fancy prompt template
response_schemas = [
ResponseSchema(name="bad_string", description="This a poorly formatted user input string"),
ResponseSchema(name="good_string", description="This is your response, a reformatted response")
]
# How to parse the output
output_parser = StructuredOutputParser.from_response_schemas(response_schemas)
format_instructions = output_parser.get_format_instructions()
output_parse_template = """
You will be given a poorly formatted string from a user.
Reformat it and make sure all the words are spelled correctly
{format_instructions}
% USER INPUT:
{user_input}
YOUR RESPONSE:
"""
output_parse_prompt = PromptTemplate(
input_variables=["user_input"],
partial_variables={"format_instructions": format_instructions},
template=output_parse_template
)
promptValue = output_parse_prompt.format(user_input="whenn is this going end")
llm_output_parser = llm(promptValue)
parsed = output_parser.parse(llm_output_parser)
# {
# "bad_string": "whenn is this going end",
# "good_string": "When is this going to end?"
# }
#################
# Example Selectors
from langchain.prompts.example_selector import SemanticSimilarityExampleSelector
from langchain.vectorstores import Chroma
example_prompt = PromptTemplate(
input_variables=["input", "output"],
template="Example Input: {input}\nExample Output: {output}",
)
examples = [
{"input": "pirate", "output": "ship"},
{"input": "pilot", "output": "plane"},
{"input": "driver", "output": "car"},
{"input": "tree", "output": "ground"},
{"input": "bird", "output": "nest"},
]
example_selector = SemanticSimilarityExampleSelector.from_examples(
examples, OpenAIEmbeddings(), Chroma, k=2
)
simlar_prompt = FewShotPromptTemplate(
example_selector=example_selector,
# Your prompt
example_prompt=example_prompt,
prefix="Give the location an item is usually found",
suffix="Input: {noun}\nOutput",
input_variables=["noun"]
)
my_noun = "plant"
# print(simlar_prompt.format(noun=my_noun))
#################
# Text Embeddings
embeddings = OpenAIEmbeddings()
text = "Learning AI is painful to start"
text_embedding = embeddings.embed_query(text)
# print(f"Embeddings Length: {len(text_embedding)}")
# print(f"A sample {text_embedding[2]}")
################
# Prompt Template
template = """
I really want to travel to {location}. What should I do there?
Respond with one short answer.
"""
prompt = PromptTemplate(
input_variables=["location"],
template=template
)
final_prompt = prompt.format(location="Lisbon")
# print(f"Final Prompt: {final_prompt}")
# print(f"LLM Output: {llm(final_prompt)}")
# Simple Chat
llm_response = llm('What day is after Tuesday')
response = chat(
[
SystemMessage(content="You are a nice AI bot that helps a user figure out what to eat in one short sentence"),
HumanMessage(content="I like chicken, what should I eat?")
]
)
| [
"\nI really want to travel to {location}. What should I do there?\n\nRespond with one short answer.\n\n",
"location",
"Input: {noun}\nOutput",
"Lisbon",
"format_instructions",
"You are a nice AI bot that helps a user figure out what to eat in one short sentence",
"Give the location an item is usually found",
"input",
"whenn is this going end",
"user_input",
"noun",
"I like chicken, what should I eat?",
"\nYou will be given a poorly formatted string from a user.\nReformat it and make sure all the words are spelled correctly\n\n{format_instructions}\n\n% USER INPUT:\n{user_input}\n\nYOUR RESPONSE:\n\n",
"Example Input: {input}\nExample Output: {output}"
] |
2024-01-10 | rick-love/lc-playground | memory.py | from config import get_OpenAI
from openai import OpenAI
from langchain.llms import OpenAI
from langchain.chat_models import ChatOpenAI
from langchain.chains import ConversationChain
from langchain.memory import ConversationBufferMemory
import streamlit as st
# Set the API key for OpenAI
try:
OpenAI.api_key = get_OpenAI()
except Exception as e:
raise Exception(f"Error setting API key for OpenAI: {e}")
# LLMs
llm_model = "gpt-3.5-turbo"
llm = ChatOpenAI(temperature=0.6, model=llm_model) # temperature=0.7 is default
st.title('Memory Test:')
st.write(llm.predict("Hello, my name is John. What is your name?"))
st.write(llm.predict("Great, what is my name?")) # should be John - No Access to Memory at this point
#Memory
memory = ConversationBufferMemory()
conversation = ConversationChain(llm=llm, memory=memory, verbose=True)
st.title('Conversation Test:')
st.write(conversation.predict(input="Hello, my name is John. What is your name?"))
st.write(conversation.predict(input="Great, what is my name?")) # should be John - No Access to Memory at this point
st.write(memory.load_memory_variables({})) # {} should be empty - Access to Memory at this point
| [] |
2024-01-10 | rick-love/lc-playground | doesnt_work_speech2text.py | from pathlib import Path
from OpenAI_Training.config import get_api_key
from openai import OpenAI
from langchain.llms import OpenAI
from langchain.chat_models import ChatOpenAI
import streamlit as st
# Set the API key for OpenAI
try:
OpenAI.api_key = get_api_key()
except Exception as e:
raise Exception(f"Error setting API key for OpenAI: {e}")
# LLMs
client = OpenAI()
response = client.audio.speech.create(
model="tts-1",
voice="alloy",
input="Hello world! This is a streaming test.",
)
response.stream_to_file("output.mp3")
############
# Show to the screen
# App Framework
st.title('Boiler Plate:')
st.audio("speech.mp3") | [] |
2024-01-10 | rick-love/lc-playground | getWeather.py | # This file is used to get the weather for a given location
from config import get_OpenAI, get_OpenWeatherAPIKey
from langchain.llms import OpenAI
from langchain.agents import AgentType, initialize_agent, load_tools
# Set the API key for OpenAI
try:
OpenAI.api_key = get_OpenAI()
except Exception as e:
raise Exception(f"Error setting API key for OpenAI: {e}")
# Set the API key for OpenWeatherMap
try:
openWeather_api_key = get_OpenWeatherAPIKey()
except Exception as e:
raise Exception(f"Error setting API key for OpenAI: {e}")
llm = OpenAI(temperature=0)
tools = load_tools(["openweathermap-api"], llm)
agent_chain = initialize_agent(tools=tools, llm=llm, agent_type=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True)
agent_chain.run("What is the weather in New York?") | [] |
2024-01-10 | rick-love/lc-playground | pydantic_parser.py | from config import get_OpenAI
from openai import OpenAI
from langchain.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
#import Pydantic
from langchain.output_parsers import PydanticOutputParser
from pydantic import BaseModel, Field, field_validator, validator
from typing import List
# Set the API key for OpenAI
try:
OpenAI.api_key = get_OpenAI()
except Exception as e:
raise Exception(f"Error setting API key for OpenAI: {e}")
llm_model = "gpt-3.5-turbo"
chat = ChatOpenAI(temperature=0, model=llm_model)
email_response = """
We have an issue with the import of the following customer feed file. There are 5 other customers with the same issue.
Import ID 2289581
Import URL https://transport.productsup.io/bee95abe02f1f5a18c63/channel/123456/example.xml
User ID 321
Start time 2023-11-28T06:00:13Z
End time 2023-11-28T06:00:13Z
Error internal error, second error, third error
Internal Error write to spool file: write /feed-downloads/feed-ebayk-2289581: no space left on device
"""
email_template = """
From the following email, please extract the following information:
User_Id: what is the user id?
Import_ID: what is the import id?
start_time: what is the start time?
end_time: what is the end time?
errors: what are the errors? If there are multiple errors, please list them all in square brackets as an array.
Format the response as JSON with the following keys:
user_id
import_id
start_time
end_time
errors
email = {email}
"""
####################
email_template_revised = """
From the following email, please extract the following information:
User_Id: what is the user id?
Import_ID: what is the import id?
start_time: what is the start time?
end_time: what is the end time?
errors: what are the errors? If there are multiple errors, please list them all in square brackets as an array.
email: {email}
{format_instructions}
"""
# Define Class
class ErrorInfo(BaseModel):
num_incidents: int = Field(description="this is an integar or the number of errors")
user_id : str = Field(description="This is the customers user id")
import_id : str = Field(description="This is the Import Id")
# Custom validator
@field_validator("num_incidents")
@classmethod
def num_incidents_must_be_positive(cls, v):
if v < 0:
raise ValueError("number of incidents must be positive")
return v
# set up the parser
pydantic_parser = PydanticOutputParser(pydantic_object=ErrorInfo)
format_instructions = pydantic_parser.get_format_instructions()
update_template = ChatPromptTemplate.from_template(template=email_template_revised)
messages = update_template.format_messages(email=email_response, format_instructions=format_instructions)
format_response = chat(messages)
print(type(format_response.content))
error_object = pydantic_parser.parse(format_response.content)
print(error_object)
print(type(error_object)) | [
"\nFrom the following email, please extract the following information:\nUser_Id: what is the user id?\n\nImport_ID: what is the import id?\nstart_time: what is the start time?\nend_time: what is the end time?\nerrors: what are the errors? If there are multiple errors, please list them all in square brackets as an array.\n\nemail: {email}\n{format_instructions}\n\n",
"\nFrom the following email, please extract the following information:\nUser_Id: what is the user id?\n\nImport_ID: what is the import id?\nstart_time: what is the start time?\nend_time: what is the end time?\nerrors: what are the errors? If there are multiple errors, please list them all in square brackets as an array.\n\nFormat the response as JSON with the following keys:\n user_id\n import_id\n start_time\n end_time\n errors\n \nemail = {email}\n\n"
] |
2024-01-10 | rick-love/lc-playground | getNews.py | from config import get_NewsAPIKey, get_OpenAI
from newsapi import NewsApiClient
from openai import OpenAI
from langchain.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
# Set the API key for NewsAPI
try:
newsapi = NewsApiClient(api_key=get_NewsAPIKey())
except Exception as e:
raise Exception(f"Error setting API key for NewsAPI: {e}")
# Set the API key for OpenAI
try:
OpenAI.api_key = get_OpenAI()
except Exception as e:
raise Exception(f"Error setting API key for OpenAI: {e}")
model = OpenAI(temperature=0, model_name="gpt-3.5-turbo-1106")
chat = ChatOpenAI(temperature=0, model="gpt-3.5-turbo-1106")
# Get the top headlines for a given query
sources = newsapi.get_sources()
# top_headlines = newsapi.get_top_headlines(q='ukraine', country='us', category='business', language='en')
top_headlines = newsapi.get_top_headlines(country='de', language='de')
news_response = """
source: {sources}
headlines: {top_headlines}
"""
# prompt_template = ChatPromptTemplate.from_template(prompt)
# headline_list = prompt_template.format_messages(top_headlines=top_headlines, prompt=prompt)
# response = headline_list
# print(type(response))
# print(type(top_headlines)) # dict
# print(sources)
# print(top_headlines)
| [] |
2024-01-10 | rick-love/lc-playground | story_generator.py | from config import get_OpenAI
from langchain.llms import OpenAI
from langchain.chat_models import ChatOpenAI
from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain, SequentialChain
import streamlit as st
# Set the API key for OpenAI
try:
OpenAI.api_key = get_OpenAI()
except Exception as e:
raise Exception(f"Error setting API key for OpenAI: {e}")
# LLMs
llm_model = "gpt-3.5-turbo-1106"
open_ai = OpenAI(temperature = 0.0)
def generate_story(location, name, language):
template = """
As a childrens book author, write a simple and short (90 words) story lullaby based on the location
{location}
and the main character
{name}
STORY:
"""
prompt = PromptTemplate(
input_variables=["location", "name"],
template=template,
)
chain_story = LLMChain(llm=open_ai, prompt=prompt, output_key="story", verbose=True)
# SequentialChain
translation_template = """
Translate the {story} to {language}.
Make sure the translation is simple and fun to read for children.
TRANSLATION:
"""
prompt_translation = PromptTemplate(
input_variables=["story", "language"],
template=translation_template,
)
chain_translation = LLMChain(llm=open_ai, prompt=prompt_translation, output_key="translated")
overall_chain = SequentialChain(
chains=[chain_story, chain_translation],
input_variables=["location", "name", "language"],
output_variables=["story", "translated"])
response = overall_chain({"location": location, "name": name, "language": language })
return response
def main():
st.set_page_config(page_title="Story Generator", page_icon="📚", layout="centered")
st.title("AI 📖 Story Generator")
st.header("Get started...")
location_input = st.text_input(label="Enter a location")
character_input = st.text_input(label="Enter a name")
language_input = st.text_input(label="Enter a language")
submit_button = st.button("Generate Story")
if location_input and character_input and language_input:
if submit_button:
with st.spinner("Generating story..."):
response = generate_story(location=location_input, name=character_input, language=language_input)
with st.expander("English Version"):
st.write(response['story'])
with st.expander(f"{language_input} Version"):
st.write(response['translated'])
st.success("Story generated!")
pass
# Invoke Main function
if __name__ == "__main__":
main() | [
"location",
"name",
"\n Translate the {story} to {language}.\n\n Make sure the translation is simple and fun to read for children.\n\n TRANSLATION:\n ",
"\n As a childrens book author, write a simple and short (90 words) story lullaby based on the location\n {location}\n and the main character\n {name}\n\n STORY:\n ",
"language"
] |
2024-01-10 | rick-love/lc-playground | blogGenerator.py | from OpenAI_Training.config import get_OpenAI
from openai import OpenAI
from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain, SequentialChain
from langchain.memory import ConversationBufferMemory
from langchain.utilities import WikipediaAPIWrapper
from langchain.chat_models import ChatOpenAI
from langchain.globals import get_verbose
current_verbose = get_verbose()
import streamlit as st
# Set the API key for OpenAI
try:
OpenAI.api_key = get_OpenAI()
except Exception as e:
raise Exception(f"Error setting API key for OpenAI: {e}")
# LLMs
llm = OpenAI(temperature=0.9)
chat_model = ChatOpenAI()
#Memory
blog_title_memory = ConversationBufferMemory(input_key='topic', memory_key='chat_history')
blog_subject_memory = ConversationBufferMemory(input_key='title', memory_key='chat_history')
# Prompt Templates
prompt = st.text_input('Enter your topic:')
blog_title_template = PromptTemplate(
input_variables=['topic'],
template='Write a Blog title about {topic}'
)
blog_subject_templte = PromptTemplate(
input_variables=['title', 'wikipedia_research'],
template='Write a Blog article based on this title: {title} while also leveraging this wikipedia research: {wikipedia_research}. The article should be less 500 words long.'
)
title_chain= LLMChain(llm=llm, prompt=blog_title_template, output_key='title', memory=blog_title_memory)
subject_chain= LLMChain(llm=llm, prompt=blog_subject_templte, output_key='title', memory=blog_subject_memory)
wiki = WikipediaAPIWrapper()
############
# Show to the screen
# App Framework
st.title('Blog Creator')
if prompt:
title = title_chain.run(prompt)
wiki_research = wiki.run(prompt)
subject = subject_chain.run(title=title, wikipedia_research=wiki_research)
st.write(title)
st.write(subject)
with st.expander('Title History'):
st.info(blog_title_memory.buffer)
with st.expander('Script History'):
st.info(blog_subject_memory.buffer)
with st.expander('Wikipedia Research'):
st.info(wiki_research)
| [
"Write a Blog title about {topic}",
"Enter your topic:",
"Write a Blog article based on this title: {title} while also leveraging this wikipedia research: {wikipedia_research}. The article should be less 500 words long."
] |
2024-01-10 | rick-love/lc-playground | languageConverter.py | from langchain.llms import OpenAI
import streamlit as st
from config import get_OpenAI
from langchain.prompts import PromptTemplate
template = """
Below is a text message that maybe poorly written.
Your goal is to:
- Properly format the text
- Convert the text to the desired tone
- Convert the text to the desired language
Here is an example of different tones:
- Formal: "I am writing to inform you that the product you ordered has been shipped."
- Informal: "Hey! Just wanted to let you know that your order has been shipped."
- Casual: "Yo! Your order has shipped."
Here are some examples of different languages:
- English: "I am writing to inform you that the product you ordered has been shipped."
- German: "Ich schreibe Ihnen, um Sie darüber zu informieren, dass das von Ihnen bestellte Produkt versandt wurde."
- Spanish: "Le escribo para informarle que el producto que ha pedido ha sido enviado."
Below is the text, tone and language:
TONE: {tone}
LANGUAGE: {language}
TEXT: {text}
YOUR RESPONSE:
"""
prompt = PromptTemplate(
input_variables=['tone', 'language', 'text'],
template=template,
)
# Set the API key for OpenAI
try:
OpenAI.api_key = get_OpenAI()
except Exception as e:
raise Exception(f"Error setting API key for OpenAI: {e}")
def load_LLM():
llm = OpenAI(temperature=0, max_tokens=100)
return llm
llm = load_LLM()
st.set_page_config(page_title="Langchain Playground", page_icon="🧊", layout="wide")
st.header("Langchain Playground")
col1, col2, col3 = st.columns(3)
with col1:
st.write('Creating a language conversion app which will be the base for the Chat Agent.')
with col2:
st.image('day_1.png')
st.markdown('---')
st.markdown('## Enter your text here:')
col1, col2 = st.columns(2)
with col1:
option_tone = st.selectbox('Tone', ('Formal', 'Informal', 'Casual'))
with col2:
option_lang = st.selectbox('Language', ('English', 'German', 'Spanish'))
def get_text():
input_text = st.text_area(label='text', label_visibility='hidden', placeholder='Enter text here', key='text_area')
return input_text
text_input = get_text()
st.markdown('Converted text:')
if text_input:
prompt_with_text = prompt.format(
tone=option_tone,
language=option_lang,
text=text_input
)
formatted_text = llm(prompt_with_text)
st.write(formatted_text) | [
"Yo! Your order has shipped.",
"Ich schreibe Ihnen, um Sie darüber zu informieren, dass das von Ihnen bestellte Produkt versandt wurde.",
"tone",
"Hey! Just wanted to let you know that your order has been shipped.",
"Le escribo para informarle que el producto que ha pedido ha sido enviado.",
"\nBelow is a text message that maybe poorly written.\nYour goal is to:\n- Properly format the text\n- Convert the text to the desired tone\n- Convert the text to the desired language\n\nHere is an example of different tones:\n- Formal: \"I am writing to inform you that the product you ordered has been shipped.\"\n- Informal: \"Hey! Just wanted to let you know that your order has been shipped.\"\n- Casual: \"Yo! Your order has shipped.\"\n\nHere are some examples of different languages:\n- English: \"I am writing to inform you that the product you ordered has been shipped.\"\n- German: \"Ich schreibe Ihnen, um Sie darüber zu informieren, dass das von Ihnen bestellte Produkt versandt wurde.\"\n- Spanish: \"Le escribo para informarle que el producto que ha pedido ha sido enviado.\"\n\nBelow is the text, tone and language:\nTONE: {tone}\nLANGUAGE: {language}\nTEXT: {text}\n\nYOUR RESPONSE:\n",
"I am writing to inform you that the product you ordered has been shipped.",
"language"
] |
2024-01-10 | rick-love/lc-playground | starter.py | from config import get_OpenAI
from openai import OpenAI
from langchain.llms import OpenAI
from langchain.chat_models import ChatOpenAI
from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain, SequentialChain
from langchain.memory import ConversationBufferMemory
import streamlit as st
# Set the API key for OpenAI
try:
OpenAI.api_key = get_OpenAI()
except Exception as e:
raise Exception(f"Error setting API key for OpenAI: {e}")
# LLMs
llm = OpenAI(temperature=0, model_name="gpt-3.5-turbo-1106")
chat_model = ChatOpenAI(temperature=0) # temperature=0.7 is default
############
# Show to the screen
# App Framework
st.title('Boiler Plate:') | [] |
2024-01-10 | rick-love/lc-playground | promptTemplates.py | from OpenAI_Training.config import get_OpenAI, get_PineCone
from openai import OpenAI
from langchain.llms import OpenAI
from langchain.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
import streamlit as st
# Set the API key for OpenAI
try:
OpenAI.api_key = get_OpenAI()
except Exception as e:
raise Exception(f"Error setting API key for OpenAI: {e}")
# LLMs
# llm = OpenAI(temperature=0.9, model_name="gpt-4-1106-preview")
chat_model = ChatOpenAI(temperature=.7)
#Templates
human_input = "Hello, how are you?"
template_string = """
Translates from English to German in a nice tone.
{human_input}
"""
prompt_template = ChatPromptTemplate.from_template(template_string)
translation = prompt_template.format_messages(human_input=human_input)
response = chat_model(translation)
print(response)
############
# Show to the screen
# App Framework
st.title('Boiler Plate:')
st.write(response) | [
"\n\nTranslates from English to German in a nice tone.\n{human_input}\n\n"
] |
2024-01-10 | BDSI-Utwente/steers | ingest~deprecated~04-topics_openai.py | from dotenv import load_dotenv
load_dotenv(".env")
from database import *
import openai
from openai.error import RateLimitError
import os
import random
import backoff
from peewee import DataError
openai.api_key = os.getenv("OPENAI_APIKEY")
# prepare topic getter with exponential backoff baked in
@backoff.on_exception(backoff.expo, RateLimitError)
def get_topics(essay: Essay):
summary = essay.summary_en
if len(summary) > 10_000:
print(f"[WARNING] Summary truncated to 10k characters")
summary = essay.summary_en[:10000]
result = openai.ChatCompletion.create(
model="gpt-3.5-turbo",
messages=[
{"role": "system", "content": "You are a topic extraction engine. When you get a message, you will reply with a comma-separated list of up to 8 topics and concepts that are most relevant to that message."},
{"role": "user", "content": summary }
]
)
return [c.lower().strip(" ,.!?:;") for c in result["choices"][0]["message"]["content"].split(",")]
for essay_index, essay in enumerate(Essay.select().iterator()):
if essay.language == "xx" or essay.summary_en is None or len(essay.summary_en) < 50:
continue
# skip if already gotten topics with this method
if EssayTopic.get_or_none(EssayTopic.essay == essay, EssayTopic.method == "openai gpt-3.5-turbo"):
continue
# if random.random() > 0.05: # only for a random subset of ~5%
# continue
print(f"[{essay_index + 1}]", essay.title[:120])
labels = get_topics(essay)
attempt = 1
while any(map(lambda label: len(label) > 50, labels)):
if attempt < 5:
print(f"[WARNING] unusually long topic(s), retrying...")
attempt += 1
else:
print(f"[ERROR] unusually long topic(s) after {attempt} retries, giving up!")
for label in labels:
print(f"\t{label}")
labels = get_topics(essay)
for index, label in enumerate(labels):
topic, created = Topic.get_or_create(name=label)
link, _ = EssayTopic.get_or_create(
essay=essay,
topic=topic,
method="openai gpt-3.5-turbo",
)
print(" + " if created else " ", label, sep = "")
| [
"You are a topic extraction engine. When you get a message, you will reply with a comma-separated list of up to 8 topics and concepts that are most relevant to that message."
] |
2024-01-10 | BDSI-Utwente/steers | ingest~deprecated~03-categories_openai.py | from dotenv import load_dotenv
load_dotenv(".env")
from database import *
import openai
from openai.error import RateLimitError
import os
import random
import backoff
from typing import List
from peewee import DataError
openai.api_key = os.getenv("OPENAI_APIKEY")
# prepare category getter with exponential backoff baked in
@backoff.on_exception(backoff.expo, RateLimitError)
def get_categories(essay: Essay) -> List[str]:
summary = essay.summary_en
if len(summary) > 10_000:
print(f"[WARNING] Summary truncated to 10k characters")
summary = essay.summary_en[:10000]
result = openai.ChatCompletion.create(
model="gpt-3.5-turbo",
messages=[
{"role": "system", "content": "You are an academic library classification engine. When you get a message, you will reply with a comma-separated list of academic domains that best fit the thesis described in the message."},
{"role": "user", "content": summary }
]
)
return [c.lower().strip(" ,.!?:;") for c in result["choices"][0]["message"]["content"].split(",")]
for essay_index, essay in enumerate(Essay.select().iterator()):
if essay.language == "xx" or essay.summary_en is None or len(essay.summary_en) < 50:
continue
# skip if already gotten categories with this method
if EssayCategory.get_or_none(EssayCategory.essay == essay, EssayCategory.method == "openai gpt-3.5-turbo"):
continue
# if random.random() > 0.05: # only for a random subset of ~5%
# continue
print(f"[{essay_index + 1}]", essay.title[:120])
categories = get_categories(essay)
for index, label in enumerate(categories):
category, created = Category.get_or_create(name=label)
link, _ = EssayCategory.get_or_create(
essay=essay,
category=category,
method="openai gpt-3.5-turbo",
)
print(" + " if created else " ", label, sep = "")
| [
"You are an academic library classification engine. When you get a message, you will reply with a comma-separated list of academic domains that best fit the thesis described in the message."
] |
2024-01-10 | mikelapierre/chat-with-your-data-solution-accelerator | code~utilities~helpers~LLMHelper.py | import openai
from typing import List
from langchain.chat_models import AzureChatOpenAI
from langchain.embeddings import OpenAIEmbeddings
from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler
from .EnvHelper import EnvHelper
class LLMHelper:
def __init__(self):
env_helper: EnvHelper = EnvHelper()
# Configure OpenAI API
openai.api_type = "azure"
openai.api_version = env_helper.AZURE_OPENAI_API_VERSION
openai.api_base = env_helper.OPENAI_API_BASE
openai.api_key = env_helper.OPENAI_API_KEY
self.llm_model = env_helper.AZURE_OPENAI_MODEL
self.llm_max_tokens = env_helper.AZURE_OPENAI_MAX_TOKENS if env_helper.AZURE_OPENAI_MAX_TOKENS != '' else None
self.embedding_model = env_helper.AZURE_OPENAI_EMBEDDING_MODEL
def get_llm(self):
return AzureChatOpenAI(deployment_name=self.llm_model, temperature=0, max_tokens=self.llm_max_tokens, openai_api_version=openai.api_version)
# TODO: This needs to have a custom callback to stream back to the UI
def get_streaming_llm(self):
return AzureChatOpenAI(streaming=True, callbacks=[StreamingStdOutCallbackHandler], deployment_name=self.llm_model, temperature=0,
max_tokens=self.llm_max_tokens, openai_api_version=openai.api_version)
def get_embedding_model(self):
return OpenAIEmbeddings(deployment=self.embedding_model, chunk_size=1)
def get_chat_completion_with_functions(self, messages: List[dict], functions: List[dict], function_call: str="auto"):
return openai.ChatCompletion.create(
deployment_id=self.llm_model,
messages=messages,
functions=functions,
function_call=function_call,
)
def get_chat_completion(self, messages: List[dict]):
return openai.ChatCompletion.create(
deployment_id=self.llm_model,
messages=messages,
)
| [] |
2024-01-10 | mikelapierre/chat-with-your-data-solution-accelerator | code~utilities~document_chunking~Layout.py | from typing import List
from .DocumentChunkingBase import DocumentChunkingBase
from langchain.text_splitter import MarkdownTextSplitter
from .Strategies import ChunkingSettings
from ..common.SourceDocument import SourceDocument
class LayoutDocumentChunking(DocumentChunkingBase):
def __init__(self) -> None:
pass
def chunk(self, documents: List[SourceDocument], chunking: ChunkingSettings) -> List[SourceDocument]:
full_document_content = "".join(list(map(lambda document: document.content, documents)))
document_url = documents[0].source
splitter = MarkdownTextSplitter.from_tiktoken_encoder(chunk_size=chunking.chunk_size, chunk_overlap=chunking.chunk_overlap)
chunked_content_list = splitter.split_text(full_document_content)
# Create document for each chunk
documents = []
chunk_offset = 0
for idx, chunked_content in enumerate(chunked_content_list):
documents.append(
SourceDocument.from_metadata(
content=chunked_content,
document_url=document_url,
metadata={"offset": chunk_offset},
idx=idx,
)
)
chunk_offset += len(chunked_content)
return documents
| [] |
2024-01-10 | mikelapierre/chat-with-your-data-solution-accelerator | code~utilities~orchestrator~Strategies.py | from enum import Enum
class OrchestrationStrategy(Enum):
OPENAI_FUNCTION = 'openai_function'
LANGCHAIN = 'langchain'
def get_orchestrator(orchestration_strategy: str):
if orchestration_strategy == OrchestrationStrategy.OPENAI_FUNCTION.value:
from .OpenAIFunctions import OpenAIFunctionsOrchestrator
return OpenAIFunctionsOrchestrator()
elif orchestration_strategy == OrchestrationStrategy.LANGCHAIN.value:
from .LangChainAgent import LangChainAgent
return LangChainAgent()
else:
raise Exception(f"Unknown orchestration strategy: {orchestration_strategy}")
| [] |
2024-01-10 | zharry29/curious_code_prompts | datasets~imdb~imdb_old.py | import argparse
import openai
from datasets import load_dataset
import random
random.seed(29)
from promptsource.templates import DatasetTemplates
import time
from sklearn.metrics import accuracy_score
import pickle
from transformers import AutoTokenizer
tokenizer = AutoTokenizer.from_pretrained("gpt2")
parser = argparse.ArgumentParser()
parser.add_argument('--prompt', default='text', type=str, help='Either text or code.')
parser.add_argument('--model', default='codex', type=str, help='Either davinci, curie or codex.')
parser.add_argument('--max_prompt', type=int, default=4000, help='Maximum number of tokens in the prompt.')
parser.add_argument('--key', default='harry', type=str, help='The name of the OpenAI API key file.')
args = parser.parse_args()
openai.api_key = open(f'../../_private/{args.key}.key').read()
SELECTED_PROMPT_NAME = "Movie Expressed Sentiment"
template = DatasetTemplates('imdb')[SELECTED_PROMPT_NAME]
dataset = load_dataset("imdb")
def predict():
# Build prompt
def build_text_prompt(inference_input_text):
text_prompt = ""
prev_prompt = ""
example_indices = random.sample(range(len(dataset['train'])), 100)
for example_index in example_indices:
if len(tokenizer(text_prompt + inference_input_text)['input_ids']) > args.max_prompt - 5:
break
example = dataset['train'][example_index]
input_text, output_text = template.apply(example)
prev_prompt = text_prompt
text_prompt += input_text + ' ' + output_text + '.\n\n'
return(prev_prompt + inference_input_text)
def build_code_prompt():
code_prompt = ""
return code_prompt
def run_llm(prompt, model, temperature=0, stop=['\n']):
model_name = {
"davinci": "text-davinci-002",
"curie": "text-curie-001",
"ada": "text-ada-001",
"codex": "code-davinci-002",
}
while True:
try:
ret = openai.Completion.create(
engine=model_name[model],
prompt=prompt,
temperature=temperature,
max_tokens=5,
top_p=1,
frequency_penalty=0,
presence_penalty=0,
stop=stop
)
break
except Exception as e:
print(e)
print("Retrying in 10 seconds")
time.sleep(10)
gen_text = ret["choices"][0]["text"].strip()#.split('\n')[0]
return gen_text
preds = []
golds = []
print("Total examples: ", len(dataset['test']))
count = 0
#print(len(dataset['test']))
#raise SystemExit
with open("sampled_1000_indices.pkl", "rb") as f:
indices = pickle.load(f)
for index in indices:
example = dataset['test'][index]
#print(example)
#raise SystemExit
count += 1
print(count)
input_text, output_text = template.apply(example)
if args.prompt == "text":
prompt = build_text_prompt(input_text)
elif "code" in args.prompt:
prompt = build_code_prompt(args.prompt, input_text)
#print(prompt)
#print(len(tokenizer(prompt)['input_ids']))
pred_text = run_llm(prompt, args.model)
#print(pred_text)
#raise SystemExit
if "negative" in pred_text:
pred = 0
else:
pred = 1
gold = example['label']
preds.append(pred)
golds.append(gold)
with open(f'pred_{args.model}_{args.prompt}_{args.max_prompt}.txt', 'w') as f:
f.writelines([str(x) + '\n' for x in preds])
with open('gold.txt', 'w') as f:
f.writelines([str(x) + '\n' for x in golds])
def evaluate():
with open(f'pred_{args.model}_{args.prompt}_{args.max_prompt}.txt', 'r') as f:
preds = [x.strip() for x in f.readlines()]
with open('gold.txt', 'r') as f:
golds = [x.strip() for x in f.readlines()]
print("Accuracy", accuracy_score(golds, preds))
return "Accuracy", accuracy_score(golds, preds)
if __name__ == "__main__":
predict()
evaluate() | [
"PLACEHOLDER PLACEHOLDER.\n\n",
"Movie Expressed Sentiment"
] |
2024-01-10 | zharry29/curious_code_prompts | datasets~cnn_dailymail~cnn_dailymail.py | import argparse
import openai
from datasets import load_dataset
import random
random.seed(29)
from promptsource.templates import DatasetTemplates
import time
from transformers import AutoTokenizer
from tqdm import tqdm
from rouge import FilesRouge
parser = argparse.ArgumentParser()
parser.add_argument('--prompt', required=True, type=str, help='Either text or code.')
parser.add_argument('--model', required=True, type=str, help='Either davinci, curie or codex.')
parser.add_argument('--max_prompt', type=int, default=4000, help='Maximum number of tokens in the prompt.')
parser.add_argument('--key', required=True, type=str, help='The name of the OpenAI API key file.')
args = parser.parse_args()
openai.api_key = open(f'../../_private/{args.key}.key').read()
SELECTED_PROMPT_NAME = "2_or_3_sentences"
MAX_RESPONSE_TOKENS = 300
rouge = FilesRouge()
template = DatasetTemplates("cnn_dailymail/3.0.0")[SELECTED_PROMPT_NAME]
dataset = load_dataset("cnn_dailymail", "3.0.0", cache_dir="/nlp/data/huggingface_cache")
tokenizer = AutoTokenizer.from_pretrained("gpt2")
def apply_code_template(example):
with open(args.prompt + '.py') as f:
template = f.read()
highlights = example["highlights"].replace('\n', ' ')
template = template.replace("{article}", example["article"]).replace("{highlights}", highlights)
return template.split("<\split>")
def predict():
# Build prompt
def build_text_prompt(model, input_text):
len_input = len(tokenizer(input_text)['input_ids'])
text_prompt = ""
max_len = args.max_prompt - MAX_RESPONSE_TOKENS - len_input
sampled_indices = []
while True:
index = random.choice(range(len(dataset['train'])))
while index in sampled_indices:
index = random.choice(range(len(dataset['train'])))
sampled_indices.append(index)
example = dataset['train'][index]
input_text, output_text = template.apply(example)
new_prompt = text_prompt + input_text + '\n\nAnswer: ' + output_text + '\n\n\n'
if len(tokenizer(new_prompt)['input_ids']) > max_len - 20:
break
text_prompt = new_prompt
return text_prompt, sampled_indices
def build_code_prompt(model, input_text):
len_input = len(tokenizer(input_text)['input_ids'])
code_prompt = ""
max_len = args.max_prompt - MAX_RESPONSE_TOKENS - len_input
sampled_indices = []
while True:
index = random.choice(range(len(dataset['train'])))
while index in sampled_indices:
index = random.choice(range(len(dataset['train'])))
sampled_indices.append(index)
example = dataset['train'][index]
input_text, output_text = apply_code_template(example)
new_prompt = code_prompt + input_text + output_text + '\n\n\n'
total_added = input_text + output_text + '\n\n\n'
if len(tokenizer(new_prompt)['input_ids']) > max_len - 20:
break
code_prompt = new_prompt
return code_prompt, sampled_indices
def run_llm(prompt, model, stop=['\n\n\n']):
model_name = {
"davinciOld": "davinci",
"davinci": "text-davinci-002",
"davinci3": "text-davinci-003",
"curie": "text-curie-001",
"ada": "text-ada-001",
"codex": "code-davinci-002",
}
while True:
try:
ret = openai.Completion.create(
engine=model_name[model],
prompt=prompt,
temperature=0.7,
max_tokens=MAX_RESPONSE_TOKENS,
top_p=1,
frequency_penalty=0,
presence_penalty=0,
stop=stop
)
break
except Exception as e:
print(e)
print("Retrying in 10 seconds")
time.sleep(10)
gen_text = ret["choices"][0]["text"].strip()#.split('\n')[0]
return gen_text
preds = []
golds = []
full_indices = []
f = open("sampled_1000_indices.txt", "r")
example_indices = [int(s.strip()) for s in f.readlines()]
for index in tqdm(example_indices):
example = dataset['validation'][index]
if args.prompt == "text":
input_text, _ = template.apply(example)
prompt, indices = build_text_prompt(args.model, input_text)
pred = run_llm(prompt + input_text + '\n\nAnswer:', args.model)
elif args.prompt.startswith("code"):
input_text, _ = apply_code_template(example)
if len(tokenizer(input_text)['input_ids']) > args.max_prompt - MAX_RESPONSE_TOKENS:
preds.append("")
golds.append(example["highlights"])
full_indices.append("")
continue
prompt, indices = build_code_prompt(args.model, input_text)
pred = run_llm(prompt + input_text, args.model)
gold = example["highlights"]
preds.append(pred)
golds.append(gold)
full_indices.append(indices)
with open(f'pred-{args.model}-{args.max_prompt}-{args.prompt}.txt', 'w') as f:
f.writelines([x.strip('\"').replace('\n', ' ') + '\n' for x in preds])
with open(f'gold-{args.model}-{args.max_prompt}-{args.prompt}.txt', 'w') as f:
f.writelines([x.replace('\n', ' ') + '\n' for x in golds])
with open(f'indices-{args.model}-{args.max_prompt}-{args.prompt}.txt', 'w') as f:
f.writelines([str(x) + '\n' for x in full_indices])
def evaluate():
scores = rouge.get_scores(f'pred-{args.model}-{args.max_prompt}-{args.prompt}.txt',f'gold-{args.model}-{args.max_prompt}-{args.prompt}.txt',avg=True) #TODO: Double check that this is correct/makes sense
print("Rouge Score", scores)
return "Rouge", scores
if __name__ == "__main__":
predict()
evaluate() | [
"cnn_dailymail/3.0.0",
"PLACEHOLDERPLACEHOLDER\n\nAnswer: PLACEHOLDER\n\n\n",
"{highlights}",
"2_or_3_sentences",
"PLACEHOLDERPLACEHOLDERPLACEHOLDER\n\n\n"
] |
2024-01-10 | zharry29/curious_code_prompts | datasets~Winogrande~winogrande.py | import os
import argparse
import ast
import pickle
import random
import time
import numpy as np
import openai
from sklearn.metrics import accuracy_score, f1_score
from tqdm import tqdm
import utils
class Winogrande():
def __init__(self, templates):
self.apply_template = templates
def build_text_prompt(self, max_len):
print('Building prompts...')
text_prompt = ""
total_token = max_len
threshold = args.context_size
tolerance = 0
counter = 0
while total_token < threshold:
example_index = random.sample(range(len(dataset['train'])), 1)
example = dataset['train'][example_index]
input_text, output_text = self.apply_template(example)
candidate_prompt = input_text.replace('[', '').replace(']', '') + '\n\nAnswer: ' + output_text.replace('[', '').replace(']', '') + '\n\n\n'
token_count = utils.gpt3_tokenizer(candidate_prompt)
prev_total = total_token
if total_token + token_count < threshold:
text_prompt += candidate_prompt
total_token += token_count
counter += 1
if total_token - prev_total < 10:
tolerance += 1
if tolerance > 1:
break
print(f'Total samples in prompt: {counter}')
print(f'Average tokens per sample: {total_token / counter}')
return text_prompt
def build_code_prompt(self, max_len, prompt):
print('Building prompts...')
if prompt:
code_prompt = prompt
total_token = utils.gpt3_tokenizer(prompt)
else:
code_prompt = ""
total_token = max_len
threshold = args.context_size
tolerance = 0
while total_token < threshold:
example_index = random.sample(range(len(dataset['train'])), 1)
example = dataset['train'][example_index]
input_text, output_text = self.apply_template(example)
candidate_prompt = input_text + output_text + '\n\n'
token_count = utils.gpt3_tokenizer(candidate_prompt)
prev_total = total_token
if total_token + token_count < threshold:
code_prompt += candidate_prompt
total_token += token_count
if total_token - prev_total < 10:
tolerance += 1
if tolerance > 1:
break
return code_prompt
def parse_input(self, inp):
return '- ' + "'" + inp.replace('-', '').strip() + "'"
def run_llm(self, prompt, model, max_tokens, temperature=0.7, stop=['\n']):
model_name = {
"davinci": "text-davinci-002",
"davinci-old": "davinci",
"davinci003": "text-davinci-003",
"curie": "text-curie-001",
"codex": "code-davinci-002",
"ada": "text-ada-001",
}
while True:
try:
ret = openai.Completion.create(
engine=model_name[model],
prompt=prompt,
temperature=temperature,
max_tokens=max_tokens,
top_p=1,
frequency_penalty=0,
presence_penalty=0,
stop=stop
)
break
except Exception as e:
print(e)
print("Retrying in 10 seconds")
time.sleep(10)
gen_text = ret["choices"][0]["text"].strip()#.split('\n')[0]
return gen_text
def predict(self, index=None):
val_data = dataset['validation']
if not index:
val_idx = np.random.choice(np.arange(len(val_data['answer'])), 1000, replace=False)
with open(f'./indices/{args.model}_val_idx.pkl', 'wb') as f:
pickle.dump(val_idx, f)
f.close()
else:
val_idx = pickle.load(open(f'./indices/{args.index}.pkl', 'rb'))
max_len = compute_longest_prompt(val_idx, val_data, self.apply_template)
if args.style == 'comment':
prompt = "'''\nThis is a coference resolution task. There will be a '_' in a given sentence and options will be provided. You need to choose from given options and fill in the '_'.\n'''\n\n"
elif args.style == 'class':
with open(f'./code-prompts/class_header.py') as f:
prompt = f.read()
f.close()
else:
prompt = None
if args.prompt == "text":
prompt = self.build_text_prompt(max_len)
elif args.prompt == "code":
prompt = self.build_code_prompt(max_len, prompt)
preds = []
golds = []
for idx in tqdm(val_idx):
example = val_data[int(idx)]
input_text, output_text = self.apply_template(example)
if args.prompt == 'text':
options = '[' + ','.join(['"' + e.replace('-', '').lower().strip() + '"' for e in input_text.split('\n')[-2:]]) + ']'
elif args.style == 'class':
options = input_text.split('\n')[-3].split('=')[-1].strip()
else:
options = input_text.split('\n')[-2].split('=')[-1].strip()
options = ast.literal_eval(options)
options = [e.strip().lower() for e in options]
if args.prompt == 'text':
input_text = input_text.split('\n')
input_text[-2], input_text[-1] = self.parse_input(input_text[-2]), self.parse_input(input_text[-1])
input_text = '\n'.join(input_text)
if args.prompt == "text":
pred = self.run_llm(prompt + input_text + '\n\nAnswer:', args.model, args.completion_size)
else:
pred = self.run_llm(prompt + input_text, args.model, args.completion_size)
pred = pred.replace("'", '').replace('"', '').lower().strip()
if pred in options:
pred = str(options.index(pred) + 1)
else:
pred = str(-1)
gold = example['answer']
preds.append(pred)
golds.append(gold)
pred_name, gold_name = get_fname()
with open(f'./result/{pred_name}.txt', 'w') as f:
f.writelines([x + '\n' for x in preds])
with open(f'./result/{gold_name}.txt', 'w') as f:
f.writelines([x + '\n' for x in golds])
def evaluate(self):
pred_name, gold_name = get_fname()
with open(f'./result/{pred_name}.txt', 'r') as f:
preds = [x.strip() for x in f.readlines()]
with open(f'./result/{gold_name}.txt', 'r') as f:
golds = [x.strip() for x in f.readlines()]
print("Accuracy", accuracy_score(golds, preds))
print("F1 Score", f1_score(golds, preds, average='macro'))
return accuracy_score(golds, preds)
def compute_longest_prompt(val_idx, val_data, apply_template):
max_len = 0
for idx in tqdm(val_idx):
example = val_data[int(idx)]
input_text, output_text = apply_template(example)
cur_len = utils.gpt3_tokenizer(input_text + '\n\nAnswer:')
if cur_len > max_len:
max_len = cur_len
return max_len
def apply_code_template(example):
with open(f'./code-prompts/{args.style}' + '.py') as f:
template = f.read()
ret = []
options = example['option1'] + example['option2']
for t in template.split('$'):
if type(example['sentence']) is list:
ret.append(t.replace("{sentence}", example["sentence"][0]).replace("{option1}", example["option1"][0]).replace("{option2}", example["option2"][0]).replace("{answer}", options[int(example["answer"][0])-1]))
else:
ret.append(t.replace("{sentence}", example["sentence"]).replace("{option1}", example["option1"]).replace("{option2}", example["option2"]).replace("{answer}", options[int(example["answer"])-1]))
return ret
def get_fname():
if not args.style:
pred_name = f'{args.prompt}_{args.model}_pred_{args.context_size}_{args.seed}'
else:
pred_name = f'{args.prompt}_{args.style}_{args.model}_pred_{args.context_size}'
if not args.style:
gold_name = f'{args.prompt}_{args.model}_gold_{args.context_size}_{args.seed}'
else:
gold_name = f'{args.prompt}_{args.style}_{args.model}_gold_{args.context_size}'
return pred_name, gold_name
parser = argparse.ArgumentParser()
parser.add_argument('--prompt', type=str, default='text',help='Either text or code.')
parser.add_argument('--model', type=str, help='Either davinci, curie or codex.')
parser.add_argument('--style', type=str, help='choose style of code prompt from one of ["vanilla", "good_var_name", "with_comments", "class_obj"]')
parser.add_argument('--context_size', type=int, help='token threshold for GPT3 context prompt.')
parser.add_argument('--completion_size', type=int, help='token threshold for GPT3 completion.')
parser.add_argument('--seed', type=int, default=None, help='random seed')
parser.add_argument('--index', type=str, help='file name of the saved indices')
#parser.add_argument('--dataset', type=str, help='Name of the datasset')
#parser.add_argument('--xxx', action='store_true', help='')
parser.add_argument('--key', type=str, help='The name of the OpenAI API key file.')
if __name__ == '__main__':
args = parser.parse_args()
openai.api_key_path = f'../../_private/{args.key}.key'
if args.seed:
random.seed(args.seed)
np.random.seed(args.seed)
data_name = 'winogrande'
dataset, templates = utils.load_data(data_name)
if args.prompt == "text":
apply_template = templates.apply
elif args.prompt == "code":
apply_template = apply_code_template
inference_model = Winogrande(apply_template)
inference_model.predict()
inference_model.evaluate()
| [
"PLACEHOLDERPLACEHOLDER\n\n",
"'''\nThis is a coference resolution task. There will be a '_' in a given sentence and options will be provided. You need to choose from given options and fill in the '_'.\n'''\n\n",
"None",
"\n\n\n",
"\n\nAnswer: "
] |
2024-01-10 | zharry29/curious_code_prompts | datasets~imdb~imdb.py | import argparse
import openai
from datasets import load_dataset
import random
random.seed(29)
from promptsource.templates import DatasetTemplates
import time
from sklearn.metrics import accuracy_score
import pickle
from transformers import AutoTokenizer
tokenizer = AutoTokenizer.from_pretrained("gpt2")
from scipy.stats import pearsonr
import backoff
parser = argparse.ArgumentParser()
parser.add_argument('--prompt', default='text', type=str, help='Either text or code.')
parser.add_argument('--model', default='codex', type=str, help='Either davinci, curie or codex.')
parser.add_argument('--max_prompt', type=int, default=4000, help='Maximum number of tokens in the prompt.')
parser.add_argument('--key', default='harry', type=str, help='The name of the OpenAI API key file.')
parser.add_argument('--seed', default='', type=str, help='Random seed.')
args = parser.parse_args()
openai.api_key = open(f'../../_private/{args.key}.key').read()
if args.seed:
args.seed = '_' + args.seed
random.seed(int(args.seed[1:]))
SELECTED_PROMPT_NAME = "Movie Expressed Sentiment"
template = DatasetTemplates('imdb')[SELECTED_PROMPT_NAME]
dataset = load_dataset("imdb")
def apply_code_template(example):
with open(args.prompt + '.py') as f:
template = f.read()
ret = []
for t in template.split('$'):
ret.append(t.replace("{text}", example["text"]).replace("{label}", '"positive"' if example["label"] == 1 else '"negative"'))
return ret
if args.prompt == "text":
apply_template = template.apply
elif args.prompt.startswith("code"):
apply_template = apply_code_template
def predict():
# Build prompt
def build_text_prompt(example):
inference_input_text = apply_template(example)[0]
text_prompt = ""
prev_prompt = ""
example_indices = random.sample(range(len(dataset['train'])), 100)
for example_index in example_indices:
if len(tokenizer(text_prompt + inference_input_text)['input_ids']) > args.max_prompt - 20:
break
example = dataset['train'][example_index]
input_text, output_text = apply_template(example)
prev_prompt = text_prompt
text_prompt += input_text + ' ' + output_text + '.\n\n'
return(prev_prompt + inference_input_text)
def build_code_prompt(example):
inference_input_text = apply_template(example)[0]
text_prompt = ""
prev_prompt = ""
example_indices = random.sample(range(len(dataset['train'])), 100)
for example_index in example_indices:
if len(tokenizer(text_prompt + inference_input_text)['input_ids']) > args.max_prompt:
break
example = dataset['train'][example_index]
input_text, output_text = apply_template(example)
prev_prompt = text_prompt
text_prompt += input_text + output_text + '\n\n\n'
return(prev_prompt + inference_input_text)
@backoff.on_exception(backoff.expo, openai.error.RateLimitError)
def run_llm(prompt, model, temperature=0, stop=['\n']):
model_name = {
"davinci": "text-davinci-002",
"davinci003": "text-davinci-003",
"old_davinci": "davinci",
"curie": "text-curie-001",
"ada": "text-ada-001",
"codex": "code-davinci-002",
}
while True:
try:
ret = openai.Completion.create(
engine=model_name[model],
prompt=prompt,
temperature=temperature,
max_tokens=5,
top_p=1,
frequency_penalty=0,
presence_penalty=0,
stop=stop
)
break
except Exception as e:
print(e)
print("Retrying in 10 seconds")
time.sleep(10)
gen_text = ret["choices"][0]["text"].strip()#.split('\n')[0]
return gen_text
preds = []
golds = []
print("Total examples: ", len(dataset['test']))
count = 0
#print(len(dataset['test']))
#raise SystemExit
with open("sampled_1000_indices.pkl", "rb") as f:
indices = pickle.load(f)
for index in indices:
example = dataset['test'][index]
#print(example)
#raise SystemExit
count += 1
print(count)
input_text, output_text = template.apply(example)
if args.prompt == "text":
prompt = build_text_prompt(example)
elif "code" in args.prompt:
prompt = build_code_prompt(example)
#print(len(tokenizer(prompt)['input_ids']))
#print(prompt)
#raise SystemExit
pred_text = run_llm(prompt, args.model)
if "negative" in pred_text:
pred = 0
else:
pred = 1
gold = example['label']
preds.append(pred)
golds.append(gold)
with open(f'pred_{args.model}_{args.prompt}_{args.max_prompt}{args.seed}.txt', 'w') as f:
f.writelines([str(x) + '\n' for x in preds])
with open('gold.txt', 'w') as f:
f.writelines([str(x) + '\n' for x in golds])
def evaluate():
with open(f'pred_{args.model}_{args.prompt}_{args.max_prompt}{args.seed}.txt', 'r') as f:
preds = [x.strip() for x in f.readlines()]
with open('gold.txt', 'r') as f:
golds = [x.strip() for x in f.readlines()]
print("Accuracy", accuracy_score(golds, preds))
return "Accuracy", accuracy_score(golds, preds)
if __name__ == "__main__":
predict()
evaluate() | [
"PLACEHOLDERPLACEHOLDER\n\n\n",
"PLACEHOLDER PLACEHOLDER.\n\n",
"Movie Expressed Sentiment"
] |
2024-01-10 | zharry29/curious_code_prompts | datasets~OpenPI-v2~code-prompts~class_prefix.py | import openai
from utils import build_prompt
class EntityStateGeneration():
'''function to generate entity state changes given the goal, context, and current step of a procedure. '''
def __init__(self):
pass
def gpt4(self, prompt):
res = openai.Completion.create(
engine='text-davinci-004',
prompt=prompt,
temperature=0.7,
max_tokens=300,
top_p=1,
frequency_penalty=0,
presence_penalty=0,
stop=['\n\n']
)
return res
def forward(self, goal, context, cur_step):
prompt = build_prompt(goal, context, cur_step)
answer = self.gpt4(prompt)
return answer
entity_model = EntityStateGeneration()
| [] |
2024-01-10 | zharry29/curious_code_prompts | datasets~HotpotQA~hotpotqa.py | import time
import json
import utils
import random
import pickle
import openai
import argparse
import numpy as np
from tqdm import tqdm
from datasets import load_dataset
from sklearn.metrics import accuracy_score
class HotpotQA():
def __init__(self, apply_template):
self.apply_template = apply_template
def build_text_prompt(self, input_text):
text_prompt = ""
total_token = utils.gpt3_tokenizer(input_text)
threshold = args.context_size
counter = 0
while total_token < threshold:
example_index = random.sample(range(len(dataset['train'])), 1)[0]
example = dataset['train'][example_index]
input_text, output_text = self.apply_template(example)
candidate_prompt = input_text.replace('[', '').replace(']', '') + '\n\nAnswer: ' + output_text.replace('[', '').replace(']', '') + '\n\n\n'
token_count = utils.gpt3_tokenizer(candidate_prompt)
if total_token + token_count < threshold:
text_prompt += candidate_prompt
total_token += token_count
counter += 1
else:
if text_prompt:
break
print(f'Total samples in prompt: {counter}')
print(f'Average tokens per sample: {total_token / counter}')
return text_prompt
def build_code_prompt(self, input_text, prompt=None):
if prompt:
text_prompt = prompt
else:
text_prompt = ""
total_token = utils.gpt3_tokenizer(input_text)
threshold = args.context_size
tolerance = 0
while total_token < threshold:
example_index = random.sample(range(len(dataset['train'])), 1)
example = dataset['train'][example_index]
input_text, output_text = self.apply_template(example)
candidate_prompt = input_text + output_text + '\n\n'
token_count = utils.gpt3_tokenizer(candidate_prompt)
prev_total = total_token
if total_token + token_count < threshold:
text_prompt += candidate_prompt
total_token += token_count
if total_token - prev_total < 10:
tolerance += 1
if tolerance > 1:
break
return text_prompt
def run_llm(self, prompt, model, max_tokens, temperature=0.7, stop=['\n']):
model_name = {
"davinci": "text-davinci-002",
"davinci003": "text-davinci-003",
"curie": "text-curie-001",
"codex": "code-davinci-002",
"ada": "text-ada-001",
}
while True:
try:
ret = openai.Completion.create(
engine=model_name[model],
prompt=prompt,
temperature=temperature,
max_tokens=max_tokens,
top_p=1,
frequency_penalty=0,
presence_penalty=0,
stop=stop
)
break
except Exception as e:
print(e)
print("Retrying in 10 seconds")
time.sleep(10)
gen_text = ret["choices"][0]["text"].strip()#.split('\n')[0]
return gen_text
def predict(self, index=None):
val_data = dataset['validation']
if not index:
val_idx = np.random.choice(np.arange(len(val_data['answer'])), 1000, replace=False)
with open(f'./indices/{args.model}_val_idx.pkl', 'wb') as f:
pickle.dump(val_idx, f)
f.close()
else:
val_idx = pickle.load(open(f'./indices/{args.index}.pkl', 'rb'))
preds = {}
golds = []
preds['answer'] = {}
for i, idx in enumerate(tqdm(val_idx)):
example = val_data[int(idx)]
input_text, output_text = self.apply_template(example)
if args.style == 'comment':
prompt = open('./code-prompts/comment_prefix.py').read()
elif args.style == 'class':
prompt = open('./code-prompts/class_prefix.py').read()
else:
prompt = None
if args.prompt == "text":
prompt = self.build_text_prompt(input_text)
elif args.prompt == "code":
prompt = self.build_code_prompt(input_text, prompt)
if args.prompt == 'text':
pred = self.run_llm(prompt + input_text + '\n\nAnswer:', args.model, args.completion_size)
else:
pred = self.run_llm(prompt + input_text, args.model, args.completion_size)
gold = example['answer']
preds['answer'][f'seacow-{i}'] = pred
golds.append({'_id': f'seacow-{i}', 'answer': gold})
pred_name, gold_name = get_fname()
with open(f'./result/{pred_name}.json', 'w') as f:
json.dump(preds, f, indent=4)
f.close()
with open(f'./result/{gold_name}.pkl', 'wb') as f:
pickle.dump(golds, f)
f.close()
def evaluate():
with open('pred.txt', 'r') as f:
preds = [x.strip() for x in f.readlines()]
with open('gold.txt', 'r') as f:
golds = [x.strip() for x in f.readlines()]
print("Accuracy", accuracy_score(golds, preds))
return accuracy_score(golds, preds)
def apply_code_template(example):
with open(f'./code-prompts/{args.style}' + '.py') as f:
template = f.read()
ret = []
question = example['question']
answer = example['answer']
if type(question) is list:
question = question[0]
if type(answer) is list:
answer = answer[0]
try:
supporting_facts = example['context']['sentences']
except:
supporting_facts = example['context'][0]['sentences']
supporting_facts = [[s.replace('"', "'") for s in supporting_facts[i]] for i in range(len(supporting_facts))]
if args.style == 'vanilla':
supporting_facts_vars = [f'input{str(i+2)} = "{" ".join(supporting_facts[i])}"' for i in range(len(supporting_facts))]
elif args.style in ['good_varname', 'comment']:
supporting_facts_vars = [f'supporting_fact{str(i+1)} = "{" ".join(supporting_facts[i])}"' for i in range(len(supporting_facts))]
elif args.style == 'class':
supporting_facts_vars = [f'\t"{" ".join(supporting_facts[i])}"' for i in range(len(supporting_facts))]
supporting_facts = '\n'.join(supporting_facts_vars)
for t in template.split('$'):
ret.append(t.replace('{question}', question.replace('"', "'")).replace('{supporting-documents}', supporting_facts).replace('{answer}', answer))
return ret
def get_fname():
if not args.style:
pred_name = f'{args.prompt}_{args.model}_pred_{args.context_size}_{args.seed}'
else:
pred_name = f'{args.prompt}_{args.style}_{args.model}_pred_{args.context_size}'
if not args.style:
gold_name = f'{args.prompt}_{args.model}_gold_{args.context_size}_{args.seed}'
else:
gold_name = f'{args.prompt}_{args.style}_{args.model}_gold_{args.context_size}'
return pred_name, gold_name
parser = argparse.ArgumentParser()
parser.add_argument('--prompt', type=str, help='Either text or code.')
parser.add_argument('--model', type=str, help='Either davinci, curie or codex.')
parser.add_argument('--context_size', type=int, help='Context window size of GPT3 model.')
parser.add_argument('--completion_size', type=int, help='completion (max_lens) size of GPT3 model.')
parser.add_argument('--style', type=str, help='choose style of code prompt from one of ["vanilla", "good_var_name", "with_comments", "class_obj"]')
parser.add_argument('--index', type=str, help='file name of the saved indices')
parser.add_argument('--seed', type=int, default=None, help='random seed')
#parser.add_argument('--dataset', type=str, help='Name of the datasset')
#parser.add_argument('--xxx', action='store_true', help='')
parser.add_argument('--key', type=str, help='The name of the OpenAI API key file.')
def compute_longest_prompt(val_idx, val_data, apply_template):
max_len = 0
for idx in tqdm(val_idx):
example = val_data[int(idx)]
input_text, output_text = apply_template(example)
cur_len = utils.gpt3_tokenizer(input_text + '\n\nAnswer:')
if cur_len > max_len:
max_len = cur_len
return max_len
if __name__ == '__main__':
args = parser.parse_args()
openai.api_key_path = f'../../_private/{args.key}.key'
if args.seed:
np.random.seed(args.seed)
random.seed(args.seed)
data_name = 'hotpot_qa'
dataset, templates = utils.load_data(data_name)
if args.prompt == "text":
apply_template = templates.apply
elif args.prompt == "code":
apply_template = apply_code_template
inference_model = HotpotQA(apply_template)
inference_model.predict(args.index)
inference_model.evaluate()
| [
"./code-prompts/comment_prefix.py",
"PLACEHOLDERPLACEHOLDER\n\n",
"None",
"./code-prompts/class_prefix.py",
"\n\n\n",
"\n\nAnswer: "
] |
2024-01-10 | zharry29/curious_code_prompts | datasets~wikihow_temporal~wikihow_temporal.py | import argparse
import openai
from datasets import load_dataset
import random
random.seed(29)
from promptsource.templates import DatasetTemplates
import time
from sklearn.metrics import accuracy_score
import csv
import pickle
from transformers import AutoTokenizer
tokenizer = AutoTokenizer.from_pretrained("gpt2")
import backoff
parser = argparse.ArgumentParser()
parser.add_argument('--prompt', default='text', type=str, help='Either text or code.')
parser.add_argument('--model', default='codex', type=str, help='Either davinci, curie or codex.')
parser.add_argument('--max_prompt', type=int, default=4000, help='Maximum number of tokens in the prompt.')
parser.add_argument('--key', default='harry', type=str, help='The name of the OpenAI API key file.')
parser.add_argument('--seed', default='', type=str, help='Random seed.')
args = parser.parse_args()
openai.api_key = open(f'../../_private/{args.key}.key').read()
if args.seed:
args.seed = '_' + args.seed
random.seed(int(args.seed[1:]))
def load_data():
dataset = {'train': [], 'test': []}
for split in ['train', 'test']:
with open(f'order_{split}.csv', encoding = "ISO-8859-1") as f:
reader = csv.DictReader(f)
for row in reader:
dataset[split].append(row)
return dataset
dataset = load_data()
def apply_text_template(example):
input_prompt = f"You are trying to {example['goal'].lower()}. You need to do two things:\n(a) {example['step0'].strip('.')}\n(b) {example['step1'].strip('.')}\nThe first thing to do is"
output_prompt = ['(a) ' + example['step0'].strip('.'), '(b) ' + example['step1'].strip('.')][int(example["label"])]
return input_prompt, output_prompt
def apply_code_template(example):
with open(args.prompt + '.py') as f:
template = f.read()
ret = []
for t in template.split('$'):
ret.append(t.replace("{step0}", example["step0"]).replace("{step1}", example["step1"]).replace("{goal}", example["goal"]).replace("{label_first}", str(example["label"])).replace("{label_after}", str(1-int(example["label"]))))
return ret
if args.prompt == "text":
apply_template = apply_text_template
elif args.prompt.startswith("code"):
apply_template = apply_code_template
def predict():
# Build prompt
def build_text_prompt(example):
inference_input_text = apply_template(example)[0]
text_prompt = ""
prev_prompt = ""
example_indices = random.sample(range(len(dataset['train'])), 100)
for example_index in example_indices:
if len(tokenizer(text_prompt + inference_input_text)['input_ids']) > args.max_prompt - 20:
break
example = dataset['train'][example_index]
input_text, output_text = apply_template(example)
prev_prompt = text_prompt
text_prompt += input_text + ' ' + output_text + '\n\n'
return(prev_prompt + inference_input_text)
def build_code_prompt(example):
inference_input_text = apply_template(example)[0]
text_prompt = ""
prev_prompt = ""
example_indices = random.sample(range(len(dataset['train'])), 100)
for example_index in example_indices:
if len(tokenizer(text_prompt + inference_input_text)['input_ids']) > args.max_prompt:
break
example = dataset['train'][example_index]
input_text, output_text = apply_template(example)
prev_prompt = text_prompt
text_prompt += input_text + output_text + '\n\n\n'
return(prev_prompt + inference_input_text)
@backoff.on_exception(backoff.expo, openai.error.RateLimitError)
def run_llm(prompt, model, temperature=0, stop=['\n']):
model_name = {
"davinci": "text-davinci-002",
"davinci003": "text-davinci-003",
"old_davinci": "davinci",
"curie": "text-curie-001",
"ada": "text-ada-001",
"codex": "code-davinci-002",
}
while True:
try:
ret = openai.Completion.create(
engine=model_name[model],
prompt=prompt,
temperature=temperature,
max_tokens=20,
top_p=1,
frequency_penalty=0,
presence_penalty=0,
stop=stop
)
break
except Exception as e:
print(e)
print("Retrying in 10 seconds")
time.sleep(10)
gen_text = ret["choices"][0]["text"].strip()#.split('\n')[0]
return gen_text
preds = []
golds = []
print("Total examples: ", len(dataset['test']))
count = 0
with open("sampled_1000_indices.pkl", "rb") as f:
indices = pickle.load(f)
for index in indices:
example = dataset['test'][index]
count += 1
print(count)
if args.prompt == "text":
prompt = build_text_prompt(example)
elif "code" in args.prompt:
prompt = build_code_prompt(example)
pred_text = run_llm(prompt, args.model)
#print(prompt)
#print(pred_text)
#print(len(tokenizer(prompt)['input_ids']))
if args.prompt == "text":
if '(b)' in pred_text:
pred = 1
else:
pred = 0
else:
if 'input1, input0' in pred_text:
pred = 1
else:
pred = 0
#print(pred)
#raise SystemExit
gold = int(example['label'])
preds.append(pred)
golds.append(gold)
with open(f'pred_{args.model}_{args.prompt}_{args.max_prompt}{args.seed}.txt', 'w') as f:
f.writelines([str(x) + '\n' for x in preds])
with open('gold.txt', 'w') as f:
f.writelines([str(x) + '\n' for x in golds])
def evaluate():
with open(f'pred_{args.model}_{args.prompt}_{args.max_prompt}{args.seed}.txt', 'r') as f:
preds = [x.strip() for x in f.readlines()]
with open('gold.txt', 'r') as f:
golds = [x.strip() for x in f.readlines()]
print("Accuracy", accuracy_score(golds, preds))
return "Accuracy", accuracy_score(golds, preds)
if __name__ == "__main__":
predict()
evaluate() | [
"(a) ",
"You are trying to placeholder. You need to do two things:\n(a) PLACEHOLDER\n(b) PLACEHOLDER\nThe first thing to do is",
"(b) ",
"PLACEHOLDER PLACEHOLDER\n\n",
"PLACEHOLDERPLACEHOLDER\n\n\n"
] |
2024-01-10 | zharry29/curious_code_prompts | datasets~xsum~xsum.py | import argparse
import openai
from datasets import load_dataset
import random
random.seed(29)
from promptsource.templates import DatasetTemplates
import time
from transformers import AutoTokenizer
from tqdm import tqdm
from rouge import FilesRouge
parser = argparse.ArgumentParser()
parser.add_argument('--prompt', required=True, type=str, help='Either text or code.')
parser.add_argument('--model', required=True, type=str, help='Either davinci, curie or codex.')
parser.add_argument('--max_prompt', type=int, default=4000, help='Maximum number of tokens in the prompt.')
parser.add_argument('--key', required=True, type=str, help='The name of the OpenAI API key file.')
args = parser.parse_args()
openai.api_key = open(f'../../_private/{args.key}.key').read()
SELECTED_PROMPT_NAME = "DOC_tldr"
MAX_RESPONSE_TOKENS = 50
rouge = FilesRouge()
template = DatasetTemplates("xsum")[SELECTED_PROMPT_NAME]
dataset = load_dataset("xsum", cache_dir="/nlp/data/huggingface_cache")
tokenizer = AutoTokenizer.from_pretrained("gpt2")
print(args.max_prompt)
def apply_code_template(example):
with open(args.prompt + '.py') as f:
template = f.read()
input = example["document"].replace('\n','')
template = template.replace("{article}", input).replace("{highlights}", example["summary"])
return template.split("<\split>")
def predict():
# Build prompt
def build_text_prompt(input_text):
len_input = len(tokenizer(input_text)['input_ids'])
text_prompt = ""
max_len = args.max_prompt - MAX_RESPONSE_TOKENS - len_input
sampled_indices = []
while True:
index = random.choice(range(len(dataset['train'])))
while index in sampled_indices:
index = random.choice(range(len(dataset['train'])))
sampled_indices.append(index)
example = dataset['train'][index]
input_text, output_text = template.apply(example)
new_prompt = text_prompt + input_text + ' ' + output_text + '\n\n\n'
if len(tokenizer(new_prompt)['input_ids']) > max_len - 50:
break
text_prompt = new_prompt
return text_prompt, sampled_indices
def build_code_prompt(model, input_text):
len_input = len(tokenizer(input_text)['input_ids'])
code_prompt = ""
max_len = args.max_prompt - MAX_RESPONSE_TOKENS - len_input
sampled_indices = []
while True:
index = random.choice(range(len(dataset['train'])))
while index in sampled_indices:
index = random.choice(range(len(dataset['train'])))
sampled_indices.append(index)
example = dataset['train'][index]
input_text, output_text = apply_code_template(example)
new_prompt = code_prompt + input_text + output_text + '\n\n'
if len(tokenizer(new_prompt)['input_ids']) > max_len - 50:
break
code_prompt = new_prompt
return code_prompt, sampled_indices
def run_llm(prompt, model, stop=['\n\n\n']):
model_name = {
"davinci": "text-davinci-002",
"davinciOld": "davinci",
"davinci3": "text-davinci-003",
"curie": "text-curie-001",
"ada": "text-ada-001",
"codex": "code-davinci-002",
}
while True:
try:
ret = openai.Completion.create(
engine=model_name[model],
prompt=prompt,
temperature=0.7,
max_tokens=MAX_RESPONSE_TOKENS,
top_p=1,
frequency_penalty=0,
presence_penalty=0,
stop=stop
)
break
except Exception as e:
print(e)
print("Retrying in 10 seconds")
time.sleep(10)
gen_text = ret["choices"][0]["text"].strip()#.split('\n')[0]
return gen_text
preds = []
golds = []
full_indices = []
f = open("sampled_1000_indices.txt", "r")
example_indices = [int(s.strip()) for s in f.readlines()]
for index in tqdm(example_indices):
example = dataset['validation'][index]
if args.prompt == "text":
input_text, _ = template.apply(example)
prompt, indices = build_text_prompt(args.model, input_text)
pred = run_llm(prompt + input_text, args.model)
elif args.prompt.startswith("code"):
input_text, _ = apply_code_template(example)
if len(tokenizer(input_text)['input_ids']) > args.max_prompt - MAX_RESPONSE_TOKENS:
preds.append("")
golds.append(example["summary"])
full_indices.append("")
continue
prompt, indices = build_code_prompt(args.model, input_text)
pred = run_llm(prompt + input_text, args.model)
gold = example["summary"]
preds.append(pred)
golds.append(gold)
full_indices.append(indices)
with open(f'pred-{args.model}-{args.max_prompt}-{args.prompt}.txt', 'w') as f:
f.writelines([x.strip('\"').replace('\n', ' ') + '\n' for x in preds])
with open(f'gold-{args.model}-{args.max_prompt}-{args.prompt}.txt', 'w') as f:
f.writelines([x.replace('\n', ' ') + '\n' for x in golds])
with open(f'indices-{args.model}-{args.max_prompt}-{args.prompt}.txt', 'w') as f:
f.writelines([str(x) + '\n' for x in full_indices])
def evaluate():
scores = rouge.get_scores(f'pred-{args.model}-{args.max_prompt}-{args.prompt}.txt',f'gold-{args.model}-{args.max_prompt}-{args.prompt}.txt',avg=True) #TODO: Double check that this is correct/makes sense
print("Rouge Score", scores)
return "Rouge", scores
if __name__ == "__main__":
predict()
evaluate() | [
"{highlights}",
"PLACEHOLDERPLACEHOLDER PLACEHOLDER\n\n\n",
"DOC_tldr",
"PLACEHOLDERPLACEHOLDERPLACEHOLDER\n\n"
] |
2024-01-10 | zharry29/curious_code_prompts | datasets~mmlu~mmlu.py | import argparse
import openai
import os
import numpy as np
import pandas as pd
import time
from crop import crop
choices = ["A", "B", "C", "D"]
def softmax(x):
z = x - max(x)
numerator = np.exp(z)
denominator = np.sum(numerator)
softmax = numerator/denominator
return softmax
def format_subject(subject):
l = subject.split("_")
s = ""
for entry in l:
s += " " + entry
return s
def format_example(df, idx, include_answer=True):
# print("Index " + str(idx))
# print("DF len " + str(len(df)))
prompt = df.iloc[idx, 0]
k = df.shape[1] - 2
for j in range(k):
prompt += "\n{}. {}".format(choices[j], df.iloc[idx, j+1])
prompt += "\nAnswer:"
if include_answer:
prompt += " {}\n\n".format(df.iloc[idx, k + 1])
return prompt
def gen_text_prompt(train_df, subject, k=-1):
prompt = "The following are multiple choice questions (with answers) about {}.\n\n".format(format_subject(subject))
if k == -1:
k = train_df.shape[0]
for i in range(k):
#print("I am in generating text prompt on train df")
prompt += format_example(train_df, i)
return prompt
def gen_prompt(args, train_df, subject, k=-1):
if args.prompt == 'text':
return gen_text_prompt(train_df, subject, k)
if args.prompt == 'code':
print("Code prompt not implemented! - Using text prompt")
return gen_text_prompt(train_df, subject, k)
def eval(args, subject, engine, dev_df, test_df):
cors = []
all_probs = []
answers = choices[:test_df.shape[1]-2]
for i in range(test_df.shape[0]):
# get prompt and make sure it fits
k = args.ntrain
#print("I am in generating text prompt on test df")
prompt_end = format_example(test_df, i, include_answer=False)
train_prompt = gen_prompt(args, dev_df, subject, k)
prompt = train_prompt + prompt_end
while crop(prompt) != prompt:
k -= 1
train_prompt = gen_prompt(args, dev_df, subject, k)
prompt = train_prompt + prompt_end
label = test_df.iloc[i, test_df.shape[1]-1]
#print(k)
while True:
try:
c = openai.Completion.create(
engine=engine,
prompt=prompt,
max_tokens=1,
logprobs=100,
temperature=0,
echo=True
)
break
except:
print("pausing")
time.sleep(1)
continue
lprobs = []
for ans in answers:
try:
lprobs.append(c["choices"][0]["logprobs"]["top_logprobs"][-1][" {}".format(ans)])
except:
print("Warning: {} not found. Artificially adding log prob of -100.".format(ans))
lprobs.append(-100)
pred = {0: "A", 1: "B", 2: "C", 3: "D"}[np.argmax(lprobs)]
probs = softmax(np.array(lprobs))
cor = pred == label
cors.append(cor)
all_probs.append(probs)
acc = np.mean(cors)
cors = np.array(cors)
all_probs = np.array(all_probs)
print("Average accuracy {:.3f} - {}".format(acc, subject))
return cors, acc, all_probs
def main(args):
if not os.path.exists(args.data_dir):
print("No data found -- Downloading dataset")
import wget, tarfile
os.mkdir(args.data_dir)
wget.download("https://people.eecs.berkeley.edu/~hendrycks/data.tar", "data.tar")
data = tarfile.open('data.tar')
data.extractall(args.data_dir)
data.close()
os.remove('data.tar')
args.data_dir += '/data'
engines = args.model
subjects = sorted([f.split("_test.csv")[0] for f in os.listdir(os.path.join(args.data_dir, "test")) if "_test.csv" in f])
if not os.path.exists(args.save_dir):
os.mkdir(args.save_dir)
for engine in engines:
if not os.path.exists(os.path.join(args.save_dir, "results_{}".format(engine))):
os.mkdir(os.path.join(args.save_dir, "results_{}".format(engine)))
print(subjects)
print(args)
for engine in engines:
print(engine)
all_cors = []
for subject in subjects:
dev_df = pd.read_csv(os.path.join(args.data_dir, "dev", subject + "_dev.csv"), header=None)
val_df = pd.read_csv(os.path.join(args.data_dir, "val", subject + "_val.csv"), header=None)
dev_df = pd.concat([dev_df, val_df])
test_df = pd.read_csv(os.path.join(args.data_dir, "test", subject + "_test.csv"), header=None)
cors, acc, probs = eval(args, subject, engine, dev_df, test_df)
all_cors.append(cors)
test_df["{}_correct".format(engine)] = cors
for j in range(probs.shape[1]):
choice = choices[j]
test_df["{}_choice{}_probs".format(engine, choice)] = probs[:, j]
test_df.to_csv(os.path.join(args.save_dir, "results_{}".format(engine), "{}.csv".format(subject)), index=None)
weighted_acc = np.mean(np.concatenate(all_cors))
print("Average accuracy: {:.3f}".format(weighted_acc))
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument("--ntrain", "-k", type=int, default=5)
parser.add_argument("--data_dir", "-d", type=str, default="data")
parser.add_argument("--save_dir", "-s", type=str, default="results")
parser.add_argument("--model", "-e", choices=["davinci", "curie", "babbage", "ada"],
default=["davinci", "curie", "babbage", "ada"], nargs="+")
parser.add_argument('--prompt', required=True, type=str, help='Either text or code.')
parser.add_argument('--key', required=True, type=str, help='The name of the OpenAI API key file.')
args = parser.parse_args()
openai.api_key = open(f'../../_private/{args.key}.key').read()
main(args) | [
"\n{}. {}",
"PLACEHOLDERPLACEHOLDER",
"\nAnswer:",
"The following are multiple choice questions (with answers) about {}.\n\n",
" {}\n\n"
] |
2024-01-10 | zharry29/curious_code_prompts | datasets~squad~squad.py | import argparse
import openai
from datasets import load_dataset
import random
random.seed(29)
from promptsource.templates import DatasetTemplates
import time
from transformers import AutoTokenizer
from tqdm import tqdm
parser = argparse.ArgumentParser()
parser.add_argument('--prompt', required=True, type=str, help='Either text or code.')
parser.add_argument('--model', required=True, type=str, help='Either davinci, curie or codex.')
parser.add_argument('--max_prompt', type=int, default=4000, help='Maximum number of tokens in the prompt.')
parser.add_argument('--key', required=True, type=str, help='The name of the OpenAI API key file.')
args = parser.parse_args()
openai.api_key = open(f'../../_private/{args.key}.key').read()
SELECTED_PROMPT_NAME = "Questions with Context +unanswerable"
MAX_RESPONSE_TOKENS = 300
template = DatasetTemplates("squad_v2")[SELECTED_PROMPT_NAME]
dataset = load_dataset("squad_v2", cache_dir="/nlp/data/huggingface_cache")
tokenizer = AutoTokenizer.from_pretrained("gpt2")
def apply_code_template(example):
with open(args.prompt + '.py') as f:
template = f.read()
answer = example["answers"]["text"][0] if len(example["answers"]["text"]) > 0 else "unanswerable"
template = template.replace("{context}", example["context"]).replace("{question}", example["question"]).replace("{answer}", answer)
return template.split("<\split>")
def predict():
# Build prompt
def build_text_prompt(model, input_text):
len_input = len(tokenizer(input_text)['input_ids'])
text_prompt = ""
max_len = args.max_prompt - MAX_RESPONSE_TOKENS - len_input
sampled_indices = []
while True:
index = random.choice(range(len(dataset['train'])))
while index in sampled_indices:
index = random.choice(range(len(dataset['train'])))
sampled_indices.append(index)
example = dataset['train'][index]
input_text, output_text = template.apply(example)
new_prompt = text_prompt + input_text + ' ' + output_text + '\n\n'
if len(tokenizer(new_prompt)['input_ids']) > max_len:
break
text_prompt = new_prompt
return text_prompt, sampled_indices
def build_code_prompt(model, input_text):
len_input = len(tokenizer(input_text)['input_ids'])
code_prompt = ""
max_len = args.max_prompt - MAX_RESPONSE_TOKENS - len_input
sampled_indices = []
while True:
index = random.choice(range(len(dataset['train'])))
while index in sampled_indices:
index = random.choice(range(len(dataset['train'])))
sampled_indices.append(index)
example = dataset['train'][index]
input_text, output_text = apply_code_template(example)
new_prompt = code_prompt + input_text + output_text + '\n\n'
if len(tokenizer(new_prompt)['input_ids']) > max_len - 20:
break
code_prompt = new_prompt
return code_prompt, sampled_indices
def run_llm(prompt, model, temperature=0, stop=['\n']):
model_name = {
"davinciOld": "davinci",
"davinci": "text-davinci-002",
"davinci3": "text-davinci-003",
"curie": "text-curie-001",
"ada": "text-ada-001",
"codex": "code-davinci-002",
}
while True:
try:
ret = openai.Completion.create(
engine=model_name[model],
prompt=prompt,
temperature=temperature,
max_tokens=MAX_RESPONSE_TOKENS,
top_p=1,
frequency_penalty=0,
presence_penalty=0,
stop=stop
)
break
except Exception as e:
print(e)
print("Retrying in 10 seconds")
time.sleep(10)
gen_text = ret["choices"][0]["text"].strip()#.split('\n')[0]
return gen_text
preds = []
golds = []
full_indices = []
f = open("sampled_1000_indices.txt", "r")
example_indices = [int(s.strip()) for s in f.readlines()]
for index in tqdm(example_indices):
example = dataset['validation'][index]
if args.prompt == "text":
input_text, _ = template.apply(example)
prompt, indices = build_text_prompt(args.model, input_text)
pred = run_llm(prompt + input_text, args.model)
elif args.prompt.startswith("code"):
input_text, _ = apply_code_template(example)
prompt, indices = build_code_prompt(args.model, input_text)
pred = run_llm(prompt + input_text, args.model)
gold = example["answers"]["text"]
pred = normalize_text(pred)
preds.append(pred if pred != 'unanswerable' else '')
golds.append(gold if len(gold) > 0 else [''])
full_indices.append(indices)
with open(f'pred-{args.model}-{args.max_prompt}-{args.prompt}.txt', 'w') as f:
f.writelines([str(x) + '\n' for x in preds])
with open(f'gold-{args.model}-{args.max_prompt}-{args.prompt}.txt', 'w') as f:
f.writelines([str(x) + '\n' for x in golds])
with open(f'indices-{args.model}-{args.max_prompt}-{args.prompt}.txt', 'w') as f:
f.writelines([str(x) + '\n' for x in full_indices])
def normalize_text(s):
"""Removing articles and punctuation, and standardizing whitespace are all typical text processing steps."""
import string, re
def remove_articles(text):
regex = re.compile(r"\b(a|an|the)\b", re.UNICODE)
return re.sub(regex, " ", text)
def white_space_fix(text):
return " ".join(text.split())
def remove_punc(text):
exclude = set(string.punctuation)
return "".join(ch for ch in text if ch not in exclude)
def lower(text):
return text.lower()
return white_space_fix(remove_articles(remove_punc(lower(s))))
def compute_exact_match(prediction, truth):
return int(normalize_text(prediction) == normalize_text(truth))
def compute_f1(prediction, truth):
pred_tokens = normalize_text(prediction).split()
truth_tokens = normalize_text(truth).split()
# if either the prediction or the truth is no-answer then f1 = 1 if they agree, 0 otherwise
if len(pred_tokens) == 0 or len(truth_tokens) == 0:
return int(pred_tokens == truth_tokens)
common_tokens = set(pred_tokens) & set(truth_tokens)
# if there are no common tokens then f1 = 0
if len(common_tokens) == 0:
return 0
prec = len(common_tokens) / len(pred_tokens)
rec = len(common_tokens) / len(truth_tokens)
return 2 * (prec * rec) / (prec + rec)
def evaluate():
with open(f'pred-{args.model}-{args.max_prompt}-{args.prompt}.txt', 'r') as f:
preds = [x.strip() for x in f.readlines()]
with open(f'gold-{args.model}-{args.max_prompt}-{args.prompt}.txt', 'r') as f:
golds = [eval(x.strip()) for x in f.readlines()]
em_scores = []
f1_scores = []
for pred, gold in zip(preds,golds):
em = max((compute_exact_match(pred, answer)) for answer in gold)
f1 = max((compute_f1(pred, answer)) for answer in gold)
em_scores.append(em)
f1_scores.append(f1)
em = sum(em_scores) / len(em_scores)
f1 = sum(f1_scores) / len(f1_scores) #TODO: Double check that this is the right way to report this
print("EM", em)
print("F1", f1)
return em, f1
if __name__ == "__main__":
predict()
evaluate() | [
"{context}",
"{answer}",
"PLACEHOLDERPLACEHOLDER PLACEHOLDER\n\n",
"question",
"PLACEHOLDERPLACEHOLDERPLACEHOLDER\n\n",
"Questions with Context +unanswerable",
"context",
"{question}"
] |
2024-01-10 | zharry29/curious_code_prompts | datasets~wikihow_goal_step~wikihow_goal_step.py | import argparse
import openai
from datasets import load_dataset
import random
random.seed(29)
from promptsource.templates import DatasetTemplates
import time
from sklearn.metrics import accuracy_score
import csv
import pickle
from transformers import AutoTokenizer
tokenizer = AutoTokenizer.from_pretrained("gpt2")
import backoff
parser = argparse.ArgumentParser()
parser.add_argument('--prompt', default='text', type=str, help='Either text or code.')
parser.add_argument('--model', default='codex', type=str, help='Either davinci, curie or codex.')
parser.add_argument('--max_prompt', type=int, default=4000, help='Maximum number of tokens in the prompt.')
parser.add_argument('--key', default='harry', type=str, help='The name of the OpenAI API key file.')
parser.add_argument('--seed', default='', type=str, help='Random seed.')
args = parser.parse_args()
openai.api_key = open(f'../../_private/{args.key}.key').read()
if args.seed:
args.seed = '_' + args.seed
random.seed(int(args.seed[1:]))
def load_data():
dataset = {'train': [], 'test': []}
for split in ['train', 'test']:
with open(f'goal_{split}.csv', encoding = "ISO-8859-1") as f:
reader = csv.DictReader(f)
for row in reader:
dataset[split].append(row)
return dataset
dataset = load_data()
def apply_text_template(example):
input_prompt = f"Given an action: {example['step'].strip('.')}\nWhat is the most likely goal of that action?\n(a) {example['goal0']}\n(b) {example['goal1']}\n(c) {example['goal2']}\n(d) {example['goal3']}\nThe most likely goal is: "
output_prompt = ['(a)', '(b)', '(c)', '(d)'][int(example['label'])] + ' ' + example[f"goal{example['label']}"]
return input_prompt, output_prompt
def apply_code_template(example):
with open(args.prompt + '.py') as f:
template = f.read()
ret = []
for t in template.split('$'):
ret.append(t.replace("{step}", example["step"]).replace("{goal0}", example["goal0"]).replace("{goal1}", example["goal1"]).replace("{goal2}", example["goal2"]).replace("{goal3}", example["goal3"]).replace("{label}", str(example["label"])))
return ret
if args.prompt == "text":
apply_template = apply_text_template
elif args.prompt.startswith("code"):
apply_template = apply_code_template
def predict():
# Build prompt
def build_text_prompt(example):
inference_input_text = apply_template(example)[0]
text_prompt = ""
prev_prompt = ""
example_indices = random.sample(range(len(dataset['train'])), 100)
for example_index in example_indices:
if len(tokenizer(text_prompt + inference_input_text)['input_ids']) > args.max_prompt - 20:
break
example = dataset['train'][example_index]
input_text, output_text = apply_template(example)
prev_prompt = text_prompt
text_prompt += input_text + ' ' + output_text + '\n\n'
return(prev_prompt + inference_input_text)
def build_code_prompt(example):
inference_input_text = apply_template(example)[0]
text_prompt = ""
prev_prompt = ""
example_indices = random.sample(range(len(dataset['train'])), 100)
for example_index in example_indices:
if len(tokenizer(text_prompt + inference_input_text)['input_ids']) > args.max_prompt:
break
example = dataset['train'][example_index]
input_text, output_text = apply_template(example)
prev_prompt = text_prompt
text_prompt += input_text + output_text + '\n\n\n'
return(prev_prompt + inference_input_text)
@backoff.on_exception(backoff.expo, openai.error.RateLimitError)
def run_llm(prompt, model, temperature=0, stop=['\n']):
model_name = {
"davinci": "text-davinci-002",
"davinci003": "text-davinci-003",
"old_davinci": "davinci",
"curie": "text-curie-001",
"ada": "text-ada-001",
"codex": "code-davinci-002",
}
while True:
try:
ret = openai.Completion.create(
engine=model_name[model],
prompt=prompt,
temperature=temperature,
max_tokens=20,
top_p=1,
frequency_penalty=0,
presence_penalty=0,
stop=stop
)
break
except Exception as e:
print(e)
print("Retrying in 10 seconds")
time.sleep(10)
gen_text = ret["choices"][0]["text"].strip()#.split('\n')[0]
return gen_text
preds = []
golds = []
print("Total examples: ", len(dataset['test']))
count = 0
with open("sampled_1000_indices.pkl", "rb") as f:
indices = pickle.load(f)
for index in indices:
example = dataset['test'][index]
count += 1
print(count)
if args.prompt == "text":
prompt = build_text_prompt(example)
elif "code" in args.prompt:
prompt = build_code_prompt(example)
pred_text = run_llm(prompt, args.model)
if args.prompt == "text":
if '(b)' in pred_text:
pred = 1
else:
pred = 0
else:
pred = int(pred_text.strip()[0])
#print(prompt)
#print(pred_text)
#print(len(tokenizer(prompt)['input_ids']))
#raise SystemExit
gold = int(example['label'])
preds.append(pred)
golds.append(gold)
with open(f'pred_{args.model}_{args.prompt}_{args.max_prompt}{args.seed}.txt', 'w') as f:
f.writelines([str(x) + '\n' for x in preds])
with open('gold.txt', 'w') as f:
f.writelines([str(x) + '\n' for x in golds])
def evaluate():
with open(f'pred_{args.model}_{args.prompt}_{args.max_prompt}{args.seed}.txt', 'r') as f:
preds = [x.strip() for x in f.readlines()]
with open('gold.txt', 'r') as f:
golds = [x.strip() for x in f.readlines()]
print("Accuracy", accuracy_score(golds, preds))
return "Accuracy", accuracy_score(golds, preds)
if __name__ == "__main__":
predict()
evaluate() | [
"Given an action: PLACEHOLDER\nWhat is the most likely goal of that action?\n(a) PLACEHOLDER\n(b) PLACEHOLDER\n(c) PLACEHOLDER\n(d) PLACEHOLDER\nThe most likely goal is: ",
"PLACEHOLDER PLACEHOLDER\n\n",
" ",
"goalPLACEHOLDER",
"PLACEHOLDERPLACEHOLDER\n\n\n"
] |
2024-01-10 | zharry29/curious_code_prompts | datasets~OpenPI-v2~openpi.py | import re
import ast
import json
import time
import utils
import pickle
import random
import openai
import argparse
import numpy as np
from tqdm import tqdm
from datasets import load_dataset
from sklearn.metrics import accuracy_score
class OpenPI():
def __init__(self, metadata, apply_template):
self.metadata = metadata
self.apply_template = apply_template
def build_text_prompt(self, max_len):
train_dict = self.metadata['train']
prompt = ''
cur_len = 0
counter = 0
while cur_len + max_len <= args.context_size:
cur_idx = str(np.random.choice(len(train_dict), 1, replace=False)[0])
event_dict = train_dict[cur_idx]
goal = event_dict['goal']
steps = event_dict['steps']
cur_prompt = apply_template(goal, steps)
cur_len += utils.gpt3_tokenizer(cur_prompt)
prompt += cur_prompt
counter += 1
print(f'Total samples in prompt: {counter}')
print(f'Average tokens per sample: {cur_len / counter}')
return prompt
def build_code_prompt(self, max_len):
train_dict = self.metadata['train']
prompt = ''
cur_len = 0
for event_dict in train_dict.values():
goal = event_dict['goal']
steps = event_dict['steps']
cur_prompt = apply_template(goal, steps)
cur_prompt = [' '.join(lst) for lst in cur_prompt]
for sub_prompt in cur_prompt:
cur_len += utils.gpt3_tokenizer(sub_prompt)
if cur_len + max_len > args.context_size:
break
else:
prompt += sub_prompt + '\n\n'
return prompt
def run_llm(self, prompt, model, temperature=0.7, stop=['\n\n']):
model_name = {
"davinci": "text-davinci-002",
"davinci003": "text-davinci-003",
"davinci-old": "davinci",
"curie": "text-curie-001",
"codex": "code-davinci-002",
"ada": "text-ada-001"
}
while True:
try:
ret = openai.Completion.create(
engine=model_name[model],
prompt=prompt,
temperature=temperature,
max_tokens=300,
top_p=1,
frequency_penalty=0,
presence_penalty=0,
stop=stop
)
break
except Exception as e:
print(e)
print("Retrying in 10 seconds")
time.sleep(10)
gen_text = ret["choices"][0]["text"].strip()#.split('\n')[0]
return gen_text
def predict(self):
pred_name, gold_name = get_fname()
val_data = self.metadata['test']
max_len = compute_longest_prompt(val_data, self.apply_template)
print(max_len)
if args.prompt == "text":
prompt = self.build_text_prompt(max_len)
elif args.prompt == "code":
if args.style == 'comment':
prompt = open(f'./code-prompts/comment_prefix.py').read()
elif args.style == 'class':
prompt = open(f'./code-prompts/class_prefix.py').read()
else:
prompt = ''
prompt += self.build_code_prompt(max_len)
preds = []
golds = []
for id, example in tqdm(val_data.items(), position=0, leave=False):
goal = example['goal']
steps = example['steps']
if args.prompt == 'text':
cur_prompt = prompt + f'Goal: {goal}\n\n'
for i, step in enumerate(tqdm(steps, position=1, leave=False)):
step_state_changes = step['state_changes']
step_desc = step['description']
cur_prompt += f'Step {i+1}: {step_desc}\n\n'
cur_prompt += f'Entity status changes:\n'
llm_pred = self.run_llm(cur_prompt, args.model, stop='\n\n')
llm_pred = utils.parse_preds(llm_pred)
if len(llm_pred) == 0:
llm_pred.append('There will be no change.')
for line in llm_pred:
# entries = re.match(r'The (.*) is (.*) before and (.*) afterwards.', line)
# print((entries.group(1), entries.group(2), entries.group(3)))
cur_prompt += '- ' + line.strip() + '\n'
cur_prompt += '\n'
preds.append({'id': f'{str(id)}||{str(i+1)}', 'answers': llm_pred})
state_change_lst = []
if step_state_changes:
for state_change in step_state_changes:
entity, attr, pre, post = state_change
state_change_lst.append(f'The {attr.split("|")[0].strip()}) of ({entity.split("|")[0].strip()}) is ({pre.split("|")[0].strip()}) before and ({post.split("|")[0].strip()}) afterwards.')
golds.append({'id': f'{str(id)}||{str(i+1)}', 'answers': state_change_lst})
elif args.prompt == 'code':
cur_template = apply_template(goal, steps)
prompt_template = [lst[0] for lst in cur_template]
cur_gold = [ast.literal_eval(lst[1].strip()) for lst in cur_template]
for i, step_prompt in enumerate(tqdm(prompt_template, position=1, leave=False)):
cur_prompt = prompt + step_prompt
llm_pred = self.run_llm(cur_prompt, args.model, stop='\n\n').strip()
print(llm_pred[-1])
if llm_pred[-1] in ["'", '"']:
llm_pred += ']'
try:
llm_pred = ast.literal_eval(llm_pred)
except:
llm_pred = ','.join(llm_pred.split(',')[:-1]) + ']'
try:
llm_pred = ast.literal_eval(llm_pred)
except:
llm_pred = []
if len(llm_pred) == 0:
llm_pred.append('There will be no change.')
preds.append({'id': f'{str(id)}||{str(i+1)}', 'answers': llm_pred})
golds += [{'id': f'{str(id)}||{str(i+1)}', 'answers': g} for i, g in enumerate(cur_gold)]
with open(f'./result/test_{pred_name}.jsonl', 'w') as f:
for d in preds:
json.dump(d, f)
f.write('\n')
with open(f'./result/test_{gold_name}.jsonl', 'w') as f:
for d in golds:
json.dump(d, f)
f.write('\n')
def apply_text_template(goal, steps, train=True):
prompt = f'Goal: {goal}\n\n'
step_prompts = []
for i, step in enumerate(steps):
cur_prompt = ''
step_state_changes = step['state_changes']
step_desc = step['description']
cur_prompt += f'Step {i+1}: {step_desc}\n\n'
cur_prompt += f'Entity status changes:\n'
if train:
if step_state_changes:
for state_change in step_state_changes:
entity, attr, pre, post = state_change
if '|' in entity:
entity = utils.choose_openpi_options(entity)
if '|' in attr:
attr = utils.choose_openpi_options(attr)
if '|' in pre:
pre = utils.choose_openpi_options(pre)
if '|' in post:
post = utils.choose_openpi_options(post)
cur_prompt += f'- The {attr} of {entity} is {pre} before and {post} afterwards.\n'
# cur_prompt += '\n'
else:
cur_prompt += '- There will be no change.\n'
step_prompts.append(cur_prompt)
if train:
prompt += '\n'.join(step_prompts)
else:
prompt = step_prompts
return prompt + '\n'
def apply_code_template(goal, steps):
with open(f'./code-prompts/{args.style}' + '.py') as f:
template = f.read()
f.close()
contexts = ['start.']
cur_steps = []
cur_states = []
for i, step in enumerate(steps):
step_state_changes = step['state_changes']
if step_state_changes:
for state_change in step_state_changes:
entity, attr, pre, post = state_change
if '|' in entity:
entity = utils.choose_openpi_options(entity)
if '|' in attr:
attr = utils.choose_openpi_options(attr)
if '|' in pre:
pre = utils.choose_openpi_options(pre)
if '|' in post:
post = utils.choose_openpi_options(post)
cur_states.append(f'the {attr} of {entity} is {pre} before and {post} afterwards.')
# cur_prompt += '\n'
else:
cur_states.append('there will be no change.\n')
cur_steps.append(step['description'])
contexts.append(contexts[-1] + ' ' + cur_steps[-1].lower())
all_prompts = []
for context, cur_step in zip(contexts, cur_steps):
ret = []
for t in template.split('$'):
ret.append(t.replace("{goal}", goal).replace("{context}", context).replace("{current_step}", cur_step).replace("{answer}", str(cur_states)))
all_prompts.append(ret)
return all_prompts
def compute_longest_prompt(val_data, apply_template):
max_len = 0
for key, val in tqdm(val_data.items()):
goal = val['goal']
steps = val['steps']
cur_prompt = apply_template(goal, steps)
if args.prompt == 'code':
cur_prompt = [' '.join(lst) for lst in cur_prompt]
for sub_prompt in cur_prompt:
cur_len = utils.gpt3_tokenizer(sub_prompt + '\n\nAnswer:')
if cur_len > max_len:
max_len = cur_len
else:
cur_len = utils.gpt3_tokenizer(cur_prompt + '\n\nAnswer:')
if cur_len > max_len:
max_len = cur_len
return max_len
def get_fname():
if not args.style:
pred_name = f'{args.prompt}_{args.model}_pred_{args.context_size}_{args.seed}'
else:
pred_name = f'{args.prompt}_{args.style}_{args.model}_pred_{args.context_size}'
if not args.style:
gold_name = f'{args.prompt}_{args.model}_gold_{args.context_size}_{args.seed}'
else:
gold_name = f'{args.prompt}_{args.style}_{args.model}_gold_{args.context_size}'
return pred_name, gold_name
parser = argparse.ArgumentParser()
parser.add_argument('--prompt', type=str, help='Either text or code.')
parser.add_argument('--model', type=str, help='Either davinci, curie or codex.')
parser.add_argument('--data_path', type=str, help='Path to the folder that stores parsed OpenPI datasets.')
parser.add_argument('--style', type=str, help='choose style of code prompt from one of ["vanilla", "good_var_name", "with_comments", "class_obj"]')
parser.add_argument('--context_size', type=int, help='token threshold for GPT3 context prompt.')
parser.add_argument('--completion_size', type=int, help='token threshold for GPT3 completion.')
parser.add_argument('--seed', type=int, default=None, help='random seed')
#parser.add_argument('--dataset', type=str, help='Name of the datasset')
#parser.add_argument('--xxx', action='store_true', help='')
parser.add_argument('--key', type=str, help='The name of the OpenAI API key file.')
if __name__ == '__main__':
args = parser.parse_args()
if args.seed:
random.seed(args.seed)
np.random.seed(args.seed)
openai.api_key_path = f'../../_private/{args.key}.key'
data_name = 'anli'
NUM_EXAMPLES_IN_PROMPT = 2
meta_data = utils.load_meta_data(args.data_path)
if args.prompt == "text":
apply_template = apply_text_template
elif args.prompt == "code":
apply_template = apply_code_template
inference_model = OpenPI(meta_data, apply_template)
inference_model.predict()
| [
"./code-prompts/comment_prefix.py",
"\n",
"[]",
"PLACEHOLDER\n\n",
"- The PLACEHOLDER of PLACEHOLDER is PLACEHOLDER before and PLACEHOLDER afterwards.\n",
"PLACEHOLDERPLACEHOLDER",
"PLACEHOLDERGoal: PLACEHOLDER\n\n",
"./code-prompts/class_prefix.py",
"['P L A C E H O L D E R']",
"Goal: PLACEHOLDER\n\n",
"Entity status changes:\n",
"- ",
"2",
"- There will be no change.\n",
"['P']"
] |
2024-01-10 | zharry29/curious_code_prompts | datasets~HellaSWAG~hellaswag.py | import argparse
import openai
from datasets import load_dataset
import random
random.seed(29)
from promptsource.templates import DatasetTemplates
import time
from sklearn.metrics import accuracy_score
import pickle
from transformers import AutoTokenizer
tokenizer = AutoTokenizer.from_pretrained("gpt2")
import backoff
parser = argparse.ArgumentParser()
parser.add_argument('--prompt', default='text', type=str, help='Either text or code.')
parser.add_argument('--model', default='codex', type=str, help='Either davinci, curie or codex.')
parser.add_argument('--max_prompt', type=int, default=4000, help='Maximum number of tokens in the prompt.')
parser.add_argument('--key', default='harry', type=str, help='The name of the OpenAI API key file.')
parser.add_argument('--seed', default='', type=str, help='Random seed.')
args = parser.parse_args()
openai.api_key = open(f'../../_private/{args.key}.key').read()
if args.seed:
random.seed(int(args.seed[1:]))
SELECTED_PROMPT_NAME = "how_ends"
template = DatasetTemplates('hellaswag')[SELECTED_PROMPT_NAME]
dataset = load_dataset("hellaswag")
def apply_code_template(example):
with open(args.prompt + '.py') as f:
template = f.read()
ret = []
for t in template.split('$'):
ret.append(t.replace("{ctx}", example["ctx"]).replace("{ending0}", example["endings"][0]).replace("{ending1}", example["endings"][1]).replace("{ending2}", example["endings"][2]).replace("{ending3}", example["endings"][3]).replace("{label}", example["label"]))
return ret
if args.prompt == "text":
apply_template = template.apply
elif args.prompt.startswith("code"):
apply_template = apply_code_template
def predict():
# Build prompt
def build_text_prompt(example):
inference_input_text = apply_template(example)[0]
text_prompt = ""
prev_prompt = ""
example_indices = random.sample(range(len(dataset['train'])), 100)
for example_index in example_indices:
if len(tokenizer(text_prompt + inference_input_text + '\n\nAnswer: Ending')['input_ids']) > args.max_prompt - 20:
break
example = dataset['train'][example_index]
input_text, output_text = apply_template(example)
prev_prompt = text_prompt
text_prompt += input_text + '\n\nAnswer: ' + output_text + '\n\n\n'
return(prev_prompt + inference_input_text + '\n\nAnswer: Ending')
def build_code_prompt(example):
inference_input_text = apply_template(example)[0]
text_prompt = ""
prev_prompt = ""
example_indices = random.sample(range(len(dataset['train'])), 100)
for example_index in example_indices:
if len(tokenizer(text_prompt + inference_input_text)['input_ids']) > args.max_prompt:
break
example = dataset['train'][example_index]
input_text, output_text = apply_template(example)
prev_prompt = text_prompt
text_prompt += input_text + output_text + '\n\n\n'
return(prev_prompt + inference_input_text)
@backoff.on_exception(backoff.expo, openai.error.RateLimitError)
def run_llm(prompt, model, temperature=0, stop=['\n']):
model_name = {
"davinci": "text-davinci-002",
"davinci003": "text-davinci-003",
"old_davinci": "davinci",
"curie": "text-curie-001",
"ada": "text-ada-001",
"codex": "code-davinci-002",
}
while True:
try:
ret = openai.Completion.create(
engine=model_name[model],
prompt=prompt,
temperature=temperature,
max_tokens=2,
top_p=1,
frequency_penalty=0,
presence_penalty=0,
stop=stop
)
break
except Exception as e:
print(e)
print("Retrying in 10 seconds")
time.sleep(10)
gen_text = ret["choices"][0]["text"].strip()#.split('\n')[0]
return gen_text
preds = []
golds = []
#print("Total examples: ", len(dataset['test']))
count = 0
with open("sampled_1000_indices.pkl", "rb") as f:
indices = pickle.load(f)
for index in indices:
example = dataset['validation'][index]
count += 1
print(count)
if args.prompt == "text":
prompt = build_text_prompt(example)
elif "code" in args.prompt:
prompt = build_code_prompt(example)
#print(prompt)
#print(len(tokenizer(prompt)['input_ids']))
pred = run_llm(prompt, args.model)
if args.prompt == "text":
pred = str(int(pred) - 1)
#print(pred)
#raise SystemExit()
gold = str(int(example['label']))
preds.append(pred)
golds.append(gold)
with open(f'pred_{args.model}_{args.prompt}_{args.max_prompt}{args.seed}.txt', 'w') as f:
f.writelines([x + '\n' for x in preds])
with open('gold.txt', 'w') as f:
f.writelines([x + '\n' for x in golds])
def evaluate():
with open(f'pred_{args.model}_{args.prompt}_{args.max_prompt}{args.seed}.txt', 'r') as f:
preds = [x.strip() for x in f.readlines()]
with open('gold.txt', 'r') as f:
golds = [x.strip() for x in f.readlines()]
print("Accuracy", accuracy_score(golds, preds))
return "Accuracy", accuracy_score(golds, preds)
if __name__ == "__main__":
predict()
evaluate() | [
"PLACEHOLDER\n\nAnswer: PLACEHOLDER\n\n\n",
"PLACEHOLDERPLACEHOLDER\n\n\n",
"how_ends"
] |
2024-01-10 | zharry29/curious_code_prompts | datasets~yelp~yelp.py | import argparse
import openai
from datasets import load_dataset
import random
random.seed(29)
from promptsource.templates import DatasetTemplates
import time
from sklearn.metrics import accuracy_score
import pickle
from transformers import AutoTokenizer
tokenizer = AutoTokenizer.from_pretrained("gpt2")
from scipy.stats import pearsonr
import backoff
parser = argparse.ArgumentParser()
parser.add_argument('--prompt', default='text', type=str, help='Either text or code.')
parser.add_argument('--model', default='codex', type=str, help='Either davinci, curie or codex.')
parser.add_argument('--max_prompt', type=int, default=4000, help='Maximum number of tokens in the prompt.')
parser.add_argument('--key', default='harry', type=str, help='The name of the OpenAI API key file.')
parser.add_argument('--seed', default='', type=str, help='Random seed.')
args = parser.parse_args()
openai.api_key = open(f'../../_private/{args.key}.key').read()
if args.seed:
args.seed = '_' + args.seed
random.seed(int(args.seed[1:]))
SELECTED_PROMPT_NAME = "based_on_that"
template = DatasetTemplates('yelp_review_full')[SELECTED_PROMPT_NAME]
dataset = load_dataset("yelp_review_full")
def apply_code_template(example):
with open(args.prompt + '.py') as f:
template = f.read()
ret = []
for t in template.split('$'):
ret.append(t.replace("{text}", example["text"]).replace("{label}", str(example["label"])))
return ret
if args.prompt == "text":
apply_template = template.apply
elif args.prompt.startswith("code"):
apply_template = apply_code_template
def predict():
# Build prompt
def build_text_prompt(example):
inference_input_text = apply_template(example)[0]
text_prompt = ""
prev_prompt = ""
example_indices = random.sample(range(len(dataset['train'])), 100)
for example_index in example_indices:
if len(tokenizer(text_prompt + inference_input_text)['input_ids']) > args.max_prompt - 20:
break
example = dataset['train'][example_index]
input_text, output_text = apply_template(example)
prev_prompt = text_prompt
text_prompt += input_text + ' ' + output_text + '.\n\n'
return(prev_prompt + inference_input_text)
def build_code_prompt(example):
inference_input_text = apply_template(example)[0]
text_prompt = ""
prev_prompt = ""
example_indices = random.sample(range(len(dataset['train'])), 100)
for example_index in example_indices:
if len(tokenizer(text_prompt + inference_input_text)['input_ids']) > args.max_prompt:
break
example = dataset['train'][example_index]
input_text, output_text = apply_template(example)
prev_prompt = text_prompt
text_prompt += input_text + output_text + '\n\n\n'
return(prev_prompt + inference_input_text)
@backoff.on_exception(backoff.expo, openai.error.RateLimitError)
def run_llm(prompt, model, temperature=0, stop=['\n']):
model_name = {
"davinci": "text-davinci-002",
"davinci003": "text-davinci-003",
"old_davinci": "davinci",
"curie": "text-curie-001",
"ada": "text-ada-001",
"codex": "code-davinci-002",
}
while True:
try:
ret = openai.Completion.create(
engine=model_name[model],
prompt=prompt,
temperature=temperature,
max_tokens=5,
top_p=1,
frequency_penalty=0,
presence_penalty=0,
stop=stop
)
break
except Exception as e:
print(e)
print("Retrying in 10 seconds")
time.sleep(10)
gen_text = ret["choices"][0]["text"].strip()#.split('\n')[0]
return gen_text
preds = []
golds = []
print("Total examples: ", len(dataset['test']))
count = 0
#print(len(dataset['test']))
#raise SystemExit
with open("sampled_1000_indices.pkl", "rb") as f:
indices = pickle.load(f)
for index in indices:
example = dataset['test'][index]
#print(example)
#raise SystemExit
count += 1
print(count)
if args.prompt == "text":
prompt = build_text_prompt(example)
elif "code" in args.prompt:
prompt = build_code_prompt(example)
#print(prompt)
#print(len(tokenizer(prompt)['input_ids']))
#raise SystemExit
pred_text = run_llm(prompt, args.model)
pred = pred_text.strip()[0]
gold = example['label']
preds.append(pred)
golds.append(gold)
with open(f'pred_{args.model}_{args.prompt}_{args.max_prompt}{args.seed}.txt', 'w') as f:
f.writelines([str(x) + '\n' for x in preds])
with open('gold.txt', 'w') as f:
f.writelines([str(x) + '\n' for x in golds])
def evaluate():
with open(f'pred_{args.model}_{args.prompt}_{args.max_prompt}{args.seed}.txt', 'r') as f:
preds = [int(l.strip()) for l in f.readlines()]
with open('gold.txt', 'r') as f:
golds = [int(l.strip()) + 1 for l in f.readlines()]
print("Pearson's R", pearsonr(golds, preds)[0])
return "Pearson's R", pearsonr(golds, preds)[0]
if __name__ == "__main__":
predict()
evaluate() | [
"yelp_review_full",
"PLACEHOLDER PLACEHOLDER.\n\n",
"PLACEHOLDERPLACEHOLDER\n\n\n",
"based_on_that"
] |
2024-01-10 | zharry29/curious_code_prompts | datasets~ANLI~anli.py | import time
import json
import utils
import pickle
import random
import openai
import argparse
import numpy as np
from tqdm import tqdm
from datasets import load_dataset
from sklearn.metrics import accuracy_score
random.seed(29)
class ANLI():
def __init__(self, apply_template, idx):
self.apply_template = apply_template
self.idx = idx
def build_text_prompt(self, max_len):
print('Building prompts...')
text_prompt = ""
total_token = max_len
threshold = args.context_size
tolerance = 0
counter = 0
while total_token < threshold:
example_index = random.sample(range(len(dataset[f'train_r{self.idx}'])), 1)[0]
example = dataset[f'train_r{self.idx}'][example_index]
input_text, output_text = self.apply_template(example)
candidate_prompt = input_text.replace('[', '').replace(']', '') + '\n\nAnswer: ' + output_text.replace('[', '').replace(']', '') + '\n\n\n'
token_count = utils.gpt3_tokenizer(candidate_prompt)
prev_total = total_token
if total_token + token_count < threshold:
text_prompt += candidate_prompt
total_token += token_count
counter += 1
if total_token - prev_total < 10:
tolerance += 1
if tolerance > 1:
break
print(f'Total samples in prompt: {counter}')
print(f'Average tokens per sample: {total_token / counter}')
return text_prompt
def build_code_prompt(self, max_len, prompt):
if prompt:
code_prompt = prompt
total_token = utils.gpt3_tokenizer(prompt)
else:
code_prompt = ""
total_token = max_len
threshold = args.context_size
tolerance = 0
while total_token < threshold:
example_index = random.sample(range(len(dataset[f'train_r{self.idx}'])), 1)
example = dataset[f'train_r{self.idx}'][example_index]
input_text, output_text = self.apply_template(example)
candidate_prompt = input_text + output_text + '\n\n'
token_count = utils.gpt3_tokenizer(candidate_prompt)
prev_total = total_token
if total_token + token_count < threshold:
code_prompt += candidate_prompt
total_token += token_count
if total_token - prev_total < 10:
tolerance += 1
if tolerance > 1:
break
return code_prompt
def run_llm(self, prompt, model, max_tokens, temperature=0, stop=['\n']):
model_name = {
"davinci": "text-davinci-002",
"davinci-old": "davinci",
"davinci003": "text-davinci-003",
"curie": "text-curie-001",
"codex": "code-davinci-002",
"ada": "text-ada-001",
}
while True:
try:
ret = openai.Completion.create(
engine=model_name[model],
prompt=prompt,
temperature=temperature,
max_tokens=max_tokens,
top_p=1,
frequency_penalty=0,
presence_penalty=0,
stop=stop
)
break
except Exception as e:
print(e)
print("Retrying in 10 seconds")
time.sleep(10)
gen_text = ret["choices"][0]["text"].strip()#.split('\n')[0]
return gen_text
def parse_pred(self, pred):
if pred.strip().lower() == 'true':
return 0
elif pred.strip().lower() == 'neither':
return 1
elif pred.strip().lower() == 'false':
return 2
else:
return -1
def predict(self, val_idx=None):
val_data = dataset[f'dev_r{self.idx}']
if not val_idx:
val_idx = np.random.choice(np.arange(len(val_data)), 333, replace=False)
max_len = compute_longest_prompt(val_idx, val_data, self.apply_template)
if args.prompt == "text":
prompt = self.build_text_prompt(max_len)
elif args.prompt == "code":
if args.style == 'comment':
prompt = open('./code-prompts/comment_prefix.py').read()
prompt = self.build_code_prompt(max_len, prompt)
elif args.style == 'class':
prompt = open('./code-prompts/class_prefix.py').read()
prompt = self.build_code_prompt(max_len, prompt)
else:
prompt = None
prompt = self.build_code_prompt(max_len, prompt)
preds = []
golds = []
for idx in tqdm(val_idx):
example = val_data[int(idx)]
input_text, output_text = self.apply_template(example)
if args.prompt == 'text':
pred = self.run_llm(prompt + input_text + '\n\nAnswer:', args.model, args.completion_size)
elif args.prompt == 'code':
pred = self.run_llm(prompt + input_text, args.model, args.completion_size)
pred = self.parse_pred(pred.replace('"', ''))
gold = example['label']
preds.append(pred)
golds.append(gold)
return list(val_idx), preds, golds
def evaluate(self):
pred_name, gold_name = get_fname()
with open(f'./result/{pred_name}.txt', 'r') as f:
preds = [x.strip() for x in f.readlines()]
with open(f'./result/{gold_name}.txt', 'r') as f:
golds = [x.strip() for x in f.readlines()]
print("Accuracy", accuracy_score(golds, preds))
return accuracy_score(golds, preds)
def compute_longest_prompt(val_idx, val_data, apply_template):
max_len = 0
for idx in tqdm(val_idx):
example = val_data[int(idx)]
input_text, output_text = apply_template(example)
cur_len = utils.gpt3_tokenizer(input_text + '\n\nAnswer:')
if cur_len > max_len:
max_len = cur_len
return max_len
def apply_code_template(example):
with open(f'./code-prompts/{args.style}' + '.py') as f:
template = f.read()
ret = []
label_to_text = {'0': "True", '1': "Neither", '2': "False"}
premise = example['premise']
hypothesis = example['hypothesis']
label_idx = example['label']
if type(premise) is list:
premise = premise[0]
if type(hypothesis) is list:
hypothesis = hypothesis[0]
if type(label_idx) is list:
label_idx = label_idx[0]
label_text = label_to_text[str(label_idx)]
for t in template.split('$'):
if hypothesis.strip()[-1] != '.':
hypothesis += '.'
ret.append(t.replace("{premise}", premise).replace("{hypothesis}", hypothesis).replace("{label}", label_text))
return ret
def get_fname():
if not args.style:
pred_name = f'{args.prompt}_{args.model}_pred_{args.context_size}_{args.seed}'
else:
pred_name = f'{args.prompt}_{args.style}_{args.model}_pred_{args.context_size}'
if not args.style:
gold_name = f'{args.prompt}_{args.model}_gold_{args.context_size}_{args.seed}'
else:
gold_name = f'{args.prompt}_{args.style}_{args.model}_gold_{args.context_size}'
return pred_name, gold_name
parser = argparse.ArgumentParser()
parser.add_argument('--prompt', type=str, help='Either text or code.')
parser.add_argument('--model', type=str, help='Either davinci, curie or codex.')
parser.add_argument('--context_size', type=int, help='token threshold for GPT3 context prompt.')
parser.add_argument('--completion_size', type=int, help='token threshold for GPT3 completion.')
parser.add_argument('--style', type=str, default=None, help='choose style of code prompt from one of ["vanilla", "good_var_name", "with_comments", "class_obj"]')
parser.add_argument('--seed', type=int, default=None, help='set seed')
parser.add_argument('--index', type=str, help='file name of the saved indices')
#parser.add_argument('--dataset', type=str, help='Name of the datasset')
#parser.add_argument('--xxx', action='store_true', help='')
parser.add_argument('--key', type=str, help='The name of the OpenAI API key file.')
if __name__ == '__main__':
args = parser.parse_args()
openai.api_key_path = f'../../_private/{args.key}.key'
if args.seed:
random.seed(args.seed)
np.random.seed(args.seed)
data_name = 'anli'
dataset, templates = utils.load_data(data_name)
if args.prompt == "text":
apply_template = templates.apply
elif args.prompt == "code":
apply_template = apply_code_template
if not args.index:
val_idx_dict = []
else:
val_idx_dict = pickle.load(open(f'./indices/{args.index}.pkl', 'rb'))
preds, golds = [], []
for i in range(1, 4):
inference_model = ANLI(apply_template, i)
if args.index:
val_idx = val_idx_dict[i-1]
else:
val_idx = None
val_idx, pred, gold = inference_model.predict(val_idx)
if not args.index:
val_idx_dict.append(val_idx)
preds += pred
golds += gold
pred_name, gold_name = get_fname()
with open(f'./result/{pred_name}.txt', 'w') as f:
f.writelines([str(x) + '\n' for x in preds])
with open(f'./result/{gold_name}.txt', 'w') as f:
f.writelines([str(x) + '\n' for x in golds])
with open(f'./indices/{args.model}_val_idx_{args.context_size}.pkl', 'wb') as f:
pickle.dump(val_idx_dict, f)
f.close()
for i in range(1, 4):
inference_model = ANLI(templates, i)
inference_model.evaluate()
| [
"./code-prompts/comment_prefix.py",
"PLACEHOLDERPLACEHOLDER\n\n",
"None",
"./code-prompts/class_prefix.py",
"\n\n\n",
"\n\nAnswer: "
] |
2024-01-10 | jitingxu1/llama_index | llama_index~evaluation~dataset_generation.py | """Dataset generation from documents"""
from __future__ import annotations
import re
from typing import List, Optional
from llama_index import (
Document,
SummaryIndex,
ServiceContext,
)
from llama_index.llms.openai import OpenAI
from llama_index.prompts.base import BasePromptTemplate, PromptTemplate
from llama_index.schema import BaseNode, NodeWithScore, MetadataMode
from llama_index.indices.postprocessor.node import KeywordNodePostprocessor
DEFAULT_QUESTION_GENERATION_PROMPT = """Context information is below.\n"
"\n---------------------\n{context_str}\n---------------------\n"
"Given the context information and not prior knowledge.\n"
"generate only questions based on the below query.\n"
"{query_str}\n"
"""
def _get_default_service_context() -> ServiceContext:
"""Get default service context."""
llm = OpenAI(temperature=0, model="gpt-3.5-turbo")
service_context = ServiceContext.from_defaults(llm=llm, chunk_size_limit=3000)
return service_context
class DatasetGenerator:
"""Generate dataset (question/ question-answer pairs) \
based on the given documents.
NOTE: this is a beta feature, subject to change!
Args:
nodes (List[Node]): List of nodes. (Optional)
service_context (ServiceContext): Service Context.
num_questions_per_chunk: number of question to be \
generated per chunk. Each document is chunked of size 512 words.
text_question_template: Question generation template.
question_gen_query: Question generation query.
"""
def __init__(
self,
nodes: List[BaseNode],
service_context: Optional[ServiceContext] = None,
num_questions_per_chunk: int = 10,
text_question_template: Optional[BasePromptTemplate] = None,
question_gen_query: Optional[str] = None,
required_keywords: Optional[List[str]] = None,
exclude_keywords: Optional[List[str]] = None,
metadata_mode: MetadataMode = MetadataMode.NONE,
) -> None:
"""Init params."""
if service_context is None:
service_context = _get_default_service_context()
self.service_context = service_context
self.text_question_template = text_question_template or PromptTemplate(
DEFAULT_QUESTION_GENERATION_PROMPT
)
self.question_gen_query = (
question_gen_query
or f"You are a Teacher/ Professor. Your task is to setup \
{num_questions_per_chunk} questions for an upcoming \
quiz/examination. The questions should be diverse in nature \
across the document. Restrict the questions to the \
context information provided."
)
self.nodes = nodes
self._metadata_mode = metadata_mode
@classmethod
def from_documents(
cls,
documents: List[Document],
service_context: Optional[ServiceContext] = None,
num_questions_per_chunk: int = 10,
text_question_template: Optional[BasePromptTemplate] = None,
question_gen_query: Optional[str] = None,
required_keywords: Optional[List[str]] = None,
exclude_keywords: Optional[List[str]] = None,
) -> "DatasetGenerator":
"""Generate dataset from documents."""
if service_context is None:
service_context = _get_default_service_context()
nodes = service_context.node_parser.get_nodes_from_documents(documents)
# use node postprocessor to filter nodes
required_keywords = required_keywords or []
exclude_keywords = exclude_keywords or []
node_postprocessor = KeywordNodePostprocessor(
service_context=service_context,
required_keywords=required_keywords,
exclude_keywords=exclude_keywords,
)
node_with_scores = [NodeWithScore(node=node) for node in nodes]
node_with_scores = node_postprocessor.postprocess_nodes(node_with_scores)
nodes = [node_with_score.node for node_with_score in node_with_scores]
return cls(
nodes=nodes,
service_context=service_context,
num_questions_per_chunk=num_questions_per_chunk,
text_question_template=text_question_template,
question_gen_query=question_gen_query,
)
def _node_question_generator(
self, nodes: List[BaseNode], num: Optional[int] = None
) -> List[str]:
"""Node question generator."""
questions: List[str] = []
for node in nodes:
if num is not None and len(questions) >= num:
break
index = SummaryIndex.from_documents(
[
Document(
text=node.get_content(metadata_mode=self._metadata_mode),
metadata=node.metadata,
)
]
)
query_engine = index.as_query_engine(
service_context=self.service_context,
text_qa_template=self.text_question_template,
use_async=True,
)
response = query_engine.query(
self.question_gen_query,
)
result = str(response).strip().split("\n")
cleaned_questions = [
re.sub(r"^\d+[\).\s]", "", question).strip() for question in result
]
questions.extend(cleaned_questions)
questions = [question for question in questions if question != ""]
if num is not None:
questions = questions[:num]
return questions
def generate_questions_from_nodes(self, num: Optional[int] = None) -> List[str]:
"""Generates questions for each document."""
return self._node_question_generator(self.nodes, num)
| [
"Context information is below.\n\"\n\"\n---------------------\n{context_str}\n---------------------\n\"\n\"Given the context information and not prior knowledge.\n\"\n\"generate only questions based on the below query.\n\"\n\"{query_str}\n\"\n"
] |
2024-01-10 | yamyyao/langchain | libs~experimental~langchain_experimental~comprehend_moderation~pii.py | import asyncio
from typing import Any, Dict, Optional
from langchain_experimental.comprehend_moderation.base_moderation_exceptions import (
ModerationPiiError,
)
class ComprehendPII:
def __init__(
self,
client: Any,
callback: Optional[Any] = None,
unique_id: Optional[str] = None,
chain_id: Optional[str] = None,
) -> None:
self.client = client
self.moderation_beacon = {
"moderation_chain_id": chain_id,
"moderation_type": "PII",
"moderation_status": "LABELS_NOT_FOUND",
}
self.callback = callback
self.unique_id = unique_id
def validate(self, prompt_value: str, config: Any = None) -> str:
redact = config.get("redact")
return (
self._detect_pii(prompt_value=prompt_value, config=config)
if redact
else self._contains_pii(prompt_value=prompt_value, config=config)
)
def _contains_pii(self, prompt_value: str, config: Any = None) -> str:
"""
Checks for Personally Identifiable Information (PII) labels above a
specified threshold. Uses Amazon Comprehend Contains PII Entities API. See -
https://docs.aws.amazon.com/comprehend/latest/APIReference/API_ContainsPiiEntities.html
Args:
prompt_value (str): The input text to be checked for PII labels.
config (Dict[str, Any]): Configuration for PII check and actions.
Returns:
str: the original prompt
Note:
- The provided client should be initialized with valid AWS credentials.
"""
pii_identified = self.client.contains_pii_entities(
Text=prompt_value, LanguageCode="en"
)
if self.callback and self.callback.pii_callback:
self.moderation_beacon["moderation_input"] = prompt_value
self.moderation_beacon["moderation_output"] = pii_identified
threshold = config.get("threshold")
pii_labels = config.get("labels")
pii_found = False
for entity in pii_identified["Labels"]:
if (entity["Score"] >= threshold and entity["Name"] in pii_labels) or (
entity["Score"] >= threshold and not pii_labels
):
pii_found = True
break
if self.callback and self.callback.pii_callback:
if pii_found:
self.moderation_beacon["moderation_status"] = "LABELS_FOUND"
asyncio.create_task(
self.callback.on_after_pii(self.moderation_beacon, self.unique_id)
)
if pii_found:
raise ModerationPiiError
return prompt_value
def _detect_pii(self, prompt_value: str, config: Optional[Dict[str, Any]]) -> str:
"""
Detects and handles Personally Identifiable Information (PII) entities in the
given prompt text using Amazon Comprehend's detect_pii_entities API. The
function provides options to redact or stop processing based on the identified
PII entities and a provided configuration. Uses Amazon Comprehend Detect PII
Entities API.
Args:
prompt_value (str): The input text to be checked for PII entities.
config (Dict[str, Any]): A configuration specifying how to handle
PII entities.
Returns:
str: The processed prompt text with redacted PII entities or raised
exceptions.
Raises:
ValueError: If the prompt contains configured PII entities for
stopping processing.
Note:
- If PII is not found in the prompt, the original prompt is returned.
- The client should be initialized with valid AWS credentials.
"""
pii_identified = self.client.detect_pii_entities(
Text=prompt_value, LanguageCode="en"
)
if self.callback and self.callback.pii_callback:
self.moderation_beacon["moderation_input"] = prompt_value
self.moderation_beacon["moderation_output"] = pii_identified
if (pii_identified["Entities"]) == []:
if self.callback and self.callback.pii_callback:
asyncio.create_task(
self.callback.on_after_pii(self.moderation_beacon, self.unique_id)
)
return prompt_value
pii_found = False
if not config and pii_identified["Entities"]:
for entity in pii_identified["Entities"]:
if entity["Score"] >= 0.5:
pii_found = True
break
if self.callback and self.callback.pii_callback:
if pii_found:
self.moderation_beacon["moderation_status"] = "LABELS_FOUND"
asyncio.create_task(
self.callback.on_after_pii(self.moderation_beacon, self.unique_id)
)
if pii_found:
raise ModerationPiiError
else:
threshold = config.get("threshold") # type: ignore
pii_labels = config.get("labels") # type: ignore
mask_marker = config.get("mask_character") # type: ignore
pii_found = False
for entity in pii_identified["Entities"]:
if (
pii_labels
and entity["Type"] in pii_labels
and entity["Score"] >= threshold
) or (not pii_labels and entity["Score"] >= threshold):
pii_found = True
char_offset_begin = entity["BeginOffset"]
char_offset_end = entity["EndOffset"]
mask_length = char_offset_end - char_offset_begin + 1
masked_part = mask_marker * mask_length
prompt_value = (
prompt_value[:char_offset_begin]
+ masked_part
+ prompt_value[char_offset_end + 1 :]
)
if self.callback and self.callback.pii_callback:
if pii_found:
self.moderation_beacon["moderation_status"] = "LABELS_FOUND"
asyncio.create_task(
self.callback.on_after_pii(self.moderation_beacon, self.unique_id)
)
return prompt_value
| [] |
2024-01-10 | yamyyao/langchain | libs~langchain~langchain~vectorstores~elasticsearch.py | import logging
import uuid
from abc import ABC, abstractmethod
from typing import (
TYPE_CHECKING,
Any,
Callable,
Dict,
Iterable,
List,
Literal,
Optional,
Tuple,
Union,
)
import numpy as np
from langchain.docstore.document import Document
from langchain.schema.embeddings import Embeddings
from langchain.schema.vectorstore import VectorStore
from langchain.vectorstores.utils import DistanceStrategy, maximal_marginal_relevance
if TYPE_CHECKING:
from elasticsearch import Elasticsearch
logger = logging.getLogger(__name__)
class BaseRetrievalStrategy(ABC):
"""Base class for `Elasticsearch` retrieval strategies."""
@abstractmethod
def query(
self,
query_vector: Union[List[float], None],
query: Union[str, None],
*,
k: int,
fetch_k: int,
vector_query_field: str,
text_field: str,
filter: List[dict],
similarity: Union[DistanceStrategy, None],
) -> Dict:
"""
Executes when a search is performed on the store.
Args:
query_vector: The query vector,
or None if not using vector-based query.
query: The text query, or None if not using text-based query.
k: The total number of results to retrieve.
fetch_k: The number of results to fetch initially.
vector_query_field: The field containing the vector
representations in the index.
text_field: The field containing the text data in the index.
filter: List of filter clauses to apply to the query.
similarity: The similarity strategy to use, or None if not using one.
Returns:
Dict: The Elasticsearch query body.
"""
@abstractmethod
def index(
self,
dims_length: Union[int, None],
vector_query_field: str,
similarity: Union[DistanceStrategy, None],
) -> Dict:
"""
Executes when the index is created.
Args:
dims_length: Numeric length of the embedding vectors,
or None if not using vector-based query.
vector_query_field: The field containing the vector
representations in the index.
similarity: The similarity strategy to use,
or None if not using one.
Returns:
Dict: The Elasticsearch settings and mappings for the strategy.
"""
def before_index_setup(
self, client: "Elasticsearch", text_field: str, vector_query_field: str
) -> None:
"""
Executes before the index is created. Used for setting up
any required Elasticsearch resources like a pipeline.
Args:
client: The Elasticsearch client.
text_field: The field containing the text data in the index.
vector_query_field: The field containing the vector
representations in the index.
"""
def require_inference(self) -> bool:
"""
Returns whether or not the strategy requires inference
to be performed on the text before it is added to the index.
Returns:
bool: Whether or not the strategy requires inference
to be performed on the text before it is added to the index.
"""
return True
class ApproxRetrievalStrategy(BaseRetrievalStrategy):
"""Approximate retrieval strategy using the `HNSW` algorithm."""
def __init__(
self,
query_model_id: Optional[str] = None,
hybrid: Optional[bool] = False,
):
self.query_model_id = query_model_id
self.hybrid = hybrid
def query(
self,
query_vector: Union[List[float], None],
query: Union[str, None],
k: int,
fetch_k: int,
vector_query_field: str,
text_field: str,
filter: List[dict],
similarity: Union[DistanceStrategy, None],
) -> Dict:
knn = {
"filter": filter,
"field": vector_query_field,
"k": k,
"num_candidates": fetch_k,
}
# Embedding provided via the embedding function
if query_vector and not self.query_model_id:
knn["query_vector"] = query_vector
# Case 2: Used when model has been deployed to
# Elasticsearch and can infer the query vector from the query text
elif query and self.query_model_id:
knn["query_vector_builder"] = {
"text_embedding": {
"model_id": self.query_model_id, # use 'model_id' argument
"model_text": query, # use 'query' argument
}
}
else:
raise ValueError(
"You must provide an embedding function or a"
" query_model_id to perform a similarity search."
)
# If hybrid, add a query to the knn query
# RRF is used to even the score from the knn query and text query
if self.hybrid:
return {
"knn": knn,
"query": {
"bool": {
"must": [
{
"match": {
text_field: {
"query": query,
}
}
}
],
"filter": filter,
}
},
"rank": {"rrf": {}},
}
else:
return {"knn": knn}
def index(
self,
dims_length: Union[int, None],
vector_query_field: str,
similarity: Union[DistanceStrategy, None],
) -> Dict:
"""Create the mapping for the Elasticsearch index."""
if similarity is DistanceStrategy.COSINE:
similarityAlgo = "cosine"
elif similarity is DistanceStrategy.EUCLIDEAN_DISTANCE:
similarityAlgo = "l2_norm"
elif similarity is DistanceStrategy.DOT_PRODUCT:
similarityAlgo = "dot_product"
else:
raise ValueError(f"Similarity {similarity} not supported.")
return {
"mappings": {
"properties": {
vector_query_field: {
"type": "dense_vector",
"dims": dims_length,
"index": True,
"similarity": similarityAlgo,
},
}
}
}
class ExactRetrievalStrategy(BaseRetrievalStrategy):
"""Exact retrieval strategy using the `script_score` query."""
def query(
self,
query_vector: Union[List[float], None],
query: Union[str, None],
k: int,
fetch_k: int,
vector_query_field: str,
text_field: str,
filter: Union[List[dict], None],
similarity: Union[DistanceStrategy, None],
) -> Dict:
if similarity is DistanceStrategy.COSINE:
similarityAlgo = (
f"cosineSimilarity(params.query_vector, '{vector_query_field}') + 1.0"
)
elif similarity is DistanceStrategy.EUCLIDEAN_DISTANCE:
similarityAlgo = (
f"1 / (1 + l2norm(params.query_vector, '{vector_query_field}'))"
)
elif similarity is DistanceStrategy.DOT_PRODUCT:
similarityAlgo = f"""
double value = dotProduct(params.query_vector, '{vector_query_field}');
return sigmoid(1, Math.E, -value);
"""
else:
raise ValueError(f"Similarity {similarity} not supported.")
queryBool: Dict = {"match_all": {}}
if filter:
queryBool = {"bool": {"filter": filter}}
return {
"query": {
"script_score": {
"query": queryBool,
"script": {
"source": similarityAlgo,
"params": {"query_vector": query_vector},
},
},
}
}
def index(
self,
dims_length: Union[int, None],
vector_query_field: str,
similarity: Union[DistanceStrategy, None],
) -> Dict:
"""Create the mapping for the Elasticsearch index."""
return {
"mappings": {
"properties": {
vector_query_field: {
"type": "dense_vector",
"dims": dims_length,
"index": False,
},
}
}
}
class SparseRetrievalStrategy(BaseRetrievalStrategy):
"""Sparse retrieval strategy using the `text_expansion` processor."""
def __init__(self, model_id: Optional[str] = None):
self.model_id = model_id or ".elser_model_1"
def query(
self,
query_vector: Union[List[float], None],
query: Union[str, None],
k: int,
fetch_k: int,
vector_query_field: str,
text_field: str,
filter: List[dict],
similarity: Union[DistanceStrategy, None],
) -> Dict:
return {
"query": {
"bool": {
"must": [
{
"text_expansion": {
f"{vector_query_field}.tokens": {
"model_id": self.model_id,
"model_text": query,
}
}
}
],
"filter": filter,
}
}
}
def _get_pipeline_name(self) -> str:
return f"{self.model_id}_sparse_embedding"
def before_index_setup(
self, client: "Elasticsearch", text_field: str, vector_query_field: str
) -> None:
# If model_id is provided, create a pipeline for the model
if self.model_id:
client.ingest.put_pipeline(
id=self._get_pipeline_name(),
description="Embedding pipeline for langchain vectorstore",
processors=[
{
"inference": {
"model_id": self.model_id,
"target_field": vector_query_field,
"field_map": {text_field: "text_field"},
"inference_config": {
"text_expansion": {"results_field": "tokens"}
},
}
}
],
)
def index(
self,
dims_length: Union[int, None],
vector_query_field: str,
similarity: Union[DistanceStrategy, None],
) -> Dict:
return {
"mappings": {
"properties": {
vector_query_field: {
"properties": {"tokens": {"type": "rank_features"}}
}
}
},
"settings": {"default_pipeline": self._get_pipeline_name()},
}
def require_inference(self) -> bool:
return False
class ElasticsearchStore(VectorStore):
"""`Elasticsearch` vector store.
Example:
.. code-block:: python
from langchain.vectorstores import ElasticsearchStore
from langchain.embeddings.openai import OpenAIEmbeddings
embeddings = OpenAIEmbeddings()
vectorstore = ElasticsearchStore(
embedding=OpenAIEmbeddings(),
index_name="langchain-demo",
es_url="http://localhost:9200"
)
Args:
index_name: Name of the Elasticsearch index to create.
es_url: URL of the Elasticsearch instance to connect to.
cloud_id: Cloud ID of the Elasticsearch instance to connect to.
es_user: Username to use when connecting to Elasticsearch.
es_password: Password to use when connecting to Elasticsearch.
es_api_key: API key to use when connecting to Elasticsearch.
es_connection: Optional pre-existing Elasticsearch connection.
vector_query_field: Optional. Name of the field to store
the embedding vectors in.
query_field: Optional. Name of the field to store the texts in.
strategy: Optional. Retrieval strategy to use when searching the index.
Defaults to ApproxRetrievalStrategy. Can be one of
ExactRetrievalStrategy, ApproxRetrievalStrategy,
or SparseRetrievalStrategy.
distance_strategy: Optional. Distance strategy to use when
searching the index.
Defaults to COSINE. Can be one of COSINE,
EUCLIDEAN_DISTANCE, or DOT_PRODUCT.
If you want to use a cloud hosted Elasticsearch instance, you can pass in the
cloud_id argument instead of the es_url argument.
Example:
.. code-block:: python
from langchain.vectorstores import ElasticsearchStore
from langchain.embeddings.openai import OpenAIEmbeddings
vectorstore = ElasticsearchStore(
embedding=OpenAIEmbeddings(),
index_name="langchain-demo",
es_cloud_id="<cloud_id>"
es_user="elastic",
es_password="<password>"
)
You can also connect to an existing Elasticsearch instance by passing in a
pre-existing Elasticsearch connection via the es_connection argument.
Example:
.. code-block:: python
from langchain.vectorstores import ElasticsearchStore
from langchain.embeddings.openai import OpenAIEmbeddings
from elasticsearch import Elasticsearch
es_connection = Elasticsearch("http://localhost:9200")
vectorstore = ElasticsearchStore(
embedding=OpenAIEmbeddings(),
index_name="langchain-demo",
es_connection=es_connection
)
ElasticsearchStore by default uses the ApproxRetrievalStrategy, which uses the
HNSW algorithm to perform approximate nearest neighbor search. This is the
fastest and most memory efficient algorithm.
If you want to use the Brute force / Exact strategy for searching vectors, you
can pass in the ExactRetrievalStrategy to the ElasticsearchStore constructor.
Example:
.. code-block:: python
from langchain.vectorstores import ElasticsearchStore
from langchain.embeddings.openai import OpenAIEmbeddings
vectorstore = ElasticsearchStore(
embedding=OpenAIEmbeddings(),
index_name="langchain-demo",
es_url="http://localhost:9200",
strategy=ElasticsearchStore.ExactRetrievalStrategy()
)
Both strategies require that you know the similarity metric you want to use
when creating the index. The default is cosine similarity, but you can also
use dot product or euclidean distance.
Example:
.. code-block:: python
from langchain.vectorstores import ElasticsearchStore
from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.vectorstores.utils import DistanceStrategy
vectorstore = ElasticsearchStore(
embedding=OpenAIEmbeddings(),
index_name="langchain-demo",
es_url="http://localhost:9200",
distance_strategy="DOT_PRODUCT"
)
"""
def __init__(
self,
index_name: str,
*,
embedding: Optional[Embeddings] = None,
es_connection: Optional["Elasticsearch"] = None,
es_url: Optional[str] = None,
es_cloud_id: Optional[str] = None,
es_user: Optional[str] = None,
es_api_key: Optional[str] = None,
es_password: Optional[str] = None,
vector_query_field: str = "vector",
query_field: str = "text",
distance_strategy: Optional[
Literal[
DistanceStrategy.COSINE,
DistanceStrategy.DOT_PRODUCT,
DistanceStrategy.EUCLIDEAN_DISTANCE,
]
] = None,
strategy: BaseRetrievalStrategy = ApproxRetrievalStrategy(),
):
self.embedding = embedding
self.index_name = index_name
self.query_field = query_field
self.vector_query_field = vector_query_field
self.distance_strategy = (
DistanceStrategy.COSINE
if distance_strategy is None
else DistanceStrategy[distance_strategy]
)
self.strategy = strategy
if es_connection is not None:
self.client = es_connection.options(
headers={"user-agent": self.get_user_agent()}
)
elif es_url is not None or es_cloud_id is not None:
self.client = ElasticsearchStore.connect_to_elasticsearch(
es_url=es_url,
username=es_user,
password=es_password,
cloud_id=es_cloud_id,
api_key=es_api_key,
)
else:
raise ValueError(
"""Either provide a pre-existing Elasticsearch connection, \
or valid credentials for creating a new connection."""
)
@staticmethod
def get_user_agent() -> str:
from langchain import __version__
return f"langchain-py-vs/{__version__}"
@staticmethod
def connect_to_elasticsearch(
*,
es_url: Optional[str] = None,
cloud_id: Optional[str] = None,
api_key: Optional[str] = None,
username: Optional[str] = None,
password: Optional[str] = None,
) -> "Elasticsearch":
try:
import elasticsearch
except ImportError:
raise ImportError(
"Could not import elasticsearch python package. "
"Please install it with `pip install elasticsearch`."
)
if es_url and cloud_id:
raise ValueError(
"Both es_url and cloud_id are defined. Please provide only one."
)
connection_params: Dict[str, Any] = {}
if es_url:
connection_params["hosts"] = [es_url]
elif cloud_id:
connection_params["cloud_id"] = cloud_id
else:
raise ValueError("Please provide either elasticsearch_url or cloud_id.")
if api_key:
connection_params["api_key"] = api_key
elif username and password:
connection_params["basic_auth"] = (username, password)
es_client = elasticsearch.Elasticsearch(
**connection_params,
headers={"user-agent": ElasticsearchStore.get_user_agent()},
)
try:
es_client.info()
except Exception as e:
logger.error(f"Error connecting to Elasticsearch: {e}")
raise e
return es_client
@property
def embeddings(self) -> Optional[Embeddings]:
return self.embedding
def similarity_search(
self,
query: str,
k: int = 4,
filter: Optional[List[dict]] = None,
**kwargs: Any,
) -> List[Document]:
"""Return Elasticsearch documents most similar to query.
Args:
query: Text to look up documents similar to.
k: Number of Documents to return. Defaults to 4.
filter: Array of Elasticsearch filter clauses to apply to the query.
Returns:
List of Documents most similar to the query,
in descending order of similarity.
"""
results = self._search(query=query, k=k, filter=filter, **kwargs)
return [doc for doc, _ in results]
def max_marginal_relevance_search(
self,
query: str,
k: int = 4,
fetch_k: int = 20,
lambda_mult: float = 0.5,
fields: Optional[List[str]] = None,
**kwargs: Any,
) -> List[Document]:
"""Return docs selected using the maximal marginal relevance.
Maximal marginal relevance optimizes for similarity to query AND diversity
among selected documents.
Args:
query (str): Text to look up documents similar to.
k (int): Number of Documents to return. Defaults to 4.
fetch_k (int): Number of Documents to fetch to pass to MMR algorithm.
lambda_mult (float): Number between 0 and 1 that determines the degree
of diversity among the results with 0 corresponding
to maximum diversity and 1 to minimum diversity.
Defaults to 0.5.
fields: Other fields to get from elasticsearch source. These fields
will be added to the document metadata.
Returns:
List[Document]: A list of Documents selected by maximal marginal relevance.
"""
if self.embedding is None:
raise ValueError("You must provide an embedding function to perform MMR")
remove_vector_query_field_from_metadata = True
if fields is None:
fields = [self.vector_query_field]
elif self.vector_query_field not in fields:
fields.append(self.vector_query_field)
else:
remove_vector_query_field_from_metadata = False
# Embed the query
query_embedding = self.embedding.embed_query(query)
# Fetch the initial documents
got_docs = self._search(
query_vector=query_embedding, k=fetch_k, fields=fields, **kwargs
)
# Get the embeddings for the fetched documents
got_embeddings = [doc.metadata[self.vector_query_field] for doc, _ in got_docs]
# Select documents using maximal marginal relevance
selected_indices = maximal_marginal_relevance(
np.array(query_embedding), got_embeddings, lambda_mult=lambda_mult, k=k
)
selected_docs = [got_docs[i][0] for i in selected_indices]
if remove_vector_query_field_from_metadata:
for doc in selected_docs:
del doc.metadata["vector"]
return selected_docs
def similarity_search_with_score(
self, query: str, k: int = 4, filter: Optional[List[dict]] = None, **kwargs: Any
) -> List[Tuple[Document, float]]:
"""Return Elasticsearch documents most similar to query, along with scores.
Args:
query: Text to look up documents similar to.
k: Number of Documents to return. Defaults to 4.
filter: Array of Elasticsearch filter clauses to apply to the query.
Returns:
List of Documents most similar to the query and score for each
"""
return self._search(query=query, k=k, filter=filter, **kwargs)
def similarity_search_by_vector_with_relevance_scores(
self,
embedding: List[float],
k: int = 4,
filter: Optional[List[Dict]] = None,
**kwargs: Any,
) -> List[Tuple[Document, float]]:
"""Return Elasticsearch documents most similar to query, along with scores.
Args:
embedding: Embedding to look up documents similar to.
k: Number of Documents to return. Defaults to 4.
filter: Array of Elasticsearch filter clauses to apply to the query.
Returns:
List of Documents most similar to the embedding and score for each
"""
return self._search(query_vector=embedding, k=k, filter=filter, **kwargs)
def _search(
self,
query: Optional[str] = None,
k: int = 4,
query_vector: Union[List[float], None] = None,
fetch_k: int = 50,
fields: Optional[List[str]] = None,
filter: Optional[List[dict]] = None,
custom_query: Optional[Callable[[Dict, Union[str, None]], Dict]] = None,
) -> List[Tuple[Document, float]]:
"""Return Elasticsearch documents most similar to query, along with scores.
Args:
query: Text to look up documents similar to.
k: Number of Documents to return. Defaults to 4.
query_vector: Embedding to look up documents similar to.
fetch_k: Number of candidates to fetch from each shard.
Defaults to 50.
fields: List of fields to return from Elasticsearch.
Defaults to only returning the text field.
filter: Array of Elasticsearch filter clauses to apply to the query.
custom_query: Function to modify the Elasticsearch
query body before it is sent to Elasticsearch.
Returns:
List of Documents most similar to the query and score for each
"""
if fields is None:
fields = []
if "metadata" not in fields:
fields.append("metadata")
if self.query_field not in fields:
fields.append(self.query_field)
if self.embedding and query is not None:
query_vector = self.embedding.embed_query(query)
query_body = self.strategy.query(
query_vector=query_vector,
query=query,
k=k,
fetch_k=fetch_k,
vector_query_field=self.vector_query_field,
text_field=self.query_field,
filter=filter or [],
similarity=self.distance_strategy,
)
logger.debug(f"Query body: {query_body}")
if custom_query is not None:
query_body = custom_query(query_body, query)
logger.debug(f"Calling custom_query, Query body now: {query_body}")
# Perform the kNN search on the Elasticsearch index and return the results.
response = self.client.search(
index=self.index_name,
**query_body,
size=k,
source=fields,
)
docs_and_scores = []
for hit in response["hits"]["hits"]:
for field in fields:
if field in hit["_source"] and field not in [
"metadata",
self.query_field,
]:
hit["_source"]["metadata"][field] = hit["_source"][field]
docs_and_scores.append(
(
Document(
page_content=hit["_source"].get(self.query_field, ""),
metadata=hit["_source"]["metadata"],
),
hit["_score"],
)
)
return docs_and_scores
def delete(
self,
ids: Optional[List[str]] = None,
refresh_indices: Optional[bool] = True,
**kwargs: Any,
) -> Optional[bool]:
"""Delete documents from the Elasticsearch index.
Args:
ids: List of ids of documents to delete.
refresh_indices: Whether to refresh the index
after deleting documents. Defaults to True.
"""
try:
from elasticsearch.helpers import BulkIndexError, bulk
except ImportError:
raise ImportError(
"Could not import elasticsearch python package. "
"Please install it with `pip install elasticsearch`."
)
body = []
if ids is None:
raise ValueError("ids must be provided.")
for _id in ids:
body.append({"_op_type": "delete", "_index": self.index_name, "_id": _id})
if len(body) > 0:
try:
bulk(self.client, body, refresh=refresh_indices, ignore_status=404)
logger.debug(f"Deleted {len(body)} texts from index")
return True
except BulkIndexError as e:
logger.error(f"Error deleting texts: {e}")
firstError = e.errors[0].get("index", {}).get("error", {})
logger.error(f"First error reason: {firstError.get('reason')}")
raise e
else:
logger.debug("No texts to delete from index")
return False
def _create_index_if_not_exists(
self, index_name: str, dims_length: Optional[int] = None
) -> None:
"""Create the Elasticsearch index if it doesn't already exist.
Args:
index_name: Name of the Elasticsearch index to create.
dims_length: Length of the embedding vectors.
"""
if self.client.indices.exists(index=index_name):
logger.debug(f"Index {index_name} already exists. Skipping creation.")
else:
if dims_length is None and self.strategy.require_inference():
raise ValueError(
"Cannot create index without specifying dims_length "
"when the index doesn't already exist. We infer "
"dims_length from the first embedding. Check that "
"you have provided an embedding function."
)
self.strategy.before_index_setup(
client=self.client,
text_field=self.query_field,
vector_query_field=self.vector_query_field,
)
indexSettings = self.strategy.index(
vector_query_field=self.vector_query_field,
dims_length=dims_length,
similarity=self.distance_strategy,
)
logger.debug(
f"Creating index {index_name} with mappings {indexSettings['mappings']}"
)
self.client.indices.create(index=index_name, **indexSettings)
def add_texts(
self,
texts: Iterable[str],
metadatas: Optional[List[Dict[Any, Any]]] = None,
ids: Optional[List[str]] = None,
refresh_indices: bool = True,
create_index_if_not_exists: bool = True,
bulk_kwargs: Optional[Dict] = None,
**kwargs: Any,
) -> List[str]:
"""Run more texts through the embeddings and add to the vectorstore.
Args:
texts: Iterable of strings to add to the vectorstore.
metadatas: Optional list of metadatas associated with the texts.
ids: Optional list of ids to associate with the texts.
refresh_indices: Whether to refresh the Elasticsearch indices
after adding the texts.
create_index_if_not_exists: Whether to create the Elasticsearch
index if it doesn't already exist.
*bulk_kwargs: Additional arguments to pass to Elasticsearch bulk.
- chunk_size: Optional. Number of texts to add to the
index at a time. Defaults to 500.
Returns:
List of ids from adding the texts into the vectorstore.
"""
try:
from elasticsearch.helpers import BulkIndexError, bulk
except ImportError:
raise ImportError(
"Could not import elasticsearch python package. "
"Please install it with `pip install elasticsearch`."
)
bulk_kwargs = bulk_kwargs or {}
embeddings = []
ids = ids or [str(uuid.uuid4()) for _ in texts]
requests = []
if self.embedding is not None:
# If no search_type requires inference, we use the provided
# embedding function to embed the texts.
embeddings = self.embedding.embed_documents(list(texts))
dims_length = len(embeddings[0])
if create_index_if_not_exists:
self._create_index_if_not_exists(
index_name=self.index_name, dims_length=dims_length
)
for i, (text, vector) in enumerate(zip(texts, embeddings)):
metadata = metadatas[i] if metadatas else {}
requests.append(
{
"_op_type": "index",
"_index": self.index_name,
self.query_field: text,
self.vector_query_field: vector,
"metadata": metadata,
"_id": ids[i],
}
)
else:
# the search_type doesn't require inference, so we don't need to
# embed the texts.
if create_index_if_not_exists:
self._create_index_if_not_exists(index_name=self.index_name)
for i, text in enumerate(texts):
metadata = metadatas[i] if metadatas else {}
requests.append(
{
"_op_type": "index",
"_index": self.index_name,
self.query_field: text,
"metadata": metadata,
"_id": ids[i],
}
)
if len(requests) > 0:
try:
success, failed = bulk(
self.client,
requests,
stats_only=True,
refresh=refresh_indices,
**bulk_kwargs,
)
logger.debug(
f"Added {success} and failed to add {failed} texts to index"
)
logger.debug(f"added texts {ids} to index")
return ids
except BulkIndexError as e:
logger.error(f"Error adding texts: {e}")
firstError = e.errors[0].get("index", {}).get("error", {})
logger.error(f"First error reason: {firstError.get('reason')}")
raise e
else:
logger.debug("No texts to add to index")
return []
@classmethod
def from_texts(
cls,
texts: List[str],
embedding: Optional[Embeddings] = None,
metadatas: Optional[List[Dict[str, Any]]] = None,
bulk_kwargs: Optional[Dict] = None,
**kwargs: Any,
) -> "ElasticsearchStore":
"""Construct ElasticsearchStore wrapper from raw documents.
Example:
.. code-block:: python
from langchain.vectorstores import ElasticsearchStore
from langchain.embeddings.openai import OpenAIEmbeddings
db = ElasticsearchStore.from_texts(
texts,
// embeddings optional if using
// a strategy that doesn't require inference
embeddings,
index_name="langchain-demo",
es_url="http://localhost:9200"
)
Args:
texts: List of texts to add to the Elasticsearch index.
embedding: Embedding function to use to embed the texts.
metadatas: Optional list of metadatas associated with the texts.
index_name: Name of the Elasticsearch index to create.
es_url: URL of the Elasticsearch instance to connect to.
cloud_id: Cloud ID of the Elasticsearch instance to connect to.
es_user: Username to use when connecting to Elasticsearch.
es_password: Password to use when connecting to Elasticsearch.
es_api_key: API key to use when connecting to Elasticsearch.
es_connection: Optional pre-existing Elasticsearch connection.
vector_query_field: Optional. Name of the field to
store the embedding vectors in.
query_field: Optional. Name of the field to store the texts in.
distance_strategy: Optional. Name of the distance
strategy to use. Defaults to "COSINE".
can be one of "COSINE",
"EUCLIDEAN_DISTANCE", "DOT_PRODUCT".
bulk_kwargs: Optional. Additional arguments to pass to
Elasticsearch bulk.
"""
elasticsearchStore = ElasticsearchStore._create_cls_from_kwargs(
embedding=embedding, **kwargs
)
# Encode the provided texts and add them to the newly created index.
elasticsearchStore.add_texts(
texts, metadatas=metadatas, bulk_kwargs=bulk_kwargs
)
return elasticsearchStore
@staticmethod
def _create_cls_from_kwargs(
embedding: Optional[Embeddings] = None, **kwargs: Any
) -> "ElasticsearchStore":
index_name = kwargs.get("index_name")
if index_name is None:
raise ValueError("Please provide an index_name.")
es_connection = kwargs.get("es_connection")
es_cloud_id = kwargs.get("es_cloud_id")
es_url = kwargs.get("es_url")
es_user = kwargs.get("es_user")
es_password = kwargs.get("es_password")
es_api_key = kwargs.get("es_api_key")
vector_query_field = kwargs.get("vector_query_field")
query_field = kwargs.get("query_field")
distance_strategy = kwargs.get("distance_strategy")
strategy = kwargs.get("strategy", ElasticsearchStore.ApproxRetrievalStrategy())
optional_args = {}
if vector_query_field is not None:
optional_args["vector_query_field"] = vector_query_field
if query_field is not None:
optional_args["query_field"] = query_field
return ElasticsearchStore(
index_name=index_name,
embedding=embedding,
es_url=es_url,
es_connection=es_connection,
es_cloud_id=es_cloud_id,
es_user=es_user,
es_password=es_password,
es_api_key=es_api_key,
strategy=strategy,
distance_strategy=distance_strategy,
**optional_args,
)
@classmethod
def from_documents(
cls,
documents: List[Document],
embedding: Optional[Embeddings] = None,
bulk_kwargs: Optional[Dict] = None,
**kwargs: Any,
) -> "ElasticsearchStore":
"""Construct ElasticsearchStore wrapper from documents.
Example:
.. code-block:: python
from langchain.vectorstores import ElasticsearchStore
from langchain.embeddings.openai import OpenAIEmbeddings
db = ElasticsearchStore.from_documents(
texts,
embeddings,
index_name="langchain-demo",
es_url="http://localhost:9200"
)
Args:
texts: List of texts to add to the Elasticsearch index.
embedding: Embedding function to use to embed the texts.
Do not provide if using a strategy
that doesn't require inference.
metadatas: Optional list of metadatas associated with the texts.
index_name: Name of the Elasticsearch index to create.
es_url: URL of the Elasticsearch instance to connect to.
cloud_id: Cloud ID of the Elasticsearch instance to connect to.
es_user: Username to use when connecting to Elasticsearch.
es_password: Password to use when connecting to Elasticsearch.
es_api_key: API key to use when connecting to Elasticsearch.
es_connection: Optional pre-existing Elasticsearch connection.
vector_query_field: Optional. Name of the field
to store the embedding vectors in.
query_field: Optional. Name of the field to store the texts in.
bulk_kwargs: Optional. Additional arguments to pass to
Elasticsearch bulk.
"""
elasticsearchStore = ElasticsearchStore._create_cls_from_kwargs(
embedding=embedding, **kwargs
)
# Encode the provided texts and add them to the newly created index.
elasticsearchStore.add_documents(documents, bulk_kwargs=bulk_kwargs)
return elasticsearchStore
@staticmethod
def ExactRetrievalStrategy() -> "ExactRetrievalStrategy":
"""Used to perform brute force / exact
nearest neighbor search via script_score."""
return ExactRetrievalStrategy()
@staticmethod
def ApproxRetrievalStrategy(
query_model_id: Optional[str] = None,
hybrid: Optional[bool] = False,
) -> "ApproxRetrievalStrategy":
"""Used to perform approximate nearest neighbor search
using the HNSW algorithm.
At build index time, this strategy will create a
dense vector field in the index and store the
embedding vectors in the index.
At query time, the text will either be embedded using the
provided embedding function or the query_model_id
will be used to embed the text using the model
deployed to Elasticsearch.
if query_model_id is used, do not provide an embedding function.
Args:
query_model_id: Optional. ID of the model to use to
embed the query text within the stack. Requires
embedding model to be deployed to Elasticsearch.
hybrid: Optional. If True, will perform a hybrid search
using both the knn query and a text query.
Defaults to False.
"""
return ApproxRetrievalStrategy(query_model_id=query_model_id, hybrid=hybrid)
@staticmethod
def SparseVectorRetrievalStrategy(
model_id: Optional[str] = None,
) -> "SparseRetrievalStrategy":
"""Used to perform sparse vector search via text_expansion.
Used for when you want to use ELSER model to perform document search.
At build index time, this strategy will create a pipeline that
will embed the text using the ELSER model and store the
resulting tokens in the index.
At query time, the text will be embedded using the ELSER
model and the resulting tokens will be used to
perform a text_expansion query.
Args:
model_id: Optional. Default is ".elser_model_1".
ID of the model to use to embed the query text
within the stack. Requires embedding model to be
deployed to Elasticsearch.
"""
return SparseRetrievalStrategy(model_id=model_id)
| [] |
2024-01-10 | yamyyao/langchain | libs~langchain~tests~integration_tests~vectorstores~test_xata.py | """Test Xata vector store functionality.
Before running this test, please create a Xata database by following
the instructions from:
https://python.langchain.com/docs/integrations/vectorstores/xata
"""
import os
from langchain.docstore.document import Document
from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.vectorstores.xata import XataVectorStore
class TestXata:
@classmethod
def setup_class(cls) -> None:
assert os.getenv("XATA_API_KEY"), "XATA_API_KEY environment variable is not set"
assert os.getenv("XATA_DB_URL"), "XATA_DB_URL environment variable is not set"
def test_similarity_search_without_metadata(
self, embedding_openai: OpenAIEmbeddings
) -> None:
"""Test end to end constructions and search without metadata."""
texts = ["foo", "bar", "baz"]
docsearch = XataVectorStore.from_texts(
api_key=os.getenv("XATA_API_KEY"),
db_url=os.getenv("XATA_DB_URL"),
texts=texts,
embedding=embedding_openai,
)
docsearch.wait_for_indexing(ndocs=3)
output = docsearch.similarity_search("foo", k=1)
assert output == [Document(page_content="foo")]
docsearch.delete(delete_all=True)
def test_similarity_search_with_metadata(
self, embedding_openai: OpenAIEmbeddings
) -> None:
"""Test end to end construction and search with a metadata filter.
This test requires a column named "a" of type integer to be present
in the Xata table."""
texts = ["foo", "foo", "foo"]
metadatas = [{"a": i} for i in range(len(texts))]
docsearch = XataVectorStore.from_texts(
api_key=os.getenv("XATA_API_KEY"),
db_url=os.getenv("XATA_DB_URL"),
texts=texts,
embedding=embedding_openai,
metadatas=metadatas,
)
docsearch.wait_for_indexing(ndocs=3)
output = docsearch.similarity_search("foo", k=1, filter={"a": 1})
assert output == [Document(page_content="foo", metadata={"a": 1})]
docsearch.delete(delete_all=True)
| [] |
2024-01-10 | yamyyao/langchain | libs~experimental~langchain_experimental~comprehend_moderation~toxicity.py | import asyncio
import importlib
from typing import Any, List, Optional
from langchain_experimental.comprehend_moderation.base_moderation_exceptions import (
ModerationToxicityError,
)
class ComprehendToxicity:
def __init__(
self,
client: Any,
callback: Optional[Any] = None,
unique_id: Optional[str] = None,
chain_id: Optional[str] = None,
) -> None:
self.client = client
self.moderation_beacon = {
"moderation_chain_id": chain_id,
"moderation_type": "Toxicity",
"moderation_status": "LABELS_NOT_FOUND",
}
self.callback = callback
self.unique_id = unique_id
def _toxicity_init_validate(self, max_size: int) -> Any:
"""
Validate and initialize toxicity processing configuration.
Args:
max_size (int): Maximum sentence size defined in the
configuration object.
Raises:
Exception: If the maximum sentence size exceeds the 5KB limit.
Note:
This function ensures that the NLTK punkt tokenizer is downloaded
if not already present.
Returns:
None
"""
if max_size > 1024 * 5:
raise Exception("The sentence length should not exceed 5KB.")
try:
nltk = importlib.import_module("nltk")
nltk.data.find("tokenizers/punkt")
return nltk
except ImportError:
raise ModuleNotFoundError(
"Could not import nltk python package. "
"Please install it with `pip install nltk`."
)
except LookupError:
nltk.download("punkt")
def _split_paragraph(
self, prompt_value: str, max_size: int = 1024 * 4
) -> List[List[str]]:
"""
Split a paragraph into chunks of sentences, respecting the maximum size limit.
Args:
paragraph (str): The input paragraph to be split into chunks.
max_size (int, optional): The maximum size limit in bytes for
each chunk. Defaults to 1024.
Returns:
List[List[str]]: A list of chunks, where each chunk is a list
of sentences.
Note:
This function validates the maximum sentence size based on service
limits using the 'toxicity_init_validate' function. It uses the NLTK
sentence tokenizer to split the paragraph into sentences.
Example:
paragraph = "This is a sample paragraph. It
contains multiple sentences. ..."
chunks = split_paragraph(paragraph, max_size=2048)
"""
# validate max. sentence size based on Service limits
nltk = self._toxicity_init_validate(max_size)
sentences = nltk.sent_tokenize(prompt_value)
chunks = list() # type: ignore
current_chunk = list() # type: ignore
current_size = 0
for sentence in sentences:
sentence_size = len(sentence.encode("utf-8"))
# If adding a new sentence exceeds max_size
# or current_chunk has 10 sentences, start a new chunk
if (current_size + sentence_size > max_size) or (len(current_chunk) >= 10):
if current_chunk: # Avoid appending empty chunks
chunks.append(current_chunk)
current_chunk = []
current_size = 0
current_chunk.append(sentence)
current_size += sentence_size
# Add any remaining sentences
if current_chunk:
chunks.append(current_chunk)
return chunks
def validate(self, prompt_value: str, config: Any = None) -> str:
"""
Check the toxicity of a given text prompt using AWS
Comprehend service and apply actions based on configuration.
Args:
prompt_value (str): The text content to be checked for toxicity.
config (Dict[str, Any]): Configuration for toxicity checks and actions.
Returns:
str: The original prompt_value if allowed or no toxicity found.
Raises:
ValueError: If the prompt contains toxic labels and cannot be
processed based on the configuration.
"""
chunks = self._split_paragraph(prompt_value=prompt_value)
for sentence_list in chunks:
segments = [{"Text": sentence} for sentence in sentence_list]
response = self.client.detect_toxic_content(
TextSegments=segments, LanguageCode="en"
)
if self.callback and self.callback.toxicity_callback:
self.moderation_beacon["moderation_input"] = segments # type: ignore
self.moderation_beacon["moderation_output"] = response
toxicity_found = False
threshold = config.get("threshold")
toxicity_labels = config.get("labels")
if not toxicity_labels:
for item in response["ResultList"]:
for label in item["Labels"]:
if label["Score"] >= threshold:
toxicity_found = True
break
else:
for item in response["ResultList"]:
for label in item["Labels"]:
if (
label["Name"] in toxicity_labels
and label["Score"] >= threshold
):
toxicity_found = True
break
if self.callback and self.callback.toxicity_callback:
if toxicity_found:
self.moderation_beacon["moderation_status"] = "LABELS_FOUND"
asyncio.create_task(
self.callback.on_after_toxicity(
self.moderation_beacon, self.unique_id
)
)
if toxicity_found:
raise ModerationToxicityError
return prompt_value
| [] |
2024-01-10 | yamyyao/langchain | libs~langchain~langchain~memory~readonly.py | from typing import Any, Dict, List
from langchain.schema import BaseMemory
class ReadOnlySharedMemory(BaseMemory):
"""A memory wrapper that is read-only and cannot be changed."""
memory: BaseMemory
@property
def memory_variables(self) -> List[str]:
"""Return memory variables."""
return self.memory.memory_variables
def load_memory_variables(self, inputs: Dict[str, Any]) -> Dict[str, str]:
"""Load memory variables from memory."""
return self.memory.load_memory_variables(inputs)
def save_context(self, inputs: Dict[str, Any], outputs: Dict[str, str]) -> None:
"""Nothing should be saved or changed"""
pass
def clear(self) -> None:
"""Nothing to clear, got a memory like a vault."""
pass
| [] |
2024-01-10 | huqianghui/aigc-langchain-bot | common~bing_search_multi_market.py | """Util that calls Bing Search.
In order to set this up, follow instructions at:
https://levelup.gitconnected.com/api-tutorial-how-to-use-bing-web-search-api-in-python-4165d5592a7e
"""
from typing import Dict, List
import requests
from langchain.utilities import BingSearchAPIWrapper
class BingSearchAPIMultiMarketWrapper(BingSearchAPIWrapper):
"""Wrapper for Bing Search API.
In order to set this up, follow instructions at:
https://levelup.gitconnected.com/api-tutorial-how-to-use-bing-web-search-api-in-python-4165d5592a7e
"""
bing_subscription_key: str
bing_search_url: str
k: int = 3
market: str = "en-US" # 添加 market 参数，默认为 en-US
def _bing_search_results(self, search_term: str, count: int,market: str) -> List[dict]:
headers = {"Ocp-Apim-Subscription-Key": self.bing_subscription_key}
params = {
"q": search_term,
"count": count,
"textDecorations": True,
"textFormat": "HTML",
"mkt": self.market, # 将 market 参数添加到搜索请求中
}
response = requests.get(
self.bing_search_url, headers=headers, params=params # type: ignore
)
response.raise_for_status()
search_results = response.json()
return search_results["webPages"]["value"]
def run(self, query: str) -> str:
"""Run query through BingSearch and parse result."""
snippets = []
results = self._bing_search_results(query, count=self.k,market=self.market)
if len(results) == 0:
return "No good Bing Search Result was found"
for result in results:
snippets.append(result["snippet"])
return " ".join(snippets)
def results(self, query: str, num_results: int) -> List[Dict]:
"""Run query through BingSearch and return metadata.
Args:
query: The query to search for.
num_results: The number of results to return.
Returns:
A list of dictionaries with the following keys:
snippet - The description of the result.
title - The title of the result.
link - The link to the result.
"""
metadata_results = []
results = self._bing_search_results(query, count=num_results,market=self.market)
if len(results) == 0:
return [{"Result": "No good Bing Search Result was found"}]
for result in results:
metadata_result = {
"snippet": result["snippet"],
"title": result["name"],
"link": result["url"],
}
metadata_results.append(metadata_result)
return metadata_results
| [] |
2024-01-10 | aahn33/llm-summary | map_and_refine~refine.py | from langchain.chat_models import ChatOpenAI
from langchain.docstore.document import Document
from langchain.prompts import PromptTemplate
from langchain.chains.summarize import load_summarize_chain
from langchain.text_splitter import CharacterTextSplitter
from langchain.callbacks import get_openai_callback
import tiktoken
import os
class TextRefiner:
def __init__(self, llm, model_name):
self.llm = llm
self.model_name = model_name
self.total_tokens = 0
# Setup summarization and refinement prompts
sum_prompt_template = """
Write a summary of the text that includes the main points and any important details in paragraph form.
{text}
"""
self.sum_prompt = PromptTemplate(template=sum_prompt_template, input_variables=["text"])
refine_prompt_template = '''
Your assignment is to expand an existing summary by adding new information that follows it. Here's the current summary up to a specified point:
{existing}
Now, consider the following content which occurs after the existing summary:
{text}
Evaluate the additional content for its relevance and importance in relation to the existing summary. If this new information is significant and directly relates to what has already been summarized, integrate it smoothly into the existing summary to create a comprehensive and cohesive final version. If the additional content doesn't provide substantial value or isn't relevant to the existing summary, simply return the original summary as it is. If the summary is getting too long you can shorten it by removing unnecessary details.
Your final output must only be the comprehensive and cohesive final version of the summary. It should contain no other text, such as reasoning behind the summary.
Summary:
'''
self.refine_prompt = PromptTemplate(template=refine_prompt_template, input_variables=["existing", "text"])
# Load chains
self.sum_chain = load_summarize_chain(llm, chain_type="stuff", prompt=self.sum_prompt)
self.refine_chain = load_summarize_chain(llm, chain_type="stuff", prompt=self.refine_prompt)
# Setup text splitter
self.text_splitter = CharacterTextSplitter.from_tiktoken_encoder(chunk_size=3500, chunk_overlap=0)
def refine(self, text):
texts = self.text_splitter.split_text(text)
print(f"The text was split into {len(texts)} chunks.")
texts_docs = [[Document(page_content=text)] for text in texts]
cur_summary = ""
for num, chunk in enumerate(texts_docs):
with get_openai_callback() as cb:
print(f"Processing chunk {num}")
chunk_sum = self.sum_chain.run(chunk)
self.save_to_file(chunk_sum, "chunk_sum", num)
input = {'existing': cur_summary, 'input_documents': [Document(page_content=chunk_sum)]}
cur_summary = self.refine_chain.run(input)
self.total_tokens += cb.total_tokens
self.save_to_file(cur_summary, "cur_summary", num)
return cur_summary, self.total_tokens
def save_to_file(self, text, name, iteration):
directory = "refine"
if not os.path.exists(directory):
os.makedirs(directory)
filename = f"{name}_{iteration}.txt"
with open(os.path.join(directory, filename), 'w', encoding='utf-8') as file:
file.write(text)
if __name__ == '__main__':
# Usage of the TextRefiner class
model_name = "gpt-3.5-turbo"
llm = ChatOpenAI(temperature=0, openai_api_key="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", model_name=model_name)
refiner = TextRefiner(llm, model_name)
file_path = 'Gatsby.txt'
with open(file_path, 'r', encoding='utf-8') as file:
book_text = file.read()
summary, total_tokens = refiner.refine(book_text)
print(f"Total tokens: {total_tokens}")
print(summary)
| [
"\n Your assignment is to expand an existing summary by adding new information that follows it. Here's the current summary up to a specified point:\n\n {existing}\n\n Now, consider the following content which occurs after the existing summary:\n\n {text}\n\n Evaluate the additional content for its relevance and importance in relation to the existing summary. If this new information is significant and directly relates to what has already been summarized, integrate it smoothly into the existing summary to create a comprehensive and cohesive final version. If the additional content doesn't provide substantial value or isn't relevant to the existing summary, simply return the original summary as it is. If the summary is getting too long you can shorten it by removing unnecessary details.\n\n Your final output must only be the comprehensive and cohesive final version of the summary. It should contain no other text, such as reasoning behind the summary.\n\n Summary:\n ",
"\n Write a summary of the text that includes the main points and any important details in paragraph form.\n {text}\n "
] |