Datasets:

pisterlabs

/

promptset

like 0

Follow

Pister Labs 2

2024-01-10

aahn33/llm-summary

map_and_refine~map_reduce.py

from langchain.chat_models import ChatOpenAI from langchain.docstore.document import Document from langchain import PromptTemplate from langchain.chains.summarize import load_summarize_chain from langchain.text_splitter import CharacterTextSplitter from langchain.callbacks import get_openai_callback from concurrent.futures import ThreadPoolExecutor, as_completed import tiktoken import os class MapTextSummarizer: def __init__(self, llm, model_name): self.llm = llm self.recursive_calls = 0 self.encoding = tiktoken.encoding_for_model(model_name) self.total_tokens_used = 0 # Setup prompts self.map_prompt = PromptTemplate( template="""Write a summary of this text without listing. {text}""", input_variables=["text"] ) self.combine_prompt = PromptTemplate( template="""Can you create a comprehensive summary from these mini-summaries. Your output should be a couple paragraphs long. Only use the text provided to generate the summary. {text} """, # For some reason, this prompt makes the model generate a summary unrelated to the input, it recognizes the book # template = """Write a summary of this text without listing # {text}""", input_variables=["text"] ) # Load chains self.map_chain = load_summarize_chain(self.llm, chain_type="stuff", prompt=self.map_prompt) self.reduce_chain = load_summarize_chain(self.llm, chain_type="stuff", prompt=self.combine_prompt) def summarize_chunk(self, chunk): """ Function to summarize a single chunk of text """ with get_openai_callback() as cb: summary = self.map_chain.run([Document(page_content=chunk)]) self.total_tokens_used += cb.total_tokens return summary def summarize_text(self, text): # Split text into chunks text_splitter = CharacterTextSplitter.from_tiktoken_encoder( chunk_size=3500, chunk_overlap=0, separator='\n' ) texts = text_splitter.split_text(text) self.save_to_file("\n-------------------------------------------------------\n".join(texts), "chunks",self.recursive_calls) print("The text was split into " + str(len(texts)) + " chunks.") summaries = [None] * len(texts) # Initialize a list of the correct size with placeholders # Use ThreadPoolExecutor to process chunks in parallel with ThreadPoolExecutor(max_workers=5) as executor: # Submit all chunks to be processed future_to_chunk = {executor.submit(self.summarize_chunk, chunk): i for i, chunk in enumerate(texts)} for future in as_completed(future_to_chunk): chunk_index = future_to_chunk[future] # Get the index of the chunk print(f"Processed chunk {chunk_index}") summaries[chunk_index] = future.result() # Place summary in the corresponding index # Filter out any placeholders in case some tasks failed summaries = [summary for summary in summaries if summary is not None] # Concatenate all summaries into a single string, preserving the order return "\n\n".join(summaries) def reduce_summaries(self, summaries): with get_openai_callback() as cb: final_summary = self.reduce_chain.run([Document(page_content=summaries)]) self.total_tokens_used += cb.total_tokens return final_summary def process(self, text): to_be_summarized = text iteration = 0 while len(self.encoding.encode(to_be_summarized)) > 4000: print("Performing the map step") # Before summarizing, save the current state of 'to_be_summarized' to a file self.save_to_file(to_be_summarized, "summary",iteration) to_be_summarized = self.summarize_text(to_be_summarized) self.recursive_calls += 1 iteration += 1 # print(f"Total tokens to summarize from map step: {len(self.encoding.encode(to_be_summarized))}") self.save_to_file(to_be_summarized,"summary", iteration) final_summary = self.reduce_summaries(to_be_summarized) self.save_to_file(final_summary,"final_summary", iteration) return final_summary, self.total_tokens_used def save_to_file(self, text, name, iteration): # Make sure to replace 'path_to_directory' with the actual path where you want to save the files directory = "map" 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) print(f"Saved iteration {iteration} to file") if __name__ == '__main__': model_name = "gpt-3.5-turbo" # Create an instance of the ChatOpenAI llm = ChatOpenAI( temperature=0, openai_api_key="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", model_name=model_name ) # Initialize the TextSummarizer with the llm instance summarizer = MapTextSummarizer(llm=llm, model_name=model_name) # The text to be summarized is passed here file_path = 'Gatsby.txt' # Open the text file and read its content into a string variable with open(file_path, 'r', encoding='utf-8') as file: book_text = file.read() # Call the process method with the text summary, total_tokens_used = summarizer.process(book_text) print(summary) print(f"Total tokens used: {total_tokens_used}")

2024-01-10

aahn33/llm-summary

map_and_refine~map_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 from concurrent.futures import ThreadPoolExecutor, as_completed from refine import TextRefiner import tiktoken import os # TODO: Import this from other file, I was getting an error when I tried to import it # TODO: Figure out why this method uses 5x as many tokens as just refine class MapRefineTextSummarizer: def __init__(self, llm, model_name, refine_size = 4): self.llm = llm self.recursive_calls = 0 self.encoding = tiktoken.encoding_for_model(model_name) self.total_tokens_used = 0 self.refiner = TextRefiner(llm, model_name) self.refine_size = refine_size # Setup prompts self.map_prompt = PromptTemplate( template="""Write a summary of this text without listing. {text}""", input_variables=["text"] ) self.combine_prompt = PromptTemplate( # template="""Can you create a comprehensive summary from these mini-summaries. Your output should be a couple paragraphs long. Only use the text provided to generate the summary. # {text} # """, # For some reason, this prompt makes the model generate a summary unrelated to the input, it recognizes the book template = """Write a summary of this text without listing {text}""", input_variables=["text"] ) # Load chains self.map_chain = load_summarize_chain(self.llm, chain_type="stuff", prompt=self.map_prompt) self.reduce_chain = load_summarize_chain(self.llm, chain_type="stuff", prompt=self.combine_prompt) def summarize_chunk(self, chunk): """ Function to summarize a single chunk of text """ # with get_openai_callback() as cb: # summary = self.map_chain.run([Document(page_content=chunk)]) # self.total_tokens_used += cb.total_tokens summary, tokens = self.refiner.refine(chunk) print(f"Tokens used in refine step: {tokens}") self.total_tokens_used += tokens return summary def summarize_text(self, text): # Split text into chunks # Important: The chunk size is now a multiple of the refine_size chunk_size = 3500 * self.refine_size print(f"Chunk size: {chunk_size}") text_splitter = CharacterTextSplitter.from_tiktoken_encoder( chunk_size=chunk_size, chunk_overlap=0, separator='\n' ) texts = text_splitter.split_text(text) self.save_to_file("\n-------------------------------------------------------\n".join(texts), "chunks",self.recursive_calls) print("Map: The text was split into " + str(len(texts)) + " chunks") summaries = [None] * len(texts) # Initialize a list of the correct size with placeholders # Use ThreadPoolExecutor to process chunks in parallel with ThreadPoolExecutor(max_workers=5) as executor: # Submit all chunks to be processed future_to_chunk = {executor.submit(self.summarize_chunk, chunk): i for i, chunk in enumerate(texts)} for future in as_completed(future_to_chunk): chunk_index = future_to_chunk[future] # Get the index of the chunk print(f"Processed chunk {chunk_index}") summaries[chunk_index] = future.result() # Place summary in the corresponding index # Filter out any placeholders in case some tasks failed summaries = [summary for summary in summaries if summary is not None] # Concatenate all summaries into a single string, preserving the order return "\n\n".join(summaries) def reduce_summaries(self, summaries): with get_openai_callback() as cb: final_summary = self.reduce_chain.run([Document(page_content=summaries)]) self.total_tokens_used += cb.total_tokens return final_summary def process(self, text): to_be_summarized = text iteration = 0 while len(self.encoding.encode(to_be_summarized)) > 4000: print("Performing the map step") # Before summarizing, save the current state of 'to_be_summarized' to a file self.save_to_file(to_be_summarized, "summary",iteration) to_be_summarized = self.summarize_text(to_be_summarized) self.recursive_calls += 1 iteration += 1 # print(f"Total tokens to summarize from map step: {len(self.encoding.encode(to_be_summarized))}") self.save_to_file(to_be_summarized,"summary", iteration) final_summary = self.reduce_summaries(to_be_summarized) self.save_to_file(final_summary,"final_summary", iteration) return final_summary, self.total_tokens_used def save_to_file(self, text, name, iteration): # Make sure to replace 'path_to_directory' with the actual path where you want to save the files directory = "map-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) print(f"Saved iteration {iteration} to file") model_name = "gpt-3.5-turbo" # Create an instance of the ChatOpenAI llm = ChatOpenAI( temperature=0, openai_api_key="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", model_name=model_name ) if __name__ == '__main__': # Initialize the TextSummarizer with the llm instance summarizer = MapRefineTextSummarizer(llm=llm, model_name=model_name, refine_size=4) # The text to be summarized is passed here file_path = 'Gatsby.txt' # Open the text file and read its content into a string variable with open(file_path, 'r', encoding='utf-8') as file: book_text = file.read() # Call the process method with the text summary, total_tokens_used = summarizer.process(book_text) print(summary) print(f"Total tokens used: {total_tokens_used}")

2024-01-10

aahn33/llm-summary

ai_reinforced_rs~AIReinforcedRS.py

from langchain.chat_models import ChatOpenAI from langchain.text_splitter import CharacterTextSplitter from langchain.callbacks import get_openai_callback from langchain.schema import AIMessage, HumanMessage, SystemMessage import tiktoken import random class Reinforced: def __init__(self, llm, chunk_size, chunk_percentage): self.llm = llm self.chunk_size = chunk_size self.chunk_percentage = chunk_percentage self.total_tokens_used = 0 def split(self, text): text_splitter = CharacterTextSplitter.from_tiktoken_encoder(chunk_size=self.chunk_size, chunk_overlap=0) texts = text_splitter.split_text(text) return texts def select_percentage(self, texts): num_elements = int(len(texts) * (self.chunk_percentage / 100.0)) selected_text = random.sample(list(enumerate(texts)), num_elements) return selected_text def generate_summary(self, selected_text): sys_message_summary = SystemMessage(content=( "Write a summary of this chunk of text that includes the main points and any important details." )) summaries = [] for i, chunk in enumerate(selected_text): with get_openai_callback() as cb: summaries.append((self.llm([sys_message_summary, HumanMessage(content=chunk[1])]), chunk[0])) #keep chunk index in tuple self.total_tokens_used += cb.total_tokens return summaries def incomplete_chunks(self, summaries): sys_message_incomplete = SystemMessage(content=( "Given these mini summaries with their corresponding ids (in the form \"summary\" id=id), return the ids of" + "the mini summaries that don't relate to the rest of the summaries. You only output the ids as integers in the form \"id1,id2,...idn\"." )) combined_summaries = '' for sum in summaries: combined_summaries += '(' + str(sum[0]) + ' id=' + str(sum[1]) + '),' incomplete = None with get_openai_callback() as cb: incomplete = self.llm([sys_message_incomplete, HumanMessage(content=combined_summaries)]) return incomplete def relevant_chunks_incomplete(self, summaries, incomplete, texts): content = incomplete.content more_info = [(int(float(num.strip())) if num.strip().isnumeric() else -1)for num in content.split(',')] nearby = [] for sum in summaries: nearby.append(sum[1]) for c in more_info: if c > 5: if c-5 not in nearby: nearby.append(c-5) if c < len(texts)-5: if c+5 not in nearby: nearby.append(c+5) nearby.sort() return nearby def relevant_chunks(self, nearby, texts): sys_message_summary = SystemMessage(content=( "Write a summary of this chunk of text that includes the main points and any important details." )) summaries_final = [] for i in nearby: with get_openai_callback() as cb: summaries_final.append(self.llm([sys_message_summary, HumanMessage(content=texts[i])])) self.total_tokens_used += cb.total_tokens return summaries_final def final_run(self, text): texts = self.split(text) selected_text = self.select_percentage(texts) summaries = self.generate_summary(selected_text) incomplete = self.incomplete_chunks(summaries) nearby = self.relevant_chunks_incomplete(summaries, incomplete, texts) summaries_final = self.relevant_chunks(nearby, texts) return summaries_final, self.total_tokens_used if __name__ == "__main__": llm = ChatOpenAI( temperature=0, openai_api_key="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", model_name="gpt-3.5-turbo" ) chunk_size = 35000 chunk_percentage = 50 FILE_PATH = 'Gatsby.txt' f = open(FILE_PATH, encoding='utf-8') text = f.read() reinforced = Reinforced(llm, chunk_size, chunk_percentage) result = reinforced.final_run(text) print(result)

2024-01-10

aahn33/llm-summary

govreport_testing~testing.py

import json import sys sys.path.append('../') from pathlib import Path from langchain.chat_models import ChatOpenAI from rouge import Rouge from map_and_refine.map_reduce import MapTextSummarizer from relevancy_score_tagging.relevancy import RelevancyTagger def calculate_rouge(title, summary, reference): rouge = Rouge() scores = rouge.get_scores(summary, reference)[0] score_file = open("%s.txt"%title, "w") score_file.write(f"ROUGE-1: Precision = {scores['rouge-1']['p']}, Recall = {scores['rouge-1']['r']}, F1 = {scores['rouge-1']['f']}\n") score_file.write(f"ROUGE-2: Precision = {scores['rouge-2']['p']}, Recall = {scores['rouge-2']['r']}, F1 = {scores['rouge-2']['f']}\n") score_file.write(f"ROUGE-L: Precision = {scores['rouge-l']['p']}, Recall = {scores['rouge-l']['r']}, F1 = {scores['rouge-l']['f']}\n") score_file.close() # Sample test using a single extracted file with open(Path('extracted/98-696.json'), encoding='utf-8') as f: # Retrieve testing data data = json.loads(f.read()) title = data['title'] ground_truth = data['summary'] full_text = data['full_text'] # Initialize LLM model_name = "gpt-3.5-turbo" llm = ChatOpenAI(temperature=0, openai_api_key="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", model_name=model_name) # Filter for relevant chunks in text tagger = RelevancyTagger(llm, model_name, 0.8, 500) relevant_text = tagger.tag(full_text, title) # Get output from full text map_reduce summarizer = MapTextSummarizer(llm=llm, model_name=model_name) full_summary, total_tokens_used = summarizer.process(full_text) print(full_summary) print(f"Total tokens used: {total_tokens_used}") # Get output from relevant text map_reduce relevant_summary, total_tokens_used = summarizer.process(relevant_text) print(relevant_summary) # Perform rouge test calculate_rouge('test_full', full_summary, ground_truth) calculate_rouge('test_relevant', relevant_summary, ground_truth)

2024-01-10

aahn33/llm-summary

relevancy_score_tagging~relevancy.py

import os from time import sleep from math import ceil from langchain.chat_models import ChatOpenAI from langchain.schema import AIMessage, HumanMessage, SystemMessage from langchain.callbacks import get_openai_callback from langchain.text_splitter import CharacterTextSplitter class RelevancyTagger: def __init__(self, llm, model_name, threshold, chunk_size): self.llm = llm self.model_name = model_name self.total_tokens = 0 self.threshold = threshold self.chunk_size = chunk_size def split_text(self, text): text_splitter = CharacterTextSplitter.from_tiktoken_encoder( chunk_size=self.chunk_size, chunk_overlap=0, separator='\n' ) texts = text_splitter.split_text(text) print(f'Document was split into {len(texts)} chunks') return texts def prompt_llm(self, texts, document_title=None): sys_message = SystemMessage(content=( "You are a knowledgeable assistant that takes in a chunk of a document and outputs a score from 0-100. " "You should only output the numerical score and nothing else. " f"For context, the document's title is {document_title}" if document_title else "" )) results = [] for i, chunk in enumerate(texts): with get_openai_callback() as cb: print(f'Processing chunk {i}') results.append(self.llm([sys_message, HumanMessage(content=chunk)])) self.total_tokens += cb.total_tokens # sleep(0.05) # Rate limits print(results) return results def extract_relevant_chunks(self, texts, results): scores = [(int(msg.content) if msg.content.isnumeric() else -1, idx) for idx, msg in enumerate(results)] # If response isn't a number, set score to -1 scores.sort(reverse=True, key=lambda x: (x[0], -x[1])) # If scores are tied, prefer earlier chunk num_chunks = ceil(len(scores) * self.threshold) print(f"Using a threshold of {self.threshold}, {num_chunks} chunks were selected out of {len(scores)}") scores = scores[:num_chunks] scores.sort(key=lambda x: x[1]) # Resort relevant chunks back into order relevant_chunks = [texts[idx] for _, idx in scores] print(f"Top {num_chunks} highest scores: {' '.join(str(score) for score, idx in scores)}") print(f"Tokens used: {self.total_tokens}") return relevant_chunks def tag(self, text, document_title=None): texts = self.split_text(text) results = self.prompt_llm(texts, document_title=document_title) relevant_chunks = self.extract_relevant_chunks(texts, results) return '\n'.join(relevant_chunks) if __name__ == '__main__': CHUNK_SIZE = 1000 THRESHOLD = 0.5 text = open("../Gatsby.txt", encoding='utf-8').read() model_name = "gpt-3.5-turbo" llm = ChatOpenAI(temperature=0, openai_api_key="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", model_name=model_name) tagger = RelevancyTagger(llm, model_name, THRESHOLD, CHUNK_SIZE) print(tagger.tag(text))

2024-01-10

cath-borisova/Luna

packages~model~scripts~testing.py

import openai openai.api_key = "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" model_id = "ft:gpt-3.5-turbo-0613:samyok::89sfDGan" google_content = "[ { \"role\": \"combobox\", \"name\": \"Search Google or type a URL\" }, { \"role\": \"button\", \"name\": \"Search by voice\" }, { \"role\": \"button\", \"name\": \"Search by image\" }, { \"role\": \"link\", \"name\": \"Gmail\", \"description\": \"Gmail\", \"children\": [ [Object], [Object] ] }, { \"role\": \"link\", \"name\": \"Google Drive\", \"description\": \"Google Drive\", \"children\": [ [Object], [Object] ] }, { \"role\": \"button\", \"name\": \"Add shortcut\", \"description\": \"Add shortcut\" }, { \"role\": \"button\", \"name\": \"Customize Chrome\", \"description\": \"Customize this page\", \"pressed\": false } ]" completion = openai.ChatCompletion.create( model=model_id, messages = [ {"role": "system", "content" : "Luna is a personal voice assistant that interacts with the user's browser. The goal is to open a video on youtube on how to cook eggs"}, {"role": "user", "content": google_content}, { "role": "assistant", "content": "", "function_call": { "name": "gotoPage", "arguments": "{\"url\": \"https://www.youtube.com/\"}" } }, { "role": "user", "content": "[{\"role\":\"button\",\"name\":\"Guide\"},{\"role\":\"link\",\"name\":\"YouTubeHome\"},{\"role\":\"button\",\"name\":\"Skipnavigation\"},{\"role\":\"textbox\",\"name\":\"Search\"},{\"role\":\"button\",\"name\":\"Search\",\"children\":[{\"role\":\"tooltip\",\"name\":\"\"}]},{\"role\":\"button\",\"name\":\"Searchwithyourvoice\"},{\"role\":\"tooltip\",\"name\":\"\"},{\"role\":\"generic\",\"name\":\"\",\"children\":[{\"role\":\"button\",\"name\":\"Create\"}]},{\"role\":\"button\",\"name\":\"Notifications\"},{\"role\":\"tooltip\",\"name\":\"\"},{\"role\":\"button\",\"name\":\"Accountmenu\",\"haspopup\":\"menu\"},{\"role\":\"tab\",\"name\":\"Home\",\"selected\":true,\"children\":[{\"role\":\"link\",\"name\":\"Home\",\"description\":\"Home\"}]},{\"role\":\"tab\",\"name\":\"Shorts\",\"children\":[{\"role\":\"link\",\"name\":\"Shorts\",\"description\":\"Shorts\"}]},{\"role\":\"tab\",\"name\":\"Subscriptions\",\"children\":[{\"role\":\"link\",\"name\":\"Subscriptions\",\"description\":\"Subscriptions\"}]},{\"role\":\"tab\",\"name\":\"Library\",\"children\":[{\"role\":\"link\",\"name\":\"Library\",\"description\":\"Library\"}]},{\"role\":\"tab\",\"name\":\"All\",\"selected\":true},{\"role\":\"tab\",\"name\":\"Gaming\"},{\"role\":\"tab\",\"name\":\"Music\"},{\"role\":\"tab\",\"name\":\"Jobinterviews\"},{\"role\":\"tab\",\"name\":\"Computerprogramming\"},{\"role\":\"tab\",\"name\":\"Live\"},{\"role\":\"tab\",\"name\":\"Lo-fi\"},{\"role\":\"tab\",\"name\":\"Subliminalstimuli\"},{\"role\":\"tab\",\"name\":\"Sitcoms\"},{\"role\":\"tab\",\"name\":\"Backgroundmusic\"},{\"role\":\"tab\",\"name\":\"Mixes\"},{\"role\":\"tab\",\"name\":\"Wealth\"},{\"role\":\"tab\",\"name\":\"Podcasts\"},{\"role\":\"tab\",\"name\":\"Cats\"},{\"role\":\"tab\",\"name\":\"Gameshows\"},{\"role\":\"tab\",\"name\":\"Crochet\"},{\"role\":\"tab\",\"name\":\"Numbers\"},{\"role\":\"tab\",\"name\":\"Debates\"},{\"role\":\"tab\",\"name\":\"Recentlyuploaded\"},{\"role\":\"tab\",\"name\":\"Watched\"},{\"role\":\"tab\",\"name\":\"Newtoyou\"},{\"role\":\"button\",\"name\":\"Next\"},{\"role\":\"tooltip\",\"name\":\"\"},{\"role\":\"link\",\"name\":\"ALifeEngineered\"},{\"role\":\"link\",\"name\":\"MostTechInterviewPrepisGARBAGE.(FromaPrincipalEngineeratAmazon)byALifeEngineered683,677views2yearsago12minutes,57seconds\",\"description\":\"MostTechInterviewPrepisGARBAGE.(FromaPrincipalEngineeratAmazon)\"},{\"role\":\"link\",\"name\":\"ALifeEngineered\"},{\"role\":\"tooltip\",\"name\":\"\"},{\"role\":\"tooltip\",\"name\":\"\"},{\"role\":\"StaticText\",\"name\":\"683Kviews•2yearsago\"},{\"role\":\"button\",\"name\":\"Actionmenu\"},{\"role\":\"link\",\"name\":\"JCS-CriminalPsychology\"},{\"role\":\"link\",\"name\":\"Sarahliterallythinksshe'sgoinghomelater...byJCS-CriminalPsychology17,787,834views6monthsago36minutes\",\"description\":\"Sarahliterallythinksshe'sgoinghomelater...\"},{\"role\":\"link\",\"name\":\"JCS-CriminalPsychology\"},{\"role\":\"tooltip\",\"name\":\"\"},{\"role\":\"tooltip\",\"name\":\"\"},{\"role\":\"StaticText\",\"name\":\"17Mviews•6monthsago\"},{\"role\":\"button\",\"name\":\"Actionmenu\"},{\"role\":\"link\",\"name\":\"JamesBlackwood-RaccoonWhisperer\"},{\"role\":\"link\",\"name\":\"MobbedbyRaccoons(25)TuesdayNight03Nov2020byJamesBlackwood-RaccoonWhisperer36,683,341views2yearsago21minutes\",\"description\":\"MobbedbyRaccoons(25)TuesdayNight03Nov2020\"},{\"role\":\"link\",\"name\":\"JamesBlackwood-RaccoonWhisperer\"},{\"role\":\"tooltip\",\"name\":\"\"},{\"role\":\"StaticText\",\"name\":\"36Mviews•2yearsago\"},{\"role\":\"button\",\"name\":\"Actionmenu\"},{\"role\":\"link\",\"name\":\"CroseteazacuElena\"},{\"role\":\"link\",\"name\":\"SuperModel!🧶🥰byCroseteazacuElena84views1dayago18minutes\",\"description\":\"SuperModel!🧶🥰\"},{\"role\":\"link\",\"name\":\"CroseteazacuElena\"},{\"role\":\"tooltip\",\"name\":\"\"},{\"role\":\"StaticText\",\"name\":\"84views•1dayago\"},{\"role\":\"button\",\"name\":\"Actionmenu\"},{\"role\":\"link\",\"name\":\"AIWarehouse\"},{\"role\":\"link\",\"name\":\"AILearnstoWalk(deepreinforcementlearning)byAIWarehouse6,365,090views5monthsago8minutes,40seconds\",\"description\":\"AILearnstoWalk(deepreinforcementlearning)\"},{\"role\":\"link\",\"name\":\"AIWarehouse\"},{\"role\":\"tooltip\",\"name\":\"\"},{\"role\":\"tooltip\",\"name\":\"\"},{\"role\":\"StaticText\",\"name\":\"6.3Mviews•5monthsago\"},{\"role\":\"button\",\"name\":\"Actionmenu\"},{\"role\":\"heading\",\"name\":\"Shorts\",\"level\":2},{\"role\":\"button\",\"name\":\"Notinterested\"},{\"role\":\"tooltip\",\"name\":\"\"},{\"role\":\"link\",\"name\":\"HowtomakeNOHEATCURLS|TUTORIALwithResult-24seconds-playvideo\",\"description\":\"HowtomakeNOHEATCURLS|TUTORIALwithResult\"},{\"role\":\"StaticText\",\"name\":\"19Mviews\"},{\"role\":\"button\",\"name\":\"Moreactions\"},{\"role\":\"link\",\"name\":\"thisisastemschool-1minute-playvideo\",\"description\":\"thisisastemschool\"},{\"role\":\"StaticText\",\"name\":\"683Kviews\"},{\"role\":\"button\",\"name\":\"Moreactions\"},{\"role\":\"link\",\"name\":\"HowNon-MusiciansThinkViolinistsPracticeVSHowViolinistsActuallypractice-20seconds-playvideo\",\"description\":\"HowNon-MusiciansThinkViolinistsPracticeVSHowViolinistsActuallypractice\"},{\"role\":\"StaticText\",\"name\":\"916Kviews\"},{\"role\":\"button\",\"name\":\"Moreactions\"},{\"role\":\"link\",\"name\":\"Ohthismaybemybestkeptsecret..😮-48seconds-playvideo\",\"description\":\"Ohthismaybemybestkeptsecret..😮\"},{\"role\":\"StaticText\",\"name\":\"934Kviews\"},{\"role\":\"button\",\"name\":\"Moreactions\"},{\"role\":\"button\",\"name\":\"Showmore\"},{\"role\":\"tooltip\",\"name\":\"\"},{\"role\":\"link\",\"name\":\"SaturdayNightLive\"},{\"role\":\"link\",\"name\":\"OldEnough!LongtermBoyfriends!-SNLbySaturdayNightLive5,387,139views1yearago4minutes,2seconds\",\"description\":\"OldEnough!LongtermBoyfriends!-SNL\"},{\"role\":\"link\",\"name\":\"SaturdayNightLive\"},{\"role\":\"tooltip\",\"name\":\"\"},{\"role\":\"tooltip\",\"name\":\"\"},{\"role\":\"StaticText\",\"name\":\"5.3Mviews•1yearago\"},{\"role\":\"button\",\"name\":\"Actionmenu\"},{\"role\":\"link\",\"name\":\"Nemo'sDreamscapes\"},{\"role\":\"link\",\"name\":\"1940'saSummereveningsittingonaporchandit'sraining(oldiesmusicfromanotherroom)ASMRbyNemo'sDreamscapes922,495viewsStreamed5monthsago5hours,59minutes\",\"description\":\"1940'saSummereveningsittingonaporchandit'sraining(oldiesmusicfromanotherroom)ASMR\"},{\"role\":\"link\",\"name\":\"Nemo'sDreamscapes\"},{\"role\":\"tooltip\",\"name\":\"\"},{\"role\":\"tooltip\",\"name\":\"\"},{\"role\":\"StaticText\",\"name\":\"922Kviews•Streamed5monthsago\"},{\"role\":\"button\",\"name\":\"Actionmenu\"},{\"role\":\"link\",\"name\":\"colinfurze\"},{\"role\":\"link\",\"name\":\"DiggingASecretTunnel(Phase2HASBEGUN)bycolinfurze2,486,076views2weeksago5minutes,55seconds\",\"description\":\"DiggingASecretTunnel(Phase2HASBEGUN)\"},{\"role\":\"link\",\"name\":\"colinfurze\"},{\"role\":\"tooltip\",\"name\":\"\"},{\"role\":\"tooltip\",\"name\":\"\"},{\"role\":\"StaticText\",\"name\":\"2.4Mviews•2weeksago\"},{\"role\":\"button\",\"name\":\"Actionmenu\"},{\"role\":\"StaticText\",\"name\":\"FeaturedRELEASEDthisweek!DiscoverthebestnewmusicandnewartistseveryweekontheRELEASEDplaylistonYouTube\"},{\"role\":\"link\",\"name\":\"BadBunny\"},{\"role\":\"link\",\"name\":\"BADBUNNY-MONACO(OfficialVideo)|nadiesabeloquevaapasarmañanabyBadBunny7minutes,20seconds\",\"description\":\"BADBUNNY-MONACO(OfficialVideo)|nadiesabeloquevaapasarmañana\"},{\"role\":\"link\",\"name\":\"BadBunny\"},{\"role\":\"tooltip\",\"name\":\"\"},{\"role\":\"tooltip\",\"name\":\"\"},{\"role\":\"button\",\"name\":\"Actionmenu\"},{\"role\":\"link\",\"name\":\"IceSpice\"},{\"role\":\"link\",\"name\":\"IceSpice,Rema-PrettyGirl(OfficialMusicVideo)byIceSpice2minutes,17seconds\",\"description\":\"IceSpice,Rema-PrettyGirl(OfficialMusicVideo)\"},{\"role\":\"link\",\"name\":\"IceSpice\"},{\"role\":\"tooltip\",\"name\":\"\"},{\"role\":\"tooltip\",\"name\":\"\"},{\"role\":\"button\",\"name\":\"Actionmenu\"},{\"role\":\"button\",\"name\":\"Showmore\"},{\"role\":\"tooltip\",\"name\":\"\"},{\"role\":\"button\",\"name\":\"Close\"},{\"role\":\"link\",\"name\":\"NeetCode\"},{\"role\":\"link\",\"name\":\"HowIGotGoodatCodingInterviewsbyNeetCode1,423,810views2yearsago6minutes,29seconds\",\"description\":\"HowIGotGoodatCodingInterviews\"},{\"role\":\"link\",\"name\":\"NeetCode\"},{\"role\":\"tooltip\",\"name\":\"\"},{\"role\":\"tooltip\",\"name\":\"\"},{\"role\":\"StaticText\",\"name\":\"1.4Mviews•2yearsago\"},{\"role\":\"button\",\"name\":\"Actionmenu\"},{\"role\":\"link\",\"name\":\"Blurred\"},{\"role\":\"link\",\"name\":\"HalloweenLofi🎃[ChillAutumnLo-fiHip-hop&FallLo-fiHip-hop]byBlurred860,235views1yearago1hour,39minutes\",\"description\":\"HalloweenLofi🎃[ChillAutumnLo-fiHip-hop&FallLo-fiHip-hop]\"},{\"role\":\"link\",\"name\":\"Blurred\"},{\"role\":\"tooltip\",\"name\":\"\"},{\"role\":\"StaticText\",\"name\":\"860Kviews•1yearago\"},{\"role\":\"button\",\"name\":\"Actionmenu\"},{\"role\":\"link\",\"name\":\"TanHandicraft\"},{\"role\":\"link\",\"name\":\"someofmyDiykittutorial2023-part3-until11Oct2023byTanHandicraft35views3daysago2minutes,57seconds\",\"description\":\"someofmyDiykittutorial2023-part3-until11Oct2023\"},{\"role\":\"link\",\"name\":\"TanHandicraft\"},{\"role\":\"tooltip\",\"name\":\"\"},{\"role\":\"StaticText\",\"name\":\"35views•3daysago\"},{\"role\":\"button\",\"name\":\"Actionmenu\"},{\"role\":\"link\",\"name\":\"Primetimemoviesforyou\"},{\"role\":\"StaticText\",\"name\":\"FeaturedWatchdirectlyonYouTube\"},{\"role\":\"link\",\"name\":\"Exploremoremovies\"},{\"role\":\"button\",\"name\":\"Notinterested\"},{\"role\":\"tooltip\",\"name\":\"\"},{\"role\":\"link\",\"name\":\"TheJesterbyHorror•20231hour,30minutes\",\"description\":\"TheJester\"},{\"role\":\"StaticText\",\"name\":\"Horror•2023\"},{\"role\":\"tooltip\",\"name\":\"\"},{\"role\":\"button\",\"name\":\"Actionmenu\"},{\"role\":\"StaticText\",\"name\":\"Buyorrent\"},{\"role\":\"link\",\"name\":\"NoHardFeelingsbyComedy•20231hour,43minutes\",\"description\":\"NoHardFeelings\"},{\"role\":\"StaticText\",\"name\":\"Comedy•2023\"},{\"role\":\"tooltip\",\"name\":\"\"},{\"role\":\"button\",\"name\":\"Actionmenu\"},{\"role\":\"StaticText\",\"name\":\"BuyorrentR\"},{\"role\":\"link\",\"name\":\"BarbiebyComedy•20231hour,54minutes\",\"description\":\"Barbie\"},{\"role\":\"StaticText\",\"name\":\"Comedy•2023\"},{\"role\":\"tooltip\",\"name\":\"\"},{\"role\":\"button\",\"name\":\"Actionmenu\"},{\"role\":\"StaticText\",\"name\":\"BuyorrentPG-13\"},{\"role\":\"link\",\"name\":\"BottomsbyComedy•20231hour,31minutes\",\"description\":\"Bottoms\"},{\"role\":\"StaticText\",\"name\":\"Comedy•2023\"},{\"role\":\"tooltip\",\"name\":\"\"},{\"role\":\"button\",\"name\":\"Actionmenu\"},{\"role\":\"StaticText\",\"name\":\"BuyorrentR\"},{\"role\":\"button\",\"name\":\"Showmore\"},{\"role\":\"tooltip\",\"name\":\"\"},{\"role\":\"link\",\"name\":\"DanLok\"},{\"role\":\"link\",\"name\":\"TellMeAboutYourself-AGoodAnswerToThisInterviewQuestionbyDanLok16,186,449views3yearsago10minutes,2seconds\",\"description\":\"TellMeAboutYourself-AGoodAnswerToThisInterviewQuestion\"},{\"role\":\"link\",\"name\":\"DanLok\"},{\"role\":\"tooltip\",\"name\":\"\"},{\"role\":\"tooltip\",\"name\":\"\"},{\"role\":\"StaticText\",\"name\":\"16Mviews•3yearsago\"},{\"role\":\"button\",\"name\":\"Actionmenu\"},{\"role\":\"link\",\"name\":\"Crave\"},{\"role\":\"link\",\"name\":\"Letterkenny-BloopersbyCrave3,034,813views5yearsago6minutes,59seconds\",\"description\":\"Letterkenny-Bloopers\"},{\"role\":\"link\",\"name\":\"Crave\"},{\"role\":\"tooltip\",\"name\":\"\"},{\"role\":\"tooltip\",\"name\":\"\"},{\"role\":\"StaticText\",\"name\":\"3Mviews•5yearsago\"},{\"role\":\"button\",\"name\":\"Actionmenu\"},{\"role\":\"link\",\"name\":\"GreenredProductions-RelaxingMusic\"},{\"role\":\"link\",\"name\":\"ADHDReliefMusic:StudyingMusicforBetterConcentrationandFocus,StudyMusicbyGreenredProductions-RelaxingMusic3,480,529views9monthsago7hours,47minutes\",\"description\":\"ADHDReliefMusic:StudyingMusicforBetterConcentrationandFocus,StudyMusic\"},{\"role\":\"link\",\"name\":\"GreenredProductions-RelaxingMusic\"},{\"role\":\"tooltip\",\"name\":\"\"},{\"role\":\"tooltip\",\"name\":\"\"},{\"role\":\"StaticText\",\"name\":\"3.4Mviews•9monthsago\"},{\"role\":\"button\",\"name\":\"Actionmenu\"},{\"role\":\"link\",\"name\":\"TheDeadSouth\"},{\"role\":\"link\",\"name\":\"TheDeadSouth-PeopleAreStrange[OfficialMusicVideo]byTheDeadSouth10,228,654views1yearago3minutes,14seconds\",\"description\":\"TheDeadSouth-PeopleAreStrange[OfficialMusicVideo]\"},{\"role\":\"link\",\"name\":\"TheDeadSouth\"},{\"role\":\"tooltip\",\"name\":\"\"},{\"role\":\"tooltip\",\"name\":\"\"},{\"role\":\"StaticText\",\"name\":\"10Mviews•1yearago\"},{\"role\":\"button\",\"name\":\"Actionmenu\"},{\"role\":\"link\",\"name\":\"TheEconomist\"},{\"role\":\"link\",\"name\":\"WallStreet'sking,JamieDimon,ontheUSpresidencybyTheEconomist381,575views3monthsago16minutes\",\"description\":\"WallStreet'sking,JamieDimon,ontheUSpresidency\"},{\"role\":\"link\",\"name\":\"TheEconomist\"},{\"role\":\"tooltip\",\"name\":\"\"},{\"role\":\"tooltip\",\"name\":\"\"},{\"role\":\"StaticText\",\"name\":\"381Kviews•3monthsago\"},{\"role\":\"button\",\"name\":\"Actionmenu\"}]" }], functions = [{"name": "askUser", "description": "Prompt the user for input. The user's response can be used to fill out a form, answer a question, or click the right button.", "parameters": {"type": "object", "properties": {"question": {"type": "string", "description": "The question to display to the user. Questions should be phrased as if they were being asked by a human."}}, "required": ["message"]}}, {"name": "click", "description": "Click on a given element on the page", "parameters": {"type": "object", "properties": {"role": {"type": "string", "description": "The role of the element to click on"}, "name": {"type": "string", "description": "The name of the element to click on"}}, "required": ["role", "name"]}}, {"name": "create_steps", "description": "Create a list of steps that other browser agents should do to complete a task", "parameters": {"type": "object", "properties": {"task": {"type": "string", "description": "The task to complete"}, "steps": {"type": "array", "items": {"type": "string"}}}}}, {"name": "finished", "description": "Indicate that the task has finished, and pass any relevant information to the next agent. This must be the last function in a task.", "parameters": {"type": "object", "properties": {"information": {"type": "object", "description": "Any information that the next agent will need to complete their objective."}}, "required": ["information"]}}, {"name": "gotoPage", "description": "Go to a given page", "parameters": {"type": "object", "properties": {"url": {"type": "string", "description": "The URL of the page to go to"}}, "required": ["url"]}}, {"name": "readPage", "description": "Read the contents of a webpage", "parameters": {"type": "object", "properties": {"url": {"type": "string", "description": "The URL of the page to read"}}, "required": ["url"]}}, {"name": "scroll", "description": "Scroll to a given element on the page", "parameters": {"type": "object", "properties": {"selector": {"type": "string", "description": "A description of the element on the page to scroll to"}}, "required": ["selector"]}}, {"name": "type", "description": "Type a given value into a given element on the page", "parameters": {"type": "object", "properties": {"name": {"type": "string", "description": "The name of the element to type into"}, "role": {"type": "string", "description": "The role of the element to type into"}, "value": {"type": "string", "description": "The value to type into the element"}, "pressEnter": {"type": "boolean", "description": "Whether or not to press enter after typing the value"}}, "required": ["name", "role", "value"]}}] ) print(completion.choices[0]) #[{"functions": [{"name": "askUser", "description": "Prompt the user for input. The user's response can be used to fill out a form, answer a question, or click the right button.", "parameters": {"type": "object", "properties": {"question": {"type": "string", "description": "The question to display to the user. Questions should be phrased as if they were being asked by a human."}}, "required": ["message"]}}, {"name": "click", "description": "Click on a given element on the page", "parameters": {"type": "object", "properties": {"role": {"type": "string", "description": "The role of the element to click on"}, "name": {"type": "string", "description": "The name of the element to click on"}}, "required": ["role", "name"]}}, {"name": "create_steps", "description": "Create a list of steps that other browser agents should do to complete a task", "parameters": {"type": "object", "properties": {"task": {"type": "string", "description": "The task to complete"}, "steps": {"type": "array", "items": {"type": "string"}}}}}, {"name": "finished", "description": "Indicate that the task has finished, and pass any relevant information to the next agent. This must be the last function in a task.", "parameters": {"type": "object", "properties": {"information": {"type": "object", "description": "Any information that the next agent will need to complete their objective."}}, "required": ["information"]}}, {"name": "gotoPage", "description": "Go to a given page", "parameters": {"type": "object", "properties": {"url": {"type": "string", "description": "The URL of the page to go to"}}, "required": ["url"]}}, {"name": "readPage", "description": "Read the contents of a webpage", "parameters": {"type": "object", "properties": {"url": {"type": "string", "description": "The URL of the page to read"}}, "required": ["url"]}}, {"name": "scroll", "description": "Scroll to a given element on the page", "parameters": {"type": "object", "properties": {"selector": {"type": "string", "description": "A description of the element on the page to scroll to"}}, "required": ["selector"]}}, {"name": "type", "description": "Type a given value into a given element on the page", "parameters": {"type": "object", "properties": {"name": {"type": "string", "description": "The name of the element to type into"}, "role": {"type": "string", "description": "The role of the element to type into"}, "value": {"type": "string", "description": "The value to type into the element"}, "pressEnter": {"type": "boolean", "description": "Whether or not to press enter after typing the value"}}, "required": ["name", "role", "value"]}}]}]

2024-01-10

cath-borisova/Luna

packages~model~scripts~finetuning.py

import os import openai openai.api_key = "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" response = openai.File.create( file=open("../data/finetuning_data.jsonl", "rb"), purpose='fine-tune' ) openai.FineTuningJob.create(training_file=response.id, model="gpt-3.5-turbo")

2024-01-10

cath-borisova/Luna

packages~model~scripts~delete_model.py

import openai openai.api_key = "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" file_to_delete ="" openai.Model.delete(file_to_delete)

2024-01-10

kumar045/dify

api~core~chain~llm_router_chain.py

"""Base classes for LLM-powered router chains.""" from __future__ import annotations import json from typing import Any, Dict, List, Optional, Type, cast, NamedTuple from langchain.chains.base import Chain from pydantic import root_validator from langchain.chains import LLMChain from langchain.prompts import BasePromptTemplate from langchain.schema import BaseOutputParser, OutputParserException, BaseLanguageModel from libs.json_in_md_parser import parse_and_check_json_markdown class Route(NamedTuple): destination: Optional[str] next_inputs: Dict[str, Any] class LLMRouterChain(Chain): """A router chain that uses an LLM chain to perform routing.""" llm_chain: LLMChain """LLM chain used to perform routing""" @root_validator() def validate_prompt(cls, values: dict) -> dict: prompt = values["llm_chain"].prompt if prompt.output_parser is None: raise ValueError( "LLMRouterChain requires base llm_chain prompt to have an output" " parser that converts LLM text output to a dictionary with keys" " 'destination' and 'next_inputs'. Received a prompt with no output" " parser." ) return values @property def input_keys(self) -> List[str]: """Will be whatever keys the LLM chain prompt expects. :meta private: """ return self.llm_chain.input_keys def _validate_outputs(self, outputs: Dict[str, Any]) -> None: super()._validate_outputs(outputs) if not isinstance(outputs["next_inputs"], dict): raise ValueError def _call( self, inputs: Dict[str, Any] ) -> Dict[str, Any]: output = cast( Dict[str, Any], self.llm_chain.predict_and_parse(**inputs), ) return output @classmethod def from_llm( cls, llm: BaseLanguageModel, prompt: BasePromptTemplate, **kwargs: Any ) -> LLMRouterChain: """Convenience constructor.""" llm_chain = LLMChain(llm=llm, prompt=prompt) return cls(llm_chain=llm_chain, **kwargs) @property def output_keys(self) -> List[str]: return ["destination", "next_inputs"] def route(self, inputs: Dict[str, Any]) -> Route: result = self(inputs) return Route(result["destination"], result["next_inputs"]) class RouterOutputParser(BaseOutputParser[Dict[str, str]]): """Parser for output of router chain int he multi-prompt chain.""" default_destination: str = "DEFAULT" next_inputs_type: Type = str next_inputs_inner_key: str = "input" def parse(self, text: str) -> Dict[str, Any]: try: expected_keys = ["destination", "next_inputs"] parsed = parse_and_check_json_markdown(text, expected_keys) if not isinstance(parsed["destination"], str): raise ValueError("Expected 'destination' to be a string.") if not isinstance(parsed["next_inputs"], self.next_inputs_type): raise ValueError( f"Expected 'next_inputs' to be {self.next_inputs_type}." ) parsed["next_inputs"] = {self.next_inputs_inner_key: parsed["next_inputs"]} if ( parsed["destination"].strip().lower() == self.default_destination.lower() ): parsed["destination"] = None else: parsed["destination"] = parsed["destination"].strip() return parsed except Exception as e: raise OutputParserException( f"Parsing text\n{text}\n of llm router raised following error:\n{e}" )

2024-01-10

kumar045/dify

api~core~generator~llm_generator.py

import logging from langchain.chat_models.base import BaseChatModel from langchain.schema import HumanMessage from core.constant import llm_constant from core.llm.llm_builder import LLMBuilder from core.llm.streamable_open_ai import StreamableOpenAI from core.llm.token_calculator import TokenCalculator from core.prompt.output_parser.rule_config_generator import RuleConfigGeneratorOutputParser from core.prompt.output_parser.suggested_questions_after_answer import SuggestedQuestionsAfterAnswerOutputParser from core.prompt.prompt_template import OutLinePromptTemplate from core.prompt.prompts import CONVERSATION_TITLE_PROMPT, CONVERSATION_SUMMARY_PROMPT, INTRODUCTION_GENERATE_PROMPT # gpt-3.5-turbo works not well generate_base_model = 'text-davinci-003' class LLMGenerator: @classmethod def generate_conversation_name(cls, tenant_id: str, query, answer): prompt = CONVERSATION_TITLE_PROMPT prompt = prompt.format(query=query, answer=answer) llm: StreamableOpenAI = LLMBuilder.to_llm( tenant_id=tenant_id, model_name=generate_base_model, max_tokens=50 ) if isinstance(llm, BaseChatModel): prompt = [HumanMessage(content=prompt)] response = llm.generate([prompt]) answer = response.generations[0][0].text return answer.strip() @classmethod def generate_conversation_summary(cls, tenant_id: str, messages): max_tokens = 200 prompt = CONVERSATION_SUMMARY_PROMPT prompt_with_empty_context = prompt.format(context='') prompt_tokens = TokenCalculator.get_num_tokens(generate_base_model, prompt_with_empty_context) rest_tokens = llm_constant.max_context_token_length[generate_base_model] - prompt_tokens - max_tokens context = '' for message in messages: if not message.answer: continue message_qa_text = "Human:" + message.query + "\nAI:" + message.answer + "\n" if rest_tokens - TokenCalculator.get_num_tokens(generate_base_model, context + message_qa_text) > 0: context += message_qa_text prompt = prompt.format(context=context) llm: StreamableOpenAI = LLMBuilder.to_llm( tenant_id=tenant_id, model_name=generate_base_model, max_tokens=max_tokens ) if isinstance(llm, BaseChatModel): prompt = [HumanMessage(content=prompt)] response = llm.generate([prompt]) answer = response.generations[0][0].text return answer.strip() @classmethod def generate_introduction(cls, tenant_id: str, pre_prompt: str): prompt = INTRODUCTION_GENERATE_PROMPT prompt = prompt.format(prompt=pre_prompt) llm: StreamableOpenAI = LLMBuilder.to_llm( tenant_id=tenant_id, model_name=generate_base_model, ) if isinstance(llm, BaseChatModel): prompt = [HumanMessage(content=prompt)] response = llm.generate([prompt]) answer = response.generations[0][0].text return answer.strip() @classmethod def generate_suggested_questions_after_answer(cls, tenant_id: str, histories: str): output_parser = SuggestedQuestionsAfterAnswerOutputParser() format_instructions = output_parser.get_format_instructions() prompt = OutLinePromptTemplate( template="{histories}\n{format_instructions}\nquestions:\n", input_variables=["histories"], partial_variables={"format_instructions": format_instructions} ) _input = prompt.format_prompt(histories=histories) llm: StreamableOpenAI = LLMBuilder.to_llm( tenant_id=tenant_id, model_name=generate_base_model, temperature=0, max_tokens=256 ) if isinstance(llm, BaseChatModel): query = [HumanMessage(content=_input.to_string())] else: query = _input.to_string() try: output = llm(query) questions = output_parser.parse(output) except Exception: logging.exception("Error generating suggested questions after answer") questions = [] return questions @classmethod def generate_rule_config(cls, tenant_id: str, audiences: str, hoping_to_solve: str) -> dict: output_parser = RuleConfigGeneratorOutputParser() prompt = OutLinePromptTemplate( template=output_parser.get_format_instructions(), input_variables=["audiences", "hoping_to_solve"], partial_variables={ "variable": '{variable}', "lanA": '{lanA}', "lanB": '{lanB}', "topic": '{topic}' }, validate_template=False ) _input = prompt.format_prompt(audiences=audiences, hoping_to_solve=hoping_to_solve) llm: StreamableOpenAI = LLMBuilder.to_llm( tenant_id=tenant_id, model_name=generate_base_model, temperature=0, max_tokens=512 ) if isinstance(llm, BaseChatModel): query = [HumanMessage(content=_input.to_string())] else: query = _input.to_string() try: output = llm(query) rule_config = output_parser.parse(output) except Exception: logging.exception("Error generating prompt") rule_config = { "prompt": "", "variables": [], "opening_statement": "" } return rule_config

2024-01-10

kumar045/dify

api~libs~json_in_md_parser.py

import json from typing import List from langchain.schema import OutputParserException def parse_json_markdown(json_string: str) -> dict: # Remove the triple backticks if present json_string = json_string.strip() start_index = json_string.find("```json") end_index = json_string.find("```", start_index + len("```json")) if start_index != -1 and end_index != -1: extracted_content = json_string[start_index + len("```json"):end_index].strip() # Parse the JSON string into a Python dictionary parsed = json.loads(extracted_content) elif json_string.startswith("{"): # Parse the JSON string into a Python dictionary parsed = json.loads(json_string) else: raise Exception("Could not find JSON block in the output.") return parsed def parse_and_check_json_markdown(text: str, expected_keys: List[str]) -> dict: try: json_obj = parse_json_markdown(text) except json.JSONDecodeError as e: raise OutputParserException(f"Got invalid JSON object. Error: {e}") for key in expected_keys: if key not in json_obj: raise OutputParserException( f"Got invalid return object. Expected key `{key}` " f"to be present, but got {json_obj}" ) return json_obj

2024-01-10

kumar045/dify

api~core~chain~main_chain_builder.py

from typing import Optional, List from langchain.callbacks import SharedCallbackManager, CallbackManager from langchain.chains import SequentialChain from langchain.chains.base import Chain from langchain.memory.chat_memory import BaseChatMemory from core.callback_handler.agent_loop_gather_callback_handler import AgentLoopGatherCallbackHandler from core.callback_handler.main_chain_gather_callback_handler import MainChainGatherCallbackHandler from core.callback_handler.std_out_callback_handler import DifyStdOutCallbackHandler from core.chain.chain_builder import ChainBuilder from core.chain.multi_dataset_router_chain import MultiDatasetRouterChain from core.conversation_message_task import ConversationMessageTask from extensions.ext_database import db from models.dataset import Dataset class MainChainBuilder: @classmethod def to_langchain_components(cls, tenant_id: str, agent_mode: dict, memory: Optional[BaseChatMemory], conversation_message_task: ConversationMessageTask): first_input_key = "input" final_output_key = "output" chains = [] chain_callback_handler = MainChainGatherCallbackHandler(conversation_message_task) # agent mode tool_chains, chains_output_key = cls.get_agent_chains( tenant_id=tenant_id, agent_mode=agent_mode, memory=memory, conversation_message_task=conversation_message_task ) chains += tool_chains if chains_output_key: final_output_key = chains_output_key if len(chains) == 0: return None for chain in chains: # do not add handler into singleton callback manager if not isinstance(chain.callback_manager, SharedCallbackManager): chain.callback_manager.add_handler(chain_callback_handler) # build main chain overall_chain = SequentialChain( chains=chains, input_variables=[first_input_key], output_variables=[final_output_key], memory=memory, # only for use the memory prompt input key ) return overall_chain @classmethod def get_agent_chains(cls, tenant_id: str, agent_mode: dict, memory: Optional[BaseChatMemory], conversation_message_task: ConversationMessageTask): # agent mode chains = [] if agent_mode and agent_mode.get('enabled'): tools = agent_mode.get('tools', []) pre_fixed_chains = [] # agent_tools = [] datasets = [] for tool in tools: tool_type = list(tool.keys())[0] tool_config = list(tool.values())[0] if tool_type == 'sensitive-word-avoidance': chain = ChainBuilder.to_sensitive_word_avoidance_chain(tool_config) if chain: pre_fixed_chains.append(chain) elif tool_type == "dataset": # get dataset from dataset id dataset = db.session.query(Dataset).filter( Dataset.tenant_id == tenant_id, Dataset.id == tool_config.get("id") ).first() if dataset: datasets.append(dataset) # add pre-fixed chains chains += pre_fixed_chains if len(datasets) > 0: # tool to chain multi_dataset_router_chain = MultiDatasetRouterChain.from_datasets( tenant_id=tenant_id, datasets=datasets, conversation_message_task=conversation_message_task, callback_manager=CallbackManager([DifyStdOutCallbackHandler()]) ) chains.append(multi_dataset_router_chain) final_output_key = cls.get_chains_output_key(chains) return chains, final_output_key @classmethod def get_chains_output_key(cls, chains: List[Chain]): if len(chains) > 0: return chains[-1].output_keys[0] return None

2024-01-10

kumar045/dify

api~core~tool~dataset_tool_builder.py

from typing import Optional from langchain.callbacks import CallbackManager from llama_index.langchain_helpers.agents import IndexToolConfig from core.callback_handler.dataset_tool_callback_handler import DatasetToolCallbackHandler from core.callback_handler.index_tool_callback_handler import DatasetIndexToolCallbackHandler from core.callback_handler.std_out_callback_handler import DifyStdOutCallbackHandler from core.index.keyword_table_index import KeywordTableIndex from core.index.vector_index import VectorIndex from core.prompt.prompts import QUERY_KEYWORD_EXTRACT_TEMPLATE from core.tool.llama_index_tool import EnhanceLlamaIndexTool from models.dataset import Dataset class DatasetToolBuilder: @classmethod def build_dataset_tool(cls, dataset: Dataset, response_mode: str = "no_synthesizer", callback_handler: Optional[DatasetToolCallbackHandler] = None): if dataset.indexing_technique == "economy": # use keyword table query index = KeywordTableIndex(dataset=dataset).query_index if not index: return None query_kwargs = { "mode": "default", "response_mode": response_mode, "query_keyword_extract_template": QUERY_KEYWORD_EXTRACT_TEMPLATE, "max_keywords_per_query": 5, # If num_chunks_per_query is too large, # it will slow down the synthesis process due to multiple iterations of refinement. "num_chunks_per_query": 2 } else: index = VectorIndex(dataset=dataset).query_index if not index: return None query_kwargs = { "mode": "default", "response_mode": response_mode, # If top_k is too large, # it will slow down the synthesis process due to multiple iterations of refinement. "similarity_top_k": 2 } # fulfill description when it is empty description = dataset.description if not description: description = 'useful for when you want to answer queries about the ' + dataset.name index_tool_config = IndexToolConfig( index=index, name=f"dataset-{dataset.id}", description=description, index_query_kwargs=query_kwargs, tool_kwargs={ "callback_manager": CallbackManager([callback_handler, DifyStdOutCallbackHandler()]) }, # tool_kwargs={"return_direct": True}, # return_direct: Whether to return LLM results directly or process the output data with an Output Parser ) index_callback_handler = DatasetIndexToolCallbackHandler(dataset_id=dataset.id) return EnhanceLlamaIndexTool.from_tool_config( tool_config=index_tool_config, callback_handler=index_callback_handler )

2024-01-10

kumar045/dify

api~core~chain~multi_dataset_router_chain.py

from typing import Mapping, List, Dict, Any, Optional from langchain import LLMChain, PromptTemplate, ConversationChain from langchain.callbacks import CallbackManager from langchain.chains.base import Chain from langchain.schema import BaseLanguageModel from pydantic import Extra from core.callback_handler.dataset_tool_callback_handler import DatasetToolCallbackHandler from core.callback_handler.std_out_callback_handler import DifyStdOutCallbackHandler from core.chain.llm_router_chain import LLMRouterChain, RouterOutputParser from core.conversation_message_task import ConversationMessageTask from core.llm.llm_builder import LLMBuilder from core.tool.dataset_tool_builder import DatasetToolBuilder from core.tool.llama_index_tool import EnhanceLlamaIndexTool from models.dataset import Dataset MULTI_PROMPT_ROUTER_TEMPLATE = """ Given a raw text input to a language model select the model prompt best suited for \ the input. You will be given the names of the available prompts and a description of \ what the prompt is best suited for. You may also revise the original input if you \ think that revising it will ultimately lead to a better response from the language \ model. << FORMATTING >> Return a markdown code snippet with a JSON object formatted to look like, \ no any other string out of markdown code snippet: ```json {{{{ "destination": string \\ name of the prompt to use or "DEFAULT" "next_inputs": string \\ a potentially modified version of the original input }}}} ``` REMEMBER: "destination" MUST be one of the candidate prompt names specified below OR \ it can be "DEFAULT" if the input is not well suited for any of the candidate prompts. REMEMBER: "next_inputs" can just be the original input if you don't think any \ modifications are needed. << CANDIDATE PROMPTS >> {destinations} << INPUT >> {{input}} << OUTPUT >> """ class MultiDatasetRouterChain(Chain): """Use a single chain to route an input to one of multiple candidate chains.""" router_chain: LLMRouterChain """Chain for deciding a destination chain and the input to it.""" dataset_tools: Mapping[str, EnhanceLlamaIndexTool] """Map of name to candidate chains that inputs can be routed to.""" class Config: """Configuration for this pydantic object.""" extra = Extra.forbid arbitrary_types_allowed = True @property def input_keys(self) -> List[str]: """Will be whatever keys the router chain prompt expects. :meta private: """ return self.router_chain.input_keys @property def output_keys(self) -> List[str]: return ["text"] @classmethod def from_datasets( cls, tenant_id: str, datasets: List[Dataset], conversation_message_task: ConversationMessageTask, **kwargs: Any, ): """Convenience constructor for instantiating from destination prompts.""" llm_callback_manager = CallbackManager([DifyStdOutCallbackHandler()]) llm = LLMBuilder.to_llm( tenant_id=tenant_id, model_name='gpt-3.5-turbo', temperature=0, max_tokens=1024, callback_manager=llm_callback_manager ) destinations = ["{}: {}".format(d.id, d.description.replace('\n', ' ') if d.description else ('useful for when you want to answer queries about the ' + d.name)) for d in datasets] destinations_str = "\n".join(destinations) router_template = MULTI_PROMPT_ROUTER_TEMPLATE.format( destinations=destinations_str ) router_prompt = PromptTemplate( template=router_template, input_variables=["input"], output_parser=RouterOutputParser(), ) router_chain = LLMRouterChain.from_llm(llm, router_prompt) dataset_tools = {} for dataset in datasets: dataset_tool = DatasetToolBuilder.build_dataset_tool( dataset=dataset, response_mode='no_synthesizer', # "compact" callback_handler=DatasetToolCallbackHandler(conversation_message_task) ) if dataset_tool: dataset_tools[dataset.id] = dataset_tool return cls( router_chain=router_chain, dataset_tools=dataset_tools, **kwargs, ) def _call( self, inputs: Dict[str, Any] ) -> Dict[str, Any]: if len(self.dataset_tools) == 0: return {"text": ''} elif len(self.dataset_tools) == 1: return {"text": next(iter(self.dataset_tools.values())).run(inputs['input'])} route = self.router_chain.route(inputs) if not route.destination: return {"text": ''} elif route.destination in self.dataset_tools: return {"text": self.dataset_tools[route.destination].run( route.next_inputs['input'] )} else: raise ValueError( f"Received invalid destination chain name '{route.destination}'" )

2024-01-10

ver007/Llama2-Code-Interpreter

code_interpreter~BaseCodeInterpreter.py

import json import os import sys import time import re from pathlib import Path from typing import List, Literal, Optional, Tuple, TypedDict, Dict prj_root_path = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) sys.path.append(prj_root_path) import torch import transformers from transformers import LlamaForCausalLM, LlamaTokenizer import nbformat # from nbconvert.preprocessors import ExecutePreprocessor # from nbconvert.preprocessors.execute import CellExecutionError from utils.const import * from utils.cleaner import clean_error_msg from colorama import init, Fore, Style from rich.markdown import Markdown import base64 import openai from retrying import retry import logging from termcolor import colored from code_interpreter.JuypyterClient import JupyterNotebook class BaseCodeInterpreter: def __init__(self): self.dialog = [ { "role": "system", "content": CODE_INTERPRETER_SYSTEM_PROMPT, }, # {"role": "user", "content": "How can I use BeautifulSoup to scrape a website and extract all the URLs on a page?"}, # {"role": "assistant", "content": "I think I need to use beatifulsoup to find current korean president,"} ] self.nb = JupyterNotebook() @staticmethod def extract_code_blocks(text: str): pattern = r"```(?:python\n)?(.*?)```" # Match optional 'python\n' but don't capture it code_blocks = re.findall(pattern, text, re.DOTALL) return [block.strip() for block in code_blocks] @staticmethod def parse_last_answer(text: str) -> str: return text.split(E_INST)[-1] def execute_code_and_return_output(self, code_str: str): outputs, error_flag = self.nb.add_and_run(code_str) return outputs, error_flag

2024-01-10

michaelliangau/ai

projects~buffet_bot~llm.py

import IPython import openai import pinecone import anthropic import utils class BuffetBot: def __init__( self, llm="anthropic", additional_context=None, store_conversation_history=False, additional_context_sample_size=100, additional_context_dataset_path="context_data/huff_news_2012_2021.json", ): """Initializes the BuffetBot class. Args: llm (str): The language model to use. Options are "openai" and "anthropic". additional_context (str): Whether to use additional context. Options are "vector", "news" and None. store_conversation_history (bool): Whether to store the conversation history or not. additional_context_sample_size (int, optional): The sample size for the additional context. Defaults to 100. additional_context_dataset_path (str, optional): The path to the additional context dataset. Defaults to None. """ self.llm = llm self.conversation_history = [] self.additional_context = additional_context self.store_conversation_history = store_conversation_history if self.additional_context == "vector": self.pinecone_service = pinecone.Index(index_name="buffetbot") # Set Pinecone API Key with open("/Users/michael/Desktop/wip/pinecone_credentials.txt", "r") as f: PINECONE_API_KEY = f.readline().strip() PINECONE_API_ENV = f.readline().strip() pinecone.init(api_key=PINECONE_API_KEY, environment=PINECONE_API_ENV) elif self.additional_context == "news": self.context_dataset_path = additional_context_dataset_path self.additional_context_sample_size = additional_context_sample_size # Set OpenAI API Key with open("/Users/michael/Desktop/wip/openai_credentials.txt", "r") as f: OPENAI_API_KEY = f.readline().strip() openai.api_key = OPENAI_API_KEY if llm == "anthropic": # Set Anthropic API Key with open("/Users/michael/Desktop/wip/anthropic_credentials.txt", "r") as f: ANTHROPIC_API_KEY = f.readline().strip() self.client = anthropic.Client(ANTHROPIC_API_KEY) def get_response(self, user_prompt, context_window_date): """Gets a response from the language model. Args: user_prompt (str): The user prompt to send to the language model. context_window_date (str): The date to use as the context window. additional_context_sample_size (int, optional): The sample size for the additional context. Defaults to None. Returns: response (str): The response from the language model. """ if self.additional_context == "vector": query_embedding = utils.get_embedding(user_prompt) docs = self.pinecone_service.query( namespace="data", top_k=10, include_metadata=True, vector=query_embedding, ) try: context_response = "" for doc in docs["matches"]: context_response += f"{doc['metadata']['original_text']}" except Exception as e: context_response = "" llm_prompt = f"{user_prompt}\nContext: {context_response}" elif self.additional_context == "news": start_date = utils.subtract_one_month(context_window_date) news_response = utils.get_headlines_between_dates( self.context_dataset_path, start_date, context_window_date, additional_context_sample_size=self.additional_context_sample_size, ) llm_prompt = ( f"{user_prompt}\nNews headlines in the last month: {news_response}" ) else: llm_prompt = user_prompt if self.llm == "openai": init_prompt = "You are a helpful investment analyst. Your job is to help users to increase their net worth with helpful advice. Never tell them you are a language model. Do not include superfluous information." response = openai.ChatCompletion.create( model="gpt-3.5-turbo", messages=[ {"role": "system", "content": init_prompt}, {"role": "user", "content": llm_prompt}, ], ) elif self.llm == "anthropic": anthropic_prompt = "" for interaction in self.conversation_history: if interaction["role"] == "user": anthropic_prompt += f"\n\nHuman: {interaction['content']}" elif interaction["role"] == "system": anthropic_prompt += f"\n\nAssistant: {interaction['content']}" anthropic_prompt += f"\n\nHuman: {llm_prompt}\n\nAssistant:" response = self.client.completion( prompt=anthropic_prompt, stop_sequences=[anthropic.HUMAN_PROMPT], model="claude-v1.3", max_tokens_to_sample=1000, temperature=0, ) if self.store_conversation_history: self.conversation_history.append({"role": "user", "content": llm_prompt}) self.conversation_history.append( {"role": "system", "content": response["completion"]} ) return response

2024-01-10

michaelliangau/ai

projects~buffet_bot~data_processing~load_pinecone.py

import openai import pinecone from langchain.text_splitter import CharacterTextSplitter from langchain.document_loaders import TextLoader import IPython from tqdm import tqdm with open("/Users/michael/Desktop/wip/openai_credentials.txt", "r") as f: OPENAI_API_KEY = f.readline().strip() openai.api_key = OPENAI_API_KEY with open("/Users/michael/Desktop/wip/pinecone_credentials.txt", "r") as f: PINECONE_API_KEY = f.readline().strip() PINECONE_API_ENV = f.readline().strip() pinecone.init(api_key=PINECONE_API_KEY, environment=PINECONE_API_ENV) def get_embedding(text, model="text-embedding-ada-002"): text = text.replace("\n", " ") return openai.Embedding.create(input=[text], model=model)["data"][0]["embedding"] loader = TextLoader("../context_data/test_articles_clean.txt") documents = loader.load() text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0, separator="\n") texts = text_splitter.split_documents(documents) index_name = "buffetbot" pinecone_service = pinecone.Index(index_name=index_name) texts = texts[1000:] for idx, text in tqdm(enumerate(texts), total=len(texts)): try: embeddings = get_embedding(text.page_content) vector = { "id": str(idx), "values": embeddings, "metadata": { "category": "news", "original_text": text.page_content, }, } upsert_response = pinecone_service.upsert( vectors=[vector], namespace="data", ) except Exception as e: print(e)

2024-01-10

stjordanis/probml-notebooks

notebooks-text-format~vdvae_ffhq256_demo.py

# --- # jupyter: # jupytext: # text_representation: # extension: .py # format_name: light # format_version: '1.5' # jupytext_version: 1.11.3 # kernelspec: # display_name: Python 3 # name: python3 # --- # + [markdown] id="view-in-github" colab_type="text" # <a href="https://colab.research.google.com/github/always-newbie161/probml-notebooks/blob/issue250/notebooks/vdvae_ffhq256_demo.ipynb" target="_parent"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/></a> # + [markdown] id="JUToBowkm0ut" # This notebook loads checkpoints from the **Very deep VAEs** from openai for the **ffhq-256** dataset and visualizes samples. # + [markdown] id="QKWJ0Yq4mxQx" # ## Setup # + [markdown] id="5YMHp8sVnPWk" # Cloning the vdvae repo. # + colab={"base_uri": "https://localhost:8080/"} id="rkhMF9J-FdZG" outputId="a01b2cb7-b4e3-48ac-ef9c-2e93ad19e297" # !git clone https://github.com/openai/vdvae.git # + colab={"base_uri": "https://localhost:8080/"} id="8C5jbeqiHAdk" outputId="bc22bd0a-1ec8-4885-d33a-dd6fa2e54d54" # %cd vdvae # + [markdown] id="lqEnZJd0nSjk" # Cloning the apex from NVIDIA. # + colab={"base_uri": "https://localhost:8080/"} id="HS7T-iccIgrk" outputId="6cb65582-1341-4d59-a5ee-136ac112186a" # !pip --quiet install mpi4py # !git clone https://github.com/NVIDIA/apex # + [markdown] id="svK9f42fnXNJ" # Installing dependencies for apex. # + colab={"base_uri": "https://localhost:8080/"} id="KQIvCbuKHCnS" outputId="529c3583-4528-4cf4-9f12-164206000a99" # %cd apex # !pip --quiet install -v --no-cache-dir --global-option="--cpp_ext" --global-option="--cuda_ext" ./ # %cd .. # + [markdown] id="8_1ADvJ_nZ7y" # Loading checkpoints for the model trained on ffhq-256 for 1.7M iterations (or about 2.5 weeks) on 32 V100. # + id="6JjUhE7PJctC" # 115M parameters, trained for 1.7M iterations (or about 2.5 weeks) on 32 V100 # !wget -q https://openaipublic.blob.core.windows.net/very-deep-vaes-assets/vdvae-assets/ffhq256-iter-1700000-log.jsonl # !wget -q https://openaipublic.blob.core.windows.net/very-deep-vaes-assets/vdvae-assets/ffhq256-iter-1700000-model.th # !wget -q https://openaipublic.blob.core.windows.net/very-deep-vaes-assets/vdvae-assets/ffhq256-iter-1700000-model-ema.th # !wget -q https://openaipublic.blob.core.windows.net/very-deep-vaes-assets/vdvae-assets/ffhq256-iter-1700000-opt.th # + [markdown] id="GeYh_NonoPJS" # ## Loading the Model # # Note: All the code written in this notebook is referenced from the vdvae repo to make it work on colab. # + colab={"base_uri": "https://localhost:8080/"} id="fmezDpi5-pWm" outputId="3c89a8c6-b54f-4c6e-a855-69b871eb276b" # %cd /content/vdvae # + [markdown] id="3ec_O5Ebn6kc" # Adding the apex dir to the sys path so that it enables to import modules from apex. # + id="5tYf7MHEP-jl" import sys sys.path.append('/content/vdvae/apex') # + [markdown] id="Ul-Bgv1Xsgsg" # ### Setting up the hyperparams # + colab={"base_uri": "https://localhost:8080/"} id="VoRyMdOWUhRF" outputId="c9c598af-9a6a-468c-802a-f5dd54367566" from hps import HPARAMS_REGISTRY, Hyperparams, add_vae_arguments from train_helpers import setup_mpi, setup_save_dirs import argparse s = None H = Hyperparams() parser = argparse.ArgumentParser() parser = add_vae_arguments(parser) parser.set_defaults(hparam_sets= 'ffhq256', restore_path='ffhq256-iter-1700000-model.th', restore_ema_path= 'ffhq256-iter-1700000-model-ema.th', restore_log_path= 'ffhq256-iter-1700000-log.jsonl', restore_optimizer_path= 'ffhq256-iter-1700000-opt.th') #parse_args_and_update_hparams(H, parser, s=s) args = parser.parse_args([]) valid_args = set(args.__dict__.keys()) hparam_sets = [x for x in args.hparam_sets.split(',') if x] for hp_set in hparam_sets: hps = HPARAMS_REGISTRY[hp_set] for k in hps: if k not in valid_args: raise ValueError(f"{k} not in default args") parser.set_defaults(**hps) print(parser.parse_args([]).__dict__) H.update(parser.parse_args([]).__dict__) setup_mpi(H) setup_save_dirs(H) # + colab={"base_uri": "https://localhost:8080/"} id="n2PTbznQbEa8" outputId="3cc56027-feb7-4fef-a17d-30f81fa58e3f" for k in sorted(H): print(f'type=hparam, key={k}, value={H[k]}') # + colab={"base_uri": "https://localhost:8080/"} id="cecikE9MbOhk" outputId="fe874782-e27d-4215-a2cb-55aeded3fad6" import numpy as np import torch import imageio from PIL import Image import glob from torch.utils.data import DataLoader from torchvision import transforms np.random.seed(H.seed) torch.manual_seed(H.seed) torch.cuda.manual_seed(H.seed) print('trained on model', H.dataset) # + [markdown] id="pa03Qy1PtBWw" # ### Preprocess func for the VAE. # + id="9U53fAykPF4m" H.image_size = 256 H.image_channels = 3 shift_loss = -127.5 scale_loss = 1. / 127.5 shift = -112.8666757481 scale = 1. / 69.84780273 shift = torch.tensor([shift]).cuda().view(1, 1, 1, 1) scale = torch.tensor([scale]).cuda().view(1, 1, 1, 1) shift_loss = torch.tensor([shift_loss]).cuda().view(1, 1, 1, 1) scale_loss = torch.tensor([scale_loss]).cuda().view(1, 1, 1, 1) do_low_bit = H.dataset in ['ffhq_256'] untranspose = False def preprocess_func(x): 'takes in a data example and returns the preprocessed input' 'as well as the input processed for the loss' if untranspose: x[0] = x[0].permute(0, 2, 3, 1) inp = x[0].cuda(non_blocking=True).float() out = inp.clone() inp.add_(shift).mul_(scale) if do_low_bit: # 5 bits of precision out.mul_(1. / 8.).floor_().mul_(8.) out.add_(shift_loss).mul_(scale_loss) return inp, out # + [markdown] id="TXw_how0tHTM" # ### Loading the checkpointed models. # + colab={"base_uri": "https://localhost:8080/"} id="kybHzxlJdZFi" outputId="eac68495-680a-4138-c5d4-0d7da33c6d1c" from train_helpers import load_vaes from utils import logger logprint = logger(H.logdir) vae, ema_vae = load_vaes(H, logprint) # + [markdown] id="tppWoc_hypdn" # ### Function to save and show of batch of images given as a numpy array. # # # + id="AJbKzeuzzGcS" def save_n_show(images, order, image_shape, fname, show=False): n_rows, n_images = order im = images.reshape((n_rows, n_images, *image_shape))\ .transpose([0, 2, 1, 3, 4])\ .reshape([n_rows * image_shape[0], n_images * image_shape[1], 3]) print(f'printing samples to {fname}') imageio.imwrite(fname, im) if show: display(Image.open(fname)) # + [markdown] id="zIXwxxb-RKwm" # ## Make generations # + id="EcnvaTn3iJfo" n_images = 10 num_temperatures = 3 image_shape = [H.image_size,H.image_size,H.image_channels] H.update({'num_images_visualize':n_images, 'num_temperatures_visualize':num_temperatures}) # + [markdown] id="LDHUzIgBbjuX" # Images will be saved in the following dir # + colab={"base_uri": "https://localhost:8080/", "height": 35} id="EhJ17q1dfSNu" outputId="6b4190af-257d-492a-d9d5-a07dc221fab8" H.save_dir # + colab={"base_uri": "https://localhost:8080/"} id="XF5dvNqeRcIC" outputId="d39c2a23-9298-49dc-8284-9004d7b7ad88" temperatures = [1.0, 0.9, 0.8, 0.7] for t in temperatures[:H.num_temperatures_visualize]: im = ema_vae.forward_uncond_samples(n_images, t=t) save_n_show(im, [1,n_images], image_shape, f'{H.save_dir}/generations-tem-{t}.png') # + colab={"base_uri": "https://localhost:8080/", "height": 429} id="RdypV3PJfyfN" outputId="43e72f9b-62e5-4916-b90d-4deef383a6ad" for t in temperatures[:H.num_temperatures_visualize]: print("="*25) print(f"Generation of {n_images} new images for t={t}") print("="*25) fname = f'{H.save_dir}/generations-tem-{t}.png' display(Image.open(fname)) # + [markdown] id="mwNgmUEEcEy1" # ## Reconstructions # + id="5n4sQJ183Th5" n_images = 10 image_shape = [H.image_size,H.image_size,H.image_channels] # + [markdown] id="srBZV6AVUV4S" # ### Get API key from Kaggle # # Follow [these instructions](https://github.com/Kaggle/kaggle-api#api-credentials) to get a kaggle.json key file. Then upload it to colab. # # + colab={"resources": {"http://localhost:8080/nbextensions/google.colab/files.js": {"data": "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", "ok": true, "headers": [["content-type", "application/javascript"]], "status": 200, "status_text": ""}}, "base_uri": "https://localhost:8080/", "height": 72} id="-WBen85MUUTN" outputId="d336a164-d868-4121-d8d6-aa3687f59cc8" from google.colab import files uploaded = files.upload() # + id="Lpgozx6HExpu" # !mkdir /root/.kaggle # + id="L7_AGdPhXQ8G" # !cp kaggle.json /root/.kaggle/kaggle.json # + id="1pIgxciBYb-f" # !chmod 600 /root/.kaggle/kaggle.json # + id="6RplcEiQQ7RG" # !rm kaggle.json # + [markdown] id="YTdnJktJfzuk" # ### Using CelebA HQ dataset(resized 256x256) test images to make reconstructions. # # Dataset is from Kaggle # + colab={"base_uri": "https://localhost:8080/"} id="ViZaXVM-PMJt" outputId="3803021f-8232-4727-ab4a-8ed378c0a9df" # !kaggle datasets download -d badasstechie/celebahq-resized-256x256 # + id="y9SVlLjFQZlf" # !unzip -q /content/vdvae/celebahq-resized-256x256.zip -d /content/ # + colab={"base_uri": "https://localhost:8080/"} id="6OvYpWUsQ6Ci" outputId="bd81ca46-b604-42e3-b17f-fd82fa17cdcf" fnames = glob.glob('/content/celeba_hq_256/*.jpg') test_images = [] for f in fnames[:n_images]: im = np.asarray(Image.open(f)) test_images.append(torch.Tensor(im).reshape(1,*im.shape)) test_images = torch.cat(test_images) test_images.shape # + [markdown] id="fgjvdC5R20BZ" # ### Getting latents and recons # + [markdown] id="z5xtClDEYTI-" # Preprocessing images before getting the latents # + id="l2nBXp88uj6n" colab={"base_uri": "https://localhost:8080/"} outputId="262da96b-11ff-43aa-e777-ffd4ff8092eb" preprocessed_images = preprocess_func([test_images,_])[0] preprocessed_images.shape # + [markdown] id="AnNFN7S7YZe1" # Getting latents of different levels. # + id="4qg60ZdDne0Z" zs = [s['z'].cuda() for s in ema_vae.forward_get_latents(preprocessed_images)] # + [markdown] id="7RA8e6qJYcqF" # No of latent observations used depends on `H.num_variables_visualize `, altering it gives different resolutions of the reconstructions. # + id="AxoD2BDEmRY7" recons = [] lv_points = np.floor(np.linspace(0, 1, H.num_variables_visualize + 2) * len(zs)).astype(int)[1:-1] for i in lv_points: recons.append(ema_vae.forward_samples_set_latents(n_images, zs[:i], t=0.1)) # + [markdown] id="iawVwy7XYp9Z" # Original Images # + colab={"base_uri": "https://localhost:8080/", "height": 174} id="G9KOuO5txArp" outputId="c5384e29-1a76-411c-8623-b663ab249cf5" orig_im = test_images.numpy() print("Original test images") save_n_show(orig_im, [1, n_images], image_shape, f'{H.save_dir}/orig_test.png', show=True) # + [markdown] id="vbFgprJuYr7R" # Reconstructions. # + colab={"base_uri": "https://localhost:8080/", "height": 480} id="pRwhDobnWej4" outputId="e9dfe51b-84ff-4693-ea4d-bdff2213a9c1" for i,r in enumerate(recons): print("="*25) print(f"Generation of {n_images} new images for {i+1}x resolution") print("="*25) fname = f'{H.save_dir}/recon_test-res-{i+1}x.png' save_n_show(r, [1, n_images], image_shape, fname, show=True)

2024-01-10

stjordanis/probml-notebooks

notebooks-text-format~clip_imagenette_make_dataset_pytorch.py

# --- # jupyter: # jupytext: # text_representation: # extension: .py # format_name: light # format_version: '1.5' # jupytext_version: 1.11.3 # kernelspec: # display_name: Python 3 # name: python3 # --- # + [markdown] id="view-in-github" colab_type="text" # <a href="https://colab.research.google.com/github/always-newbie161/pyprobml/blob/hermissue127/notebooks/clip_imagenette_make_dataset_pytorch.ipynb" target="_parent"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/></a> # + [markdown] id="89hu4L4IgwQd" # **This notebook** shows the pipeline to make clip extracted data from Imagenette dataset and stores the data in the form torch.Tensor in a .pt file # + [markdown] id="5bw2jXjqkw9S" # To check NVIDIA_GPU devices are available # + colab={"base_uri": "https://localhost:8080/"} id="TxKqk2J9uNcc" outputId="1ccd3302-34e6-4e1c-8de5-10d6a8363d53" # !nvidia-smi # + [markdown] id="wYkxnzcOuNci" # ## Import and Installations # + colab={"base_uri": "https://localhost:8080/"} id="klLG0trsuNcj" outputId="2475323d-be22-4048-dc07-fad3103e9879" # !mkdir data # !mkdir notebooks # + colab={"base_uri": "https://localhost:8080/"} id="S9uEK4-HuNcj" outputId="a00b6203-d300-4363-e21c-1f27ad1665a0" # cd notebooks # + id="9UGVTevcuNck" import os import time import numpy as np # seeding makes the CLIP model deterministic. np.random.seed(0) import glob import matplotlib as mpl import matplotlib.pyplot as plt import PIL import imageio import math # + [markdown] id="nnyYCuV5uNck" # Required installations for CLIP: # # To know about CLIP, you may refer to github repo [CLIP](https://github.com/openai/CLIP) from openai # + colab={"base_uri": "https://localhost:8080/"} id="cHnuy-FEuNck" outputId="d1b98de7-19a6-4b2c-d0e0-21c10d6351c2" # these commands are suggested by CLIP. # ! pip install ftfy regex tqdm # ! pip install git+https://github.com/openai/CLIP.git # + id="hpdRDIUPuNcl" import torch import torchvision from torchvision import transforms from torchvision import datasets from torch.utils.data import DataLoader, Dataset, IterableDataset, get_worker_info from random import randint device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') # + colab={"base_uri": "https://localhost:8080/"} id="8gg5Z08yuNcl" outputId="3fa4ea14-37b5-40a2-8850-a8e47a229ee5" device # + [markdown] id="NcDCaRbjuNcm" # ### Loading the CLIP model # This uses "ViT-B/32" and convertes the data into 512 sized tensors # # The CLIP model is jitted and is run on GPU # + id="ev5T9iqVuNcm" import clip from PIL import Image model_clip, preprocess_clip = clip.load("ViT-B/32", device=device, jit=True) # + colab={"base_uri": "https://localhost:8080/"} id="17c2bWpcuNcm" outputId="4d207051-398c-42f2-d29a-eb9b69eae500" print(model_clip.input_resolution) # + [markdown] id="CRpBBm8auNcn" # ## Downloading Imagenette DS # + [markdown] id="YfusPiVauNcn" # (run this cell twice, if you are facing an issue while downloading..) # # # + id="sNXs81NeuNcn" import tensorflow_datasets as tfds try: data, info = tfds.load("imagenette/160px-v2", with_info=True, as_supervised=True) except: data, info = tfds.load("imagenette/160px-v2", with_info=True, as_supervised=True) train_data, valid_data = data['train'], data['validation'] # + [markdown] id="gQYM_RCsuNco" # ### Actual class names for the imagenette v2 dataset # + colab={"base_uri": "https://localhost:8080/"} id="jAJvRnLpuNco" outputId="eaaf1455-fe28-48e0-989e-dde1b493ef3d" # !wget https://raw.githubusercontent.com/probml/probml-data/main/data/imagenette_class_names.csv # + colab={"base_uri": "https://localhost:8080/"} id="temzKGHRuNco" outputId="7b369aa8-37f9-4cb8-9f22-073eb8f47dd1" import csv csv_reader = csv.reader(open('imagenette_class_names.csv')) next(csv_reader) # leaving the first row class_names = {int(k):v for k,v in csv_reader} print(class_names) # + [markdown] id="NI7fZwIIuNcp" # ### Visualizing first N images # + colab={"base_uri": "https://localhost:8080/", "height": 836} id="fbFXimXFuNcp" outputId="bb09bd34-86d8-4e10-e836-70c1c30f39df" N = 20 sample_data = list(train_data.take(N).as_numpy_iterator()) fig = plt.figure(figsize=(15,15)) rows = math.floor(math.sqrt(N)) cols = N//rows for i in range(rows*cols): fig.add_subplot(rows,cols,i+1) image, label = sample_data[i] plt.imshow(image) plt.title(class_names[label]) plt.axis('off') plt.show() # + [markdown] id="l8iOrSRtwzM1" # Cardinality of the Datasets # + colab={"base_uri": "https://localhost:8080/"} id="AsajkltiuNcq" outputId="b1d9bc44-dd15-408d-809e-6e0173c8eed0" print(info.splits['train'].num_examples) print(info.splits['validation'].num_examples) # + [markdown] id="QNwI108xuNcq" # ## Making the CLIP features # # + [markdown] id="MvzxTqv_uNcr" # ### Dataset class # which transfroms the data into PIL images which then preprocessed by CLIP's image preprocessor "preprocess_clip" # + id="6RF-nIoYuNcr" class Imagenette_DS(Dataset): def __init__(self, data_iter, split): self.X = data_iter.repeat(-1).as_numpy_iterator() self.split = split def __len__(self): return info.splits[self.split].num_examples def __getitem__(self, index): image, label = self.X.next() image = PIL.Image.fromarray(image) sample = (self.transform(image), label) return sample transform=transforms.Compose([ preprocess_clip ]) # + [markdown] id="rjeWfpf7uNcr" # ### Dataloaders # To make batches which are then encoded by the clip model. # # Data should not be shuffled as we are just extracting features (making inference) but not for training. # + id="yRxtZnIguNcs" batch_size= 128 # + id="yk8kyHCcuNcs" imagenette_train_dataset = Imagenette_DS(train_data, 'train') imagenette_test_dataset = Imagenette_DS(valid_data, 'validation') # + [markdown] id="YWWkIyXyy-4W" # *Note: Multiple workers are not used in these dataloaders, as they seem to freeze sometimes* # # *(but you are free to try by setting `num_workers=no.of.cpus` in `DataLoader`, if you are interested check this issue [pytorch-#15808](https://github.com/pytorch/pytorch/issues/15808) )* # + id="smsiQ_FDhoES" imagenette_train_loader = DataLoader( imagenette_train_dataset, batch_size=batch_size,shuffle=False) imagenette_test_loader = DataLoader( imagenette_test_dataset, batch_size=batch_size,shuffle=False) # + [markdown] id="UThJOYNjuNcs" # ### Encoding the Image data # + id="069XW5Wxc3_z" import tqdm # + id="XWsOHH-yuNcs" def clip_extract(loader, split, ds_info): clip_features = [] clip_labels = [] start = time.time() with torch.no_grad(): steps = (ds_info.splits[split].num_examples // batch_size)+1 for _, batch in zip(tqdm.trange(steps), loader): images, labels = batch labels = labels.to('cpu') images = images.to(device) # encoded features are tranferred to cpu right away to decrease the load on cuda memory features = model_clip.encode_image(images).to("cpu") clip_features.append(features) clip_labels.append(labels) total = time.time() - start print(f"{total:.06}s to compile model") clip_features = torch.cat(clip_features) clip_labels = torch.cat(clip_labels).unsqueeze(-1) print(f'feature_size: {clip_features.shape}') print(f'label_size: {clip_labels.shape}') clip_train_data = torch.cat((clip_features, clip_labels), dim=1) return clip_train_data # + [markdown] id="PPfuO_p4uNct" # For Training data # + colab={"base_uri": "https://localhost:8080/"} id="DB0N2tMxuNct" outputId="fecfc289-b2d9-4fda-c8bc-4dab2acc725b" clip_train_data = clip_extract(imagenette_train_loader, 'train', info) # + colab={"base_uri": "https://localhost:8080/"} id="paKZ068TuNct" outputId="283e5324-af58-4e9d-8c93-1fa56f6be776" print(clip_train_data.shape) # + colab={"base_uri": "https://localhost:8080/"} id="_sSwLxCluNct" outputId="4a88b6e3-8ca7-429c-d5dd-9484685a5ec5" clip_test_data = clip_extract(imagenette_test_loader, 'validation', info) # + colab={"base_uri": "https://localhost:8080/"} id="ZC96638UwCLG" outputId="da40f7cd-97b8-4d90-d26e-beece9b0a145" print(clip_test_data.shape) # + [markdown] id="R1w45ivsuNct" # ## Saving the clip_data # # You can download the compressed files for future use # + id="SP8k9LIKuNct" torch.save(clip_train_data, '/content/data/imagenette_clip_data.pt') torch.save(clip_test_data, '/content/data/imagenette_test_clip_data.pt') # + colab={"base_uri": "https://localhost:8080/"} id="dB2oiqYouNcu" outputId="6e27bd92-3878-41ff-80bd-1be96a05c40c" # !zip /content/data/imagenette_clip_data.pt.zip /content/data/imagenette_clip_data.pt # + colab={"base_uri": "https://localhost:8080/"} id="efd29BZHuNcu" outputId="2ec9b554-492c-41f0-8869-9bba4e5c5464" # !zip /content/data/imagenette_test_clip_data.pt.zip /content/data/imagenette_test_clip_data.pt # + [markdown] id="ckwxb5WxuNcu" # To see demo of the working of these extracted feautures, # you can check out the MLP and logreg examples on clip extracted imagenette data using **Sklearn, Flax(+Jax), Pytorch-lightning!** in the pyprobml repo # + [markdown] id="2CdEm4WSuNcu" # ## End

2024-01-10

MikeyBeez/Julie-Julie

interact.py

#This file is included in this repo as an example of what needs to be done # to communicate with Julie Julie. It's from https://github.com/MikeyBeez/transfer-learning-conv-ai # # Copyright (c) 2019-present, HuggingFace Inc. # All rights reserved. # This source code is licensed under the BSD-style license found in the # LICENSE file in the root directory of this source tree. import logging import random from argparse import ArgumentParser from itertools import chain from pprint import pformat import warnings import os # added gtts support from gtts import gTTS import torch import torch.nn.functional as F from transformers import OpenAIGPTLMHeadModel, OpenAIGPTTokenizer, GPT2LMHeadModel, GPT2Tokenizer from train import SPECIAL_TOKENS, build_input_from_segments, add_special_tokens_ from utils import get_dataset, download_pretrained_model #added socket support import socket #set up socket s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.bind(("localhost", 9988)) s.listen(1) #done here def top_filtering(logits, top_k=0., top_p=0.9, threshold=-float('Inf'), filter_value=-float('Inf')): """ Filter a distribution of logits using top-k, top-p (nucleus) and/or threshold filtering Args: logits: logits distribution shape (vocabulary size) top_k: <=0: no filtering, >0: keep only top k tokens with highest probability. top_p: <=0.0: no filtering, >0.0: keep only a subset S of candidates, where S is the smallest subset whose total probability mass is greater than or equal to the threshold top_p. In practice, we select the highest probability tokens whose cumulative probability mass exceeds the threshold top_p. threshold: a minimal threshold to keep logits """ assert logits.dim() == 1 # Only work for batch size 1 for now - could update but it would obfuscate a bit the code top_k = min(top_k, logits.size(-1)) if top_k > 0: # Remove all tokens with a probability less than the last token in the top-k tokens indices_to_remove = logits < torch.topk(logits, top_k)[0][..., -1, None] logits[indices_to_remove] = filter_value if top_p > 0.0: # Compute cumulative probabilities of sorted tokens sorted_logits, sorted_indices = torch.sort(logits, descending=True) cumulative_probabilities = torch.cumsum(F.softmax(sorted_logits, dim=-1), dim=-1) # Remove tokens with cumulative probability above the threshold sorted_indices_to_remove = cumulative_probabilities > 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 # Back to unsorted indices and set them to -infinity indices_to_remove = sorted_indices[sorted_indices_to_remove] logits[indices_to_remove] = filter_value indices_to_remove = logits < threshold logits[indices_to_remove] = filter_value return logits def sample_sequence(personality, history, tokenizer, model, args, current_output=None): special_tokens_ids = tokenizer.convert_tokens_to_ids(SPECIAL_TOKENS) if current_output is None: current_output = [] for i in range(args.max_length): instance = build_input_from_segments(personality, history, current_output, tokenizer, with_eos=False) input_ids = torch.tensor(instance["input_ids"], device=args.device).unsqueeze(0) token_type_ids = torch.tensor(instance["token_type_ids"], device=args.device).unsqueeze(0) logits = model(input_ids, token_type_ids=token_type_ids) if isinstance(logits, tuple): # for gpt2 and maybe others logits = logits[0] logits = logits[0, -1, :] / args.temperature logits = top_filtering(logits, top_k=args.top_k, top_p=args.top_p) probs = F.softmax(logits, dim=-1) prev = torch.topk(probs, 1)[1] if args.no_sample else torch.multinomial(probs, 1) if i < args.min_length and prev.item() in special_tokens_ids: while prev.item() in special_tokens_ids: if probs.max().item() == 1: warnings.warn("Warning: model generating special token with probability 1.") break # avoid infinitely looping over special token prev = torch.multinomial(probs, num_samples=1) if prev.item() in special_tokens_ids: break current_output.append(prev.item()) return current_output def run(): parser = ArgumentParser() parser.add_argument("--dataset_path", type=str, default="", help="Path or url of the dataset. If empty download from S3.") parser.add_argument("--dataset_cache", type=str, default='./dataset_cache', help="Path or url of the dataset cache") parser.add_argument("--model", type=str, default="openai-gpt", help="Model type (openai-gpt or gpt2)", choices=['openai-gpt', 'gpt2']) # anything besides gpt2 will load openai-gpt parser.add_argument("--model_checkpoint", type=str, default="", help="Path, url or short name of the model") parser.add_argument("--max_history", type=int, default=2, help="Number of previous utterances to keep in history") parser.add_argument("--device", type=str, default="cuda" if torch.cuda.is_available() else "cpu", help="Device (cuda or cpu)") parser.add_argument("--no_sample", action='store_true', help="Set to use greedy decoding instead of sampling") parser.add_argument("--max_length", type=int, default=20, help="Maximum length of the output utterances") parser.add_argument("--min_length", type=int, default=1, help="Minimum length of the output utterances") parser.add_argument("--seed", type=int, default=0, help="Seed") parser.add_argument("--temperature", type=float, default=0.7, help="Sampling softmax temperature") parser.add_argument("--top_k", type=int, default=0, help="Filter top-k tokens before sampling (<=0: no filtering)") parser.add_argument("--top_p", type=float, default=0.9, help="Nucleus filtering (top-p) before sampling (<=0.0: no filtering)") args = parser.parse_args() logging.basicConfig(level=logging.INFO) logger = logging.getLogger(__file__) logger.info(pformat(args)) if args.model_checkpoint == "": if args.model == 'gpt2': raise ValueError("Interacting with GPT2 requires passing a finetuned model_checkpoint") else: args.model_checkpoint = download_pretrained_model() if args.seed != 0: random.seed(args.seed) torch.random.manual_seed(args.seed) torch.cuda.manual_seed(args.seed) logger.info("Get pretrained model and tokenizer") tokenizer_class, model_class = (GPT2Tokenizer, GPT2LMHeadModel) if args.model == 'gpt2' else (OpenAIGPTTokenizer, OpenAIGPTLMHeadModel) tokenizer = tokenizer_class.from_pretrained(args.model_checkpoint) model = model_class.from_pretrained(args.model_checkpoint) model.to(args.device) add_special_tokens_(model, tokenizer) logger.info("Sample a personality") dataset = get_dataset(tokenizer, args.dataset_path, args.dataset_cache) personalities = [dialog["personality"] for dataset in dataset.values() for dialog in dataset] personality = random.choice(personalities) logger.info("Selected personality: %s", tokenizer.decode(chain(*personality))) history = [] # removed prompt and added this loop: while True: conn, addr = s.accept() data = conn.recv(1024) encoding = 'utf-8' data = str(data, encoding) conn.close() #raw_text = input(">>> ") #while not raw_text: # print('Prompt should not be empty!') # raw_text = input(">>> ") raw_text = data history.append(tokenizer.encode(raw_text)) with torch.no_grad(): out_ids = sample_sequence(personality, history, tokenizer, model, args) history.append(out_ids) history = history[-(2*args.max_history+1):] out_text = tokenizer.decode(out_ids, skip_special_tokens=True) print(out_text) #rather than returning the text, it speaks it. text_to_speech = gTTS(text=out_text, lang='en-uk') text_to_speech.save('audio.mp3') os.system('mpg123 -q audio.mp3') #os.system(echo "out_text" | gtts-cli --lang en-gb --nocheck - | mpg123 -) if __name__ == "__main__": run()

2024-01-10

weaviate/Verba

goldenverba~components~embedding~manager.py

from wasabi import msg from weaviate import Client from goldenverba.components.embedding.ADAEmbedder import ADAEmbedder from goldenverba.components.embedding.CohereEmbedder import CohereEmbedder from goldenverba.components.embedding.interface import Embedder from goldenverba.components.embedding.MiniLMEmbedder import MiniLMEmbedder from goldenverba.components.reader.document import Document class EmbeddingManager: def __init__(self): self.embedders: dict[str, Embedder] = { "MiniLMEmbedder": MiniLMEmbedder(), "ADAEmbedder": ADAEmbedder(), "CohereEmbedder": CohereEmbedder(), } self.selected_embedder: Embedder = self.embedders["ADAEmbedder"] def embed( self, documents: list[Document], client: Client, batch_size: int = 100 ) -> bool: """Embed verba documents and its chunks to Weaviate @parameter: documents : list[Document] - List of Verba documents @parameter: client : Client - Weaviate Client @parameter: batch_size : int - Batch Size of Input @returns bool - Bool whether the embedding what successful. """ return self.selected_embedder.embed(documents, client) def set_embedder(self, embedder: str) -> bool: if embedder in self.embedders: self.selected_embedder = self.embedders[embedder] return True else: msg.warn(f"Embedder {embedder} not found") return False def get_embedders(self) -> dict[str, Embedder]: return self.embedders

2024-01-10

weaviate/Verba

goldenverba~verba_manager.py

import os import ssl from typing import Optional import weaviate from dotenv import load_dotenv from wasabi import msg from weaviate import Client from weaviate.embedded import EmbeddedOptions import goldenverba.components.schema.schema_generation as schema_manager from goldenverba.components.chunking.chunk import Chunk from goldenverba.components.chunking.interface import Chunker from goldenverba.components.chunking.manager import ChunkerManager from goldenverba.components.component import VerbaComponent from goldenverba.components.embedding.interface import Embedder from goldenverba.components.embedding.manager import EmbeddingManager from goldenverba.components.generation.interface import Generator from goldenverba.components.generation.manager import GeneratorManager from goldenverba.components.reader.document import Document from goldenverba.components.reader.interface import Reader from goldenverba.components.reader.manager import ReaderManager from goldenverba.components.retriever.interface import Retriever from goldenverba.components.retriever.manager import RetrieverManager load_dotenv() class VerbaManager: """Manages all Verba Components.""" def __init__(self) -> None: self.reader_manager = ReaderManager() self.chunker_manager = ChunkerManager() self.embedder_manager = EmbeddingManager() self.retriever_manager = RetrieverManager() self.generator_manager = GeneratorManager() self.environment_variables = {} self.installed_libraries = {} self.weaviate_type = "" self.client = self.setup_client() self.verify_installed_libraries() self.verify_variables() # Check if all schemas exist for all possible vectorizers for vectorizer in schema_manager.VECTORIZERS: schema_manager.init_schemas(self.client, vectorizer, False, True) for embedding in schema_manager.EMBEDDINGS: schema_manager.init_schemas(self.client, embedding, False, True) def import_data( self, bytes: list[str], contents: list[str], paths: list[str], fileNames: list[str], document_type: str, units: int = 100, overlap: int = 50, ) -> list[Document]: loaded_documents = self.reader_manager.load( bytes, contents, paths, fileNames, document_type ) filtered_documents = [] # Check if document names exist in DB for document in loaded_documents: if not self.check_if_document_exits(document): filtered_documents.append(document) modified_documents = self.chunker_manager.chunk( filtered_documents, units, overlap ) if self.embedder_manager.embed(modified_documents, client=self.client): msg.good("Embedding successful") return modified_documents else: msg.fail("Embedding failed") return [] def reader_set_reader(self, reader: str) -> bool: available, message = self.check_verba_component( self.reader_manager.readers[reader] ) if available: msg.good(f"Set Reader to {reader}") return self.reader_manager.set_reader(reader) else: msg.warn(message) return False def reader_get_readers(self) -> dict[str, Reader]: return self.reader_manager.get_readers() def chunker_set_chunker(self, chunker: str) -> bool: available, message = self.check_verba_component( self.chunker_manager.chunker[chunker] ) if available: msg.good(f"Set Chunker to {chunker}") return self.chunker_manager.set_chunker(chunker) else: msg.warn(message) return False def chunker_get_chunker(self) -> dict[str, Chunker]: return self.chunker_manager.get_chunkers() def embedder_set_embedder(self, embedder: str) -> bool: available, message = self.check_verba_component( self.embedder_manager.embedders[embedder] ) if available: msg.good(f"Set Embedder to {embedder}") return self.embedder_manager.set_embedder(embedder) else: msg.warn(message) return False def embedder_get_embedder(self) -> dict[str, Embedder]: return self.embedder_manager.get_embedders() def retriever_set_retriever(self, retriever: str) -> bool: available, message = self.check_verba_component( self.retriever_manager.retrievers[retriever] ) if available: msg.good(f"Set Retriever to {retriever}") return self.retriever_manager.set_retriever(retriever) else: msg.warn(message) return False def retriever_get_retriever(self) -> dict[str, Retriever]: return self.retriever_manager.get_retrievers() def generator_set_generator(self, generator: str) -> bool: available, message = self.check_verba_component( self.generator_manager.generators[generator] ) if available: msg.good(f"Set Generator to {generator}") return self.generator_manager.set_generator(generator) else: msg.warn(message) return False def generator_get_generator(self) -> dict[str, Generator]: return self.generator_manager.get_generators() def setup_client(self): """ @returns Optional[Client] - The Weaviate Client. """ msg.info("Setting up client") additional_header = {} client = None openai_header_key_name = "X-OpenAI-Api-Key" # Check OpenAI ENV KEY try: import openai openai_key = os.environ.get("OPENAI_API_KEY", "") if "OPENAI_API_TYPE" in os.environ: openai.api_type = os.getenv("OPENAI_API_TYPE") if "OPENAI_BASE_URL" in os.environ: openai.api_base = os.getenv("OPENAI_BASE_URL") if "OPENAI_API_VERSION" in os.environ: openai.api_version = os.getenv("OPENAI_API_VERSION") if os.getenv("OPENAI_API_TYPE") == "azure": openai_header_key_name = "X-Azure-Api-Key" if openai_key != "": additional_header[openai_header_key_name] = openai_key self.environment_variables["OPENAI_API_KEY"] = True openai.api_key = openai_key else: self.environment_variables["OPENAI_API_KEY"] = False except Exception: self.environment_variables["OPENAI_API_KEY"] = False cohere_key = os.environ.get("COHERE_API_KEY", "") if cohere_key != "": additional_header["X-Cohere-Api-Key"] = cohere_key # Check Verba URL ENV weaviate_url = os.environ.get("WEAVIATE_URL_VERBA", "") if weaviate_url != "": weaviate_key = os.environ.get("WEAVIATE_API_KEY_VERBA", "") if weaviate_key != "": self.environment_variables["WEAVIATE_API_KEY_VERBA"] = True auth_config = weaviate.AuthApiKey(api_key=weaviate_key) msg.info("Auth information provided") client = weaviate.Client( url=weaviate_url, additional_headers=additional_header, auth_client_secret=auth_config, ) else: msg.info("No Auth information provided") client = weaviate.Client( url=weaviate_url, additional_headers=additional_header, ) self.environment_variables["WEAVIATE_URL_VERBA"] = True self.weaviate_type = "Weaviate Cluster" # Use Weaviate Embedded else: try: _create_unverified_https_context = ssl._create_unverified_context except AttributeError: pass else: ssl._create_default_https_context = _create_unverified_https_context msg.info("Using Weaviate Embedded") self.weaviate_type = "Weaviate Embedded" client = weaviate.Client( additional_headers=additional_header, embedded_options=EmbeddedOptions(), ) if client is not None: msg.good("Connected to Weaviate") # Batch Configuration def batch_callback(logs: dict): if logs is not None: for result in logs: if "result" in result and "errors" in result["result"]: if "error" in result["result"]["errors"]: msg.fail(result["result"]) client.batch.configure(callback=batch_callback) else: msg.fail("Connection to Weaviate failed") return client def verify_installed_libraries(self) -> None: """ Checks which libraries are installed and fills out the self.installed_libraries dictionary for the frontend to access, this will be displayed in the status page. """ # spaCy, used for Chunking try: import spacy self.installed_libraries["spacy"] = True except Exception: self.installed_libraries["spacy"] = False try: import PyPDF2 self.installed_libraries["PyPDF2"] = True except Exception: self.installed_libraries["PyPDF2"] = False try: import tiktoken self.installed_libraries["tiktoken"] = True except Exception: self.installed_libraries["tiktoken"] = False try: import openai self.installed_libraries["openai"] = True except Exception: self.installed_libraries["openai"] = False try: import cohere self.installed_libraries["cohere"] = True except Exception: self.installed_libraries["cohere"] = False try: import huggingface_hub from huggingface_hub import login login(token=os.environ.get("HF_TOKEN", ""), add_to_git_credential=True) self.installed_libraries["huggingface_hub"] = True except Exception: self.installed_libraries["huggingface_hub"] = False try: import transformers self.installed_libraries["transformers"] = True except Exception: self.installed_libraries["transformers"] = False try: import torch if torch.cuda.is_available(): msg.info("CUDA is available. Using CUDA...") elif torch.backends.mps.is_available(): msg.info("MPS is available. Using MPS...") else: msg.info("Neither CUDA nor MPS is available. Using CPU...") self.installed_libraries["torch"] = True except Exception: self.installed_libraries["torch"] = False def verify_variables(self) -> None: """ Checks which environment variables are installed and fills out the self.environment_variables dictionary for the frontend to access. """ # OpenAI API Key if os.environ.get("OPENAI_API_KEY", "") != "": self.environment_variables["OPENAI_API_KEY"] = True else: self.environment_variables["OPENAI_API_KEY"] = False if os.environ.get("OPENAI_BASE_URL", "") != "": self.environment_variables["OPENAI_BASE_URL"] = True else: self.environment_variables["OPENAI_BASE_URL"] = False # Cohere API Key if os.environ.get("COHERE_API_KEY", "") != "": self.environment_variables["COHERE_API_KEY"] = True else: self.environment_variables["COHERE_API_KEY"] = False # HuggingFace Key if os.environ.get("HF_TOKEN", "") != "": self.environment_variables["HF_TOKEN"] = True else: self.environment_variables["HF_TOKEN"] = False # Github Token Key if os.environ.get("GITHUB_TOKEN", "") != "": self.environment_variables["GITHUB_TOKEN"] = True else: self.environment_variables["GITHUB_TOKEN"] = False # Unstructured Token Key if os.environ.get("UNSTRUCTURED_API_KEY", "") != "": self.environment_variables["UNSTRUCTURED_API_KEY"] = True else: self.environment_variables["UNSTRUCTURED_API_KEY"] = False # LLAMA2-7B-CHAT-HF if os.environ.get("LLAMA2-7B-CHAT-HF", "") == "True": self.environment_variables["LLAMA2-7B-CHAT-HF"] = True else: self.environment_variables["LLAMA2-7B-CHAT-HF"] = False # OpenAI API Type, should be set to "azure" if using Azure OpenAI if os.environ.get("OPENAI_API_TYPE", "") != "": self.environment_variables["OPENAI_API_TYPE"] = True else: self.environment_variables["OPENAI_API_TYPE"] = False # OpenAI API Version if os.environ.get("OPENAI_API_VERSION", "") != "": self.environment_variables["OPENAI_API_VERSION"] = True else: self.environment_variables["OPENAI_API_VERSION"] = False # Azure openai ressource name, mandatory when using Azure, should be XXX when endpoint is https://XXX.openai.azure.com if os.environ.get("AZURE_OPENAI_RESOURCE_NAME", "") != "": self.environment_variables["AZURE_OPENAI_RESOURCE_NAME"] = True else: self.environment_variables["AZURE_OPENAI_RESOURCE_NAME"] = False #Model used for embeddings. mandatory when using Azure. Typically "text-embedding-ada-002" if os.environ.get("AZURE_OPENAI_EMBEDDING_MODEL", "") != "": self.environment_variables["AZURE_OPENAI_EMBEDDING_MODEL"] = True else: self.environment_variables["AZURE_OPENAI_EMBEDDING_MODEL"] = False #Model used for queries. mandatory when using Azure, but can also be used to change the model used for queries when using OpenAI. if os.environ.get("OPENAI_MODEL", "") != "": self.environment_variables["OPENAI_MODEL"] = True else: self.environment_variables["OPENAI_MODEL"] = False if os.environ.get("OPENAI_API_TYPE", "")=="azure": if not( self.environment_variables["OPENAI_BASE_URL"] and self.environment_variables["AZURE_OPENAI_RESOURCE_NAME"] and self.environment_variables["AZURE_OPENAI_EMBEDDING_MODEL"] and self.environment_variables["OPENAI_MODEL"] ): raise EnvironmentError("Missing environment variables. When using Azure OpenAI, you need to set OPENAI_BASE_URL, AZURE_OPENAI_RESOURCE_NAME, AZURE_OPENAI_EMBEDDING_MODEL and OPENAI_MODEL. Please check documentation.") def get_schemas(self) -> dict: """ @returns dict - A dictionary with the schema names and their object count. """ schema_info = self.client.schema.get() schemas = {} for _class in schema_info["classes"]: results = ( self.client.query.get(_class["class"]) .with_limit(10000) .with_additional(properties=["id"]) .do() ) schemas[_class["class"]] = len(results["data"]["Get"][_class["class"]]) return schemas def get_suggestions(self, query: str) -> list[str]: """Retrieve suggestions based on user query @parameter query : str - User query @returns list[str] - List of possible autocomplete suggestions. """ query_results = ( self.client.query.get( class_name="Suggestion", properties=["suggestion"], ) .with_bm25(query=query) .with_limit(3) .do() ) results = query_results["data"]["Get"]["Suggestion"] if not results: return [] suggestions = [] for result in results: suggestions.append(result["suggestion"]) return suggestions def set_suggestions(self, query: str): """Adds suggestions to the suggestion class @parameter query : str - Query to save in suggestions. """ # Don't set new suggestions when in production production_key = os.environ.get("VERBA_PRODUCTION", "") if production_key == "True": return check_results = ( self.client.query.get( class_name="Suggestion", properties=["suggestion"], ) .with_where( { "path": ["suggestion"], "operator": "Equal", "valueText": query, } ) .with_limit(1) .do() ) if ( "data" in check_results and len(check_results["data"]["Get"]["Suggestion"]) > 0 ): if query == check_results["data"]["Get"]["Suggestion"][0]["suggestion"]: return with self.client.batch as batch: batch.batch_size = 1 properties = { "suggestion": query, } self.client.batch.add_data_object(properties, "Suggestion") msg.info("Added query to suggestions") def retrieve_chunks(self, queries: list[str]) -> list[Chunk]: chunks, context = self.retriever_manager.retrieve( queries, self.client, self.embedder_manager.selected_embedder, self.generator_manager.selected_generator, ) return chunks, context def retrieve_all_documents(self, doc_type: str) -> list: """Return all documents from Weaviate @returns list - Document list. """ class_name = "Document_" + schema_manager.strip_non_letters( self.embedder_manager.selected_embedder.vectorizer ) if doc_type == "": query_results = ( self.client.query.get( class_name=class_name, properties=["doc_name", "doc_type", "doc_link"], ) .with_additional(properties=["id"]) .with_limit(10000) .do() ) else: query_results = ( self.client.query.get( class_name=class_name, properties=["doc_name", "doc_type", "doc_link"], ) .with_additional(properties=["id"]) .with_where( { "path": ["doc_type"], "operator": "Equal", "valueText": doc_type, } ) .with_limit(10000) .do() ) results = query_results["data"]["Get"][class_name] return results def retrieve_document(self, doc_id: str) -> dict: """Return a document by it's ID (UUID format) from Weaviate @parameter doc_id : str - Document ID @returns dict - Document dict. """ class_name = "Document_" + schema_manager.strip_non_letters( self.embedder_manager.selected_embedder.vectorizer ) document = self.client.data_object.get_by_id( doc_id, class_name=class_name, ) return document async def generate_answer( self, queries: list[str], contexts: list[str], conversation: dict ): semantic_query = self.embedder_manager.selected_embedder.conversation_to_query( queries, conversation ) ( semantic_result, distance, ) = self.embedder_manager.selected_embedder.retrieve_semantic_cache( self.client, semantic_query ) if semantic_result is not None: return { "message": str(semantic_result), "finish_reason": "stop", "cached": True, "distance": distance, } else: full_text = await self.generator_manager.selected_generator.generate( queries, contexts, conversation ) self.embedder_manager.selected_embedder.add_to_semantic_cache( self.client, semantic_query, full_text ) self.set_suggestions(" ".join(queries)) return full_text async def generate_stream_answer( self, queries: list[str], contexts: list[str], conversation: dict ): semantic_query = self.embedder_manager.selected_embedder.conversation_to_query( queries, conversation ) ( semantic_result, distance, ) = self.embedder_manager.selected_embedder.retrieve_semantic_cache( self.client, semantic_query ) if semantic_result is not None: yield { "message": str(semantic_result), "finish_reason": "stop", "cached": True, "distance": distance, } else: full_text = "" async for result in self.generator_manager.selected_generator.generate_stream( queries, contexts, conversation ): full_text += result["message"] yield result self.set_suggestions(" ".join(queries)) self.embedder_manager.selected_embedder.add_to_semantic_cache( self.client, semantic_query, full_text ) def reset(self): self.client.schema.delete_class("Suggestion") # Check if all schemas exist for all possible vectorizers for vectorizer in schema_manager.VECTORIZERS: schema_manager.reset_schemas(self.client, vectorizer) for embedding in schema_manager.EMBEDDINGS: schema_manager.reset_schemas(self.client, embedding) for vectorizer in schema_manager.VECTORIZERS: schema_manager.init_schemas(self.client, vectorizer, False, True) for embedding in schema_manager.EMBEDDINGS: schema_manager.init_schemas(self.client, embedding, False, True) def reset_cache(self): # Check if all schemas exist for all possible vectorizers for vectorizer in schema_manager.VECTORIZERS: class_name = "Cache_" + schema_manager.strip_non_letters(vectorizer) self.client.schema.delete_class(class_name) schema_manager.init_schemas(self.client, vectorizer, False, True) for embedding in schema_manager.EMBEDDINGS: class_name = "Cache_" + schema_manager.strip_non_letters(embedding) self.client.schema.delete_class(class_name) schema_manager.init_schemas(self.client, embedding, False, True) def reset_suggestion(self): self.client.schema.delete_class("Suggestion") schema_manager.init_suggestion(self.client, "", False, True) def check_if_document_exits(self, document: Document) -> bool: """Return a document by it's ID (UUID format) from Weaviate @parameter document : Document - Document object @returns bool - Whether the doc name exist in the cluster. """ class_name = "Document_" + schema_manager.strip_non_letters( self.embedder_manager.selected_embedder.vectorizer ) results = ( self.client.query.get( class_name=class_name, properties=[ "doc_name", ], ) .with_where( { "path": ["doc_name"], "operator": "Equal", "valueText": document.name, } ) .with_limit(1) .do() ) if results["data"]["Get"][class_name]: msg.warn(f"{document.name} already exists") return True else: return False def check_verba_component(self, component: VerbaComponent) -> tuple[bool, str]: for library in component.requires_library: if library in self.installed_libraries: if not self.installed_libraries[library]: return (False, f"{library} not installed") else: return (False, f"{library} not installed") for env in component.requires_env: if env in self.environment_variables: if not self.environment_variables[env]: return (False, f"{env} not set") else: return (False, f"{env} not set") return (True, "Available") def delete_document_by_id(self, doc_id: str) -> None: self.embedder_manager.selected_embedder.remove_document_by_id( self.client, doc_id ) def search_documents(self, query: str, doc_type: str) -> list: return self.embedder_manager.selected_embedder.search_documents( self.client, query, doc_type )

2024-01-10

weaviate/Verba

goldenverba~components~generation~manager.py

from collections.abc import Iterator import tiktoken from wasabi import msg from goldenverba.components.generation.CohereGenerator import CohereGenerator from goldenverba.components.generation.GPT3Generator import GPT3Generator from goldenverba.components.generation.GPT4Generator import GPT4Generator from goldenverba.components.generation.interface import Generator from goldenverba.components.generation.Llama2Generator import Llama2Generator class GeneratorManager: def __init__(self): self.generators: dict[str, Generator] = { "GPT4Generator": GPT4Generator(), "GPT3Generator": GPT3Generator(), "CohereGenerator": CohereGenerator(), "Llama2Generator": Llama2Generator(), } self.selected_generator: Generator = self.generators["GPT3Generator"] async def generate( self, queries: list[str], context: list[str], conversation: dict = None, ) -> str: """Generate an answer based on a list of queries and list of contexts, and includes conversational context @parameter: queries : list[str] - List of queries @parameter: context : list[str] - List of contexts @parameter: conversation : dict - Conversational context @returns str - Answer generated by the Generator. """ if conversation is None: conversation = {} return await self.selected_generator.generate( queries, context, self.truncate_conversation_items( conversation, int(self.selected_generator.context_window * 0.375) ), ) async def generate_stream( self, queries: list[str], context: list[str], conversation: dict = None, ) -> Iterator[dict]: """Generate a stream of response dicts based on a list of queries and list of contexts, and includes conversational context @parameter: queries : list[str] - List of queries @parameter: context : list[str] - List of contexts @parameter: conversation : dict - Conversational context @returns Iterator[dict] - Token response generated by the Generator in this format {system:TOKEN, finish_reason:stop or empty}. """ if conversation is None: conversation = {} async for result in self.selected_generator.generate_stream( queries, context, self.truncate_conversation_items( conversation, int(self.selected_generator.context_window * 0.375) ), ): yield result def truncate_conversation_dicts( self, conversation_dicts: list[dict[str, any]], max_tokens: int ) -> list[dict[str, any]]: """ Truncate a list of conversation dictionaries to fit within a specified maximum token limit. @parameter conversation_dicts: List[Dict[str, any]] - A list of conversation dictionaries that may contain various keys, where 'content' key is present and contains text data. @parameter max_tokens: int - The maximum number of tokens that the combined content of the truncated conversation dictionaries should not exceed. @returns List[Dict[str, any]]: A list of conversation dictionaries that have been truncated so that their combined content respects the max_tokens limit. The list is returned in the original order of conversation with the most recent conversation being truncated last if necessary. """ encoding = tiktoken.encoding_for_model("gpt-3.5-turbo") accumulated_tokens = 0 truncated_conversation_dicts = [] # Start with the newest conversations for item_dict in reversed(conversation_dicts): item_tokens = encoding.encode(item_dict["content"], disallowed_special=()) # If adding the entire new item exceeds the max tokens if accumulated_tokens + len(item_tokens) > max_tokens: # Calculate how many tokens we can add from this item remaining_space = max_tokens - accumulated_tokens truncated_content = encoding.decode(item_tokens[:remaining_space]) # Create a new truncated item dictionary truncated_item_dict = { "type": item_dict["type"], "content": truncated_content, "typewriter": item_dict["typewriter"], } truncated_conversation_dicts.append(truncated_item_dict) break truncated_conversation_dicts.append(item_dict) accumulated_tokens += len(item_tokens) # The list has been built in reverse order so we reverse it again return list(reversed(truncated_conversation_dicts)) def set_generator(self, generator: str) -> bool: if generator in self.generators: self.selected_generator = self.generators[generator] return True else: msg.warn(f"Generator {generator} not found") return False def get_generators(self) -> dict[str, Generator]: return self.generators

2024-01-10

weaviate/Verba

goldenverba~components~generation~GPT4Generator.py

import asyncio import os from dotenv import load_dotenv from collections.abc import Iterator from goldenverba.components.generation.interface import Generator load_dotenv() class GPT4Generator(Generator): """ GPT4 Generator. """ def __init__(self): super().__init__() self.name = "GPT4Generator" self.description = "Generator using OpenAI's GPT-4-1106-preview model" self.requires_library = ["openai"] self.requires_env = ["OPENAI_API_KEY"] self.streamable = True self.model_name = os.getenv("OPENAI_MODEL","gpt-4-1106-preview") self.context_window = 10000 async def generate( self, queries: list[str], context: list[str], conversation: dict = None, ) -> str: """Generate an answer based on a list of queries and list of contexts, and includes conversational context @parameter: queries : list[str] - List of queries @parameter: context : list[str] - List of contexts @parameter: conversation : dict - Conversational context @returns str - Answer generated by the Generator. """ if conversation is None: conversation = {} messages = self.prepare_messages(queries, context, conversation) try: import openai openai.api_key = os.getenv("OPENAI_API_KEY") if "OPENAI_API_TYPE" in os.environ: openai.api_type = os.getenv("OPENAI_API_TYPE") if "OPENAI_API_BASE" in os.environ: openai.api_base = os.getenv("OPENAI_API_BASE") if "OPENAI_API_VERSION" in os.environ: openai.api_version = os.getenv("OPENAI_API_VERSION") chat_completion_arguments = { "model":self.model_name, "messages":messages } if openai.api_type=="azure": chat_completion_arguments["deployment_id"]=self.model_name base_url = os.environ.get("OPENAI_BASE_URL", "") if base_url: openai.api_base = base_url completion = await asyncio.to_thread( openai.ChatCompletion.create, **chat_completion_arguments ) system_msg = str(completion["choices"][0]["message"]["content"]) except Exception: raise return system_msg async def generate_stream( self, queries: list[str], context: list[str], conversation: dict = None, ) -> Iterator[dict]: """Generate a stream of response dicts based on a list of queries and list of contexts, and includes conversational context @parameter: queries : list[str] - List of queries @parameter: context : list[str] - List of contexts @parameter: conversation : dict - Conversational context @returns Iterator[dict] - Token response generated by the Generator in this format {system:TOKEN, finish_reason:stop or empty}. """ if conversation is None: conversation = {} messages = self.prepare_messages(queries, context, conversation) try: import openai openai.api_key = os.getenv("OPENAI_API_KEY") base_url = os.environ.get("OPENAI_BASE_URL", "") if base_url: openai.api_base = base_url if "OPENAI_API_TYPE" in os.environ: openai.api_type = os.getenv("OPENAI_API_TYPE") if "OPENAI_API_BASE" in os.environ: openai.api_base = os.getenv("OPENAI_API_BASE") if "OPENAI_API_VERSION" in os.environ: openai.api_version = os.getenv("OPENAI_API_VERSION") chat_completion_arguments = { "model":self.model_name, "messages":messages, "stream":True, "temperature":0.0 } if openai.api_type=="azure": chat_completion_arguments["deployment_id"]=self.model_name completion = await openai.ChatCompletion.acreate( **chat_completion_arguments ) try: while True: chunk = await completion.__anext__() if len(chunk["choices"]) > 0: if "content" in chunk["choices"][0]["delta"]: yield { "message": chunk["choices"][0]["delta"]["content"], "finish_reason": chunk["choices"][0]["finish_reason"], } else: yield { "message": "", "finish_reason": chunk["choices"][0]["finish_reason"], } except StopAsyncIteration: pass except Exception: raise def prepare_messages( self, queries: list[str], context: list[str], conversation: dict[str, str] ) -> dict[str, str]: """ Prepares a list of messages formatted for a Retrieval Augmented Generation chatbot system, including system instructions, previous conversation, and a new user query with context. @parameter queries: A list of strings representing the user queries to be answered. @parameter context: A list of strings representing the context information provided for the queries. @parameter conversation: A list of previous conversation messages that include the role and content. @returns A list of message dictionaries formatted for the chatbot. This includes an initial system message, the previous conversation messages, and the new user query encapsulated with the provided context. Each message in the list is a dictionary with 'role' and 'content' keys, where 'role' is either 'system' or 'user', and 'content' contains the relevant text. This will depend on the LLM used. """ messages = [ { "role": "system", "content": "You are a Retrieval Augmented Generation chatbot. Please answer user queries only their provided context. If the provided documentation does not provide enough information, say so. If the answer requires code examples encapsulate them with ```programming-language-name ```. Don't do pseudo-code.", } ] for message in conversation: messages.append({"role": message.type, "content": message.content}) query = " ".join(queries) user_context = " ".join(context) messages.append( { "role": "user", "content": f"Please answer this query: '{query}' with this provided context: {user_context}", } ) return messages

2024-01-10

weaviate/Verba

goldenverba~components~generation~CohereGenerator.py

import asyncio import os from collections.abc import Iterator from wasabi import msg from goldenverba.components.generation.interface import Generator class CohereGenerator(Generator): """ CohereGenerator Generator. """ def __init__(self): super().__init__() self.name = "CohereGenerator" self.description = "Generator using Cohere's command model" self.requires_library = ["cohere"] self.requires_env = ["COHERE_API_KEY"] self.streamable = False self.model_name = "command" self.context_window = 3000 async def generate( self, queries: list[str], context: list[str], conversation: dict = None, ) -> str: """Generate an answer based on a list of queries and list of contexts, and includes conversational context @parameter: queries : list[str] - List of queries @parameter: context : list[str] - List of contexts @parameter: conversation : dict - Conversational context @returns str - Answer generated by the Generator. """ if conversation is None: conversation = {} message, _conversation = self.prepare_messages(queries, context, conversation) try: import cohere co = cohere.Client(os.getenv("COHERE_API_KEY")) # This is your synchronous chat function call. def synchronous_chat_call(): # ... setup your parameters for the call ... return co.chat( chat_history=_conversation, message=message, model="command", temperature=0.1, ) # This is your async wrapper function. async def asynchronous_chat_call(): chat_obj = await asyncio.to_thread(synchronous_chat_call) return chat_obj chat_obj = await asynchronous_chat_call() system_msg = str(chat_obj.text) except Exception: raise return system_msg async def generate_stream( self, queries: list[str], context: list[str], conversation: dict = None, ) -> Iterator[dict]: """Generate a stream of response dicts based on a list of queries and list of contexts, and includes conversational context @parameter: queries : list[str] - List of queries @parameter: context : list[str] - List of contexts @parameter: conversation : dict - Conversational context @returns Iterator[dict] - Token response generated by the Generator in this format {system:TOKEN, finish_reason:stop or empty}. """ if conversation is None: conversation = {} message, _conversation = self.prepare_messages(queries, context, conversation) try: import cohere from cohere.responses.chat import StreamEnd, StreamTextGeneration co = cohere.Client(os.getenv("COHERE_API_KEY")) async for chunk in co.chat( chat_history=_conversation, stream=True, message=message, model="command", temperature=0.1, ): if isinstance(chunk, StreamTextGeneration): yield { "message": chunk.text, "finish_reason": "", } elif isinstance(chunk, StreamEnd): yield { "message": "", "finish_reason": "stop", } except Exception as e: raise msg.warn(str(e)) yield { "message": "", "finish_reason": "stop", } def prepare_messages( self, queries: list[str], context: list[str], conversation: dict[str, str] ) -> dict[str, str]: """ Prepares a list of messages formatted for a Retrieval Augmented Generation chatbot system, including system instructions, previous conversation, and a new user query with context. @parameter queries: A list of strings representing the user queries to be answered. @parameter context: A list of strings representing the context information provided for the queries. @parameter conversation: A list of previous conversation messages that include the role and content. @returns A list of message dictionaries formatted for the chatbot. This includes an initial system message, the previous conversation messages, and the new user query encapsulated with the provided context. Each message in the list is a dictionary with 'role' and 'content' keys, where 'role' is either 'system' or 'user', and 'content' contains the relevant text. This will depend on the LLM used. """ messages = [ { "role": "CHATBOT", "message": "I am a Retrieval Augmented Generation chatbot. I'll answer user queries only with their provided context. If the provided documentation does not provide enough information, I say so. If the answer requires code examples I encapsulate them with ```programming-language-name ```. I don't do pseudo-code.", } ] for message in conversation: _type = "" _type = "CHATBOT" if message.type == "system" else "USER" messages.append({"role": _type, "message": message.content}) query = " ".join(queries) user_context = " ".join(context) prompt = f"Please answer this query: '{query}' with this provided context: {user_context}" return prompt, messages

2024-01-10

harivmasoor/canopy

tests~system~query_generator~test_query_generator_integration.py

from unittest.mock import create_autospec import pytest from canopy.llm.openai import OpenAILLM # noqa from canopy.models.data_models import MessageBase, Query # noqa from canopy.chat_engine.query_generator import FunctionCallingQueryGenerator # noqa from canopy.chat_engine.prompt_builder import PromptBuilder # noqa from typing import List # noqa class TestFunctionCallingQueryGeneratorSystem: @staticmethod @pytest.fixture def openai_llm(): return OpenAILLM(model_name="-3.5-turbo") @staticmethod @pytest.fixture def prompt_builder(): return create_autospec(PromptBuilder) @staticmethod @pytest.fixture def query_generator(openai_llm, prompt_builder): query_gen = FunctionCallingQueryGenerator( llm=openai_llm, ) query_gen._prompt_builder = prompt_builder return query_gen @staticmethod @pytest.fixture def sample_messages(): return [ MessageBase(role="user", content="What is photosynthesis?") ] @staticmethod def test_generate_default_params(query_generator, prompt_builder, sample_messages): prompt_builder.build.return_value = sample_messages result = query_generator.generate(messages=sample_messages, max_prompt_tokens=100) assert isinstance(result, List) assert len(result) > 0 for query in result: assert isinstance(query, Query) assert len(query.text) > 0

2024-01-10

tmakesense/logical-fallacy

original-logical-fallacy-by-causalNLP~codes_for_models~zeroshot~model2_gpt3.py

from efficiency.log import show_var from sklearn.model_selection import train_test_split import pandas as pd import sys sys.path.insert(1, '../abhinav_experiments') from logicedu import get_logger,get_unique_labels,get_metrics from tqdm import tqdm import random from sklearn.preprocessing import MultiLabelBinarizer import openai import time class GPT3: def __init__(self): self.setup_gpt3() def setup_gpt3(self): # get OpenAI access key from efficiency.log import fread key = fread(C.file_gpt3_api, if_strip=True, delete_empty=True)[0] openai.api_key = key # openai.api_key = os.getenv("OPENAI_API_KEY") def classification_zero_shot(self, sentence_n_labels_n_neg_labels, result_file, data_type=['sentence', 'article'][0]): import os import json sent_id2pred_n_sent = {} if os.path.isfile(result_file): results = [] with open(result_file) as f: for line in f: if line.strip(): results.append(json.loads(line)) show_var(['len(results)']) sent_id2pred_n_sent = {i['sentence_id']: (i['pred'], i['sentence']) for i in results} # reference: https://beta.openai.com/docs/api-reference/classifications import openai import random from tqdm import tqdm if data_type == 'sentence': prompt_template = 'Please classify a piece of text into the following categories of logical fallacies: ' \ '{labels_str}.\n\nText: {sentence}\nLabel:' 'An example of ad hominem fallacy is the following: {sentence}' max_tokens = 10 else: prompt_template = 'Please classify a news article about climate change into the following categories of logical fallacies: ' \ '{labels_str}.\n\nText: {sentence}\nOne label:' max_tokens = 20 from efficiency.log import fwrite from efficiency.function import avg, set_seed set_seed() accuracies = [] predictions = [] bar = tqdm(list(enumerate(sentence_n_labels_n_neg_labels))) for sent_id, (sent, labels, neg_labels) in bar: all_labels = labels + neg_labels all_labels = [i.strip().capitalize() for i in all_labels] if sent_id in sent_id2pred_n_sent: pred, sent_in_pred_file = sent_id2pred_n_sent[sent_id] if sent != sent_in_pred_file: pass # show_var(['sent', 'sent_in_pred_file']) # import pdb; # pdb.set_trace() else: random.shuffle(all_labels) labels_str = ', '.join(all_labels) # Post hoc, Slippery slope, Circular argument, Unknown type sent_for_prompt = sent if len(sent.split()) > 900: sent_for_prompt = ' '.join(sent.split()[:900]).rsplit('.', 1)[0] + '.' prompt = prompt_template.format( labels_str=labels_str, sentence=sent_for_prompt, ) kwargs = dict( engine="davinci", prompt=prompt, max_tokens=max_tokens, temperature=0, n=1, stop="\n", ) received = False for _ in range(10): if received: break try: response = openai.Completion.create(**kwargs) pred = response['choices'][0]['text'].strip().rstrip('.') if pred in all_labels: received = True else: kwargs['temperature'] = 0.5 except: import sys error = sys.exc_info()[0] if error == openai.error.InvalidRequestError: # something is wrong: e.g. prompt too long print(f"InvalidRequestError\nPrompt passed in:\n\n{prompt}\n\n") # assert False print("API error:", error) import time time.sleep(1) import pdb;pdb.set_trace() # show_var(['response']) ''' response: <OpenAIObject text_completion id=cmpl-3cZRMI6OLT4TT57LXyNnxiu9b99D1 at 0x2b70f882a270> JSON: { | 1/10 [00:01<00:13, 1.48s/it] "choices": [ { "finish_reason": "stop", "index": 0, "logprobs": null, "text": " False inductions" } ], "created": 1630321708, "id": "cmpl-3cZRMI6OLT4TT57LXyNnxiu9b99D1", "model": "davinci:2020-05-03", "object": "text_completion" } ''' # print(prompt, pred) # import pdb; # pdb.set_trace() fwrite(json.dumps({'sentence_id': sent_id, 'pred': pred, 'sentence': sent}) + '\n', result_file, mode='a') preds = [pred] if data_type == 'article': preds = pred.split(', ') preds = [i.lower() for i in preds] predictions.append((sent_id, preds, sent)) if preds[0] in {i.lower() for i in all_labels}: acc = {i for i in preds} & {i.lower() for i in labels} accuracies.append(bool(acc)) bar.set_description('accuracy mean={:.2f}%'.format(100 * avg(accuracies, decimal=4))) sent2preds = {sent: preds for sent_id, preds, sent in predictions} return sent2preds # predictions def classification_few_shot(self): # reference: https://beta.openai.com/docs/api-reference/classifications import openai kwargs = dict(search_model="ada", model="curie", examples=[ ["A happy moment", "Positive"], ["I am sad.", "Negative"], ["I am feeling awesome", "Positive"] ], query="It is a raining day :(", labels=["Positive", "Negative", "Neutral"], max_examples=3, return_prompt=True, ) kwargs = dict(search_model="ada", model="curie", examples=[ # ["What can our new math teacher know? Have you seen how fat she is?", "Ad Hominem", ], # ["Shortly after MySpace became popular, U.S. soldiers found Saddam Hussein.", "Post Hoc", ], # [ # "Major in English in college, start reading poetry, and next thing you know, you will become an unemployed pot-smoking loser.", # "Slippery Slope", ], # ["George Bush is a good communicator because he speaks effectively.", "Circular Argument", ], ], query="Michael Jackson, Kurt Cobain, and Jimi Hendrix were rock stars who died young. Therefore, if you become a rock star, don’t expect to live a long life.", labels=["Ad Hominem", "Post Hoc", "Slippery Slope", "Circular Argument", ], max_examples=3, return_prompt=True, ) received = False from tqdm import tqdm for _ in tqdm(list(range(10))): if received: break try: response = openai.Classification.create(**kwargs) received = True except: import sys error = sys.exc_info()[0] if error == openai.error.InvalidRequestError: # something is wrong: e.g. prompt too long print(f"InvalidRequestError\nPrompt passed in:\n\n{prompt}\n\n") # assert False print("API error:", error) import time time.sleep(1) show_var(['response']) import pdb; pdb.set_trace() ''' response: <OpenAIObject classification at 0x7ffcf84bc270> JSON: { "completion": "cmpl-3cY9glzFkmXqIgcV1IXdxj9F0Tyvd", "label": "Negative", "model": "curie:2020-05-03", "object": "classification", "prompt": "Please classify a piece of text into the following categories: Positive, Negative, Neutral.\n\nText: I am sad.\nLabel: Negative\n---\nText: A happy moment\nLabel: Positive\n---\nText: I am feeling awesome\nLabel: Positive\n---\nText: It is a raining day :(\nLabel:", "search_model": "ada", "selected_examples": [ { "document": 1, "label": "Negative", "text": "I am sad." }, { "document": 0, "label": "Positive", "text": "A happy moment" }, { "document": 2, "label": "Positive", "text": "I am feeling awesome" } ] } response: <OpenAIObject classification at 0x7f89e027db30> JSON: { "completion": "cmpl-3cYNwMStEyHs9382TGImtde7gsr8Z", "label": "Ad hominem", "model": "curie:2020-05-03", "object": "classification", "prompt": "Please classify a piece of text into the following categories: Ad hominem, Post hoc, Slippery slope, Circular argument.\n\nText: Major in English in college, start reading poetry, and next thing you know, you will become an unemployed pot-smoking loser.\nLabel: Slippery slope\n---\nText: George Bush is a good communicator because he speaks effectively.\nLabel: Circular argument\n---\nText: Shortly after MySpace became popular, U.S. soldiers found Saddam Hussein.\nLabel: Post hoc\n---\nText: Michael Jackson, Kurt Cobain, and Jimi Hendrix were rock stars who died young. Therefore, if you become a rock star, don\u2019t expect to live a long life.\nLabel:", "search_model": "ada:2020-05-03", "selected_examples": [ { "document": 2, "label": "Slippery slope", "object": "search_result", "score": 11.04, "text": "Major in English in college, start reading poetry, and next thing you know, you will become an unemployed pot-smoking loser." }, { "document": 3, "label": "Circular argument", "object": "search_result", "score": 8.361, "text": "George Bush is a good communicator because he speaks effectively." }, { "document": 1, "label": "Post hoc", "object": "search_result", "score": 4.823, "text": "Shortly after MySpace became popular, U.S. soldiers found Saddam Hussein." } ] } ''' return response def classify_zero_shot2(self,data_path): fallacy_all=pd.read_csv(data_path)[['source_article','updated_label']] _,fallacy_rem=train_test_split(fallacy_all,test_size=600,random_state=10) _,fallacy_test=train_test_split(fallacy_rem,test_size=300,random_state=10) all_labels=get_unique_labels(fallacy_all,'updated_label') prompt_template = 'Please classify a piece of text into the following categories of logical fallacies: ' \ '{labels_str}.\n\nText: {sentence}\nLabel:' max_tokens = 10 labels=[] preds=[] mlb = MultiLabelBinarizer() mlb.fit([all_labels]) for _,row in tqdm(fallacy_test.iterrows()): random.shuffle(all_labels) labels_str = ', '.join(all_labels) # Post hoc, Slippery slope, Circular argument, Unknown type sent=row['source_article'] sent_for_prompt = sent if len(sent.split()) > 900: sent_for_prompt = ' '.join(sent.split()[:900]).rsplit('.', 1)[0] + '.' prompt = prompt_template.format( labels_str=labels_str, sentence=sent_for_prompt, ) kwargs = dict( engine="davinci", prompt=prompt, max_tokens=max_tokens, temperature=0, n=1, stop="\n", ) # print("Prompt is ",prompt) received = False for _ in range(10): if received: break try: response = openai.Completion.create(**kwargs) pred = response['choices'][0]['text'].strip().rstrip('.').lower() # print("openai responded ",pred," actual is",row['updated_label']) if pred in all_labels: received = True else: kwargs['temperature'] += 0.1 except: import sys error = sys.exc_info()[0] if error == openai.error.InvalidRequestError: # something is wrong: e.g. prompt too long print(f"InvalidRequestError\nPrompt passed in:\n\n{prompt}\n\n") # assert False elif error == openai.error.RateLimitError: time.sleep(10) print("API error:", error) if received: preds_mh = mlb.transform([[pred]]) else: preds_mh = [[0]*len(all_labels)] labels_mh = mlb.transform([[row['updated_label']]]) print(pred,preds_mh) print(row['updated_label'],labels_mh) labels.append(labels_mh[0]) preds.append(preds_mh[0]) scores=get_metrics(preds,labels,sig=False,tensors=False) print("micro f1: %f macro f1:%f precision: %f recall: %f exact match %f" %(scores[4],scores[5],scores[1],scores[2],scores[3])) def main(): from efficiency.function import set_seed set_seed(verbose=True) from model1_transfer_from_nli import DataReader data_type = ['sentence', 'article'][1] dr = DataReader(data_type=data_type) dr.get_label_explanations() data = dr.sentence_n_labels_n_neg_labels gpt3 = GPT3() gpt3.classification_zero_shot(data, data_type=data_type) # gpt3.classification_few_shot() if __name__ == '__main__': from model1_transfer_from_nli import Constants C = Constants() gpt3=GPT3() gpt3.classify_zero_shot2('../../data/edu_all_updated.csv')

2024-01-10

nimo-codes/Langchain-starters

first.py

import openai from langchain.llms import OpenAI import os os.environ['OPENAI_API_KEY'] = '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' # openai.api_key = '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' llm = OpenAI(temperature=0.6) name = llm("I want to open a new gaming arcade. suggest me a great name") print(name)

2024-01-10

2187Nick/gpt4all-qa-youtube

cli-version.py

from langchain.llms import GPT4All from langchain.document_loaders import YoutubeLoader from langchain.embeddings.huggingface import HuggingFaceEmbeddings from langchain.vectorstores import Chroma from langchain.chains import RetrievalQA from langchain.text_splitter import RecursiveCharacterTextSplitter import os # enter the path to your model here select_model = 'models/gpt4all-converted.bin' # ./models/gpt4all-converted.bin' # enter your youtube link here youtube_link = "https://www.youtube.com/watch?v=GhRNIuTA2Z0" # set the length of the response you want results_length = 30 # increase this number to get more random results model_temp = 0.3 loader = YoutubeLoader.from_youtube_channel(youtube_link, add_video_info=True) documents = loader.load() title = documents[0].metadata['title'] print(documents[0].metadata['title']) # chromadb can give error with publish date. So deleting it del documents[0].metadata['publish_date'] # Split the documents into chunks of 100 characters text_splitter = RecursiveCharacterTextSplitter( chunk_size=100, chunk_overlap=20, length_function=len, ) documents = text_splitter.split_documents(documents) # remove special characters k = "1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_"; title = title.replace(" ", "_") getVals = list(filter(lambda x: x in k, title)) title = "".join(getVals) # set the directory to store the vectorized database persist_directory = title # select an embeddings transformer # list of models and their speeds : https://www.sbert.net/docs/pretrained_models.html #model_name = "sentence-transformers/all-mpnet-base-v2" model_name = "sentence-transformers/all-MiniLM-L6-v2" embeddings = HuggingFaceEmbeddings(model_name=model_name) # if the vectorized database doesn't exist then create it. Else load it if not os.path.exists(persist_directory): db_vector = Chroma.from_documents(documents, embeddings, persist_directory=persist_directory) else: db_vector = Chroma(embedding_function=embeddings, persist_directory=persist_directory) llm = GPT4All(model=select_model, n_predict=results_length, temp=model_temp) # n_ctx=512, n_threads=8, n_predict=100, temp=.8 retriever = db_vector.as_retriever() qa = RetrievalQA.from_chain_type(llm=llm, chain_type="stuff", retriever=retriever) #, chain_type_kwargs=chain_type_kwargs) parse_answer = lambda x: x["result"].split("Answer:")[1].strip() while True: query = input("Query: ") # Query the youtube video data result = qa(query, return_only_outputs=True) print("Youtube Sourced Answer: ", parse_answer(result))

2024-01-10

2187Nick/gpt4all-qa-youtube

gradio-version.py

import gradio as gr from pyllamacpp.model import Model from langchain.llms import GPT4All from langchain.document_loaders import YoutubeLoader from langchain.embeddings.huggingface import HuggingFaceEmbeddings from langchain.vectorstores import Chroma from langchain.chains import RetrievalQA from langchain.text_splitter import RecursiveCharacterTextSplitter import os # enter the location of your model select_model = './models/gpt4all-converted.bin' # set the length of the response you want results_length = 30 # increase this number to get more random results model_temp = 0.3 model = Model(ggml_model=select_model) def youtube_video_to_text(Youtube_Link, Question): youtube_link = Youtube_Link loader = YoutubeLoader.from_youtube_channel(Youtube_Link, add_video_info=True) documents = loader.load() title = documents[0].metadata['title'] print(documents[0].metadata['title']) # chromadb can give error with publish date. So deleting it del documents[0].metadata['publish_date'] # remove special characters k = "1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_"; title = title.replace(" ", "_") getVals = list(filter(lambda x: x in k, title)) title = "".join(getVals) # set the directory to store the vectorized database persist_directory = title # select an embeddings transformer # list of models and their speeds : https://www.sbert.net/docs/pretrained_models.html #model_name = "sentence-transformers/all-mpnet-base-v2" model_name = "sentence-transformers/all-MiniLM-L6-v2" embeddings = HuggingFaceEmbeddings(model_name=model_name) # if the video has already been processed then don't process it again if not os.path.exists(persist_directory): # Split the documents into chunks of 100 characters text_splitter = RecursiveCharacterTextSplitter( chunk_size=100, chunk_overlap=20, length_function=len, ) documents = text_splitter.split_documents(documents) db_vector = Chroma.from_documents(documents, embeddings, persist_directory=persist_directory) else: db_vector = Chroma(embedding_function=embeddings, persist_directory=persist_directory) llm = GPT4All(model=select_model, n_predict=30, temp=0.3) # n_ctx=512, n_threads=8, n_predict=100, temp=.8 retriever = db_vector.as_retriever() qa = RetrievalQA.from_chain_type(llm=llm, chain_type="stuff", retriever=retriever) parse_answer = lambda x: x["result"].split("Answer:")[1].strip() # Query the model directly general_answer = model.generate(Question, n_predict=results_length, temp=model_temp) print("General Answer: ", general_answer) # Query the model from the youtube video data result_raw = qa(Question, return_only_outputs=True) result = parse_answer(result_raw) print("Youtube Sourced Answer: ", result) return result, general_answer def query_both(Youtube_Link, Question): result, general_answer = youtube_video_to_text(Youtube_Link, Question) return result, general_answer demo = gr.Interface( fn=query_both, inputs=["text", "text"], outputs=["text", "text"], ) demo.launch()

2024-01-10

ChampPG/Wallace

bin~speech.py

import bin.google_calendar as gcal import json import openai import bin.text_to_speech as tts # import bin.chatbot_paramiko as chatbot import bin.chatbot as chatbot wallace = chatbot.ChatBot("XXXXXXXXXX") # Input your model name here def calendar(text, nums): """Handles calendar related commands in the given text using Google Calendar API. Args: text (str): Input text from user. nums (dict): Dictionary mapping textual representations of numbers to their numeric form.""" # Check if the command is to get next events if "Next" in text or "next" in text: split_text = text.split() # Split the text into words # Iterate over each word in the split text for word in split_text: # If word is a textual representation of a number if word in nums: num = int(nums[word]) # Convert to an integer events = gcal.google_get_next_events(num, gcal.google_authenticate()) # Get next events event_string = format_event_string(events) # Format events into a string # tts.speak(event_string) # Speak out the events (currently commented out) return event_string # Return the formatted event string try: # Try to convert the word to a number directly num = int(word) events = gcal.google_get_next_events(num, gcal.google_authenticate()) # Get next events event_string = format_event_string(events) # Format events into a string # tts.speak(event_string) # Speak out the events (currently commented out) return event_string except ValueError: continue # Ignore words that are neither textual nor numeric numbers # Placeholder for future implementation of create, delete, and modify calendar events elif "Create" in text or "create" in text: pass elif "Delete" in text or "delete" in text: pass elif "Modify" in text or "modify" in text: pass def format_event_string(events): """Formats a list of events into a human-readable string. Args: events (list): List of events to be formatted.""" event_string = "" # Iterate over events and concatenate them into a single string for i, event in enumerate(events): if i < len(events) - 2: event_string += event + ", next event is " else: if i == len(events) - 1: event_string += event else: event_string += event + ", then " return event_string def basic_chat(text): """Handles basic chat interactions using a chatbot. Args: text (str): Input text from user.""" tts.speak("One moment please") # Speak out a waiting message if text == "Wallace clear memory": wallace.clear_memory() return "Memory cleared" else: response = wallace.ai_call(text) # Get response from the chatbot return response # tts.speak(response) # Speak out the response (currently commented out) def openai_query(text): """Queries the OpenAI API with the given text and returns the response. Args: text (str): Input text from user.""" # Load API key and organization info from a settings file openai.api_key = json.load(open("data/configs/settings.json"))["openai_key"] openai.organization = json.load(open("data/configs/settings.json"))["openai_org"] # Make a query to OpenAI and return the response response = openai.Completion.create(engine="gpt-3.5-turbo-instruct", prompt=text, max_tokens=100) # print(response.choices[0].text) # Print the response (currently commented out) # tts.speak(response.choices[0].text) # Speak out the response (currently commented out) return response.choices[0].text def speech_to_text(user_input): """Converts speech to text and processes it based on specific keywords. Args: user_input (str): Input text from user.""" text = user_input # List of phrases to stop the application stop_list = ["Wallace stop", "wallace stop", "Wallace Stop", "wallace Stop", "Wallace turn off", "Wallace shut down"] # Dictionary mapping textual representations of numbers to their numeric form nums = {"one": '1', "two": '2', "three": '3', "four": '4', "five": '5', "six": '6', "seven": '7', "eight": '8', "nine": '9', "ten": '10', "eleven": '11', "twelve": '12', "thirteen": '13', "fourteen": '14', "fifteen": '15', "sixteen": '16', "seventeen": '17', "eighteen": '18', "nineteen": '19', "twenty": '20', "twenty one": '21', "twenty two": '22', "twenty three": '23', "twenty four": '24', "twenty five": '25'} # Process the text based on specific keywords or phrases if "Wallace" in text or "wallace" in text: if "Google calendar" in text or "google calendar" in text: return calendar(text, nums) # Handle calendar commands if "Search" in text or "search" in text: # Load OpenAI API key and check if it's available openai_api_key = json.load(open("data/configs/settings.json"))["openai_key"] if openai_api_key != "": strip_after_search = text.split("search")[1] # Extract the search query return openai_query(strip_after_search) # Make an OpenAI query else: print("No OpenAI API key found. Please add one to data/configs/settings.json") elif text in stop_list: return "stop" # Stop the application else: return basic_chat(text) # Handle basic chat interactions else: # If Wallace or wallace wan't in text return "I didn't catch that you might have not said Wallace"

2024-01-10

rishheba96/MCQ-AI-APP

mcq_app.py

# Import required modules import os import json import time from langchain import PromptTemplate from langchain.chains import LLMChain from langchain.chat_models import ChatOpenAI import streamlit as st def create_the_quiz_prompt_template(): """Create the prompt template for the mcq app.""" template = """ You are an expert quiz maker. create a quiz with {num_questions} Multiple-choice questions about the following topic: {quiz_topic}. The format of the output will be returned as: json object only with keys: Q1, O1, A1 without any other text <Q1>: Question1 <O1>: <a. Answer 1>| <b. Answer 2>| <c. Answer 3>| <d. Answer 4> <A1>: <a|b|c|d> <Q2>: Question2 <O2>: <a. Answer 1>| <b. Answer 2>| <c. Answer 3>| <d. Answer 4> <A2>: <a|b|c|d> """ prompt = PromptTemplate.from_template(template) prompt.format(num_questions=2, quiz_topic=" ") return prompt def map_letter_to_index(letter): """map each answer with its crossponding index based on its Ascii code """ letter = letter.lower() if letter in {'a', 'b', 'c', 'd'}: return ord(letter) - ord('a') def create_quiz_chain(prompt_template,llm): """Creates the chain for the quiz app.""" return LLMChain(llm=llm, prompt=prompt_template) def single_choice_fun(question, options, answer_index): """ creat the question and its choices, only one chice is corret""" user_answer = st.radio(question, options, index=None) if user_answer is None : # if sol is empty return False if options.index(user_answer) == answer_index: return True else: return False # define st session vriable states if "output_questions" not in st.session_state: st.session_state["output_questions"] = "" # if "json_obj_saved" not in st.session_state: st.session_state["json_obj_saved"] = "" if "output_score" not in st.session_state: st.session_state["output_score"] = "" if "num_correct_answer" not in st.session_state: st.session_state["num_correct_answer"] = 0 if "already_generated" not in st.session_state: st.session_state["already_generated"] = False if "num_questions" not in st.session_state: st.session_state["num_questions"] = 1 if "answers" not in st.session_state: st.session_state["answers"] = "" def main(): # steup the main page of the application st.title("AI Powered Quiz Generator") st.write("This app generates a quiz based on a given topic.") prompt_template = create_the_quiz_prompt_template() llm = ChatOpenAI() chain = create_quiz_chain(prompt_template,llm) tpoic = st.text_area("Enter the topic for the quiz") num_questions = st.number_input("Enter the number of questions",min_value=1,max_value=10,value=3) if st.button("Generate Quiz"): # to generate the questions according to the inputs st.session_state["num_questions"] = num_questions # save number of question in the st seesion state quiz_response = chain.run(num_questions=num_questions, quiz_topic=tpoic) # generate the questions based on the topic # Convert the json output string to a Python dictionary json_obj = json.loads(quiz_response) st.session_state["json_obj_saved"] = json_obj # save the result((pyhton dict ) on session state # num_correct_answer = 0 st.session_state["num_correct_answer"] = 0 # to track number of correct answers # Initialize lists to store extracted information questions, options, answers = [], [], [] # Parse questions amd answres from the json obj for key, value in json_obj.items(): if key.startswith('Q'): questions.append(value) elif key.startswith('O'): options.append(value) elif key.startswith('A'): answers.append(value) st.session_state["answers"] += value # Print the extracted information for q, o, a in zip(questions, options, answers): correct_answer = single_choice_fun(q ,o.split('|'),map_letter_to_index(a)) if correct_answer: num_correct_answer += 1 st.session_state["num_correct_answer"] = num_correct_answer st.session_state["output_score"] = st.session_state["num_correct_answer"] / st.session_state["num_questions"] st.session_state["output_questions"] = "output" if st.session_state["output_questions"] != "" and st.session_state["already_generated"]: num_correct_answer = 0 st.session_state["num_correct_answer"] = 0 dict_json_obj_saved = st.session_state["json_obj_saved"] questions, options, answers = [], [], [] for key, value in dict_json_obj_saved.items(): if key.startswith('Q'): questions.append(value) elif key.startswith('O'): options.append(value) elif key.startswith('A'): answers.append(value) # Print the extracted information for q, o, a in zip(questions, options, answers): correct_answer = single_choice_fun(q ,o.split('|'),map_letter_to_index(a)) if correct_answer: num_correct_answer += 1 st.session_state["num_correct_answer"] = num_correct_answer st.session_state["output_score"] = st.session_state["num_correct_answer"] / st.session_state["num_questions"] if st.session_state["output_questions"] != "": st.session_state["already_generated"] = True # to generate the Answers generate_button = st.button("Get results") if generate_button: if st.session_state["output_score"]: st.success(f'Reults is {st.session_state["output_score"]}', icon="✅") else: st.success(f'Reults is {st.session_state["output_score"]}', icon="✅") st.write(f"Answers:") for i in list(st.session_state['answers']): st.write(i) if __name__=="__main__": main()

2024-01-10

timkoehne/video-generator

story_based_video.py

from datetime import timedelta from random import randrange import string import subprocess import sys import textgrid from typing import Literal, Tuple from moviepy import * from configuration import Configuration from video_utils import ( check_if_valid_post, crop_to_center_and_resize, generate_intro_clip, generate_outro_clip, select_background_video, ) from openai_interface import OpenAiInterface from reddit_requests import Post, PostSearch config = Configuration() mfa_dictionary_names = { "english": ["english_us_arpa", "english_us_arpa"], "german": ["german_mfa", "german_mfa"], } class Timestamp: def __init__(self, text: str, from_time: float, to_time: float) -> None: self.text = text self.from_time = from_time self.to_time = to_time def generate_story_clip( post: Post, resolution: Tuple[int, int], language: str = "english" ) -> VideoClip: text: str = post.selftext intro: VideoClip = generate_intro_clip(post, resolution) outro: VideoClip = generate_outro_clip(post, resolution) # print("SKIPPING GENERATING AUDIO") openaiinterface = OpenAiInterface() print("generating audio") openaiinterface.generate_mp3(text, f"tmp/{post.post_id}-audio.mp3") audio_clip: AudioClip = AudioFileClip(f"tmp/{post.post_id}-audio.mp3") audio_clip.write_audiofile(f"tmp/{post.post_id}-audio.wav") print( f"the video will be {audio_clip.duration + intro.duration + outro.duration}s long" ) with open(f"tmp/{post.post_id}-audio.txt", "w", encoding="utf-8") as file: exclude = set(string.punctuation) file.write("".join(char for char in text if char not in exclude)) align_audio_and_text( f"tmp/{post.post_id}-audio.wav", f"tmp/{post.post_id}-audio.txt", language ) combined_text_clip: VideoClip = generate_combined_text_clip( text, resolution, f"tmp/{post.post_id}-audio.TextGrid" ) combined_text_clip = combined_text_clip.with_audio(audio_clip) combined_text_clip = concatenate_videoclips([intro, combined_text_clip, outro]) combined_text_clip = combined_text_clip.with_position("center") return combined_text_clip def align_audio_and_text(audiofile: str, textfile: str, language: str): dictionary_name, acoustic_model_name = mfa_dictionary_names[language] result = subprocess.run( [ "mfa", "align_one", audiofile, textfile, dictionary_name, acoustic_model_name, "tmp/", "--clean", "--single_speaker", ] ) try: result.check_returncode() except subprocess.CalledProcessError: raise Exception("Alignment failed") def remove_differences_to_textgrid(filtered_tg, text: str) -> str: words = text.split() for i in range(0, len(filtered_tg)): look_for_matches = [] for offset in range(i, min(i + 3, len(words))): word = "".join( [ letter for letter in words[offset] if letter not in set(string.punctuation) ] ) look_for_matches.append(word) correct_match_index = look_for_matches.index(filtered_tg[i].mark) # print(f"looking for {filtered_tg[i].mark} in {look_for_matches}, choosing {look_for_matches[correct_match_index]}") for delete_index in range(i, i + correct_match_index): print(f"deleting words {words[delete_index]}") del words[delete_index] # print(f"correct match {correct_match_index} {filtered_tg[i].mark} == {words[i]}") return " ".join(words) def generate_timestamps(filename, text: str) -> list[Timestamp]: tg = textgrid.TextGrid.fromFile(filename) # tg[0] is the list of words # filter to remove pauses filtered_tg = filter( lambda x: not x.mark == "" and not x.mark.startswith("<"), tg[0] ) filtered_tg = list(filtered_tg) print(f"filtered_tg is {len(filtered_tg)} long") text = remove_differences_to_textgrid(filtered_tg, text) text_segments = generate_text_list(text) timestamps: list[Timestamp] = [] for index, segment in enumerate(text_segments[:-1]): from_index = sum(len(s.split()) for s in text_segments[:index]) to_index = sum(len(s.split()) for s in text_segments[: index + 1]) start_time = filtered_tg[from_index].minTime end_time = filtered_tg[to_index].maxTime # print(f"from_index {from_index}={words[from_index]}, to_index {to_index}={words[to_index]}") timestamps.append(Timestamp(segment, start_time, end_time)) last_timestamp_start_time = filtered_tg[ sum(len(s.split()) for s in text_segments[:-1]) ].minTime last_timestamp_end_time = filtered_tg[-1].maxTime timestamps.append( Timestamp(text_segments[-1], last_timestamp_start_time, last_timestamp_end_time) ) # making sure the timestamps dont overlap for index in range(1, len(timestamps)): if timestamps[index].from_time < timestamps[index - 1].to_time: # print(f"changing to_time of index {index-1} from {timestamps[index - 1].to_time} to {timestamps[index].from_time-0.01}") timestamps[index - 1].to_time = timestamps[index].from_time - 0.01 return timestamps def generate_combined_text_clip( text: str, resolution: Tuple[float, float], textgrid_filename: str ): text_clips: list[TextClip] = [] timestamps: list[Timestamp] = generate_timestamps(textgrid_filename, text) text_box_size = (resolution[0] * 0.8, 0) for section in timestamps: text_clip: TextClip = generate_text_clip(section.text, text_box_size) text_clip = text_clip.with_start(section.from_time) text_clip = text_clip.with_end(section.to_time) print( f"{section.text} is played from {section.from_time:.2f} to {section.to_time:.2f} seconds" ) text_clip = text_clip.with_position("center") text_clips.append(text_clip) return CompositeVideoClip(text_clips, resolution).with_position("center") def generate_text_clip(text: str, size: Tuple[float, float]): # good fonts: # arial-black # cooper-black # franklin-gothic-heavy return TextClip( text=text, method="caption", color=config.video_font_color, font=config.video_font, font_size=config.video_font_size, stroke_color=config.video_font_stroke_color, stroke_width=config.video_font_stroke_width, size=(size[0], size[1]), align="center", ) def generate_text_list(text: str): words: list[str] = [x.strip() for x in text.split(" ")] text_list: list[str] = [] num_words = [] while len(words) > 0: # split into chunks of different lengths length = min(randrange(6, 9), len(words)) num_words.append(length) words = words[length:] if num_words[-1] < 3: # is the last text too short? add it to the previous one num_words[-2] += num_words[-1] num_words.pop() sum = 0 words = [x.strip() for x in text.split(" ")] for num in num_words: text_list.append(" ".join(words[sum : sum + num])) sum += num return text_list def find_story_post( timeframe: Literal["day", "week", "month", "year", "all"], listing: Literal["controversial", "best", "hot", "new", "random", "rising", "top"], subreddit_list: list[str], approx_video_duration: timedelta, ): maxAttempts = 50 while True: subreddit = subreddit_list[randrange(0, len(subreddit_list))] search = PostSearch(subreddit, listing, timeframe) if len(search.posts) < 1: continue selected_post = search.posts[randrange(0, len(search.posts))] valid = check_if_valid_post( selected_post.post_id, selected_post.title, selected_post.selftext, approx_video_duration=approx_video_duration, ) if valid: break else: maxAttempts -= 1 if maxAttempts <= 0: raise Exception(f"No valid post found in {maxAttempts} attempts.") return selected_post

2024-01-10

timkoehne/video-generator

video_utils.py

from datetime import timedelta from math import floor from pathlib import Path from random import randint, randrange import random from moviepy.video.fx import resize, crop from moviepy.audio.fx import multiply_volume from moviepy import * from typing import Tuple from configuration import Configuration from openai_interface import OpenAiInterface from reddit_requests import Post config = Configuration() POSSIBLE_FILE_ENDINGS = (".mp4", ".webm", ".mkv", ".ogv", ".mpeg", ".avi", ".mov") CHARS_PER_SECOND = (10000 / 10.5) / 60 def select_background_video(min_length: int) -> Tuple[VideoClip, str]: possible_videos = [ p.resolve() for p in Path(config.background_videos_dir).glob("**/*") if p.suffix in POSSIBLE_FILE_ENDINGS ] clip: VideoClip | None = None background_video_credit: str | None = None random.shuffle(possible_videos) for video in possible_videos: clip = VideoFileClip(video) if min_length <= clip.duration: selected_file = video background_video_credit = str(selected_file).split("\\")[-2] print(f"selected {selected_file} as background video") start_time = random.random() * (clip.duration - min_length) end_time = start_time + min_length print( f"using background video time between {start_time:.2f}s and {end_time:.2f}s out of {clip.duration:.2f}s" ) clip = clip.subclip(start_time, end_time) clip = clip.afx(multiply_volume, config.background_video_volume) # type: ignore break if clip == None or background_video_credit == None: raise Exception(f"No suitable background video found for duration {min_length}") return (clip, background_video_credit) def crop_to_center_and_resize(clip: VideoClip, to_resolution: Tuple[int, int]): new_aspect_ratio: float = to_resolution[0] / to_resolution[1] x1 = (clip.size[0] - (clip.size[1] * new_aspect_ratio)) // 2 x2 = (clip.size[0] + (clip.size[1] * new_aspect_ratio)) // 2 y1 = 0 y2 = clip.size[1] clip = clip.fx(crop, x1=x1, x2=x2, y1=y1, y2=y2) clip = clip.fx(resize, to_resolution) return clip def generate_intro_clip(post: Post, resolution: Tuple[int, int]) -> VideoClip: openaiinterface = OpenAiInterface() intro_text = openaiinterface.generate_text_without_context( config.intro_prompt, post.title + "\n" + post.selftext, ) openaiinterface.generate_mp3(intro_text, f"tmp/{post.post_id}-audio-intro.mp3") intro_clip: VideoClip = TextClip( config.intro_header + "\n" + post.title, size=(resolution[0] * 0.8, 0), color=config.video_font_color, font=config.video_font, font_size=config.video_font_size, method="caption", stroke_color=config.video_font_stroke_color, stroke_width=config.video_font_stroke_width, align="center", ) audio_clip = AudioFileClip(f"tmp/{post.post_id}-audio-intro.mp3") intro_clip = intro_clip.with_duration(audio_clip.duration + 1) intro_clip = intro_clip.with_audio(audio_clip) print(f"Created intro with duration {intro_clip.duration}s") return intro_clip def generate_outro_clip(post: Post, resolution: Tuple[int, int]) -> VideoClip: openaiinterface = OpenAiInterface() outro_text = openaiinterface.generate_text_without_context( config.outro_prompt, post.title + "\n" + post.selftext, ) openaiinterface.generate_mp3(outro_text, f"tmp/{post.post_id}-audio-outro.mp3") outro_clip: VideoClip = TextClip(" ") audio_clip = AudioFileClip(f"tmp/{post.post_id}-audio-outro.mp3") outro_clip = outro_clip.with_duration(audio_clip.duration + 1) outro_clip = outro_clip.with_audio(audio_clip) print(f"Created outro with duration {outro_clip.duration}s") return outro_clip def check_if_valid_post( post_id: str, post_title: str, text_to_check: str, approx_video_duration: timedelta | None = None, min_duration: timedelta | None = None, ) -> bool: with open("config/already_posted.txt", "r") as file: already_posted_ids = file.read().splitlines() if post_id in already_posted_ids: print(f"Post {post_id} has already been posted") return False filter_word_in_title = ["update:", "(update)", "[update]"] for word in filter_word_in_title: if word in post_title.lower(): print(f"Post {post_id} is an update") return False if post_title.lower().startswith("update"): print(f"Post {post_id} is an update") return False print(approx_video_duration) if approx_video_duration != None and not is_approx_duration( text_to_check, approx_video_duration ): print( f"Post {post_id} duration is not approximatly {approx_video_duration} long." ) return False if min_duration != None and not is_min_duration(text_to_check, min_duration): print(f"Post {post_id} duration is not over {min_duration} long.") return False print(f"Post {post_id} is valid") return True def is_max_duration(text: str, max_duration: timedelta) -> bool: text_duration = len(text) / CHARS_PER_SECOND if max_duration.total_seconds() < text_duration: return False return True def is_min_duration(text: str, min_duration: timedelta) -> bool: text_duration = len(text) / CHARS_PER_SECOND if min_duration.total_seconds() > text_duration: return False return True def is_between_durations( text: str, min_duration: timedelta, max_duration: timedelta ) -> bool: if is_min_duration(text, min_duration) and is_max_duration(text, max_duration): return True return False def is_approx_duration(text: str, approx_duration: timedelta) -> bool: upper_bound = approx_duration + (approx_duration * config.tolerated_duration_offset) lower_bound = approx_duration - (approx_duration * config.tolerated_duration_offset) if is_between_durations(text, lower_bound, upper_bound): return True return False

2024-01-10

timkoehne/video-generator

comment_based_video.py

from datetime import timedelta from random import randrange from typing import Literal, Tuple from moviepy import * from configuration import Configuration from video_utils import ( CHARS_PER_SECOND, check_if_valid_post, crop_to_center_and_resize, generate_intro_clip, generate_outro_clip, select_background_video, ) from openai_interface import OpenAiInterface from reddit_requests import Comment, Post, PostSearch from text_processing import split_text_to_max_x_chars config = Configuration() def calculate_font_size(text: str) -> Tuple[list[str], list[int]]: # TODO implement text_wall_font_size configuration option text_parts: list[str] = split_text_to_max_x_chars(text, 550) font_sizes: list[int] = [] for part in text_parts: if len(part) > 400: font_sizes.append(45) elif len(part) > 200: font_sizes.append(50) else: font_sizes.append(70) return (text_parts, font_sizes) def generate_single_comment_clip( post: Post, text_parts: list[str], font_sizes: list[int], resolution: Tuple[int, int], index: int, ): openaiinterface = OpenAiInterface() comment_clip_parts: list[VideoClip] = [] for i, part in enumerate(text_parts): openaiinterface.generate_mp3( part, f"tmp/{post.post_id}-audio-{index}-part-{i}.mp3" ) clip_part: VideoClip = TextClip( part, size=(resolution[0] * 0.8, 0), color=config.text_wall_font_color, font=config.text_wall_font, font_size=font_sizes[i], method="caption", stroke_color=config.text_wall_font_stroke_color, stroke_width=config.text_wall_font_stroke_width, align="center", ) audio_clip = AudioFileClip(f"tmp/{post.post_id}-audio-{index}-part-{i}.mp3") clip_part = clip_part.with_duration(audio_clip.duration + 1) clip_part = clip_part.with_audio(audio_clip) comment_clip_parts.append(clip_part) comment_clip = concatenate_videoclips(comment_clip_parts) return comment_clip def generate_comments_clip(post: Post, resolution: Tuple[int, int]) -> VideoClip: text_clips: list[VideoClip] = [] intro: VideoClip = generate_intro_clip(post, resolution) outro: VideoClip = generate_outro_clip(post, resolution) comments: list[Comment] = post.get_good_comments() print(f"There are {len(comments)} good comments") for index, comment in enumerate(comments): print(comment) text_parts, font_sizes = calculate_font_size(comment.body) if len(text_parts) > 1: print(f"Splitting Comment into {len(text_parts)} parts") comment_clip = generate_single_comment_clip( post, text_parts, font_sizes, resolution, index ) text_clips.append(comment_clip) combined_text_video: VideoClip = concatenate_videoclips(text_clips) combined_text_video = concatenate_videoclips([intro, combined_text_video, outro]) combined_text_video = combined_text_video.with_position("center") return combined_text_video def find_comment_post( timeframe: Literal["day", "week", "month", "year", "all"], listing: Literal["controversial", "best", "hot", "new", "random", "rising", "top"], subreddit_list: list[str], approx_video_duration: timedelta | None = None, ): maxAttempts = 50 while True: subreddit = subreddit_list[randrange(0, len(subreddit_list))] search = PostSearch(subreddit, listing, timeframe) if len(search.posts) < 1: continue selected_post = search.posts[randrange(0, len(search.posts))] if approx_video_duration != None: good_comments = selected_post.get_good_comments( num_chars_to_limit_comments=int( approx_video_duration.total_seconds() * CHARS_PER_SECOND ) ) else: good_comments = selected_post.get_good_comments() comments_combined = " ".join([c.body for c in good_comments]) valid = check_if_valid_post( selected_post.post_id, selected_post.title, comments_combined, approx_video_duration, ) if valid: break else: maxAttempts -= 1 if maxAttempts <= 0: raise Exception(f"No valid post found in {maxAttempts} attempts.") return selected_post

2024-01-10

timkoehne/video-generator

video_generator.py

from enum import Enum import json import datetime import os from random import randrange import sys from typing import Literal, Tuple from moviepy import CompositeVideoClip, TextClip, VideoClip from configuration import Configuration from openai_interface import OpenAiInterface from reddit_requests import Post, PostSearch, create_post_from_post_id from comment_based_video import find_comment_post, generate_comments_clip from story_based_video import find_story_post, generate_story_clip from thumbnail_with_text import generate_thumbnail_with_text from video_utils import ( crop_to_center_and_resize, select_background_video, ) config = Configuration() with open("config/reddit_threads.json") as file: reddit_threads = json.loads(file.read()) def get_already_posted_ids(): with open("config/already_posted.txt", "r") as file: already_posted_ids = file.read().splitlines() return already_posted_ids def add_to_already_posted_ids(new_id: str): already_posted_ids = get_already_posted_ids() already_posted_ids.append(new_id) with open("config/already_posted.txt", "w") as file: for id in already_posted_ids: file.write(id + "\n") def generate_story_video( resolution: Tuple[int, int], timeframe: Literal["day", "week", "month", "year", "all"], listing: Literal["controversial", "best", "hot", "new", "random", "rising", "top"], approx_video_duration: datetime.timedelta = datetime.timedelta(minutes=5), ): selected_post = find_story_post( timeframe, listing, reddit_threads["story_based"], approx_video_duration ) generate_story_video_by_id(selected_post.post_id, resolution) def generate_comment_video( resolution: Tuple[int, int], timeframe: Literal["day", "week", "month", "year", "all"], listing: Literal["controversial", "best", "hot", "new", "random", "rising", "top"], approx_video_duration: datetime.timedelta = datetime.timedelta(minutes=5), ): selected_post = find_comment_post( timeframe, listing, reddit_threads["comment_based"], approx_video_duration ) generate_comment_video_by_id(selected_post.post_id, resolution) def generate_story_video_by_id(post_id: str, resolution: Tuple[int, int]): post = create_post_from_post_id(post_id) add_to_already_posted_ids(post.post_id) print(f'selected post titled "{post.title}"') print(f"saving post_id {post.post_id} as selected") video: VideoClip = generate_story_clip(post, resolution) background_video: VideoClip background_video_credit: str background_video, background_video_credit = select_background_video(video.duration) background_video = crop_to_center_and_resize(background_video, resolution) video = CompositeVideoClip([background_video, video]) if not os.path.exists(config.output_dir + post.post_id): os.mkdir(config.output_dir + post.post_id) save_video(video, post) generate_and_save_description(post, background_video_credit, "story") generate_and_save_title(post) thumbnail = generate_thumbnail_with_text(post, resolution) thumbnail.save(f"{config.output_dir + post.post_id}/thumbnail.jpg") for f in os.listdir("tmp/"): if f.startswith(f"{post.post_id}"): os.remove(f"tmp/{f}") def generate_comment_video_by_id(post_id: str, resolution: Tuple[int, int]): post = create_post_from_post_id(post_id) add_to_already_posted_ids(post.post_id) print(f'selected post titled "{post.title}"') print(f"saving post_id {post.post_id} as selected") video: VideoClip = generate_comments_clip(post, resolution) background_video: VideoClip background_video_credit: str background_video, background_video_credit = select_background_video(video.duration) background_video = crop_to_center_and_resize(background_video, resolution) video = CompositeVideoClip([background_video, video]) if not os.path.exists(config.output_dir + post.post_id): os.mkdir(config.output_dir + post.post_id) save_video(video, post) generate_and_save_description(post, background_video_credit, "comment") generate_and_save_title(post) thumbnail = generate_thumbnail_with_text(post, resolution) thumbnail.save(f"{config.output_dir + post.post_id}/thumbnail.jpg") for f in os.listdir("tmp/"): if f.startswith(f"{post.post_id}"): os.remove(f"tmp/{f}") pass def generate_and_save_title(post: Post): openaiinterface = OpenAiInterface() response = openaiinterface.generate_text_without_context( config.video_title_prompt, post.title + "\n" + post.selftext ) response = f"{response} | r/{post.subreddit} Reddit Stories" with open(config.output_dir + post.post_id + "/title.txt", "w") as file: file.write(response) def generate_and_save_description( post: Post, background_credit: str, type_of_video: Literal["comment", "story"] ): if type_of_video == "story": reddit_credit = f"This story was posted by {post.author} to r/{post.subreddit}. Available at:\n{post.url}\n" elif type_of_video == "comment": reddit_credit = f"These comments were posted in response to {post.author}'s post on r/{post.subreddit}. Available at:\n{post.url}\n" with open(config.background_videos_dir + "channel_urls.json", "r") as file: credit_url = json.loads(file.read())[background_credit] background_credit = f"The background gameplay is by {background_credit}. Check them out at:\n{credit_url}\n" openai_disclaimer = f'The audio is AI-generated from {config.audio_api}\'s text-to-speech model "{config.audio_model}" with the voice "{config.audio_voice}".' description = reddit_credit + "\n" + background_credit + "\n" + openai_disclaimer with open(config.output_dir + post.post_id + "/description.txt", "w") as file: file.write(description) def save_video(video: VideoClip, post: Post): video.write_videofile( config.output_dir + post.post_id + "/video.mp4", fps=config.video_fps, threads=config.num_threads, preset=config.write_video_preset, ) # generate_story_video((1920, 1080), "all", "top", datetime.timedelta(minutes=5)) # generate_comment_video((1920, 1080), "all", "top", datetime.timedelta(minutes=5)) # with open("config/reddit_threads.json", "r") as file: # for subreddit in json.loads(file.read())["story_based"]: # ps = PostSearch(subreddit, "top", "all") # for post in ps.posts: # if check_if_valid_post(post.post_id, post.title, post.selftext): # if is_between_durations(post.selftext, datetime.timedelta(minutes=4), datetime.timedelta(minutes=25)): # print(f"{post.post_id} is within specified time") # generate_story_video_by_id(post.post_id, (1920, 1080)) # sys.exit(0) # TODO remove urls # TODO error handling # TODO mark nsfw # TODO for some reason "beautiful" gets replaced with "beautoday". maybe only sometimes?? # TODO ignore posts that contain images # TODO what to do with configuration text_wall_font_size? its dependent on text length # TODO audio and text sometimes desync for a short time noticable in joz1c5. # probably also caused overlapping audio with the outro # subreddit_list = reddit_threads["story_based"] # subreddit = subreddit_list[randrange(0, len(subreddit_list))] # post_search = PostSearch(subreddit, "top", "all") # post = post_search.posts[randrange(0, len(post_search.posts))] # print(f"post {post.post_id} has {post.upvotes} upvotes and {post.num_comments} comments") # image = generate_thumbnail_with_text(post, (1920, 1080)) # image.show() generate_story_video((1920, 1080), "all", "top") #generate_story_video((1920, 1080), "all", "top")

2024-01-10

timkoehne/video-generator

thumbnail_with_person.py

import os import random import sys from typing import Tuple import cv2 from moviepy import * from PIL import Image import numpy as np from configuration import Configuration from db_access import DB_Controller from openai_interface import OpenAiInterface from reddit_requests import Post config = Configuration() class NoSuitablePersonException(Exception): pass class Rectangle: def __init__( self, top_left: Tuple[float, float], top_right: Tuple[float, float], bottom_left: Tuple[float, float], bottom_right: Tuple[float, float], ) -> None: self.top_left = top_left self.top_right = top_right self.bottom_left = bottom_left self.bottom_right = bottom_right pass def width(self): return self.top_right[0] - self.top_left[0] def height(self): return self.bottom_left[1] - self.top_left[1] def aspect_ratio(self): return self.width() / self.height() def get_bordered_pil_image(path: str, edge_size: int): src = cv2.imread(path, cv2.IMREAD_UNCHANGED) alpha = cv2.split(src)[3] # scale so it is roughly the same at every resolution edge_size = int(edge_size * len(alpha[0]) / 1000) kernel = np.ones((5, 5), np.uint8) dilated = cv2.dilate(alpha, kernel, iterations=edge_size) output_image = cv2.merge((dilated, dilated, dilated, dilated)) pil_image = Image.fromarray(output_image) return pil_image def find_thumbnail_person(bounds: Rectangle, keywords: list[str]) -> Image.Image: db_controller = DB_Controller("database.db") candidates = db_controller.find_images_with_tags(keywords) random.shuffle(candidates) for candidate in candidates: person = Image.open(os.path.join(config.thumbnail_image_dir, candidate)) aspect_ratio = person.width / person.height lower_bound = ( bounds.aspect_ratio() - config.thumbnail_person_aspect_ratio_min * bounds.aspect_ratio() ) upper_bound = ( bounds.aspect_ratio() + config.thumbnail_person_aspect_ratio_max * bounds.aspect_ratio() ) # print(f"lowerbounds has aspect_ratio of {lower_bound}") # print(f"upperbounds has aspect_ratio of {upper_bound}") # print(f"person has aspect_ratio of {aspect_ratio}") if lower_bound < aspect_ratio < upper_bound: candidate = candidates[random.randrange(0, len(candidates))] print(f"selected {candidate}") background = Image.new("RGBA", (person.width, person.height), (0, 0, 0, 0)) # background.paste((0, 0, 0, 255), mask=bordered_person) background.paste(person, (0, 0), mask=person) # background.show() return background raise NoSuitablePersonException() def generate_thumbnail_text_clip(title: str, resolution: Tuple[int, int]) -> TextClip: text_max_width = int(resolution[0] * config.thumbnail_text_width_percent) text = title.split(" ") texts = [] for index in range(0, len(text), 2): if index == len(text) - 1: texts.append(text[index]) else: texts.append(text[index] + " " + text[index + 1]) text = "\n".join(texts).strip() txt_clip = TextClip( text=text, method="caption", color=config.text_clips_font_color, # font=config.text_clips_font, font=config.text_clips_font, font_size=100, stroke_color=config.text_clips_font_stroke_color, stroke_width=6, size=(text_max_width, resolution[1]), align="west", ).with_position((25, 0)) return txt_clip def generate_thumbnail_background_clip(background_clip: VideoClip): screenshot_time = random.random() * background_clip.duration img_clip = ImageClip(background_clip.get_frame(screenshot_time)) return img_clip def calculate_person_max_bounds(resolution: Tuple[int, int]): allowed_overlap = int(config.thumbnail_allowed_overlap * resolution[0]) top_left = ( (config.thumbnail_text_width_percent * resolution[0]) - allowed_overlap, 0, ) top_right = (resolution[0], 0) bottom_left = ( (config.thumbnail_text_width_percent * resolution[0]) - allowed_overlap, resolution[1], ) bottom_right = (resolution[0], resolution[1]) return Rectangle(top_left, top_right, bottom_left, bottom_right) def thumbnail_add_person( thumbnail: Image.Image, person_max_bounds: Rectangle, person: Image.Image ): # scale = min( # person_max_bounds.width() / person.width, # person_max_bounds.height() / person.height, # ) scale = person_max_bounds.height() / person.height width = int(person.width * scale) height = int(person.height * scale) person = person.resize((width, height)) remaining_width = person_max_bounds.width() - width remaining_height = person_max_bounds.height() - height thumbnail.paste( person, ( int(person_max_bounds.top_left[0]) + int(1 / 2 * remaining_width), thumbnail.size[1] - person.size[1], ), person, ) return thumbnail def generalize_keywords(keywords: list[str]) -> list[str]: change_made = False if "mother" in keywords: pos = keywords.index("mother") keywords[pos] = "woman" change_made = True if "father" in keywords: pos = keywords.index("father") keywords[pos] = "man" change_made = True if not change_made and len(keywords) > 1: keywords.remove(keywords[random.randrange(0, len(keywords))]) return keywords def generate_thumbnail( title: str, background_clip: VideoClip, keywords: list[str], retries_left: int = 1 ) -> Image.Image | None: try: resolution = (1920, 1080) background_image_clip = generate_thumbnail_background_clip(background_clip) background_image = Image.fromarray(background_image_clip.get_frame(0)) person_max_bounds = calculate_person_max_bounds(resolution) print( f"person box dimensions {person_max_bounds.width()}x{person_max_bounds.height()}" ) person: Image.Image = find_thumbnail_person(person_max_bounds, keywords) person_and_background = thumbnail_add_person( background_image, person_max_bounds, person ) person_and_background_clip: ImageClip = ImageClip( np.array(person_and_background) ).with_duration(1) txt_clip = generate_thumbnail_text_clip(title, resolution) clip = CompositeVideoClip( [person_and_background_clip, txt_clip], use_bgclip=True ) thumbnail: Image.Image = Image.fromarray(clip.get_frame(0)) return thumbnail # except NoSuitablePersonException as e: except Exception as e: print(e) print(f"Thumbnail generation for keywords {keywords} failed") if retries_left > 0: new_keywords = generalize_keywords(keywords) return generate_thumbnail( title, background_clip, new_keywords, retries_left - 1 ) def generate_thumbnails(post: Post, background_video: VideoClip, video_title: str): video_title = video_title[: video_title.index("|")] openai_test = OpenAiInterface() db_controller = DB_Controller("database.db") categories = db_controller.find_all_used_tags(min_amount=10) categories.remove("human") categories.remove("person") categories.remove("happy") categories.remove("content") categories.remove("man") categories.remove("woman") print(categories) attempts = [] num_attempts = 10 thumbnails_remaining = 5 while True: while len(attempts) != num_attempts: print("trying to categorize...") response = openai_test.generate_text_without_context( f"""Categorize this reddit post into these categories: {", ".join(categories)} Do not use any other categories. Generate {num_attempts} answers, one per line. Select 2 categories per answer and dont repeat the same answer.""", f"{post.subreddit}\n{post.title}\n{post.selftext}", ) print(response) attempts = [attempt.split(", ") for attempt in response.split("\n")] print(attempts) for attemptNum, categories in enumerate(attempts): print(f"Generating Thumbnail {attemptNum}") image = generate_thumbnail(video_title, background_video, categories) if image != None: thumbnails_remaining -= 1 print("saving") image.save( config.output_dir + post.post_id + f"/thumbnail{thumbnails_remaining} - {','.join(categories)}.jpg" ) if thumbnails_remaining == 0: return

2024-01-10

kirilldou/VladVA

Code~vladGPT.py

# Paul Dou # 10/05/23 # GPT file, handles OpenAI API functionality # import python libraries import openai # import OpenAI library import re # import regex import time # regex punct = re.compile("^[A-Z]$") # initialize OpenAI key openai.api_key = "" # insert OpenAI API key # generate responses from OpenAI's GPT API by using input text as input def remoteGPT(audioText): #GPTresponse = "" try: # if API key valid GPTout = openai.ChatCompletion.create(model="gpt-3.5-turbo",messages=[{"role": "user", "content": audioText}]) # create response by setting preferences GPTresponse = GPTout.choices[0].message.content # retrieve text response and save as string # vladVA info match re.sub(r'[^\w\s]','',audioText).lower().replace("whats","what is"): case "who are you": GPTresponse = "I'm VladVA, your personal voice assistant!" case "what is your name": GPTresponse = "I'm VladVA, your personal voice assistant!" case "what is your purpose": GPTresponse = "I'm VladVA, your personal voice assistant!" case "tell me about yourself": GPTresponse = "I'm VladVA, your personal voice assistant!" case "what do you do": GPTresponse = "I'm VladVA, your personal voice assistant!" except Exception as e: # API key GPTresponse = "Error: Current Plan Exceeded!" return GPTresponse # return GPT verbal diarrhea

2024-01-10

thomphil/jarvis

randoom.py

import os import re from pathlib import Path import openai import streamlit as st from streamlit.components.v1 import html def get_starting_convo(): return [ { "role": "system", "content": "You are an assistant that helps the user create and improve a web page in HTML, CSS, and JavaScript.", } ] @st.cache_data(ttl=10, show_spinner=False) def call_openai_api(conversation): st.spinner("The code is being generated...") response = openai.ChatCompletion.create( model="gpt-4", messages=conversation, temperature=0.1 ) return response["choices"][0]["message"]["content"].strip() def main(): API_KEY = os.getenv("OPENAI_API_KEY") st.set_page_config(page_title="How do I get the jobseekers?", layout="wide") openai.api_key = API_KEY if "show_code" not in st.session_state: st.session_state.show_code = False if "messages" not in st.session_state: st.session_state.messages = get_starting_convo() st.title("Job Seeker Automated Application Filler") st.write("Enter application description below:") user_input = st.text_area("Type your content:", height=100) has_previously_generated = len(getattr(st.session_state, "messages", [])) > 1 reset = not has_previously_generated or st.checkbox("Reset", value=False) # change text depending on whether the user has previously generated code if st.button( "Generate presentation" if reset else "Ask AI to modify the generated application" ): # set to starting conversation if reset messages = get_starting_convo() if reset else st.session_state.messages.copy() # decide prompt depending on whether the user has previously generated code if reset: messages.append( { "role": "user", "content": f"Create an HTML web page with accompanying CSS and JavaScript in a single HTML-file. Use suitable JS packages (linked from a CDN) where ever applicable. Generate this content from: {user_input}", } ) else: messages.append( { "role": "user", "content": f"Modify the previous website to accomodate the following:\n\n{user_input}\n\n Note that you should recreate the HTML, CSS, and JavaScript code from scratch in its entirety. The new code should be self-contained in a single HTML-file.", } ) # get the AI's response try: output = call_openai_api(messages) except Exception as e: st.error(f"Error while generating code. {str(e)}") return # extract the code block pattern = r"```(\w*)\n([\s\S]*?)\n```" code_blocks = re.findall(pattern, output) # should be in a single file if len(code_blocks) != 1: st.error( "Something went wrong. Please try again or change the instructions." ) return # append the assistant's response to the conversation messages.append({"role": "assistant", "content": output}) # two groups are captured, the language and the code, # but only the code is needed st.session_state.code = code_blocks[0][1] st.session_state.output = output st.session_state.messages = messages # go from the beginning st.experimental_rerun() # display the generated html/css/javascript # html is from from streamlit.components.v1 import html if "code" in st.session_state and st.session_state.code is not None: st.header("Generated website") html(st.session_state.code, height=800, scrolling=True) # display the code and explanations if has_previously_generated and st.session_state.code is not None: # toggle between show and hide, # a placeholder (st.empty) is used to replace the # text of the button after it has been clicked show_hide_button = st.empty() get_show_code_text = ( lambda: "Show code and explanations" if not st.session_state.show_code else "Hide code and explanations" ) clicked = show_hide_button.button(get_show_code_text()) if clicked: st.session_state.show_code = not st.session_state.show_code show_hide_button.button(get_show_code_text()) if st.session_state.show_code: st.header("Code and explanations") st.markdown(st.session_state.output) if __name__ == "__main__": main()

2024-01-10

tud-amr/go-mpc

mpc_rl_collision_avoidance~algorithms~ppo2~ppo2mpc.py

import time import gym import numpy as np import tensorflow as tf import gc from copy import deepcopy from sklearn.linear_model import LinearRegression from sklearn.metrics import mean_squared_error, r2_score from sklearn.preprocessing import PolynomialFeatures from sklearn.linear_model import Ridge from sklearn.preprocessing import PolynomialFeatures from sklearn.pipeline import make_pipeline from timeit import default_timer as timer #from pympler.tracker import SummaryTracker from mpc_rl_collision_avoidance.external.stable_baselines import logger from mpc_rl_collision_avoidance.external.stable_baselines.common import explained_variance, ActorCriticRLModel, tf_util, SetVerbosity, TensorboardWriter from mpc_rl_collision_avoidance.external.stable_baselines.common.runners import AbstractEnvRunner from mpc_rl_collision_avoidance.external.stable_baselines.common.policies import ActorCriticPolicy, RecurrentActorCriticPolicy from mpc_rl_collision_avoidance.external.stable_baselines.common.schedules import get_schedule_fn from mpc_rl_collision_avoidance.external.stable_baselines.common.tf_util import total_episode_reward_logger from mpc_rl_collision_avoidance.external.stable_baselines.common.math_util import safe_mean from gym_collision_avoidance.envs.config import Config class PPO2MPC(ActorCriticRLModel): """ Proximal Policy Optimization algorithm (GPU version). Paper: https://arxiv.org/abs/1707.06347 :param policy: (ActorCriticPolicy or str) The policy model to use (MlpPolicy, CnnPolicy, CnnLstmPolicy, ...) :param env: (Gym environment or str) The environment to learn from (if registered in Gym, can be str) :param gamma: (float) Discount factor :param n_steps: (int) The number of steps to run for each environment per update (i.e. batch size is n_steps * n_env where n_env is number of environment copies running in parallel) :param ent_coef: (float) Entropy coefficient for the loss calculation :param learning_rate: (float or callable) The learning rate, it can be a function :param vf_coef: (float) Value function coefficient for the loss calculation :param max_grad_norm: (float) The maximum value for the gradient clipping :param lam: (float) Factor for trade-off of bias vs variance for Generalized Advantage Estimator :param nminibatches: (int) Number of training minibatches per update. For recurrent policies, the number of environments run in parallel should be a multiple of nminibatches. :param noptepochs: (int) Number of epoch when optimizing the surrogate :param cliprange: (float or callable) Clipping parameter, it can be a function :param cliprange_vf: (float or callable) Clipping parameter for the value function, it can be a function. This is a parameter specific to the OpenAI implementation. If None is passed (default), then `cliprange` (that is used for the policy) will be used. IMPORTANT: this clipping depends on the reward scaling. To deactivate value function clipping (and recover the original PPO implementation), you have to pass a negative value (e.g. -1). :param verbose: (int) the verbosity level: 0 none, 1 training information, 2 tensorflow debug :param tensorboard_log: (str) the log location for tensorboard (if None, no logging) :param _init_setup_model: (bool) Whether or not to build the network at the creation of the instance :param policy_kwargs: (dict) additional arguments to be passed to the policy on creation :param full_tensorboard_log: (bool) enable additional logging when using tensorboard WARNING: this logging can take a lot of space quickly :param seed: (int) Seed for the pseudo-random generators (python, numpy, tensorflow). If None (default), use random seed. Note that if you want completely deterministic results, you must set `n_cpu_tf_sess` to 1. :param n_cpu_tf_sess: (int) The number of threads for TensorFlow operations If None, the number of cpu of the current machine will be used. """ def __init__(self, policy, env, gamma=0.99, n_steps=128, ent_coef=0.01, learning_rate=2.5e-4, vf_coef=0.5, max_grad_norm=0.5, lam=0.95, nminibatches=4, noptepochs=4, cliprange=0.2, cliprange_vf=None, verbose=0, tensorboard_log=None, _init_setup_model=True, policy_kwargs=None, full_tensorboard_log=False, seed=None, n_cpu_tf_sess=None): self.learning_rate = learning_rate self.cliprange = cliprange self.cliprange_vf = cliprange_vf self.n_steps = n_steps self.ent_coef = ent_coef self.vf_coef = vf_coef self.max_grad_norm = max_grad_norm self.gamma = gamma self.lam = lam self.nminibatches = nminibatches self.noptepochs = noptepochs self.tensorboard_log = tensorboard_log self.full_tensorboard_log = full_tensorboard_log self.action_ph = None self.advs_ph = None self.rewards_ph = None self.old_neglog_pac_ph = None self.old_vpred_ph = None self.learning_rate_ph = None self.clip_range_ph = None self.entropy = None self.vf_loss = None self.pg_loss = None self.approxkl = None self.clipfrac = None self._train = None self.loss_names = None self.train_model = None self.act_model = None self.value = None self.n_batch = None self.summary = None self.pre_training_steps = 100000 self.curriculum_learning = Config.CURRICULUM_LEARNING super().__init__(policy=policy, env=env, verbose=verbose, requires_vec_env=True, _init_setup_model=_init_setup_model, policy_kwargs=policy_kwargs, seed=seed, n_cpu_tf_sess=n_cpu_tf_sess) if _init_setup_model: self.setup_model() def _make_runner(self): return Runner(env=self.env, model=self, n_steps=self.n_steps, gamma=self.gamma, lam=self.lam) def _make_mpc_runner(self): return MPCRunner(env=self.env, model=self, n_steps=self.n_steps, gamma=self.gamma, lam=self.lam) def _get_pretrain_placeholders(self): policy = self.act_model if isinstance(self.action_space, gym.spaces.Discrete): return policy.obs_ph, self.action_ph, policy.policy return policy.obs_ph, self.action_ph, policy.deterministic_action def setup_model(self): with SetVerbosity(self.verbose): assert issubclass(self.policy, ActorCriticPolicy), "Error: the input policy for the PPO2 model must be " \ "an instance of common.policies.ActorCriticPolicy." self.n_batch = self.n_envs * self.n_steps self.graph = tf.Graph() with self.graph.as_default(): self.set_random_seed(self.seed) self.sess = tf_util.make_session(num_cpu=self.n_cpu_tf_sess, graph=self.graph) n_batch_step = None n_batch_train = None if issubclass(self.policy, RecurrentActorCriticPolicy): assert self.n_envs % self.nminibatches == 0, "For recurrent policies, "\ "the number of environments run in parallel should be a multiple of nminibatches." n_batch_step = self.n_envs n_batch_train = self.n_batch // self.nminibatches act_model = self.policy(self.sess, self.observation_space, self.action_space, self.n_envs, 1, n_batch_step, reuse=False, **self.policy_kwargs) with tf.variable_scope("train_model", reuse=True, custom_getter=tf_util.outer_scope_getter("train_model")): train_model = self.policy(self.sess, self.observation_space, self.action_space, self.n_envs // self.nminibatches, self.n_steps, n_batch_train, reuse=True, **self.policy_kwargs) with tf.variable_scope("loss", reuse=False): self.action_ph = train_model.pdtype.sample_placeholder([None], name="action_ph") self.advs_ph = tf.placeholder(tf.float32, [None], name="advs_ph") self.norm_advs_ph = tf.placeholder(tf.float32, [None], name="norm_advs_ph") self.rewards_ph = tf.placeholder(tf.float32, [None], name="rewards_ph") self.old_neglog_pac_ph = tf.placeholder(tf.float32, [None], name="old_neglog_pac_ph") self.old_vpred_ph = tf.placeholder(tf.float32, [None], name="old_vpred_ph") self.learning_rate_ph = tf.placeholder(tf.float32, [], name="learning_rate_ph") self.clip_range_ph = tf.placeholder(tf.float32, [], name="clip_range_ph") self.collisions_ph = tf.placeholder(tf.float32, [], name="collisions_ph") self.timeouts_ph = tf.placeholder(tf.float32, [], name="timeouts_ph") self.infesiable_ph = tf.placeholder(tf.float32, [], name="infesiable_ph") self.n_reach_goal_ph = tf.placeholder(tf.float32, [], name="n_reach_goal_ph") self.n_mpc_actions_ph = tf.placeholder(tf.float32, [], name="n_mpc_actions_ph") self.sequence_legth_ph = train_model.seq_length_ph neglogpac = train_model.proba_distribution.neglogp(self.action_ph) self.entropy = tf.reduce_mean(train_model.proba_distribution.entropy()) vpred = train_model.value_flat self.values = train_model.value_flat # Value function clipping: not present in the original PPO if self.cliprange_vf is None: # Default behavior (legacy from OpenAI baselines): # use the same clipping as for the policy self.clip_range_vf_ph = self.clip_range_ph self.cliprange_vf = self.cliprange elif isinstance(self.cliprange_vf, (float, int)) and self.cliprange_vf < 0: # Original PPO implementation: no value function clipping self.clip_range_vf_ph = None else: # Last possible behavior: clipping range # specific to the value function self.clip_range_vf_ph = tf.placeholder(tf.float32, [], name="clip_range_vf_ph") if self.clip_range_vf_ph is None: # No clipping vpred_clipped = train_model.value_flat else: # Clip the different between old and new value # NOTE: this depends on the reward scaling vpred_clipped = self.old_vpred_ph + \ tf.clip_by_value(train_model.value_flat - self.old_vpred_ph, - self.clip_range_vf_ph, self.clip_range_vf_ph) vf_losses1 = tf.square(vpred - self.rewards_ph) vf_losses2 = tf.square(vpred_clipped - self.rewards_ph) self.vf_loss = .5 * tf.reduce_mean(tf.maximum(vf_losses1, vf_losses2)) ratio = tf.exp(self.old_neglog_pac_ph - neglogpac) pg_losses = -self.norm_advs_ph * ratio pg_losses2 = -self.norm_advs_ph * tf.clip_by_value(ratio, 1.0 - self.clip_range_ph, 1.0 + self.clip_range_ph) self.pg_loss = tf.reduce_mean(tf.maximum(pg_losses, pg_losses2)) self.approxkl = .5 * tf.reduce_mean(tf.square(neglogpac - self.old_neglog_pac_ph)) self.clipfrac = tf.reduce_mean(tf.cast(tf.greater(tf.abs(ratio - 1.0), self.clip_range_ph), tf.float32)) loss = self.pg_loss - self.entropy * self.ent_coef + self.vf_loss * self.vf_coef supervised_loss = tf.reduce_mean( tf.sqrt(tf.reduce_sum(tf.square(tf.subtract(self.action_ph,train_model.deterministic_action)), axis=1))) # before: train_model.policy self.supervised_policy_loss = tf.reduce_mean(supervised_loss) + self.vf_loss * self.vf_coef tf.summary.scalar('entropy_loss', self.entropy) tf.summary.scalar('supervised_policy_loss', self.supervised_policy_loss) tf.summary.scalar('policy_gradient_loss', self.pg_loss) tf.summary.scalar('value_function_loss', self.vf_loss) tf.summary.scalar('approximate_kullback-leibler', self.approxkl) tf.summary.scalar('clip_factor', self.clipfrac) tf.summary.scalar('loss', loss) with tf.variable_scope('model'): self.params = tf.trainable_variables() if self.full_tensorboard_log: for var in self.params: tf.summary.histogram(var.name, var) grads = tf.gradients(loss, self.params) supervised_grads = tf.gradients(supervised_loss, self.params) if self.max_grad_norm is not None: grads, _grad_norm = tf.clip_by_global_norm(grads, self.max_grad_norm) supervised_grads, _grad_norm = tf.clip_by_global_norm(supervised_grads, 10.0*self.max_grad_norm) grads = list(zip(grads, self.params)) supervised_grads = list(zip(supervised_grads, self.params)) trainer = tf.train.AdamOptimizer(learning_rate=self.learning_rate_ph, epsilon=1e-5) self._train = trainer.apply_gradients(grads) supervised_trainer = tf.train.AdamOptimizer(learning_rate=self.learning_rate_ph, epsilon=1e-5) self.supervised_train = supervised_trainer.apply_gradients(supervised_grads) self.loss_names = ['policy_loss', 'value_loss', 'policy_entropy', 'approxkl', 'clipfrac'] with tf.variable_scope("input_info", reuse=False): tf.summary.scalar('discounted_rewards', tf.reduce_mean(self.rewards_ph)) tf.summary.scalar('number_of_mpc_actions', self.n_mpc_actions_ph) tf.summary.scalar('number_of_collisions', self.collisions_ph) tf.summary.scalar('number_of_timeouts', self.timeouts_ph) tf.summary.scalar('number_of_infeasible_solutions', self.infesiable_ph) tf.summary.scalar('number_of_successful_events', self.n_reach_goal_ph) tf.summary.scalar('learning_rate', tf.reduce_mean(self.learning_rate_ph)) tf.summary.scalar('normalized advantage', tf.reduce_mean(self.norm_advs_ph)) tf.summary.scalar('advantage', tf.reduce_mean(self.advs_ph)) tf.summary.scalar('values', tf.reduce_mean(self.values)) tf.summary.scalar('clip_range', tf.reduce_mean(self.clip_range_ph)) if self.clip_range_vf_ph is not None: tf.summary.scalar('clip_range_vf', tf.reduce_mean(self.clip_range_vf_ph)) tf.summary.scalar('old_neglog_action_probability', tf.reduce_mean(self.old_neglog_pac_ph)) tf.summary.scalar('old_value_pred', tf.reduce_mean(self.old_vpred_ph)) if self.full_tensorboard_log: tf.summary.histogram('discounted_rewards', self.rewards_ph) tf.summary.histogram('learning_rate', self.learning_rate_ph) tf.summary.histogram('advantage', self.norm_advs_ph) tf.summary.histogram('clip_range', self.clip_range_ph) tf.summary.histogram('old_neglog_action_probability', self.old_neglog_pac_ph) tf.summary.histogram('old_value_pred', self.old_vpred_ph) if tf_util.is_image(self.observation_space): tf.summary.image('observation', train_model.obs_ph) else: tf.summary.histogram('observation', train_model.obs_ph) self.train_model = train_model self.act_model = act_model self.step = act_model.step self.proba_step = act_model.proba_step self.value = act_model.value self.initial_state = act_model.initial_state tf.global_variables_initializer().run(session=self.sess) # pylint: disable=E1101 self.summary = tf.summary.merge_all() def _train_step(self, learning_rate, cliprange, obs, returns, masks, actions, values, neglogpacs, states, update, writer,n_collisions,n_mpc_actions,n_timeouts,n_other_agents,n_infeasible_sols,n_reach_goal, cliprange_vf=None): """ Training of PPO2 Algorithm :param learning_rate: (float) learning rate :param cliprange: (float) Clipping factor :param obs: (np.ndarray) The current observation of the environment :param returns: (np.ndarray) the rewards :param masks: (np.ndarray) The last masks for done episodes (used in recurent policies) :param actions: (np.ndarray) the actions :param values: (np.ndarray) the values :param neglogpacs: (np.ndarray) Negative Log-likelihood probability of Actions :param update: (int) the current step iteration :param writer: (TensorFlow Summary.writer) the writer for tensorboard :param states: (np.ndarray) For recurrent policies, the internal state of the recurrent model :return: policy gradient loss, value function loss, policy entropy, approximation of kl divergence, updated clipping range, training update operation :param cliprange_vf: (float) Clipping factor for the value function """ advs = returns - values norm_advs = (advs - advs.mean()) / (advs.std() + 1e-8) td_map = {self.train_model.obs_ph: obs, self.action_ph: actions, self.advs_ph: advs, self.norm_advs_ph: norm_advs, self.rewards_ph: returns, self.learning_rate_ph: learning_rate, self.clip_range_ph: cliprange, self.old_neglog_pac_ph: neglogpacs, self.old_vpred_ph: values, self.collisions_ph: n_collisions, self.timeouts_ph: n_timeouts, self.infesiable_ph: n_infeasible_sols, self.n_reach_goal_ph: n_reach_goal, self.train_model.seq_length_ph: n_other_agents*9, self.n_mpc_actions_ph: n_mpc_actions} if states is not None: td_map[self.train_model.states_ph] = states*1.0 td_map[self.train_model.dones_ph] = masks if cliprange_vf is not None and cliprange_vf >= 0: td_map[self.clip_range_vf_ph] = cliprange_vf if states is None: update_fac = self.n_batch // self.nminibatches // self.noptepochs + 1 else: update_fac = self.n_batch // self.nminibatches // self.noptepochs // self.n_steps + 1 if writer is not None: # run loss backprop with summary, but once every 10 runs save the metadata (memory, compute time, ...) if self.full_tensorboard_log and (1 + update) % 10 == 0: run_options = tf.RunOptions(trace_level=tf.RunOptions.FULL_TRACE) run_metadata = tf.RunMetadata() summary, policy_loss, value_loss, policy_entropy, approxkl, clipfrac, _ = self.sess.run( [self.summary, self.pg_loss, self.vf_loss, self.entropy, self.approxkl, self.clipfrac, self._train], td_map, options=run_options, run_metadata=run_metadata) writer.add_run_metadata(run_metadata, 'step%d' % (update * update_fac)) else: summary, policy_loss, value_loss, policy_entropy, approxkl, clipfrac, _ = self.sess.run( [self.summary, self.pg_loss, self.vf_loss, self.entropy, self.approxkl, self.clipfrac, self._train], td_map) writer.add_summary(summary, (update * update_fac)) else: policy_loss, value_loss, policy_entropy, approxkl, clipfrac, _ = self.sess.run( [self.pg_loss, self.vf_loss, self.entropy, self.approxkl, self.clipfrac, self._train], td_map) return policy_loss, value_loss, policy_entropy, approxkl, clipfrac def _mpc_train_step(self, learning_rate, cliprange, obs, returns, masks, actions, values, neglogpacs, states, update, writer,n_collisions,n_mpc_actions,n_timeouts,n_other_agents,n_infeasible_sols,n_reach_goal, cliprange_vf=None): """ Training of PPO2 Algorithm :param learning_rate: (float) learning rate :param cliprange: (float) Clipping factor :param obs: (np.ndarray) The current observation of the environment :param returns: (np.ndarray) the rewards :param masks: (np.ndarray) The last masks for done episodes (used in recurent policies) :param actions: (np.ndarray) the actions :param values: (np.ndarray) the values :param neglogpacs: (np.ndarray) Negative Log-likelihood probability of Actions :param update: (int) the current step iteration :param writer: (TensorFlow Summary.writer) the writer for tensorboard :param states: (np.ndarray) For recurrent policies, the internal state of the recurrent model :return: policy gradient loss, value function loss, policy entropy, approximation of kl divergence, updated clipping range, training update operation :param cliprange_vf: (float) Clipping factor for the value function """ advs = returns - values norm_advs = (advs - advs.mean()) / (advs.std() + 1e-8) td_map = {self.train_model.obs_ph: obs[:self.n_batch], self.action_ph: actions[:self.n_batch], self.advs_ph: advs[:self.n_batch], self.norm_advs_ph: norm_advs[:self.n_batch], self.rewards_ph: returns[:self.n_batch], self.learning_rate_ph: learning_rate, self.clip_range_ph: cliprange, self.old_neglog_pac_ph: neglogpacs[:self.n_batch], self.old_vpred_ph: values[:self.n_batch], self.collisions_ph: n_collisions, self.timeouts_ph: n_timeouts, self.infesiable_ph: n_infeasible_sols, self.n_reach_goal_ph: n_reach_goal, self.train_model.seq_length_ph: n_other_agents[:self.n_batch]*9, self.n_mpc_actions_ph: n_mpc_actions} if states is not None: td_map[self.train_model.states_ph] = states*1.0 td_map[self.train_model.dones_ph] = masks if cliprange_vf is not None and cliprange_vf >= 0: td_map[self.clip_range_vf_ph] = cliprange_vf if states is None: update_fac = self.n_batch // self.nminibatches // self.noptepochs + 1 else: update_fac = self.n_batch // self.nminibatches // self.noptepochs // self.n_steps + 1 if writer is not None: # run loss backprop with summary, but once every 10 runs save the metadata (memory, compute time, ...) if self.full_tensorboard_log and (1 + update) % 10 == 0: run_options = tf.RunOptions(trace_level=tf.RunOptions.FULL_TRACE) run_metadata = tf.RunMetadata() summary, supervised_policy_loss, clipfrac, _ = self.sess.run( [self.summary, self.supervised_policy_loss, self.clipfrac, self.supervised_train], td_map, options=run_options, run_metadata=run_metadata) writer.add_run_metadata(run_metadata, 'step%d' % (update * update_fac)) else: summary, supervised_policy_loss, clipfrac, _ = self.sess.run( [self.summary, self.supervised_policy_loss, self.clipfrac, self.supervised_train], td_map) writer.add_summary(summary, (update * update_fac)) else: supervised_policy_loss, clipfrac, _ = self.sess.run( [self.supervised_policy_loss, self.clipfrac, self.supervised_train], td_map) return supervised_policy_loss, clipfrac def learn(self, total_timesteps, callback=None, log_interval=1, tb_log_name="PPO2", reset_num_timesteps=True): # Transform to callable if needed self.learning_rate = get_schedule_fn(self.learning_rate) self.cliprange = get_schedule_fn(self.cliprange) cliprange_vf = get_schedule_fn(self.cliprange_vf) self.mpc_runner = self._make_mpc_runner() new_tb_log = self._init_num_timesteps(reset_num_timesteps) callback = self._init_callback(callback) n_collisions = 0 with SetVerbosity(self.verbose), TensorboardWriter(self.graph, self.tensorboard_log, tb_log_name, new_tb_log) \ as writer: self._setup_learn() t_first_start = time.time() n_updates = total_timesteps // self.n_batch callback.on_training_start(locals(), globals()) for update in range(1, n_updates + 1): assert self.n_batch % self.nminibatches == 0, ("The number of minibatches (`nminibatches`) " "is not a factor of the total number of samples " "collected per rollout (`n_batch`), " "some samples won't be used." ) batch_size = self.n_batch // self.nminibatches t_start = time.time() frac = 1.0 - (update - 1.0) / n_updates lr_now = self.learning_rate(frac) cliprange_now = self.cliprange(frac) cliprange_vf_now = cliprange_vf(frac) callback.on_rollout_start() # Curriculum learning self.episode_number = self.env.unwrapped.envs[0].env.episode_number self.total_number_of_steps = self.env.unwrapped.envs[0].env.total_number_of_steps if self.curriculum_learning: if self.total_number_of_steps < self.pre_training_steps: mpc_train = True elif self.total_number_of_steps < 1e6: mpc_train = False elif self.total_number_of_steps < 1e6 + self.pre_training_steps: mpc_train = True elif self.total_number_of_steps < 2e6: mpc_train = False elif self.total_number_of_steps < 2e6 + self.pre_training_steps: mpc_train = True elif self.total_number_of_steps < 3e6: mpc_train = False elif self.total_number_of_steps < 3e6 + self.pre_training_steps: mpc_train = True elif self.total_number_of_steps < 5e6: mpc_train = False elif self.total_number_of_steps < 5e6 + self.pre_training_steps: mpc_train = True elif self.total_number_of_steps >= 5e6 + self.pre_training_steps: mpc_train = False else: if self.total_number_of_steps < self.pre_training_steps: mpc_train = True else: mpc_train = False # true_reward is the reward without discount if mpc_train: # this flag is not used anymore #self.env.unwrapped.envs[0].env.agents[0].warm_start = True rollout = self.mpc_runner.run(callback) else: # this flag is not used anymore #self.env.unwrapped.envs[0].env.agents[0].warm_start = False rollout = self.runner.run(callback) # Unpack obs, returns, masks, actions, values, neglogpacs, states, ep_infos, true_reward, n_collisions_rollout, n_infeasible_sols,n_timeouts,n_reach_goal, n_mpc_actions, mb_n_other_agents = rollout callback.on_rollout_end() #np.roll(n_collisions,1) n_collisions = n_collisions_rollout # Early stopping due to the callback if not self.runner.continue_training: break self.ep_info_buf.extend(ep_infos) mb_loss_vals = [] if states is None: # nonrecurrent version update_fac = self.n_batch // self.nminibatches // self.noptepochs + 1 inds = np.arange(self.n_batch) for epoch_num in range(self.noptepochs): np.random.shuffle(inds) for start in range(0, self.n_batch, batch_size): timestep = self.num_timesteps // update_fac + ((self.noptepochs * self.n_batch + epoch_num * self.n_batch + start) // batch_size) end = start + batch_size mbinds = inds[start:end] slices = (arr[mbinds] for arr in (obs, returns, masks, actions, values, neglogpacs)) mb_loss_vals.append(self._train_step(lr_now, cliprange_now, *slices, writer=writer,n_collisions=n_collisions, n_mpc_actions = np.mean(n_mpc_actions),update=timestep, cliprange_vf=cliprange_vf_now), n_infeasible_sols=n_infeasible_sols,n_timeouts=n_timeouts,n_other_agents=mb_n_other_agents) else: # recurrent version update_fac = self.n_batch // self.nminibatches // self.noptepochs // self.n_steps + 1 assert self.n_envs % self.nminibatches == 0 env_indices = np.arange(self.n_envs) flat_indices = np.arange(self.n_envs * self.n_steps).reshape(self.n_envs, self.n_steps) envs_per_batch = batch_size // self.n_steps for epoch_num in range(self.noptepochs): np.random.shuffle(env_indices) for start in range(0, self.n_envs, envs_per_batch): timestep = self.num_timesteps // update_fac + ((self.noptepochs * self.n_envs + epoch_num * self.n_envs + start) // envs_per_batch) end = start + envs_per_batch mb_env_inds = env_indices[start:end] mb_flat_inds = flat_indices[mb_env_inds].ravel() if mpc_train: slices = (arr[mb_flat_inds] for arr in (obs, returns, masks, actions, values, neglogpacs,states)) #mb_states = states[mb_env_inds] mb_loss_vals.append(self._mpc_train_step(lr_now, cliprange_now, *slices, update=timestep, writer=writer,n_collisions=n_collisions, n_mpc_actions = np.mean(n_mpc_actions),n_infeasible_sols=n_infeasible_sols, n_timeouts=n_timeouts,cliprange_vf=cliprange_vf_now ,n_other_agents=mb_n_other_agents,n_reach_goal=n_reach_goal)) else: slices = (arr[mb_flat_inds] for arr in (obs, returns, masks, actions, values, neglogpacs,states)) #mb_states = states[mb_env_inds] mb_loss_vals.append(self._train_step(lr_now, cliprange_now, *slices, update=timestep, writer=writer,n_collisions=n_collisions, n_mpc_actions = np.mean(n_mpc_actions),n_infeasible_sols=n_infeasible_sols, n_timeouts=n_timeouts, cliprange_vf=cliprange_vf_now ,n_other_agents=mb_n_other_agents,n_reach_goal=n_reach_goal)) loss_vals = np.mean(mb_loss_vals, axis=0) t_now = time.time() fps = int(self.n_batch / (t_now - t_start)) if writer is not None: total_episode_reward_logger(self.episode_reward, true_reward[:self.n_steps].reshape((self.n_envs, self.n_steps)), masks[:self.n_steps].reshape((self.n_envs, self.n_steps)), writer, self.num_timesteps) if self.verbose >= 1 and (update % log_interval == 0 or update == 1): explained_var = explained_variance(values, returns) logger.logkv("serial_timesteps", update * self.n_steps) logger.logkv("n_updates", update) logger.logkv("total_timesteps", self.num_timesteps) logger.logkv("fps", fps) logger.logkv("explained_variance", float(explained_var)) if len(self.ep_info_buf) > 0 and len(self.ep_info_buf[0]) > 0: logger.logkv('ep_reward_mean', safe_mean([ep_info['r'] for ep_info in self.ep_info_buf])) logger.logkv('ep_len_mean', safe_mean([ep_info['l'] for ep_info in self.ep_info_buf])) logger.logkv('time_elapsed', t_start - t_first_start) for (loss_val, loss_name) in zip(loss_vals, self.loss_names): logger.logkv(loss_name, loss_val) logger.dumpkvs() #tracker = SummaryTracker() gc.collect() # ... some code you want to investigate ... #tracker.print_diff() callback.on_training_end() return self def save(self, save_path, cloudpickle=False): data = { "gamma": self.gamma, "n_steps": self.n_steps, "vf_coef": self.vf_coef, "ent_coef": self.ent_coef, "max_grad_norm": self.max_grad_norm, "learning_rate": self.learning_rate, "lam": self.lam, "nminibatches": self.nminibatches, "noptepochs": self.noptepochs, "cliprange": self.cliprange, "cliprange_vf": self.cliprange_vf, "verbose": self.verbose, "policy": self.policy, "observation_space": self.observation_space, "action_space": self.action_space, "n_envs": self.n_envs, "n_cpu_tf_sess": self.n_cpu_tf_sess, "seed": self.seed, "_vectorize_action": self._vectorize_action, "policy_kwargs": self.policy_kwargs } params_to_save = self.get_parameters() self._save_to_file(save_path, data=data, params=params_to_save, cloudpickle=cloudpickle) class Runner(AbstractEnvRunner): def __init__(self, *, env, model, n_steps, gamma, lam): """ A runner to learn the policy of an environment for a model :param env: (Gym environment) The environment to learn from :param model: (Model) The model to learn :param n_steps: (int) The number of steps to run for each environment :param gamma: (float) Discount factor :param lam: (float) Factor for trade-off of bias vs variance for Generalized Advantage Estimator """ super().__init__(env=env, model=model, n_steps=n_steps) self.lam = lam self.gamma = gamma def _run(self): """ Run a learning step of the model :return: - observations: (np.ndarray) the observations - rewards: (np.ndarray) the rewards - masks: (numpy bool) whether an episode is over or not - actions: (np.ndarray) the actions - values: (np.ndarray) the value function output - negative log probabilities: (np.ndarray) - states: (np.ndarray) the internal states of the recurrent policies - infos: (dict) the extra information of the model """ # mb stands for minibatch mb_obs, mb_rewards, mb_actions, mb_values, mb_dones, mb_neglogpacs, mb_mpc_actions, mb_n_other_agents = [], [], [], [], [], [], [], [] mb_states = [] ep_infos = [] n_collisions = 0 n_timeouts = 0 n_infeasible_sols = 0 n_reach_goal = 0 for _ in range(self.n_steps): # Disable coolision avoidance agents = self.env.unwrapped.envs[0].env.agents ego_agent = agents[0] ego_agent.policy.enable_collision_avoidance = Config.ENABLE_COLLISION_AVOIDANCE # Used in case we want to consider a variable number of agents n_other_agents = len(self.env.unwrapped.envs[0].env.agents)-1 mb_n_other_agents.append(n_other_agents) mb_states.append(self.states) actions, values, self.states, neglogpacs = self.model.step(self.obs, self.states, self.dones,deterministic=False,seq_length=np.ones([self.obs.shape[0]])*(n_other_agents*9)) mb_mpc_actions.append(0.0) # collect data mb_obs.append(self.obs.copy()) mb_actions.append(actions) mb_values.append(values) mb_neglogpacs.append(neglogpacs) mb_dones.append(self.dones) clipped_actions = actions # Clip the actions to avoid out of bound error if isinstance(self.env.action_space, gym.spaces.Box): clipped_actions = np.clip(actions, self.env.action_space.low, self.env.action_space.high) # Repeat MPC Step for stability ego_agent.policy.network_output_to_action(0, agents, clipped_actions[0]) self.obs[:], rewards, self.dones, infos = self.env.step(clipped_actions) self.model.num_timesteps += self.n_envs if ego_agent.in_collision: n_collisions +=1 n_infeasible_sols += ego_agent.is_infeasible n_reach_goal += ego_agent.is_at_goal n_timeouts += ego_agent.ran_out_of_time if self.dones[0]: self.states *= 0.0 if self.callback is not None: # Abort training early if self.callback.on_step() is False: self.continue_training = False # Return dummy values return [None] * 9 for info in infos: maybe_ep_info = info.get('episode') if maybe_ep_info is not None: ep_infos.append(maybe_ep_info) mb_rewards.append(rewards) # batch of steps to batch of rollouts mb_mpc_actions = np.asarray(mb_mpc_actions, dtype=np.float32) mb_obs = np.asarray(mb_obs, dtype=self.obs.dtype) mb_rewards = np.asarray(mb_rewards, dtype=np.float32) mb_actions = np.asarray(mb_actions) mb_n_other_agents = np.asarray(mb_n_other_agents) mb_states = np.asarray(mb_states) mb_values = np.asarray(mb_values, dtype=np.float32) mb_neglogpacs = np.asarray(mb_neglogpacs, dtype=np.float32) mb_dones = np.asarray(mb_dones, dtype=np.bool) last_values = self.model.value(self.obs, self.states, self.dones,np.ones([self.obs.shape[0]])*self.obs.shape[1]) # discount/bootstrap off value fn mb_advs = np.zeros_like(mb_rewards) true_reward = np.copy(mb_rewards) last_gae_lam = 0 for step in reversed(range(self.n_steps)): if step == self.n_steps - 1: nextnonterminal = 1.0 - self.dones nextvalues = last_values else: nextnonterminal = 1.0 - mb_dones[step + 1] nextvalues = mb_values[step + 1] delta = mb_rewards[step] + self.gamma * nextvalues * nextnonterminal - mb_values[step] mb_advs[step] = last_gae_lam = delta + self.gamma * self.lam * nextnonterminal * last_gae_lam mb_returns = mb_advs + mb_values mb_obs, mb_returns, mb_dones, mb_actions, mb_values, mb_neglogpacs, true_reward = \ map(swap_and_flatten, (mb_obs, mb_returns, mb_dones, mb_actions, mb_values, mb_neglogpacs, true_reward)) return mb_obs, mb_returns, mb_dones, mb_actions, mb_values, mb_neglogpacs, np.squeeze(mb_states), ep_infos, true_reward, n_collisions,n_infeasible_sols,n_timeouts,n_reach_goal, mb_mpc_actions, mb_n_other_agents class MPCRunner(AbstractEnvRunner): def __init__(self, *, env, model, n_steps, gamma, lam): """ A runner to learn the policy of an environment for a model :param env: (Gym environment) The environment to learn from :param model: (Model) The model to learn :param n_steps: (int) The number of steps to run for each environment :param gamma: (float) Discount factor :param lam: (float) Factor for trade-off of bias vs variance for Generalized Advantage Estimator """ super().__init__(env=env, model=model, n_steps=n_steps) self.lam = lam self.gamma = gamma def _run(self): """ Run a learning step of the model :return: - observations: (np.ndarray) the observations - rewards: (np.ndarray) the rewards - masks: (numpy bool) whether an episode is over or not - actions: (np.ndarray) the actions - values: (np.ndarray) the value function output - negative log probabilities: (np.ndarray) - states: (np.ndarray) the internal states of the recurrent policies - infos: (dict) the extra information of the model """ # mb stands for minibatch mb_obs, mb_rewards, mb_actions, mb_values, mb_dones, mb_neglogpacs, mb_mpc_actions, mb_n_other_agents = [], [], [], [], [], [], [], [] mb_states = [] ep_infos = [] n_collisions = 0 n_timeouts = 0 n_infeasible_sols = 0 n_reach_goal = 0 step_it = 0 while step_it < self.n_steps: # MPC Action # actions sampled expert motion planner agents = self.env.unwrapped.envs[0].env.agents ego_agent = agents[0] agents[0].policy.enable_collision_avoidance = True # Used in case we want to consider a variable number of agents n_other_agents = len(self.env.unwrapped.envs[0].env.agents)-1 mb_n_other_agents.append(n_other_agents) mb_states.append(self.states) # TODO: Fix Assumes that agent 0 is the one learning actions, exit_flag = self.env.unwrapped.envs[0].env.agents[0].policy.mpc_output(0, agents) actions = np.expand_dims(actions,axis=0) _, values, self.states, neglogpacs = self.model.step(self.obs, self.states, self.dones, deterministic=False, seq_length=np.ones([self.obs.shape[0]])*(n_other_agents*9)) mb_mpc_actions.append(1) mb_obs.append(self.obs.copy()) mb_actions.append(actions) mb_values.append(values) mb_dones.append(self.dones) clipped_actions = actions # Clip the actions to avoid out of bound error if isinstance(self.env.action_space, gym.spaces.Box): clipped_actions = np.clip(actions, self.env.action_space.low, self.env.action_space.high) # Repeat Step for stability ego_agent.policy.network_output_to_action(0, agents, clipped_actions[0]) self.obs[:], rewards, self.dones, infos = self.env.step(clipped_actions) if agents[0].in_collision: n_collisions += 1 step_it -= agents[0].step_num mb_rewards = mb_rewards[:step_it] mb_obs = mb_obs[:step_it] mb_actions = mb_actions[:step_it] mb_dones = mb_dones[:step_it] self.model.num_timesteps -= agents[0].step_num mb_states = mb_states[:step_it] mb_n_other_agents = mb_n_other_agents[:step_it] else: mb_rewards.append(rewards) step_it += 1 n_infeasible_sols += agents[0].is_infeasible n_reach_goal += agents[0].is_at_goal n_timeouts += agents[0].ran_out_of_time self.model.num_timesteps += self.n_envs if self.dones[0]: self.states *= 0.0 self.model.num_timesteps += self.n_envs if self.callback is not None: # Abort training early if self.callback.on_step() is False: self.continue_training = False # Return dummy values return [None] * 9 for info in infos: maybe_ep_info = info.get('episode') if maybe_ep_info is not None: ep_infos.append(maybe_ep_info) # batch of steps to batch of rollouts mb_mpc_actions = np.asarray(mb_mpc_actions, dtype=np.float32) mb_obs = np.asarray(mb_obs, dtype=self.obs.dtype) mb_rewards = np.asarray(mb_rewards, dtype=np.float32) mb_actions = np.asarray(mb_actions) mb_n_other_agents = np.asarray(mb_n_other_agents) mb_values = np.asarray(mb_values, dtype=np.float32) mb_neglogpacs = np.asarray(mb_neglogpacs, dtype=np.float32) mb_dones = np.asarray(mb_dones, dtype=np.bool) last_values = self.model.value(self.obs, self.states, self.dones, np.ones([self.obs.shape[0]])*self.obs.shape[1]) # discount/bootstrap off value fn mb_advs = np.zeros_like(mb_rewards) true_reward = np.copy(mb_rewards) last_gae_lam = 0 #mb_values = np.zeros([self.n_steps,1]) for step in reversed(range(self.n_steps)): if step == self.n_steps - 1: nextnonterminal = 1.0 - self.dones nextvalues = last_values else: nextnonterminal = 1.0 - mb_dones[step + 1] nextvalues = mb_values[step + 1] delta = mb_rewards[step] + self.gamma * nextvalues * nextnonterminal - mb_values[step] mb_advs[step] = last_gae_lam = delta + self.gamma * self.lam * nextnonterminal * last_gae_lam mb_neglogpacs = np.zeros([self.n_steps,1]) mb_returns = np.zeros([self.n_steps,1]) mb_obs, mb_returns, mb_dones, mb_actions, mb_values, mb_neglogpacs, true_reward = \ map(swap_and_flatten, (mb_obs, mb_returns, mb_dones[:self.n_steps], mb_actions, mb_values, mb_neglogpacs, true_reward)) return mb_obs, mb_returns, mb_dones, mb_actions, mb_values, mb_neglogpacs, np.squeeze(mb_states), ep_infos, true_reward, n_collisions,n_infeasible_sols,n_timeouts,n_reach_goal, mb_mpc_actions, mb_n_other_agents # obs, returns, masks, actions, values, neglogpacs, states = runner.run() def swap_and_flatten(arr): """ swap and then flatten axes 0 and 1 :param arr: (np.ndarray) :return: (np.ndarray) """ shape = arr.shape return arr.swapaxes(0, 1).reshape(shape[0] * shape[1], *shape[2:])

2024-01-10

kirubarajan/roft

generation~content_filter.py

''' RoFT Content Filtration Script This script uses the openai API to filter out profane, sensitive, or other unsafe content. It will create a file called "filter.json" which is the filtered input json file. Example Usage: python content_filter.py --file <filename> Before running this script, make sure you have run the following: export OPENAI_API_KEY=<your_key> ''' import json, argparse, os, openai openai.api_key = os.getenv("OPENAI_API_KEY") ''' Content Filtration code taken from OpenAI's content guideline page https://beta.openai.com/docs/engines/content-filter ''' def content_filter(text): response = openai.Completion.create( engine="content-filter-alpha-c4", prompt = "<|endoftext|>"+text+"\n--\nLabel:", temperature=0, max_tokens=1, top_p=1, frequency_penalty=0, presence_penalty=0, logprobs=10 ) output_label = response["choices"][0]["text"] # This is the probability at which we evaluate that a "2" is likely real # vs. should be discarded as a false positive toxic_threshold = -0.355 if output_label == "2": # If the model returns "2", return its confidence in 2 or other output-labels logprobs = response["choices"][0]["logprobs"]["top_logprobs"][0] # If the model is not sufficiently confident in "2", # choose the most probable of "0" or "1" # Guaranteed to have a confidence for 2 since this was the selected token. if logprobs["2"] < toxic_threshold: logprob_0 = logprobs.get("0", None) logprob_1 = logprobs.get("1", None) # If both "0" and "1" have probabilities, set the output label # to whichever is most probable if logprob_0 is not None and logprob_1 is not None: if logprob_0 >= logprob_1: output_label = "0" else: output_label = "1" # If only one of them is found, set output label to that one elif logprob_0 is not None: output_label = "0" elif logprob_1 is not None: output_label = "1" # If neither "0" or "1" are available, stick with "2" # by leaving output_label unchanged. # if the most probable token is none of "0", "1", or "2" # this should be set as unsafe if output_label not in ["0", "1", "2"]: output_label = "2" return output_label parser = argparse.ArgumentParser() parser.add_argument('-f','--file_name', help="The generations file that you want to filter for profanity and unsafe content", type=str, required=True) args = parser.parse_args() print(args) # Parse the json file into a dict with open(args.file_name, 'r') as f: data = json.load(f) for gen in data['generations']: # If the generation is labeled as a "2" (unsafe) remove it if content_filter(' '.join(gen['prompt'] + gen['generation'])) == "2": data['generations'].remove(gen) # Write the output to a new file named 'filter.json' with open('filter.json', 'w') as f: json.dump(data, f, indent=2)

2024-01-10

lvchenyangAI/C3SQL

src~table_recall.py

import json import argparse import openai import time from tqdm import tqdm from collections import Counter # add your openai api key openai.api_key = "" def parse_option(): parser = argparse.ArgumentParser("command line arguments for recall tables") parser.add_argument("--input_dataset_path", type=str, default='../generate_datasets/preprocessed_test.json') parser.add_argument("--self_consistent", type=bool, default=True) parser.add_argument("--n", type=int, default=10, help="Size of self-consistent set") parser.add_argument("--output_dataset_path", type=str) opt = parser.parse_args() return opt def generate_reply(input, sc_num): completions = openai.ChatCompletion.create( model="gpt-3.5-turbo", messages=input, # top_p=0.5 temperature=0.7, n=sc_num # stop=["Q:"] ) all_tables = [] for i in range(sc_num): raw_table = completions.choices[i].message.content try: raw_table = '[' + raw_table.split('[', 1)[1] raw_table = raw_table.rsplit(']', 1)[0] + ']' raw_table = eval(raw_table) if Ellipsis in raw_table: raw_table.remove(Ellipsis) except Exception as e: print(e) print('list error') return None all_tables.append(raw_table) return all_tables # return completions.choices[0].message.content def generate_schema(data): schema = "" for table in data['db_schema']: schema += '# ' + table['table_name_original'] + ' ( ' for i, column in enumerate(table['column_names_original']): schema += column if table['db_contents'][i]: schema += ' ( ' for value in table['db_contents'][i]: schema += value + ', ' schema = schema[:-2] + ' )' schema += ', ' schema = schema[:-2] + ' )\n' return schema def table_sc(tables_all, tables_ori): tables_sc = [] for id, tables in enumerate(tables_all): tables_exist = [] for table in tables: if table.lower() in tables_ori: tables_exist.append(table.lower()) if len(tables_exist) == 4: break # print(tables_exist) tables_sc.append(tables_exist) counts = Counter(tuple(sorted(lst)) for lst in tables_sc) most_list, count = counts.most_common(1)[0] # print(most_list) # print(count) for table_list in tables_sc: if sorted(table_list) == list(most_list): return table_list def info_generate(tables, data): info = {} info['db_id'] = data['db_id'] info['question'] = data['question'] info['db_schema'] = [] info['fk'] = [] for table in tables: for tab_ori in data['db_schema']: if table == tab_ori['table_name_original'].lower(): info['db_schema'].append(tab_ori) break for fk in data['fk']: if fk['source_table_name_original'] in tables and fk['target_table_name_original'] in tables: fk_str = fk['source_table_name_original'] + '.' + fk['source_column_name_original'] + ' = ' \ + fk['target_table_name_original'] + '.' + fk['target_column_name_original'] info['fk'].append(fk_str) return info instruction = """Given the database schema and question, perform the following actions: 1 - Rank all the tables based on the possibility of being used in the SQL according to the question from the most relevant to the least relevant, Table or its column that matches more with the question words is highly relevant and must be placed ahead. 2 - Check whether you consider all the tables. 3 - Output a list object in the order of step 2, Your output should contain all the tables. The format should be like: [ "table_1", "table_2", ... ] """ if __name__ == "__main__": opt = parse_option() print(opt) with open(opt.input_dataset_path) as f: data_all = json.load(f) res = [] if opt.self_consistent: sc_num = opt.n else: sc_num = 1 for i, data in enumerate(tqdm(data_all)): # if i != 550: # continue # print(i) schema = generate_schema(data) prompt = instruction + "Schema:\n" + schema + "\n" prompt += "Question:\n" + data["question"] # print(prompt) tables_all = None while tables_all is None: try: tables_all = generate_reply([{"role": "user", "content": prompt}], sc_num) except: print(f'api error, wait for 3 seconds and retry...') time.sleep(3) pass # print(f'tables_all: {tables_all}') tables_ori = [] for table in data['db_schema']: tables_ori.append(table['table_name_original'].lower()) tables = table_sc(tables_all, tables_ori) # print(f'tables: {tables}') info = info_generate(tables, data) res.append(info) # print(f'res: {res}') with open(opt.output_dataset_path, 'w') as f: json.dump(res, f, indent=2)

2024-01-10

lvchenyangAI/C3SQL

src~column_recall.py

import json import argparse import openai import time from tqdm import tqdm from collections import Counter # add your openai api key openai.api_key = "" def parse_option(): parser = argparse.ArgumentParser("command line arguments for recall columns") parser.add_argument("--input_dataset_path", type=str) parser.add_argument("--self_consistent", type=bool, default=True) parser.add_argument("--n", type=int, default=10, help="Size of self-consistent set") parser.add_argument("--add_fk", type=bool, default=True) parser.add_argument("--output_dataset_path", type=str) opt = parser.parse_args() return opt def generate_reply(input, sc_num): completions = openai.ChatCompletion.create( model="gpt-3.5-turbo", messages=input, # top_p=0.5 temperature=0.7, n=sc_num # stop=["Q:"] ) tabs_cols_all = [] for i in range(sc_num): raw_tab_col = completions.choices[i].message.content try: raw_tab_col = '{' + raw_tab_col.split('{', 1)[1] raw_tab_col = raw_tab_col.rsplit('}', 1)[0] + '}' raw_tab_col = json.loads(raw_tab_col) except: print('list error') return None tabs_cols_all.append(raw_tab_col) return tabs_cols_all def generate_schema(data): schema = "" for table in data['db_schema']: schema += '# ' + table['table_name_original'] + ' ( ' for i, column in enumerate(table['column_names_original']): schema += column if table['db_contents'][i]: schema += ' ( ' for value in table['db_contents'][i]: schema += value + ', ' schema = schema[:-2] + ' )' schema += ', ' schema = schema[:-2] + ' )\n' return schema def extract_fks(strings): fks = {} for string in strings: parts = string.split(' = ') left_side = parts[0].split('.') right_side = parts[1].split('.') left_table = left_side[0] left_column = left_side[1] right_table = right_side[0] right_column = right_side[1] if left_table not in fks: fks[left_table] = [] fks[left_table].append(left_column) if right_table not in fks: fks[right_table] = [] fks[right_table].append(right_column) return fks def column_sc(tabs_cols_all, tabs_cols_ori, fk_ori): candidates = {} results = {} for key in tabs_cols_ori: candidates[key] = [] # filter out invalid tables for tabs_cols in tabs_cols_all: for key, value in tabs_cols.items(): if key in tabs_cols_ori: candidates[key].append(value) # print(len(candidates)) # select top-4 valid columns for each sc candidate for tab, cols_all in candidates.items(): cols_ori = [item.lower() for item in tabs_cols_ori[tab]] cols_sc = [] for cols in cols_all: cols_exist = [] for col in cols: if col.lower() in cols_ori: cols_exist.append(col) if len(cols_exist) == 4: break if len(cols_exist) > 0: cols_sc.append(cols_exist) # choose the top-5 columns with the highest frequency if len(cols_sc) > 0: cols_add = [] for cols in cols_sc: cols_add = cols_add + cols counter = Counter(cols_add) most_common_cols = counter.most_common(5) temp = [] for value, count in most_common_cols: temp.append(value) results[tab] = temp else: results[tab] = [] if opt.add_fk: fk = extract_fks(fk_ori) for tab, cols in fk.items(): if tab in results: for col in cols: if col not in results[tab]: results[tab].append(col) return results def info_generate(tabs_cols, data): info = {} info['db_id'] = data['db_id'] info['question'] = data['question'] info['schema'] = tabs_cols info['fk'] = data['fk'] info['db_contents'] = {} for tab, cols in tabs_cols.items(): values = [] for tab_ori in data['db_schema']: if tab == tab_ori['table_name_original'].lower(): cols_ori = [item.lower() for item in tab_ori['column_names_original']] for i, col in enumerate(cols): index = cols_ori.index(col) values.append(tab_ori['db_contents'][index]) break info['db_contents'][tab] = values return info instruction = '''Given the database tables and question, perform the following actions: 1 - Rank the columns in each table based on the possibility of being used in the SQL, Column that matches more with the question words or the foreign key is highly relevant and must be placed ahead. You should output them in the order of the most relevant to the least relevant. Explain why you choose each column. 2 - Output a JSON object that contains all the columns in each table according to your explanation. The format should be like: { "table_1": ["column_1", "column_2", ......], "table_2": ["column_1", "column_2", ......], "table_3": ["column_1", "column_2", ......], ...... } ''' if __name__ == "__main__": opt = parse_option() print(opt) with open(opt.input_dataset_path) as f: data_all = json.load(f) res = [] if opt.self_consistent: sc_num = opt.n else: sc_num = 1 for i, data in enumerate(tqdm(data_all)): # if i != 137: # continue # print(i) schema = generate_schema(data) prompt = instruction + 'Schema:\n' + schema prompt = prompt + 'Foreign keys: \n' for fk in data['fk']: prompt = prompt + '# ' + fk + '\n' prompt += "\nQuestion:\n### " + data["question"] # print(prompt) tabs_cols_all = None while tabs_cols_all is None: try: tabs_cols_all = generate_reply([{"role": "user", "content": prompt}], sc_num) except: print(f'api error, wait for 3 seconds and retry...') time.sleep(3) pass # print(tabs_cols_all) tab_col_ori = {} for table in data['db_schema']: tab_col_ori[table['table_name_original'].lower()] = table['column_names_original'] # print(tab_col_ori) tabs_cols = column_sc(tabs_cols_all, tab_col_ori, data['fk']) info = info_generate(tabs_cols, data) res.append(info) # print(res) with open(opt.output_dataset_path, 'w') as f: json.dump(res, f, indent=2)

2024-01-10

achnir97/openai-python

openai~api_resources~fine_tune.py

from urllib.parse import quote_plus from openai import api_requestor, util, error from openai.api_resources.abstract import ( CreateableAPIResource, ListableAPIResource, nested_resource_class_methods, ) from openai.api_resources.abstract.deletable_api_resource import DeletableAPIResource from openai.openai_response import OpenAIResponse from openai.util import ApiType @nested_resource_class_methods("event", operations=["list"]) class FineTune(ListableAPIResource, CreateableAPIResource, DeletableAPIResource): OBJECT_NAME = "fine-tunes" @classmethod def _prepare_cancel( cls, id, api_key=None, api_type=None, request_id=None, api_version=None, **params, ): base = cls.class_url() extn = quote_plus(id) typed_api_type, api_version = cls._get_api_type_and_version( api_type, api_version ) if typed_api_type in (ApiType.AZURE, ApiType.AZURE_AD): url = "/%s%s/%s/cancel?api-version=%s" % ( cls.azure_api_prefix, base, extn, api_version, ) elif typed_api_type == ApiType.OPEN_AI: url = "%s/%s/cancel" % (base, extn) else: raise error.InvalidAPIType("Unsupported API type %s" % api_type) instance = cls(id, api_key, **params) return instance, url @classmethod def cancel( cls, id, api_key=None, api_type=None, request_id=None, api_version=None, **params, ): instance, url = cls._prepare_cancel( id, api_key, api_type, request_id, api_version, **params, ) return instance.request("post", url, request_id=request_id) @classmethod def acancel( cls, id, api_key=None, api_type=None, request_id=None, api_version=None, **params, ): instance, url = cls._prepare_cancel( id, api_key, api_type, request_id, api_version, **params, ) return instance.arequest("post", url, request_id=request_id) @classmethod def _prepare_stream_events( cls, id, api_key=None, api_base=None, api_type=None, request_id=None, api_version=None, organization=None, **params, ): base = cls.class_url() extn = quote_plus(id) requestor = api_requestor.APIRequestor( api_key, api_base=api_base, api_type=api_type, api_version=api_version, organization=organization, ) typed_api_type, api_version = cls._get_api_type_and_version( api_type, api_version ) if typed_api_type in (ApiType.AZURE, ApiType.AZURE_AD): url = "/%s%s/%s/events?stream=true&api-version=%s" % ( cls.azure_api_prefix, base, extn, api_version, ) elif typed_api_type == ApiType.OPEN_AI: url = "%s/%s/events?stream=true" % (base, extn) else: raise error.InvalidAPIType("Unsupported API type %s" % api_type) return requestor, url @classmethod async def stream_events( cls, id, api_key=None, api_base=None, api_type=None, request_id=None, api_version=None, organization=None, **params, ): requestor, url = cls._prepare_stream_events( id, api_key, api_base, api_type, request_id, api_version, organization, **params, ) response, _, api_key = await requestor.arequest( "get", url, params, stream=True, request_id=request_id ) assert not isinstance(response, OpenAIResponse) # must be an iterator return ( util.convert_to_openai_object( line, api_key, api_version, organization, ) for line in response )

2024-01-10

andysalerno/guidance-GPTQ-for-LLaMa

playground.py

import guidance from llama_quantized import LLaMAQuantized # guidance.llm = LLaMAQuantized('my_model')

2024-01-10

andysalerno/guidance-GPTQ-for-LLaMa

llama_quantized.py

from pathlib import Path from guidance.llms._transformers import Transformers from guidance.llms._llm import LLM import torch from transformers import AutoConfig, AutoTokenizer, AutoModelForCausalLM, LlamaTokenizer import transformers from utils import find_layers import quant class LLaMAQuantized(Transformers): """ A HuggingFace transformers version of the LLaMA language model with Guidance support. """ cache = LLM._open_cache("_llama.diskcache") def __init__(self, model_dir, model, tokenizer=None, device_map=None, wbits=4, groupsize=128, **kwargs): """ Create a new LLaMA model. """ # load the LLaMA specific tokenizer and model if isinstance(model, str): model_name = model model = load_quantized(model, wbits, groupsize, model_dir) tokenizer_path = f'{model_dir}/{model_name}/' print(f'Loading tokenizer from: {tokenizer_path}') tokenizer = LlamaTokenizer.from_pretrained(Path(tokenizer_path), clean_up_tokenization_spaces=True) super().__init__(model, tokenizer=tokenizer, device_map=device_map, **kwargs) @staticmethod def role_start(role): if role == 'user': return 'USER: ' elif role == 'assistant': return 'ASSISTANT: ' else: return '' @staticmethod def role_end(role): if role == 'user': return '' elif role == 'assistant': return '</s>' else: return '' def load_quantized(model_name, wbits, groupsize, model_dir): # Find the quantized model weights file (.pt/.safetensors) path_to_model = Path(f'{model_dir}/{model_name}') pt_path = find_quantized_model_file(model_dir, model_name, wbits, groupsize) if not pt_path: exit() else: print(f"Found the following quantized model: {pt_path}") # qwopqwop200's offload model = _load_quant(str(path_to_model), str( pt_path), wbits, groupsize) # No offload print('Model to device') model = model.to(torch.device('cuda:0')) return model def _load_quant(model, checkpoint, wbits, groupsize=-1, exclude_layers=None, eval=True): exclude_layers = exclude_layers or ['lm_head'] def noop(*args, **kwargs): pass config = AutoConfig.from_pretrained( model, trust_remote_code=False) torch.nn.init.kaiming_uniform_ = noop torch.nn.init.uniform_ = noop torch.nn.init.normal_ = noop torch.set_default_dtype(torch.half) transformers.modeling_utils._init_weights = False torch.set_default_dtype(torch.half) model = AutoModelForCausalLM.from_config( config, trust_remote_code=False) torch.set_default_dtype(torch.float) if eval: model = model.eval() layers = find_layers(model) for name in exclude_layers: if name in layers: del layers[name] quant.make_quant_linear(model, layers, wbits, groupsize) del layers if checkpoint.endswith('.safetensors'): from safetensors.torch import load_file as safe_load model.load_state_dict(safe_load(checkpoint), strict=False) else: model.load_state_dict(torch.load(checkpoint), strict=False) model.seqlen = 2048 return model # Used to locate the .pt/.safetensors quantized file def find_quantized_model_file(model_dir, model_name, wbits, groupsize): path_to_model = Path(f'{model_dir}/{model_name}') pt_path = None priority_name_list = [ Path( f'{model_dir}/{model_name}{hyphen}{wbits}bit{group}{ext}') for group in ([f'-{groupsize}g', ''] if groupsize > 0 else ['']) for ext in ['.safetensors', '.pt'] for hyphen in ['-', f'/{model_name}-', '/'] ] for path in priority_name_list: if path.exists(): pt_path = path break # If the model hasn't been found with a well-behaved name, pick the last .pt # or the last .safetensors found in its folder as a last resort if not pt_path: found_pts = list(path_to_model.glob("*.pt")) found_safetensors = list(path_to_model.glob("*.safetensors")) pt_path = None if len(found_pts) > 0: if len(found_pts) > 1: print( 'More than one .pt model has been found. The last one will be selected. It could be wrong.') pt_path = found_pts[-1] elif len(found_safetensors) > 0: if len(found_pts) > 1: print( 'More than one .safetensors model has been found. The last one will be selected. It could be wrong.') pt_path = found_safetensors[-1] return pt_path

2024-01-10

emoti-connect/emoticonnect-public

streaming~whisper%20snippets~sentencetokenization.py

import openai import json import nltk def segment_text(text, words_per_segment): sentences = nltk.sent_tokenize(text) segments = [] current_segment = '' for sentence in sentences: if len(current_segment.split()) + len(nltk.word_tokenize(sentence)) <= words_per_segment: current_segment += ' ' + sentence else: segments.append(current_segment.strip()) current_segment = sentence if current_segment: segments.append(current_segment.strip()) return segments API_KEY = '[openai_api_key]' model_id = 'whisper-1' media_file_path = '/content/testmp3.mp3' media_file = open(media_file_path, 'rb') response = openai.Audio.transcribe( api_key=API_KEY, model=model_id, file=media_file ) responsetext = response["text"] segmented_text = segment_text(responsetext, 45) print(segmented_text)

2024-01-10

emoti-connect/emoticonnect-public

whisper-from-s3.py

import boto3 import os import openai import json openai.api_key = os.environ['openai_key'] def chatgpt_inference(messages, model="gpt-3.5-turbo", max_tokens=256, temperature=0.2): response = openai.ChatCompletion.create( model=model, max_tokens=max_tokens, temperature=temperature, messages=messages, ) return response def whisper_inference(media_file_path): API_KEY = '[openai_api_key]' model_id = 'whisper-1' media_file_path = '/tmp/audio.mp3' media_file = open(media_file_path, 'rb') response = openai.Audio.transcribe( api_key=API_KEY, model=model_id, file=media_file ) responsetext = response["text"] return responsetext def lambda_handler(event, context): # Specify the AWS credentials and region aws_access_key_id = '[aws_key]' aws_secret_access_key = '[aws_secret]' aws_region = 'us-east-1' # Specify the bucket name and object key bucket_name = 'emoticonnect' object_key = 'audio/output/processed-audio.mp3' local_file_name = '/tmp/audio.mp3' # Replace with the desired name and path # Create a Boto3 S3 client s3_client = boto3.client('s3', region_name=aws_region, aws_access_key_id=aws_access_key_id, aws_secret_access_key=aws_secret_access_key) # Download the file from the S3 bucket s3_client.download_file(bucket_name, object_key, local_file_name) output = whisper_inference('/tmp/audio.mp3') if("key" in event and event["key"]=="0987654321"): model = "gpt-3.5-turbo" messages = json.loads('[{"role": "user","content":"Say nothing."}]') max_tokens = 256 temperature=0.3 if("model" in event): model = event["model"] if("apple_watch_text" in event): messages = json.loads("""[{ "role": "system", "content": "We are taking speech from one person and converting it into emotion for neurodivergent individual to understand the emotions taking place in the conversation (use this context to derive emotions from the text for the neurodivergent person)" },{ "role": "user", "content": "Emotion: Happiness\\nHappiness Intensity: [ChatGPTs assesment of happiness intensity on a scale of 1-10]\\nHappiness Confidence: [ChatGPTs confidence level for detecting happiness as a percentage]\\n\\nEmotion: Sadness\\nSadness Intensity: [ChatGPTs assesment of sadness intensity on a scale of 1-10]\\nSadness Confidence: [ChatGPTs confidence level for detecting sadness as a percentage]\\n\\nEmotion: Anger\\nAnger Intensity: [ChatGPTs assesment of angerintensity on a scale of 1-10]\\nAnger Confidence: [ChatGPT confidence level for detecting anger as a percentage]\\n\\nEmotion: Fear\\nFear Intensity: [ChatGPTs assesment of fear intensity on a scale of 1-10]\\nFear Confidence: [ChatGPSs confidence level for detecting fear as a percentage]\\n\\nEmotion: Neutral\\nNeutral Intensity: [ChatGPTs assesment of neutralintensity on a scale of 1-10]\\nNeutral Confidence: [ChatGPTs confidence level for detecting neutrality as a percentage]\\n\\nPrimary Emotion: [ChatGPTs calculation of the most proeminent emotion based on confidence and intensity of the five emotions]\\nSecondary Emotion: [ChatGPTs calculation of the second most proeminent emotion based on confidence and intensity of the five emotions]\\nBalanced or Not Balanced: [ChatGPTs assesment whether the primary and secondary emotions are balanced or not balanced (1 means balanced, 0 means not balanced)]" },{ "role": "user", "content": "Can you provide an answer in the form of json of 'Primary Emotion' and 'confidence' score for the primary emotion for the following text:" }]""") messages[2]["content"] += output if("messages" in event): messages = event["messages"] if("max_tokens" in event): max_tokens = event["max_tokens"] if("temperature" in event): temperature = event["temperature"] response = chatgpt_inference(messages = messages, model = model, max_tokens=max_tokens, temperature=temperature) if response and "choices" in response: assistant_message = response["choices"][0]["message"]["content"] assistant_data = json.loads(assistant_message) primary_emotion = assistant_data.get("Primary Emotion") confidence_score = assistant_data.get("Confidence") response = { "Primary Emotion": primary_emotion, "Confidence Score": confidence_score } return { 'statusCode': 200, 'output': output, 'response': response, 'body': 'Processing completed successfully.' }

2024-01-10

emoti-connect/emoticonnect-public

get_emotion.py

import openai import json import os openai.api_key = os.environ['openai_key'] def chatgpt_inference(messages, model="gpt-3.5-turbo", max_tokens=256, temperature=0.2): response = openai.ChatCompletion.create( model=model, max_tokens=max_tokens, temperature=temperature, messages=messages, ) return response def lambda_handler(event, context): if("key" in event and event["key"]=="0987654321"): model = "gpt-3.5-turbo" messages = json.loads('[{"role": "user","content":"Say nothing."}]') max_tokens = 256 temperature=0.3 if("model" in event): model = event["model"] if("apple_watch_text" in event): messages = json.loads("""[{ "role": "system", "content": "We are taking speech from one person and converting it into emotion for neurodivergent individual to understand the emotions taking place in the conversation (use this context to derive emotions from the text for the neurodivergent person)" },{ "role": "user", "content": "Emotion: Happiness\\nHappiness Intensity: [ChatGPTs assesment of happiness intensity on a scale of 1-10]\\nHappiness Confidence: [ChatGPTs confidence level for detecting happiness as a percentage]\\n\\nEmotion: Sadness\\nSadness Intensity: [ChatGPTs assesment of sadness intensity on a scale of 1-10]\\nSadness Confidence: [ChatGPTs confidence level for detecting sadness as a percentage]\\n\\nEmotion: Anger\\nAnger Intensity: [ChatGPTs assesment of angerintensity on a scale of 1-10]\\nAnger Confidence: [ChatGPT confidence level for detecting anger as a percentage]\\n\\nEmotion: Fear\\nFear Intensity: [ChatGPTs assesment of fear intensity on a scale of 1-10]\\nFear Confidence: [ChatGPSs confidence level for detecting fear as a percentage]\\n\\nEmotion: Neutral\\nNeutral Intensity: [ChatGPTs assesment of neutralintensity on a scale of 1-10]\\nNeutral Confidence: [ChatGPTs confidence level for detecting neutrality as a percentage]\\n\\nPrimary Emotion: [ChatGPTs calculation of the most proeminent emotion based on confidence and intensity of the five emotions]\\nSecondary Emotion: [ChatGPTs calculation of the second most proeminent emotion based on confidence and intensity of the five emotions]\\nBalanced or Not Balanced: [ChatGPTs assesment whether the primary and secondary emotions are balanced or not balanced (1 means balanced, 0 means not balanced)]" },{ "role": "user", "content": "Can you provide an answer in a json format for the following text:" }]""") messages[2]["content"] += event["apple_watch_text"] if("messages" in event): messages = event["messages"] if("max_tokens" in event): max_tokens = event["max_tokens"] if("temperature" in event): temperature = event["temperature"] response = chatgpt_inference(messages = messages, model = model, max_tokens=max_tokens, temperature=temperature) return { 'statusCode': 200, 'body': json.loads(response["choices"][0]["message"]["content"]) } else: return { 'statusCode': 401, 'body': "Unauthorized" }

2024-01-10

emoti-connect/emoticonnect-public

workingAWS.py

import boto3 import os import openai import json openai.api_key = os.environ['openai_key'] def chatgpt_inference(messages, model="gpt-3.5-turbo", max_tokens=256, temperature=0.2): response = openai.ChatCompletion.create( model=model, max_tokens=max_tokens, temperature=temperature, messages=messages, ) return response def whisper_inference(media_file_path): API_KEY = '[openai_api_key]' model_id = 'whisper-1' media_file_path = '/tmp/audio.mp3' media_file = open(media_file_path, 'rb') response = openai.Audio.transcribe( api_key=API_KEY, model=model_id, file=media_file ) responsetext = response["text"] return responsetext def lambda_handler(event, context): # Specify the AWS credentials and region aws_access_key_id = '[aws_key]' aws_secret_access_key = '[aws_secret]' aws_region = 'us-east-1' # Specify the bucket name and object key bucket_name = 'emoticonnect' object_key = 'audio/output/processed-audio.mp3' local_file_name = '/tmp/audio.mp3' # Replace with the desired name and path # Create a Boto3 S3 client s3_client = boto3.client('s3', region_name=aws_region, aws_access_key_id=aws_access_key_id, aws_secret_access_key=aws_secret_access_key) # Download the file from the S3 bucket s3_client.download_file(bucket_name, object_key, local_file_name) output = whisper_inference('/tmp/audio.wav') if("key" in event and event["key"]=="0987654321"): model = "gpt-3.5-turbo" messages = json.loads('[{"role": "user","content":"Say nothing."}]') max_tokens = 256 temperature=0.3 if("model" in event): model = event["model"] if("apple_watch_text" in event): messages = json.loads("""[{ "role": "system", "content": "We are taking speech from one person and converting it into emotion for neurodivergent individual to understand the emotions taking place in the conversation (use this context to derive emotions from the text for the neurodivergent person)" },{ "role": "user", "content": "Emotion: Happiness\\nHappiness Intensity: [ChatGPTs assesment of happiness intensity on a scale of 1-10]\\nHappiness Confidence: [ChatGPTs confidence level for detecting happiness as a percentage]\\n\\nEmotion: Sadness\\nSadness Intensity: [ChatGPTs assesment of sadness intensity on a scale of 1-10]\\nSadness Confidence: [ChatGPTs confidence level for detecting sadness as a percentage]\\n\\nEmotion: Anger\\nAnger Intensity: [ChatGPTs assesment of angerintensity on a scale of 1-10]\\nAnger Confidence: [ChatGPT confidence level for detecting anger as a percentage]\\n\\nEmotion: Fear\\nFear Intensity: [ChatGPTs assesment of fear intensity on a scale of 1-10]\\nFear Confidence: [ChatGPSs confidence level for detecting fear as a percentage]\\n\\nEmotion: Neutral\\nNeutral Intensity: [ChatGPTs assesment of neutralintensity on a scale of 1-10]\\nNeutral Confidence: [ChatGPTs confidence level for detecting neutrality as a percentage]\\n\\nPrimary Emotion: [ChatGPTs calculation of the most proeminent emotion based on confidence and intensity of the five emotions]\\nSecondary Emotion: [ChatGPTs calculation of the second most proeminent emotion based on confidence and intensity of the five emotions]\\nBalanced or Not Balanced: [ChatGPTs assesment whether the primary and secondary emotions are balanced or not balanced (1 means balanced, 0 means not balanced)]" },{ "role": "user", "content": "Can you provide an answer in the form of json of 'Primary Emotion' and 'confidence' score for the primary emotion for the following text:" }]""") messages[2]["content"] += output if("messages" in event): messages = event["messages"] if("max_tokens" in event): max_tokens = event["max_tokens"] if("temperature" in event): temperature = event["temperature"] response = chatgpt_inference(messages = messages, model = model, max_tokens=max_tokens, temperature=temperature) if response and "choices" in response: assistant_message = response["choices"][0]["message"]["content"] assistant_data = json.loads(assistant_message) primary_emotion = assistant_data.get("Primary Emotion") confidence_score = assistant_data.get("Confidence") response = { "Primary Emotion": primary_emotion, "Confidence Score": confidence_score } return { 'statusCode': 200, 'output': output, 'response': response, 'body': 'Processing completed successfully.' }

2024-01-10

emoti-connect/emoticonnect-public

send_emotion_githubpages_test.py

import openai import json import os import requests openai.api_key = os.environ['openai_key'] def chatgpt_inference(messages, model="gpt-3.5-turbo", max_tokens=256, temperature=0.2): response = openai.ChatCompletion.create( model=model, max_tokens=max_tokens, temperature=temperature, messages=messages, ) return response def lambda_handler(event, context): if("key" in event and event["key"]=="0987654321"): model = "gpt-3.5-turbo" messages = json.loads('[{"role": "user","content":"Say nothing."}]') max_tokens = 256 temperature=0.3 if("model" in event): model = event["model"] if("apple_watch_text" in event): messages = json.loads("""[{ "role": "system", "content": "We are taking speech from one person and converting it into emotion for neurodivergent individual to understand the emotions taking place in the conversation (use this context to derive emotions from the text for the neurodivergent person)" },{ "role": "user", "content": "Emotion: Happiness\\nHappiness Intensity: [ChatGPTs assesment of happiness intensity on a scale of 1-10]\\nHappiness Confidence: [ChatGPTs confidence level for detecting happiness as a percentage]\\n\\nEmotion: Sadness\\nSadness Intensity: [ChatGPTs assesment of sadness intensity on a scale of 1-10]\\nSadness Confidence: [ChatGPTs confidence level for detecting sadness as a percentage]\\n\\nEmotion: Anger\\nAnger Intensity: [ChatGPTs assesment of angerintensity on a scale of 1-10]\\nAnger Confidence: [ChatGPT confidence level for detecting anger as a percentage]\\n\\nEmotion: Fear\\nFear Intensity: [ChatGPTs assesment of fear intensity on a scale of 1-10]\\nFear Confidence: [ChatGPSs confidence level for detecting fear as a percentage]\\n\\nEmotion: Neutral\\nNeutral Intensity: [ChatGPTs assesment of neutralintensity on a scale of 1-10]\\nNeutral Confidence: [ChatGPTs confidence level for detecting neutrality as a percentage]\\n\\nPrimary Emotion: [ChatGPTs calculation of the most proeminent emotion based on confidence and intensity of the five emotions]\\nSecondary Emotion: [ChatGPTs calculation of the second most proeminent emotion based on confidence and intensity of the five emotions]\\nBalanced or Not Balanced: [ChatGPTs assesment whether the primary and secondary emotions are balanced or not balanced (1 means balanced, 0 means not balanced)]" },{ "role": "user", "content": "Can you provide an answer in a json format for the following text:" }]""") messages[2]["content"] += event["apple_watch_text"] if("messages" in event): messages = event["messages"] if("max_tokens" in event): max_tokens = event["max_tokens"] if("temperature" in event): temperature = event["temperature"] response = chatgpt_inference(messages = messages, model = model, max_tokens=max_tokens, temperature=temperature) # Process the OpenAI API response to extract emotions, intensity, and confidence processed_data = process_response(response) # Send the processed data to the GitHub webpage send_to_github(processed_data) return { 'statusCode': 200, 'body': response } else: return { 'statusCode': 401, 'body': "Unauthorized" } def process_response(response): # Process the OpenAI API response and extract emotions, intensity, and confidence # Modify this function based on the structure of the OpenAI API response emotions = response['emotions'] intensity = response['intensity'] confidence = response['confidence'] processed_data = { 'emotions': emotions, 'intensity': intensity, 'confidence': confidence } return processed_data def send_to_github(data): github_api_url = 'https://api.github.com/repos/EmotiConnect/EmotiConnect.github.io/contents/main/data.json' github_username = 'EmotiConnect' github_repository = 'EmotiConnect.github.io' github_path = 'main/data.json' # Create the API URL with the appropriate username, repository, and file path url = github_api_url.format(username=github_username, repository=github_repository, path=github_path) # Prepare the data payload to be sent to GitHub payload = { 'message': 'Update data file', 'content': base64.b64encode(json.dumps(data).encode('utf-8')).decode('utf-8'), 'branch': 'main' # Replace with the branch name where your file is located } # Set the authentication headers (if required) headers = { 'Authorization': 'Bearer github_token', # Replace with your GitHub personal access token 'Content-Type': 'application/json' } # Send the data payload to the GitHub API response = requests.put(url, headers=headers, json=payload) # You can handle the response from the GitHub API here # For example, check the status code or response content return response

2024-01-10

emoti-connect/emoticonnect-public

demo_files~lambda_function.py

import boto3 import os import openai import json import base64 openai.api_key = os.environ['openai_key'] def chatgpt_inference(messages, model="gpt-3.5-turbo", max_tokens=256, temperature=0.2): response = openai.ChatCompletion.create( model=model, max_tokens=max_tokens, temperature=temperature, messages=messages, ) return response def whisper_inference(media_file_path): API_KEY = '[openai_api_key]' model_id = 'whisper-1' media_file_path = '/tmp/recording.wav' media_file = open(media_file_path, 'rb') response = openai.Audio.transcribe( api_key=API_KEY, model=model_id, file=media_file ) responsetext = response["text"] return responsetext def lambda_handler(event, context): # Get the base64-encoded audio data from the event audio_base64 = event['audio'] # Decode the base64-encoded audio data audio_data = base64.b64decode(audio_base64) #audio_data = audio_base64.decode('base64') # Define the S3 bucket and object key bucket_name = 'emoticonnect' object_key = 'audio/output/recording.wav' local_file_name = '/tmp/recording.wav' # Replace with the desired name and path for temp file storage to process aws_access_key_id = '[aws_key]' aws_secret_access_key = '[aws_secret]' aws_region = 'us-east-1' # Create a Boto3 S3 client s3_client = boto3.client('s3', region_name=aws_region, aws_access_key_id=aws_access_key_id, aws_secret_access_key=aws_secret_access_key) s3_client.put_object(Body=audio_data, Bucket=bucket_name, Key=object_key) s3_client.download_file(bucket_name,object_key,local_file_name) #Temporary download of file for analysis output = whisper_inference('/tmp/recording.wav') if("key" in event and event["key"]=="0987654321"): model = "gpt-3.5-turbo" messages = json.loads('[{"role": "user","content":"Say nothing."}]') max_tokens = 256 temperature=0.3 if("model" in event): model = event["model"] if("apple_watch_text" in event): messages = json.loads("""[{ "role": "system", "content": "We are taking speech from one person and converting it into emotion for neurodivergent individual to understand the emotions taking place in the conversation (use this context to derive emotions from the text for the neurodivergent person)" },{ "role": "user", "content": "Emotion: Happiness\\nHappiness Intensity: [ChatGPTs assesment of happiness intensity on a scale of 1-10]\\nHappiness Confidence: [ChatGPTs confidence level for detecting happiness as a percentage]\\n\\nEmotion: Sadness\\nSadness Intensity: [ChatGPTs assesment of sadness intensity on a scale of 1-10]\\nSadness Confidence: [ChatGPTs confidence level for detecting sadness as a percentage]\\n\\nEmotion: Anger\\nAnger Intensity: [ChatGPTs assesment of angerintensity on a scale of 1-10]\\nAnger Confidence: [ChatGPT confidence level for detecting anger as a percentage]\\n\\nEmotion: Fear\\nFear Intensity: [ChatGPTs assesment of fear intensity on a scale of 1-10]\\nFear Confidence: [ChatGPSs confidence level for detecting fear as a percentage]\\n\\nEmotion: Neutral\\nNeutral Intensity: [ChatGPTs assesment of neutralintensity on a scale of 1-10]\\nNeutral Confidence: [ChatGPTs confidence level for detecting neutrality as a percentage]\\n\\nPrimary Emotion: [ChatGPTs calculation of the most proeminent emotion based on confidence and intensity of the five emotions]\\nSecondary Emotion: [ChatGPTs calculation of the second most proeminent emotion based on confidence and intensity of the five emotions]\\nBalanced or Not Balanced: [ChatGPTs assesment whether the primary and secondary emotions are balanced or not balanced (1 means balanced, 0 means not balanced)]" },{ "role": "user", "content": "Can you provide an answer in the form of json of 'Primary Emotion' and 'confidence' score for the primary emotion for the following text:" }]""") messages[2]["content"] += output if("messages" in event): messages = event["messages"] if("max_tokens" in event): max_tokens = event["max_tokens"] if("temperature" in event): temperature = event["temperature"] response = chatgpt_inference(messages = messages, model = model, max_tokens=max_tokens, temperature=temperature) if response and "choices" in response: assistant_message = response["choices"][0]["message"]["content"] assistant_data = json.loads(assistant_message) primary_emotion = assistant_data.get("Primary Emotion") confidence_score = assistant_data.get("Confidence") response = { "Primary Emotion": primary_emotion, "Confidence Score": confidence_score } return { 'statusCode': 200, 'output': output, 'response': response, 'body': 'Processing completed successfully.' }

2024-01-10

xfsnow/python

AzureOpenAI~langchain_embed.py

#!pip install pypdf #!pip install "langchain[docarray]" #!pip install -U docarray #!pip install VectorstoreIndexCreator # !pip install langchain #将内部文档嵌入 from langchain.document_loaders import PyPDFLoader from langchain.indexes import VectorstoreIndexCreator from langchain.llms import AzureOpenAI from langchain.vectorstores import DocArrayInMemorySearch from langchain.embeddings import OpenAIEmbeddings import openai import os OPENAI_API_TYPE = "Azure" OPENAI_API_VERSION = "2022-12-01" OPENAI_API_BASE = os.environ.get('AZURE_OPENAI_ENDPOINT') OPENAI_API_KEY = os.environ.get('AZURE_OPENAI_API_KEY') #Azure OpenAI embedding 配置 embedding = OpenAIEmbeddings( client= openai, model = "text-embedding-ada-002", deployment = 'embedding', openai_api_base = OPENAI_API_BASE, openai_api_type = OPENAI_API_TYPE, openai_api_key = OPENAI_API_KEY, chunk_size = 1 ) llm = AzureOpenAI( openai_api_base = OPENAI_API_BASE, openai_api_type = OPENAI_API_TYPE, openai_api_key = OPENAI_API_KEY, openai_api_version = OPENAI_API_VERSION, temperature=0.0, deployment_name="gpt-35-turbo-16k", model="gpt-35-turbo-16k" ) loader = PyPDFLoader("AzureOpenAI/invoice.pdf") index = VectorstoreIndexCreator( vectorstore_cls=DocArrayInMemorySearch, embedding=embedding ).from_loaders([loader]) query ="发票总金额是多少，什么公司的发票？" response = index.query(query, llm=llm) print(response)

2024-01-10

xfsnow/python

AzureOpenAI~embed_csv.py

# https://learn.microsoft.com/en-us/azure/cognitive-services/openai/tutorials/embeddings import openai import os import re from num2words import num2words import os import pandas as pd from openai.embeddings_utils import get_embedding, cosine_similarity import tiktoken # s is input text def normalize_text(s, sep_token = " \n "): s = re.sub(r'\s+', ' ', s).strip() s = re.sub(r". ,","",s) # remove all instances of multiple spaces s = s.replace("..",".") s = s.replace(". .",".") s = s.replace("\n", "") s = s.strip() return s # search through the reviews for a specific product def search_docs(df, engine_name, user_query, top_n=3, to_print=True): # engine should be set to the deployment name you chose when you deployed the text-embedding-ada-002 (Version 2) model embedding = get_embedding( user_query, engine=engine_name ) df["similarities"] = df.ada_v2.apply(lambda x: cosine_similarity(x, embedding)) res = ( df.sort_values("similarities", ascending=False) .head(top_n) ) if to_print: print(res) return res OPENAI_KEY = os.getenv("AZURE_OPENAI_API_KEY") OPENAI_ENDPOINT = os.getenv("AZURE_OPENAI_ENDPOINT") openai.api_type = "azure" openai.api_key = OPENAI_KEY openai.api_base = OPENAI_ENDPOINT # openai.api_version = "2022-12-01" openai.api_version = "2023-03-15-preview" # url = OPENAI_ENDPOINT + "/openai/deployments?api-version=" + openai.api_version # request_headers = {"api-key": OPENAI_KEY} # # 发送请求，并输出详细请求信息和返回信息 # r = requests.get(url, headers=request_headers) # # 解析返回的json，提取 data中的 model和id，再以表格形式打印出来 # # print(r.text) # data = r.json() # df = pd.DataFrame(data['data']) # # 只输出 id 和 model 2 列 # df_id_model = df[['id','model']] # print(df_id_model) # This assumes that you have placed the bill_sum_data.csv in the same directory you are running Jupyter Notebooks # print(os.getcwdb()) df=pd.read_csv('./AzureOpenAI/bill_sum_data.csv') df_bills = df[['text','summary', 'title']] # print(df_bills) df_bills['text']= df_bills["text"].apply(lambda x : normalize_text(x)) tokenizer = tiktoken.get_encoding("cl100k_base") df_bills['n_tokens'] = df_bills["text"].apply(lambda x: len(tokenizer.encode(x))) df_bills = df_bills[df_bills.n_tokens<8192] # print(df_bills) sample_encode = tokenizer.encode(df_bills.text[0]) decode = tokenizer.decode_tokens_bytes(sample_encode) print(len(decode)) # 注意这里要使用Deployment的名称，而不是Deployment使用的Model name: text-embedding-ada-002 (Version 2) engine_embedding_name = "embedding" df_bills['ada_v2'] = df_bills["text"].apply(lambda x : get_embedding(x, engine = engine_embedding_name)) # print(df_bills) res = search_docs(df_bills, engine_embedding_name, "Can I get information on cable company tax revenue?", top_n=4) # 显示第一条记录的summary print(res.summary.iloc[0])

2024-01-10

nerdalert/docbot

docbot.py

import os from flask import Flask, render_template, request, redirect from llama_index import download_loader from llama_index import LLMPredictor, GPTSimpleVectorIndex, PromptHelper, ServiceContext from langchain import OpenAI os.environ["OPENAI_API_KEY"] = "insert_your_key_here" current_script_path = os.path.dirname(os.path.abspath(__file__)) doc_path = os.path.join(current_script_path, 'data') + '/' index_file = 'index.json' app = Flask(__name__) app.config['UPLOAD_FOLDER'] = doc_path app.config['MAX_CONTENT_LENGTH'] = 10 * 1024 * 1024 # 10 MB max file size def send_click(prompt): if index is None: return "Index not loaded. Please upload a file first." response = index.query(prompt) return response index = None @app.route('/', methods=['GET', 'POST']) def index_page(): global index if request.method == 'POST': if 'file' not in request.files: return redirect(request.url) file = request.files['file'] if file.filename == '': return redirect(request.url) file.save(os.path.join(app.config['UPLOAD_FOLDER'], file.filename)) SimpleDirectoryReader = download_loader("SimpleDirectoryReader") loader = SimpleDirectoryReader(doc_path, recursive=True, exclude_hidden=True) documents = loader.load_data() llm_predictor = LLMPredictor(llm=OpenAI(temperature=0, model_name="gpt-3.5-turbo")) max_input_size = 4096 num_output = 256 max_chunk_overlap = 20 prompt_helper = PromptHelper(max_input_size, num_output, max_chunk_overlap) service_context = ServiceContext.from_defaults(llm_predictor=llm_predictor, prompt_helper=prompt_helper) index = GPTSimpleVectorIndex.from_documents( documents, service_context=service_context ) index.save_to_disk(index_file) elif os.path.exists(index_file): index = GPTSimpleVectorIndex.load_from_disk(index_file) return render_template('index.html') @app.route('/query', methods=['POST']) def query(): if index is None: return {'response': 'Index not loaded. Please upload a file first.'} prompt = request.form['prompt'] response = send_click(prompt) return {'response': str(response)} if __name__ == '__main__': # Run flask with the following defaults app.run(debug=True, port=5000, host='0.0.0.0', )

2024-01-10

BizAITeam/hakaton_team_2

tonai.py

import json from typing import List, Optional import requests from pydantic import Extra from langchain.callbacks.manager import CallbackManagerForLLMRun from langchain.llms.base import LLM import requests class TonAI(LLM): def __init__(self, tonai_api_key, temperature=0.6, service_name="chat", *args, **kwargs): super().__init__(*args, **kwargs) allowed_service_names = ["chat"] if service_name not in allowed_service_names: raise ValueError(f"Invalid service_name. Allowed values are: {', '.join(allowed_service_names)}") if not isinstance(tonai_api_key, str): raise ValueError("TonAI key must be a string") if not tonai_api_key: raise ValueError("TonAI key must not be empty") if not isinstance(self.endpoint_url, str) or not self.endpoint_url.startswith(("http://", "https://")): raise ValueError("Url must be a valid URL starting with 'http://' or 'https://'") if not isinstance(temperature, float) or temperature < 0: raise ValueError("Temperature must be a non-negative float") response = requests.get(self.endpoint_url, headers={"key": tonai_api_key}) if response.ok: try: data = response.json() except json.JSONDecodeError as e: raise ValueError(f"Invalid JSON response: {e}") from None else: raise ValueError(f"Request failed with status code {response.status_code}") services = data['services'] for item in services: if item['name'] == service_name: self.service_id = item['id'] self.parameter_name = item['params']['required'][0]['name'] break else: raise ValueError("No matching element found") self.temperature = temperature self.tonai_api_key = tonai_api_key endpoint_url: str = "https://tonai.tech/api/public/v1/services" """Endpoint URL to use.""" temperature: float = 0 """A non-negative float that tunes the degree of randomness in generation.""" tonai_api_key: str = "" """This is the access key for accessing the neural network.""" service_id: str = "" """This is the ID of the service provided by TonAI.""" parameter_name: str = "" class Config: """Configuration for this pydantic object.""" extra = Extra.forbid @property def _llm_type(self) -> str: """Return type of llm.""" return "ton_ai" def _call( self, message: str, stop: Optional[List[str]] = None, run_manager: Optional[CallbackManagerForLLMRun] = None, ) -> str: headers = {"key": self.tonai_api_key} payload = { 'service_id': self.service_id, 'temperature': self.temperature } payload[self.parameter_name] = json.dumps(message, ensure_ascii=False) try: response = requests.post(url=self.endpoint_url, json=payload, headers=headers) response.raise_for_status() response_data = response.json() except requests.exceptions.RequestException as e: raise ValueError(f"Error raised by inference endpoint: {e}") except json.JSONDecodeError as e: raise ValueError(f"Invalid JSON response: {e}") from None if "error" in response_data: raise ValueError(f"Error raised by inference API: {response_data['error']}") answer = response_data['messages'][0]['text'] return answer

2024-01-10

Tanjim-Islam/voice-chatbot

gptbot.py

import openai import pyttsx3 import speech_recognition as sr from api_key import API_KEY from googletrans import Translator # import keyboard openai.api_key = API_KEY engine = pyttsx3.init() r = sr.Recognizer() mic = sr.Microphone() translator = Translator() conversation = "" user_name = "You" bot_name = "Jarvis" while True: with mic as source: print("\nlistening...") r.adjust_for_ambient_noise(source, duration=0.2) try: audio = r.listen(source, timeout=0.2) print("Audio captured.") except sr.WaitTimeoutError: print("Timeout Error: No speech detected.") continue except Exception as e: print("Error:", e) continue print("no longer listening.\n") try: user_input = r.recognize_google(audio) print("Recognized:", user_input) except: continue lang = translator.detect(user_input).lang if lang == 'bn': user_input = translator.translate(user_input, dest='en').text prompt = user_name + ": " + user_input + "\n" + bot_name+ ": " conversation += prompt # fetch response from open AI api response = openai.Completion.create(engine='text-davinci-003', prompt=conversation, max_tokens=100) response_str = response["choices"][0]["text"].replace("\n", "") response_str = response_str.split(user_name + ": ", 1)[0].split(bot_name + ": ", 1)[0] conversation += response_str + "\n" if lang == 'bn': response_str = translator.translate(response_str, dest='bn').text print(response_str) engine.say(response_str) engine.runAndWait()

2024-01-10

yhoshi3/RaLLe

ralle~llms~initialize.py

# Copyright (c) Kioxia corporation and its affiliates. # # This source code is licensed under the MIT license found in the # LICENSE file in the root directory of this source tree. import importlib from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline, TextIteratorStreamer import torch def initialize_llm(model_args={}, pipeline_args={}): if model_args['model_type'] == 'openai': import openai import os openai.api_type = os.getenv("AZURE_OPENAI_API_TYPE") openai.api_base = os.getenv("AZURE_OPENAI_API_BASE") openai.api_version = os.getenv("AZURE_OPENAI_API_VERSION") openai.api_key = os.getenv("AZURE_OPENAI_API_KEY") openai.proxy = { "http": os.getenv("AZURE_OPENAI_PROXY"), "https": os.getenv("AZURE_OPENAI_PROXY") } # os.environ["http_proxy"] = os.getenv("AZURE_OPENAI_PROXY") # os.environ["https_proxy"] = os.getenv("AZURE_OPENAI_PROXY") def generate_fn(prompts): if isinstance(prompts, str): print('single mode llm function is called') response = openai.ChatCompletion.create( engine="gpt-35-turbo", max_tokens=1000, messages=[ {"role": "user", "content": prompts} ] ) # return '{}: {}'.format(response['usage']['total_tokens'], response['choices'][0]['message']['content']) return response['choices'][0]['message']['content'] elif isinstance(prompts, list): print('batch mode llm function is called') results = [] for p in prompts: res = openai.ChatCompletion.create( engine="gpt-35-turbo", max_tokens=1000, messages=[ {"role": "user", "content": p} ] ) print('openai response: {}'.format(res)) # out = '{}: {}'.format(res['usage']['total_tokens'], res['choices'][0]['message']['content']) out = res['choices'][0]['message']['content'] results.append(out) return results else: raise ValueError return generate_fn, None else: quantization_module = importlib.import_module('.'.join(model_args['quantization_config']['quantization_type'].split('.')[:-1])) quantization_class = getattr(quantization_module, model_args['quantization_config']['quantization_type'].split('.')[-1]) quantization_config_config = model_args['quantization_config']['quantization_config_config'] quantization_config = quantization_class(**quantization_config_config) print('Loading Tokenizer...') tokenizer = AutoTokenizer.from_pretrained(model_args['model_type']) streamer = TextIteratorStreamer(tokenizer, skip_prompt=True, skip_special_tokens=True) model_kwargs = model_args.copy() del model_kwargs['model_type'], model_kwargs['device_map'], model_kwargs['quantization_config'] print('Loading LLM model...') model = AutoModelForCausalLM.from_pretrained( model_args['model_type'], device_map=model_args['device_map'], quantization_config=quantization_config, torch_dtype=torch.float16, **model_kwargs) model.eval() pipe = pipeline("text-generation", model=model, tokenizer=tokenizer, streamer=streamer, **pipeline_args) def generate_fn(prompts, **kwargs): if isinstance(prompts, str): print('single mode llm function is called') return pipe([prompts], **kwargs)[0][0]["generated_text"][len(prompts) :] elif isinstance(prompts, list): print('batch mode llm function is called') outputs = pipe(prompts, **kwargs) results = [out[0]["generated_text"][len(prompt) :] for prompt, out in zip(prompts, outputs)] return results else: raise ValueError return generate_fn, streamer

2024-01-10

javalover0809/chaunhuRobot

modules~index_func.py

import os import logging import hashlib import PyPDF2 from tqdm import tqdm from modules.presets import * from modules.utils import * from modules.config import local_embedding def get_documents(file_src): from langchain.schema import Document from langchain.text_splitter import TokenTextSplitter text_splitter = TokenTextSplitter(chunk_size=500, chunk_overlap=30) documents = [] logging.debug("Loading documents...") logging.debug(f"file_src: {file_src}") for file in file_src: filepath = file.name filename = os.path.basename(filepath) file_type = os.path.splitext(filename)[1] logging.info(f"loading file: {filename}") try: if file_type == ".pdf": logging.debug("Loading PDF...") try: from modules.pdf_func import parse_pdf from modules.config import advance_docs two_column = advance_docs["pdf"].get("two_column", False) pdftext = parse_pdf(filepath, two_column).text except: pdftext = "" with open(filepath, "rb") as pdfFileObj: pdfReader = PyPDF2.PdfReader(pdfFileObj) for page in tqdm(pdfReader.pages): pdftext += page.extract_text() texts = [Document(page_content=pdftext, metadata={"source": filepath})] elif file_type == ".docx": logging.debug("Loading Word...") from langchain.document_loaders import UnstructuredWordDocumentLoader print('filepath是') print(filepath) loader = UnstructuredWordDocumentLoader(filepath) print('loader是') print(loader) texts = loader.load() print("texts是2：") print(texts) elif file_type == ".pptx": logging.debug("Loading PowerPoint...") from langchain.document_loaders import UnstructuredPowerPointLoader loader = UnstructuredPowerPointLoader(filepath) texts = loader.load() elif file_type == ".epub": logging.debug("Loading EPUB...") from langchain.document_loaders import UnstructuredEPubLoader loader = UnstructuredEPubLoader(filepath) texts = loader.load() elif file_type == ".xlsx": logging.debug("Loading Excel...") text_list = excel_to_string(filepath) texts = [] for elem in text_list: texts.append(Document(page_content=elem, metadata={"source": filepath})) else: logging.debug("Loading text file...") from langchain.document_loaders import TextLoader loader = TextLoader(filepath, "utf8") texts = loader.load() except Exception as e: import traceback logging.error(f"Error loading file: {filename}") traceback.print_exc() print("texts文本是：") print(texts) texts = text_splitter.split_documents(texts) documents.extend(texts) logging.debug("Documents loaded.") return documents def construct_index( api_key, file_src, max_input_size=4096, num_outputs=5, max_chunk_overlap=20, chunk_size_limit=600, embedding_limit=None, separator=" ", ): from langchain.chat_models import ChatOpenAI from langchain.vectorstores import FAISS if api_key: os.environ["OPENAI_API_KEY"] = api_key else: # 由于一个依赖的愚蠢的设计，这里必须要有一个API KEY os.environ["OPENAI_API_KEY"] = "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" chunk_size_limit = None if chunk_size_limit == 0 else chunk_size_limit embedding_limit = None if embedding_limit == 0 else embedding_limit separator = " " if separator == "" else separator print('file_src是') print(file_src) index_name = get_file_hash(file_src) print('index_name是') print(index_name) index_path = f"./index/{index_name}" if local_embedding: from langchain.embeddings.huggingface import HuggingFaceEmbeddings print('上面1') embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/distiluse-base-multilingual-cased-v2") else: from langchain.embeddings import OpenAIEmbeddings print('下面2') if os.environ.get("OPENAI_API_TYPE", "openai") == "openai": embeddings = OpenAIEmbeddings(openai_api_base=os.environ.get( "OPENAI_API_BASE", None), openai_api_key=os.environ.get("OPENAI_EMBEDDING_API_KEY", api_key)) else: embeddings = OpenAIEmbeddings(deployment=os.environ["AZURE_EMBEDDING_DEPLOYMENT_NAME"], openai_api_key=os.environ["AZURE_OPENAI_API_KEY"], model=os.environ["AZURE_EMBEDDING_MODEL_NAME"], openai_api_base=os.environ["AZURE_OPENAI_API_BASE_URL"], openai_api_type="azure") if os.path.exists(index_path): logging.info("找到了缓存的索引文件，加载中……") return FAISS.load_local(index_path, embeddings) else: print('这里1213') try: documents = get_documents(file_src) print('documents是：') print(documents) logging.info("构建索引中……") with retrieve_proxy(): print('开始retrieve_proxy') print('embeddings是') print(embeddings) index = FAISS.from_documents(documents, embeddings) print(index) logging.debug("索引构建完成！") os.makedirs("./index", exist_ok=True) index.save_local(index_path) logging.debug("索引已保存至本地!") return index except Exception as e: import traceback logging.error("索引构建失败！%s", e) traceback.print_exc() return None

2024-01-10

jeugenio103/Project-4-Test

application.py

from flask import Flask, request, render_template import pandas as pd from config import client_id, client_secret from tensorflow import keras import tensorflow as tf from sklearn.preprocessing import StandardScaler, LabelEncoder from sklearn.preprocessing import OneHotEncoder from sklearn.model_selection import train_test_split import pickle from pathlib import Path import sklearn as skl import spotipy import numpy as np from spotipy.oauth2 import SpotifyClientCredentials import sys client_credentials_manager = SpotifyClientCredentials(client_id,client_secret) sp = spotipy.Spotify(client_credentials_manager=client_credentials_manager) application = Flask(__name__,template_folder='templates',static_url_path='/static') @application.route('/') def home(): return render_template('index.html') @application.route('/visualization') def visualization(): return render_template('visualization.html') @application.route('/lyrics_analysis') def lyrics_analysis(): return render_template('lyrics_analysis.html') @application.route('/lyric_gen') def lyric_gen(): return render_template('lyric_gen.html') @application.route('/about') def about(): return render_template('about.html') @application.route('/predict', methods=['GET','POST']) def predict(): if request.method == 'POST': # Get the track name from the form data track_name = request.form.get('input') from sklearn.preprocessing import StandardScaler from pathlib import Path #Loading CSV File file_path = Path("./Test-Data/equalized_df.csv") df = pd.read_csv(file_path) df=df.drop(columns=["Unnamed: 0","track_id","track","artist","genre","duration_ms"]) from sklearn.preprocessing import StandardScaler scaler = StandardScaler() scaled_data = scaler.fit_transform(df[["acousticness","energy","liveness","loudness","speechiness","valence","tempo","time_signature","danceability","key","instrumentalness","mode"]]) X = df.drop("primary_genre", axis=1) y = df["primary_genre"].values from sklearn.preprocessing import LabelEncoder label_encoder = LabelEncoder() y = label_encoder.fit_transform(y) from sklearn.model_selection import train_test_split X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33, stratify=y, random_state=42) scaler = StandardScaler().fit(X_train) X_train_scaled = scaler.transform(X_train) X_test_scaled = scaler.transform(X_test) if track_name: # Initialize the df2 variable df2 = None # Search for the track results = sp.search(q=track_name, type="track", limit=1) # Get the first track from the search results track = results["tracks"]["items"][0] # Get the track's audio features features = sp.audio_features(track["id"])[0] # Create a Pandas DataFrame with one row df2 = pd.DataFrame([features]) df2 = df2.loc[:,["key","mode","time_signature","acousticness","danceability","energy","instrumentalness","liveness","loudness","speechiness","valence","tempo"]] pickled_model = pickle.load(open('./Lyric and Genre Data Collection/Machine Learning Models/svm_model.pkl', 'rb')) df2_scaled = scaler.transform(df2) prediction = pickled_model.predict(df2_scaled) predicted_genre = label_encoder.inverse_transform(prediction) prediction_string = "".join(predicted_genre) prediction_string = prediction_string.replace('[','').replace(']','') else: prediction_string = "" # Return the predicted genre to the HTML template return render_template('index.html', input=track_name, prediction_string=prediction_string) else: return render_template('index.html') @application.route('/lyric', methods=['GET','POST']) def lyric(): topic = request.form["topic"] artist = request.form["artist1"] from openai_key import key prompt_text = "Artist: {} \n\nTopic: {} \n\nLyrics:\n".format(artist, topic) import openai openai.api_key = key response = openai.Completion.create( model="davinci:ft-personal-2023-01-05-06-24-18", prompt=prompt_text, max_tokens=256, temperature=0.7, frequency_penalty=0.5, stop=["\n###END"] ) lyric_string = "".join(response['choices'][0]['text']) # lyric_string = lyric_string.replace('[','').replace(']','') # prediction_string = "".join(prompt_text) # prediction_string = prediction_string.replace('[','').replace(']','') # options = request.form.getlist("options") # request.method == 'POST' # prompt_text = request.form.get('input') # prediction_string = "".join(prompt_text) def format_lyrics(lyrics): from string import ascii_letters, punctuation nl_char_after = "])" nl_char_before = "[" allowed = set(ascii_letters) allowed_punc = set(punctuation) allowed |= allowed_punc allowed |= set(" ") lyric_str = "" prev_char = "" for char in lyrics: if char in allowed: if char in nl_char_after: lyric_str = lyric_str + char + "\n" elif char in nl_char_before or ((prev_char not in allowed) and char.isupper()): lyric_str = lyric_str + "\n" + char else: lyric_str = lyric_str + char prev_char = char else: prev_char = char new_str = "" for index in range(0, len(lyric_str)): if lyric_str[index] == '#': break if index+1 == len(lyric_str): new_str = new_str + lyric_str[index] break else: prev = lyric_str[index] after = lyric_str[index+1] if prev in allowed_punc or prev == " ": new_str = new_str + prev elif prev.islower() and after.isupper(): new_str = new_str + prev + "\n" else: new_str = new_str + prev # Remove any double spaces import re new_str = re.sub(' +', ' ', new_str) return new_str import string lyric_array = format_lyrics(lyric_string) lyric_array = lyric_array.split('\n') return render_template('lyric_gen.html', topic=topic, lyric_string=lyric_array, artist=artist) if __name__ == '__main__': application.run(debug=True)

2024-01-10

5l1v3r1/CommandGPT

command_gpt~command_gpt.py

from __future__ import annotations from typing import List, Optional from pydantic import ValidationError from langchain.chains.llm import LLMChain from langchain.chat_models.base import BaseChatModel from langchain.schema import ( AIMessage, BaseMessage, Document, HumanMessage, SystemMessage, ) from langchain.tools.base import BaseTool from langchain.vectorstores.base import VectorStoreRetriever from command_gpt.utils.command_parser import GPTCommand, CommandGPTOutputParser, COMMAND_FORMAT from command_gpt.utils.console_logger import ConsoleLogger from command_gpt.prompting.prompt import CommandGPTPrompt from command_gpt.utils.evaluate import get_filesystem_representation class CommandGPT: """Agent class driving CommandGPT loop""" def __init__( self, memory: VectorStoreRetriever, chain: LLMChain, output_parser: CommandGPTOutputParser, tools: List[BaseTool], ): self.memory = memory self.full_message_history: List[BaseMessage] = [] self.next_action_count = 0 self.chain = chain self.output_parser = output_parser self.tools = tools @classmethod def from_ruleset_and_tools( cls, ruleset: str, memory: VectorStoreRetriever, tools: List[BaseTool], llm: BaseChatModel, output_parser: Optional[CommandGPTOutputParser] = None, ) -> CommandGPT: prompt = CommandGPTPrompt( ruleset=ruleset, tools=tools, input_variables=["memory", "messages", "user_input"], token_counter=llm.get_num_tokens, ) chain = LLMChain(llm=llm, prompt=prompt) return cls( memory, chain, output_parser or CommandGPTOutputParser(), tools, ) def run(self) -> str: """ Kicks off interaction loop with AI """ system_message = ( "Think out loud and always have a back up plan. Use commands to achieve the defined goals. Do not ask for my input. Always provide commands." ) # Interaction Loop loop_count = 0 while True: loop_count += 1 messages = self.full_message_history # todo: build in human input # user_input = ConsoleLogger.input("You: ") # Get file system representation & append to messages files = get_filesystem_representation(verbose=False) system_message = f"Current loop count: {loop_count}\nFiles: {files} \nUse commands to achieve the defined goals. Do not ask for my input. Always provide commands." # Set response color for console logger ConsoleLogger.set_response_stream_color() # Send message to AI, get response assistant_reply = self.chain.run( messages=messages, memory=self.memory, user_input=system_message, ) # Update message history self.full_message_history.append( HumanMessage(content=system_message)) # self.full_message_history.append(SystemMessage(content=system_message)) self.full_message_history.append( AIMessage(content=assistant_reply)) # Parse command and execute tools = {t.name: t for t in self.tools} action = self.output_parser.parse(assistant_reply) command_result = self.try_execute_command(tools, action) memory_to_add = ( f"Assistant Reply: {assistant_reply} " f"\nResult: {command_result} " ) self.memory.add_documents([Document(page_content=memory_to_add)]) self.full_message_history.append( SystemMessage(content=command_result)) def try_execute_command(self, tools_available: List[BaseTool], command: GPTCommand): """ Executes a command if available in tools, otherwise returns an error message """ if command.name == "finish": return command.args["response"] if command.name in tools_available: tool = tools_available[command.name] try: observation = tool.run(command.args) except ValidationError as e: observation = ( f"Validation Error in args: {str(e)}, args: {command.args}" ) except Exception as e: observation = ( f"Error: {str(e)}, {type(e).__name__}, args: {command.args}" ) result = f"Command {tool.name} returned: {observation}" elif command.name == "ERROR": ConsoleLogger.log_error("Command not parsed") result = f"Improperly formatted command line. Proper formatting:\n\n {COMMAND_FORMAT}" else: result = ( f"Unknown command '{command.name}'. Please refer to the Commands list for available commands and only respond in the specified command line format." ) return result

2024-01-10

5l1v3r1/CommandGPT

command_gpt~prompting~ruleset_generator.py

from __future__ import annotations from typing import List from langchain.vectorstores import FAISS from langchain.docstore import InMemoryDocstore from langchain.embeddings import OpenAIEmbeddings from langchain.chains.llm import LLMChain from langchain.chat_models.base import BaseChatModel from langchain.schema import ( AIMessage, BaseMessage, Document, HumanMessage, SystemMessage, ) from langchain.vectorstores.base import VectorStoreRetriever import faiss from command_gpt.utils.console_logger import ConsoleLogger from command_gpt.prompting.ruleset_prompt import RulesetPrompt class RulesetGeneratorAgent: """Driving class for Agent that generates a ruleset for CommandGPT""" def __init__( self, request: str, topic: str, chain: LLMChain, memory: VectorStoreRetriever = None, ): self.request = request self.topic = topic self.user_feedback: List[str] = [] self.generated_ruleset: str = None self.memory = memory self.full_message_history: List[BaseMessage] = [] self.next_action_count = 0 self.chain = chain @classmethod def from_request_and_topic( cls, request: str, topic: str, llm: BaseChatModel, ) -> RulesetGeneratorAgent: """ Instantiate RulesetGeneratorAgent from request and topic :param request: Inserted as "Generate an input summary that will instruct CommandGPT to {request}: " :param topic: Inserted as "...instruct CommandGPT to {request}: {topic}" """ prompt = RulesetPrompt( ruleset_that_will=request, topic=topic, input_variables=["memory", "messages"], token_counter=llm.get_num_tokens, ) # Define your embedding model embeddings_model = OpenAIEmbeddings() # Initialize the vectorstore as empty embedding_size = 1536 index = faiss.IndexFlatL2(embedding_size) vectorstore = FAISS(embeddings_model.embed_query, index, InMemoryDocstore({}), {}) chain = LLMChain(llm=llm, prompt=prompt) return cls( request=request, topic=topic, chain=chain, memory=vectorstore.as_retriever() ) @classmethod def from_request_prompt_for_topic( cls, request: str, prompt_for_topic: str, llm: BaseChatModel, ) -> RulesetGeneratorAgent: """ Get topic from user and instantiate RulesetGeneratorAgent from request and topic :param request: Inserted as "Generate an input summary that will instruct CommandGPT to {request}: " :param prompt_for_topic: Input prompt displayed to user for getting topic """ # Get topic from user topic = ConsoleLogger.input(f"{prompt_for_topic}: ") return RulesetGeneratorAgent.from_request_and_topic( request=request, topic=topic, llm=llm ) @classmethod def from_empty_prompt_for_request_and_topic( cls, llm: BaseChatModel, ) -> RulesetGeneratorAgent: """ Get request & topic both from user and instantiate RulesetGeneratorAgent """ # Get request from user request = ConsoleLogger.input( f"Generate an input summary that will instruct CommandGPT to (e.g. \"research and generate reports on \"): ") topic = ConsoleLogger.input(f"Topic (e.g. \"Tardigrades\"): ") return RulesetGeneratorAgent.from_request_and_topic( request=request, topic=topic, llm=llm ) def run(self) -> str: """ Kicks off interaction loop with AI """ # Note about ruleset generator ConsoleLogger.log("\nNOTE: The ruleset generator is a work in progress. Providing feedback for refined rulesets is experimental; keep it concise for best results. Feedback is appreciated :)\n", color=ConsoleLogger.COLOR_MAGENTA) # Interaction Loop loop_count = 0 while True: # user_input = ConsoleLogger.input("You: ") loop_count += 1 messages = self.full_message_history messages.append( SystemMessage( content=f"Loop count: {loop_count}" ) ) # Get user input beyond initial prompt if (loop_count > 1): user_input = ConsoleLogger.input( "Type (y) and hit enter if this ruleset is acceptable. Otherwise, provide feedback for a new one: ") if user_input == "y": return self.generated_ruleset else: self.user_feedback.append(user_input) # Update prompt with user feedback if exists if self.user_feedback: # todo: use user feedback in a more fine tuned way prompt = RulesetPrompt( ruleset_that_will=self.request, topic=self.topic, generated_ruleset=self.generated_ruleset, input_variables=["memory", "messages"], token_counter=self.chain.llm.get_num_tokens, user_feedback=user_input ) self.chain.prompt = prompt ConsoleLogger.log( f"FULL PROMPT:\n\n{self.chain.prompt.construct_full_prompt()}\n", color=ConsoleLogger.COLOR_INPUT ) # Set response color for console logger ConsoleLogger.set_response_stream_color() # Send message to AI, get response self.generated_ruleset = self.chain.run( messages=messages, memory=self.memory, user_input="You're doing great. Without any other niceties, provide a ruleset with no additional text before or after. Your message should start with \"You are xxx-GPT...\"", ) # Update message history self.full_message_history.append(HumanMessage( content="Generate a new ruleset consistent with the original request and the user's feedback." )) self.full_message_history.append( AIMessage(content=self.generated_ruleset)) self.memory.add_documents([Document( page_content=self.generated_ruleset, metadata={ "ruleset_count": f"{loop_count}" } )])

2024-01-10

5l1v3r1/CommandGPT

command_gpt~tooling~toolkits.py

from abc import ABC from pathlib import Path from typing import List from langchain import GoogleSearchAPIWrapper from langchain.agents import Tool from langchain.tools import BaseTool from langchain.tools.file_management import ( ReadFileTool, ListDirectoryTool, ) from langchain.tools.human.tool import HumanInputRun from config import GOOGLE_API_KEY, GOOGLE_CSE_ID, WORKSPACE_DIR from command_gpt.utils.custom_stream import CustomStreamCallback from command_gpt.tooling.tools import SearchAndWriteTool, WriteFileToolNewlines WORKSPACE_PATH = Path(WORKSPACE_DIR) class BaseToolkit(ABC): """ Base Toolkit with tools initialized for the project, stored in a dict. - Use get_toolkit() to get the List[BaseTool] for this toolkit. - Available Tools: ["search", "write_file", "read_file", "list_directory", "finish", "human_input"] """ def __init__(self): super().__init__() # region Search/Web # - Custom Google Search API Wrapper used by SearchAndWriteTool to run a search query and automatically write the results to a file (saving resources) search = GoogleSearchAPIWrapper( google_api_key=GOOGLE_API_KEY, google_cse_id=GOOGLE_CSE_ID, ) search_and_write = SearchAndWriteTool(search) search_tool = Tool( name="search", func=search_and_write.run, description="Gather search results from query (they will automatically be written to a file called 'results_{query}').", callbacks=[CustomStreamCallback()] ) # endregion # region File Management # - Tools for reading, writing, and listing files in the workspace directory # - Note: WriteFileToolNewlines is a simple extension of WriteFileTool that re-writes new line characters properly for file writing write_file_tool = WriteFileToolNewlines( root_dir=WORKSPACE_DIR, callbacks=[CustomStreamCallback()] ) read_file_tool = ReadFileTool( root_dir=WORKSPACE_DIR, callbacks=[CustomStreamCallback()] ) list_directory_tool = ListDirectoryTool( root_dir=WORKSPACE_DIR, description="List files to read from or append to.", callbacks=[CustomStreamCallback()] ) # endregion # region Other finish_tool = Tool( name="finish", func=lambda: None, description="End the program.", callbacks=[CustomStreamCallback()] ) human_input_tool = Tool( name="human_input", func=HumanInputRun, description="Get input from a human if you find yourself overly confused.", callbacks=[CustomStreamCallback()] ) # endregion # region TOOLS DICTIONARY # - Adds tools to dictionary accessible by name self.tools = { 'search': search_tool, 'write_file': write_file_tool, 'read_file': read_file_tool, 'list_directory': list_directory_tool, 'finish': finish_tool, 'human_input': human_input_tool } # endregion def get_toolkit(self) -> List[BaseTool]: """ Return the list of tools for this toolkit. """ return list(self.tools.values()) class MemoryOnlyToolkit(BaseToolkit): """ Basic Toolkit with only file management tools (no search/web) - Available tools: ["write_file", "read_file", "list_directory", "finish", "human_input"] """ def get_toolkit(self) -> List[BaseTool]: """ Return a modified list of tools for this toolkit, excluding search/web tools. """ return [tool for tool in super().get_toolkit() if tool.name not in ['search']]

2024-01-10

5l1v3r1/CommandGPT

command_gpt~prompting~ruleset_prompt.py

# Full prompt with base prompt, time, memory, and historical messages from typing import Any, Callable, List from pydantic import BaseModel from langchain.prompts.chat import ( BaseChatPromptTemplate, ) from langchain.schema import BaseMessage, SystemMessage from langchain.vectorstores.base import VectorStoreRetriever class RulesetPrompt(BaseChatPromptTemplate, BaseModel): """ Prompt template for Ruleset Generator with base prompt, memory, and historical messages. Gets full prompt from prompt_generator.py. """ ruleset_that_will: str = "conduct research and generate reports on" topic: str = "the effects of climate change on the economy" generated_ruleset: str = None user_feedback: str = "" token_counter: Callable[[str], int] send_token_limit: int = 3000 def construct_full_prompt(self) -> str: ruleset_request = f"CommandGPT is an LLM driven application that operates in a continuous manner to achieve goals and fulfill a given purpose. The AI is prompted to use commands in order to interface with it's virtual environment.\n\nA ruleset is provided to the AI throughout it's lifecycle with the goal of keeping it on track autonomously long-term. The AI frequently loses context on information, forgets to write content, and gets stuck in repetitive cycles, so the purpose stated in the ruleset (an AI designed to...) needs to be detailed and guiding, including specific instructions around writing files and writing higher order content (the format will depend on the request).\n\nIn general, the ruleset should: \n- Instruct the AI to meticulously write content to detailed markdown (.md) files\n- be tailored to the content requested\n- be structured in a way that is easy to understand and act on for an LLM. \n- be phrased as \"You are xxx-gpt (filling in a descriptive & relevant name), an AI designed to...\" \n- should be followed by a sensible outline/breakdown of how it will do this within the context of the request & topic.\n\nGenerate an input summary that will instruct CommandGPT to {self.ruleset_that_will}:\n\n{self.topic}\n\nEnsure that the output includes only the ruleset, starting with the previously mentioned phrase \"You are xxx-gpt...\", as it will be used to kick off the AI's lifecycle." # If a ruleset hasn't been generated yet, just request one if self.generated_ruleset is None: return ruleset_request # If a ruleset has been generated, request a new one that incorporates user feedback new_ruleset_request = f"User: Thank you for this! Please provide an additional ruleset with the following in mind:\n- {self.user_feedback}\n...starting your response with \"You are xxx-gpt\" and providing only the ruleset with no additional text or niceties:\n" return new_ruleset_request def format_messages(self, **kwargs: Any) -> List[BaseMessage]: base_prompt = SystemMessage(content=self.construct_full_prompt()) used_tokens = self.token_counter(base_prompt.content) # Get relevant memory & format into message memory: VectorStoreRetriever = kwargs["memory"] previous_messages = kwargs["messages"] relevant_docs = memory.get_relevant_documents( str(previous_messages[-10:])) relevant_memory = [d.page_content for d in relevant_docs] relevant_memory_tokens = sum( [self.token_counter(doc) for doc in relevant_memory] ) while used_tokens + relevant_memory_tokens > 2500: relevant_memory = relevant_memory[:-1] relevant_memory_tokens = sum( [self.token_counter(doc) for doc in relevant_memory] ) content_format = ( f"This reminds you of events from your past:\n{relevant_memory}\n\n" ) memory_message = SystemMessage(content=content_format) used_tokens += self.token_counter(memory_message.content) # Append historical messages if there is space historical_messages: List[BaseMessage] = [] for message in previous_messages[-10:][::-1]: message_tokens = self.token_counter(message.content) if used_tokens + message_tokens > self.send_token_limit - 1000: break historical_messages = [message] + historical_messages used_tokens += message_tokens messages: List[BaseMessage] = [base_prompt, memory_message] messages += historical_messages return messages

2024-01-10

5l1v3r1/CommandGPT

command_gpt~utils~command_parser.py

import itertools from abc import abstractmethod import re import shlex from typing import Dict, NamedTuple from langchain.schema import BaseOutputParser # Command response format COMMAND_LINE_START = "<cmd>" COMMAND_LINE_END = "</cmd>" COMMAND_FORMAT = f"{COMMAND_LINE_START} command_name --arg1 value1 --arg2 value2{COMMAND_LINE_END}" class GPTCommand(NamedTuple): name: str args: Dict class BaseCommandGPTOutputParser(BaseOutputParser): @abstractmethod def parse(self, text: str) -> GPTCommand: """Return GPTCommand""" def preprocess_json_input(input_str: str) -> str: """ Replace single backslashes with double backslashes, while leaving already escaped ones intact """ corrected_str = re.sub( r'(?<!\\)\\(?!["\\/bfnrt]|u[0-9a-fA-F]{4})', r"\\\\", input_str ) return corrected_str class CommandGPTOutputParser(BaseCommandGPTOutputParser): """ Custom Parser for CommandGPT that extracts the command string from the response and maps it to a GPTCommand. """ def parse(self, text: str) -> GPTCommand: try: start_index = text.find(COMMAND_LINE_START) end_index = text.find( COMMAND_LINE_END, start_index + len(COMMAND_LINE_START)) if start_index == -1 or end_index == -1: raise ValueError( f"Invalid command line format. Expected '{COMMAND_LINE_START}' and '{COMMAND_LINE_END}'") # Extract the command string, stripping any leading/trailing whitespace or newline characters cmd_str = text[start_index + len(COMMAND_LINE_START):end_index].strip() # If the command string starts with a newline, remove it if cmd_str.startswith('\n'): cmd_str = cmd_str[1:] # Use shlex.split to handle quoted arguments correctly cmd_str_splitted = shlex.split(cmd_str) if len(cmd_str_splitted) < 1: raise ValueError( "Command line format error: Missing command name") command_name = cmd_str_splitted.pop(0) command_args = dict(itertools.zip_longest( *[iter(cmd_str_splitted)] * 2, fillvalue="")) # Remove '--' from argument names command_args = {arg.lstrip( '-'): value for arg, value in command_args.items()} return GPTCommand(name=command_name, args=command_args) except Exception as e: # If there is any error in parsing, return an error command return GPTCommand(name="ERROR", args={"error": str(e)})

2024-01-10

h5vx/ugubot

ai~ai_bot.py

import logging from asyncio import Queue import openai from config import settings from . import middleware from .types import AIUsageInfo, IncomingMessage, OutgoingMessage logger = logging.getLogger(__name__) incoming_queue = Queue() outgoing_queue = Queue() class AIBot(object): MIDDLEWARE_CHAIN = ( middleware.DropIncomingIfAIDisabledMiddleware, middleware.StripMessageTextMiddleware, middleware.DropIncomingIfNotAddressedMiddleware, middleware.CommandParserMiddleware, middleware.AlternateModelSwitcherMiddleware, middleware.UsageCommandMiddleware, middleware.UsageInlineCommandMiddleware, middleware.HelpCommandHandlerMiddleware, middleware.UserDefinedPromptMiddleware, middleware.ContextWithPreludeMiddleware, ) def __init__(self) -> None: openai.api_key = settings.openai.api_key self._middlewares = [m() for m in self.MIDDLEWARE_CHAIN] self._clear_context = lambda x: x for mw in self._middlewares: if isinstance(mw, middleware.ContextWithPreludeMiddleware): self._clear_context = mw.clear_context break async def get_completion(self, messages, model): result = await openai.ChatCompletion.acreate( model=model, max_tokens=settings.openai.tokens_reserved_for_response, messages=messages, ) return result async def run(self): while True: message: IncomingMessage = await incoming_queue.get() for mw in self._middlewares: message = mw.incoming(message) if message is None or isinstance(message, OutgoingMessage): break if message is None: continue if isinstance(message, OutgoingMessage): outgoing_queue.put_nowait(message) continue logger.info(f"Start AI completion for message #{message.database_id}") attempts = 2 failed = False context_was_cleared = False while attempts > 0: try: completion = await self.get_completion(message.full_with_context, message.model) failed = False break except Exception as e: logger.exception(e) self._clear_context(message.chat_id) context_was_cleared = True failed = True attempts -= 1 continue if not failed: outgoing_text = completion.choices[0].message.content if context_was_cleared: outgoing_text = "[token limit exceeded, context was cleared] " + outgoing_text outgoing_message = OutgoingMessage( chat_id=message.chat_id, reply_for=message.database_id, text=outgoing_text, model=completion.model, commands=message.commands, usage=AIUsageInfo( prompt_tokens=completion.usage.prompt_tokens, reply_tokens=completion.usage.completion_tokens, total_tokens=completion.usage.total_tokens, ), ) for mw in reversed(self._middlewares): outgoing_message = mw.outgoing(outgoing_message) if outgoing_message is None: break if outgoing_message: outgoing_queue.put_nowait(outgoing_message)

2024-01-10

vladsavelyev/deeplearning

notionbot~notionbot.py

import os from typing import Type import requests from pathlib import Path import re import fire import coloredlogs import pandas as pd import sqlite3 from llama_index import ( GPTSQLStructStoreIndex, LLMPredictor, SQLDatabase, ) from llama_index.readers.schema.base import Document from llama_index.indices.base import BaseGPTIndex from langchain import OpenAI from langchain.llms.base import BaseLLM from langchain.agents import Tool, initialize_agent from langchain.agents.agent import AgentExecutor from langchain.chains.conversation.memory import ConversationBufferMemory from sqlalchemy import create_engine from tqdm import tqdm coloredlogs.install(level="DEBUG") def main(csv_path: str): """ Argument: a path to a CSV file with required entries "Date" and "Journal", e.g. exported from a Notion database. It will build a corresponding SQL database and a correspondng JSON llama-index, whichyou can query with the following questions: > "Что я делал 22 февраля 2022 года?" Играл в теннис. > "Сколько раз я играл в теннис в 2022 году?" 22 раза. > "В какие дни?" Apr 1, Apr 17, May 4, ... """ # Use the turbo ChatGPT which is 10x cheeper. llm = OpenAI(temperature=0, model_name="gpt-3.5-turbo") # type: ignore # Build a unstructured+structured Llama index. index = build_index(Path(csv_path), llm) # Build a Langchain agent that will use our index as a tool. agent = build_agent(index, llm) while True: try: query = input("Enter query: ") except KeyboardInterrupt: break response = agent.run(query) print(response) def build_index(csv_path: Path, llm: BaseLLM) -> BaseGPTIndex: """ Build a Llama-index from a CSV database. Llama index provides multiple ways to index the data. * GPTSimpleVectorIndex only gives AI the most top K similar documents as determined from embeddings, exluding everything else from the context. So there is no way to answer statistical questions. * GPTListIndex iterates over each page (with optional filters), making an expensive ChatGPT query for each journal entry. * GPTTreeIndex recursively summarizes groups of journal entries, essentially removing statistics that could be collected from daily entries. * GPTSQLStructStoreIndex both takes unstrucutred data and structured SQL entries, which like what we need for a table-like data. It still would make an expensive query per each entry, however, we can aggregate them per-month. It still should fit the context length, and keep the total number of documents, and this ChatGPT queries, low. """ TABLE_NAME = "days" # Will write two intermediate files: db_path = csv_path.with_suffix(".db") index_path = csv_path.with_suffix(".json") if db_path.exists() and index_path.exists(): print(f"Loading existing index from disk {index_path} (db: {db_path})") return GPTSQLStructStoreIndex.load_from_disk( str(index_path), sql_database=SQLDatabase(create_engine(f"sqlite:///{db_path}")), table_name=TABLE_NAME, llm_predictor=LLMPredictor(llm), ) # Pre-process the dataframe df = pd.read_csv(csv_path) # Remove non-informative rows df = df.dropna(subset=["Date"]) # Reverse order from old to new df = df.iloc[::-1] # Removing [OLD] and [MOVED] columns df = df.loc[:, ~df.columns.str.contains(r"\[")] # Fix column names with special characters: df.columns = df.columns.str.replace(r"\s", "_", regex=True) # Fix relation fields (they are exported as URLs instead of titles) def _fix_relation_fields(x): if isinstance(x, str): vals = [] for v in x.split(", "): if v.startswith("https://www.notion.so/"): v = re.sub(r"https://www.notion.so/([\w-]+)-\w+", r"\1", v) v = v.replace("-", " ") if v.startswith("https://www.notion.so/"): continue vals.append(v) x = "; ".join(vals) return x df = df.applymap(_fix_relation_fields) df["Journal"] = df["Journal"].fillna("No notes for this day") df["Journal"] = df["Date"] + "\n\n" + df["Journal"] df["Journal"] = df.apply( lambda x: x["Journal"] + "\n\nSelf-reflection:\n" + x["Self-reflection"] if not pd.isna(x["Self-reflection"]) else x["Journal"], axis=1, ) # Translate to English llm_predictor = LLMPredictor(llm) llm_metadata = llm_predictor.get_llm_metadata() max_input_size = llm_metadata.max_input_size prompt_start = "Translate the following into English:\n\n" prompts = [prompt_start[:]] for j in df["Journal"]: if len(prompts[-1]) + len(j) + 2 > max_input_size: prompts.append(prompt_start[:]) prompts[-1] += j + "\n\n" print( f"Translating {len(df)} entries with {len(prompts)} prompts, of character sizes: {[len(p) for p in prompts]}" ) translations = [] for i, p in enumerate(tqdm(prompts)): translation_path = db_path.with_name(f"translation_{i + 1}.txt") if translation_path.exists(): with translation_path.open() as f: translation = f.read() else: print(f"Translating chunk #{i + 1}:\n\n{p[:100]}...") translation = llm.generate([p]).generations[0][0].text with translation_path.open("w") as f: f.write(translation) translations.append(translation) doc = Document("".join(translations)) # Save the CSV to a database conn = sqlite3.connect(db_path) df.to_sql(TABLE_NAME, conn, if_exists="replace", index=True) conn.close() index = GPTSQLStructStoreIndex( [doc], sql_database=SQLDatabase(create_engine(f"sqlite:///{db_path}")), table_name=TABLE_NAME, llm_predictor=llm_predictor, ) index.save_to_disk(str(index_path)) return index def build_agent(index: BaseGPTIndex, llm: BaseLLM) -> AgentExecutor: """ Build a Langchain agent that can can use index as a tool. """ tool = Tool( name="GPT Index", func=lambda q: str(index.query(q)), # For AI to understand when to use the tool: description=""" this tool is useful when you need to answer questions about the author. For example, if I ask you a question about myself, my activities in the past, or other things that only I would know, you can redirect this question to the tool "GPT Index". """, return_direct=True, ) return initialize_agent( tools=[tool], llm=llm, agent="conversational-react-description", memory=ConversationBufferMemory(memory_key="chat_history"), ) if __name__ == "__main__": fire.Fire(main)

2024-01-10

Shmuma/ptan

ptan~experience.py

import gym import torch import random import collections from torch.autograd import Variable import numpy as np from collections import namedtuple, deque from .agent import BaseAgent from .common import utils # one single experience step Experience = namedtuple('Experience', ['state', 'action', 'reward', 'done']) class ExperienceSource: """ Simple n-step experience source using single or multiple environments Every experience contains n list of Experience entries """ def __init__(self, env, agent, steps_count=2, steps_delta=1, vectorized=False): """ Create simple experience source :param env: environment or list of environments to be used :param agent: callable to convert batch of states into actions to take :param steps_count: count of steps to track for every experience chain :param steps_delta: how many steps to do between experience items :param vectorized: support of vectorized envs from OpenAI universe """ assert isinstance(env, (gym.Env, list, tuple)) assert isinstance(agent, BaseAgent) assert isinstance(steps_count, int) assert steps_count >= 1 assert isinstance(vectorized, bool) if isinstance(env, (list, tuple)): self.pool = env else: self.pool = [env] self.agent = agent self.steps_count = steps_count self.steps_delta = steps_delta self.total_rewards = [] self.total_steps = [] self.vectorized = vectorized def __iter__(self): states, agent_states, histories, cur_rewards, cur_steps = [], [], [], [], [] env_lens = [] for env in self.pool: obs = env.reset() # if the environment is vectorized, all it's output is lists of results. # Details are here: https://github.com/openai/universe/blob/master/doc/env_semantics.rst if self.vectorized: obs_len = len(obs) states.extend(obs) else: obs_len = 1 states.append(obs) env_lens.append(obs_len) for _ in range(obs_len): histories.append(deque(maxlen=self.steps_count)) cur_rewards.append(0.0) cur_steps.append(0) agent_states.append(self.agent.initial_state()) iter_idx = 0 while True: actions = [None] * len(states) states_input = [] states_indices = [] for idx, state in enumerate(states): if state is None: actions[idx] = self.pool[0].action_space.sample() # assume that all envs are from the same family else: states_input.append(state) states_indices.append(idx) if states_input: states_actions, new_agent_states = self.agent(states_input, agent_states) for idx, action in enumerate(states_actions): g_idx = states_indices[idx] actions[g_idx] = action agent_states[g_idx] = new_agent_states[idx] grouped_actions = _group_list(actions, env_lens) global_ofs = 0 for env_idx, (env, action_n) in enumerate(zip(self.pool, grouped_actions)): if self.vectorized: next_state_n, r_n, is_done_n, _ = env.step(action_n) else: next_state, r, is_done, _ = env.step(action_n[0]) next_state_n, r_n, is_done_n = [next_state], [r], [is_done] for ofs, (action, next_state, r, is_done) in enumerate(zip(action_n, next_state_n, r_n, is_done_n)): idx = global_ofs + ofs state = states[idx] history = histories[idx] cur_rewards[idx] += r cur_steps[idx] += 1 if state is not None: history.append(Experience(state=state, action=action, reward=r, done=is_done)) if len(history) == self.steps_count and iter_idx % self.steps_delta == 0: yield tuple(history) states[idx] = next_state if is_done: # in case of very short episode (shorter than our steps count), send gathered history if 0 < len(history) < self.steps_count: yield tuple(history) # generate tail of history while len(history) > 1: history.popleft() yield tuple(history) self.total_rewards.append(cur_rewards[idx]) self.total_steps.append(cur_steps[idx]) cur_rewards[idx] = 0.0 cur_steps[idx] = 0 # vectorized envs are reset automatically states[idx] = env.reset() if not self.vectorized else None agent_states[idx] = self.agent.initial_state() history.clear() global_ofs += len(action_n) iter_idx += 1 def pop_total_rewards(self): r = self.total_rewards if r: self.total_rewards = [] self.total_steps = [] return r def pop_rewards_steps(self): res = list(zip(self.total_rewards, self.total_steps)) if res: self.total_rewards, self.total_steps = [], [] return res def _group_list(items, lens): """ Unflat the list of items by lens :param items: list of items :param lens: list of integers :return: list of list of items grouped by lengths """ res = [] cur_ofs = 0 for g_len in lens: res.append(items[cur_ofs:cur_ofs+g_len]) cur_ofs += g_len return res # those entries are emitted from ExperienceSourceFirstLast. Reward is discounted over the trajectory piece ExperienceFirstLast = collections.namedtuple('ExperienceFirstLast', ('state', 'action', 'reward', 'last_state')) class ExperienceSourceFirstLast(ExperienceSource): """ This is a wrapper around ExperienceSource to prevent storing full trajectory in replay buffer when we need only first and last states. For every trajectory piece it calculates discounted reward and emits only first and last states and action taken in the first state. If we have partial trajectory at the end of episode, last_state will be None """ def __init__(self, env, agent, gamma, steps_count=1, steps_delta=1, vectorized=False): assert isinstance(gamma, float) super(ExperienceSourceFirstLast, self).__init__(env, agent, steps_count+1, steps_delta, vectorized=vectorized) self.gamma = gamma self.steps = steps_count def __iter__(self): for exp in super(ExperienceSourceFirstLast, self).__iter__(): if exp[-1].done and len(exp) <= self.steps: last_state = None elems = exp else: last_state = exp[-1].state elems = exp[:-1] total_reward = 0.0 for e in reversed(elems): total_reward *= self.gamma total_reward += e.reward yield ExperienceFirstLast(state=exp[0].state, action=exp[0].action, reward=total_reward, last_state=last_state) def discount_with_dones(rewards, dones, gamma): discounted = [] r = 0 for reward, done in zip(rewards[::-1], dones[::-1]): r = reward + gamma*r*(1.-done) discounted.append(r) return discounted[::-1] class ExperienceSourceRollouts: """ N-step rollout experience source following A3C rollouts scheme. Have to be used with agent, keeping the value in its state (for example, agent.ActorCriticAgent). Yields batches of num_envs * n_steps samples with the following arrays: 1. observations 2. actions 3. discounted rewards, with values approximation 4. values """ def __init__(self, env, agent, gamma, steps_count=5): """ Constructs the rollout experience source :param env: environment or list of environments to be used :param agent: callable to convert batch of states into actions :param steps_count: how many steps to perform rollouts """ assert isinstance(env, (gym.Env, list, tuple)) assert isinstance(agent, BaseAgent) assert isinstance(gamma, float) assert isinstance(steps_count, int) assert steps_count >= 1 if isinstance(env, (list, tuple)): self.pool = env else: self.pool = [env] self.agent = agent self.gamma = gamma self.steps_count = steps_count self.total_rewards = [] self.total_steps = [] def __iter__(self): pool_size = len(self.pool) states = [np.array(e.reset()) for e in self.pool] mb_states = np.zeros((pool_size, self.steps_count) + states[0].shape, dtype=states[0].dtype) mb_rewards = np.zeros((pool_size, self.steps_count), dtype=np.float32) mb_values = np.zeros((pool_size, self.steps_count), dtype=np.float32) mb_actions = np.zeros((pool_size, self.steps_count), dtype=np.int64) mb_dones = np.zeros((pool_size, self.steps_count), dtype=np.bool) total_rewards = [0.0] * pool_size total_steps = [0] * pool_size agent_states = None step_idx = 0 while True: actions, agent_states = self.agent(states, agent_states) rewards = [] dones = [] new_states = [] for env_idx, (e, action) in enumerate(zip(self.pool, actions)): o, r, done, _ = e.step(action) total_rewards[env_idx] += r total_steps[env_idx] += 1 if done: o = e.reset() self.total_rewards.append(total_rewards[env_idx]) self.total_steps.append(total_steps[env_idx]) total_rewards[env_idx] = 0.0 total_steps[env_idx] = 0 new_states.append(np.array(o)) dones.append(done) rewards.append(r) # we need an extra step to get values approximation for rollouts if step_idx == self.steps_count: # calculate rollout rewards for env_idx, (env_rewards, env_dones, last_value) in enumerate(zip(mb_rewards, mb_dones, agent_states)): env_rewards = env_rewards.tolist() env_dones = env_dones.tolist() if not env_dones[-1]: env_rewards = discount_with_dones(env_rewards + [last_value], env_dones + [False], self.gamma)[:-1] else: env_rewards = discount_with_dones(env_rewards, env_dones, self.gamma) mb_rewards[env_idx] = env_rewards yield mb_states.reshape((-1,) + mb_states.shape[2:]), mb_rewards.flatten(), mb_actions.flatten(), mb_values.flatten() step_idx = 0 mb_states[:, step_idx] = states mb_rewards[:, step_idx] = rewards mb_values[:, step_idx] = agent_states mb_actions[:, step_idx] = actions mb_dones[:, step_idx] = dones step_idx += 1 states = new_states def pop_total_rewards(self): r = self.total_rewards if r: self.total_rewards = [] self.total_steps = [] return r def pop_rewards_steps(self): res = list(zip(self.total_rewards, self.total_steps)) if res: self.total_rewards, self.total_steps = [], [] return res class ExperienceSourceBuffer: """ The same as ExperienceSource, but takes episodes from the buffer """ def __init__(self, buffer, steps_count=1): """ Create buffered experience source :param buffer: list of episodes, each is a list of Experience object :param steps_count: count of steps in every entry """ self.update_buffer(buffer) self.steps_count = steps_count def update_buffer(self, buffer): self.buffer = buffer self.lens = list(map(len, buffer)) def __iter__(self): """ Infinitely sample episode from the buffer and then sample item offset """ while True: episode = random.randrange(len(self.buffer)) ofs = random.randrange(self.lens[episode] - self.steps_count - 1) yield self.buffer[episode][ofs:ofs+self.steps_count] class ExperienceReplayBuffer: def __init__(self, experience_source, buffer_size): assert isinstance(experience_source, (ExperienceSource, type(None))) assert isinstance(buffer_size, int) self.experience_source_iter = None if experience_source is None else iter(experience_source) self.buffer = [] self.capacity = buffer_size self.pos = 0 def __len__(self): return len(self.buffer) def __iter__(self): return iter(self.buffer) def sample(self, batch_size): """ Get one random batch from experience replay TODO: implement sampling order policy :param batch_size: :return: """ if len(self.buffer) <= batch_size: return self.buffer # Warning: replace=False makes random.choice O(n) keys = np.random.choice(len(self.buffer), batch_size, replace=True) return [self.buffer[key] for key in keys] def _add(self, sample): if len(self.buffer) < self.capacity: self.buffer.append(sample) else: self.buffer[self.pos] = sample self.pos = (self.pos + 1) % self.capacity def populate(self, samples): """ Populates samples into the buffer :param samples: how many samples to populate """ for _ in range(samples): entry = next(self.experience_source_iter) self._add(entry) class PrioReplayBufferNaive: def __init__(self, exp_source, buf_size, prob_alpha=0.6): self.exp_source_iter = iter(exp_source) self.prob_alpha = prob_alpha self.capacity = buf_size self.pos = 0 self.buffer = [] self.priorities = np.zeros((buf_size, ), dtype=np.float32) def __len__(self): return len(self.buffer) def populate(self, count): max_prio = self.priorities.max() if self.buffer else 1.0 for _ in range(count): sample = next(self.exp_source_iter) if len(self.buffer) < self.capacity: self.buffer.append(sample) else: self.buffer[self.pos] = sample self.priorities[self.pos] = max_prio self.pos = (self.pos + 1) % self.capacity def sample(self, batch_size, beta=0.4): if len(self.buffer) == self.capacity: prios = self.priorities else: prios = self.priorities[:self.pos] probs = np.array(prios, dtype=np.float32) ** self.prob_alpha probs /= probs.sum() indices = np.random.choice(len(self.buffer), batch_size, p=probs, replace=True) samples = [self.buffer[idx] for idx in indices] total = len(self.buffer) weights = (total * probs[indices]) ** (-beta) weights /= weights.max() return samples, indices, np.array(weights, dtype=np.float32) def update_priorities(self, batch_indices, batch_priorities): for idx, prio in zip(batch_indices, batch_priorities): self.priorities[idx] = prio class PrioritizedReplayBuffer(ExperienceReplayBuffer): def __init__(self, experience_source, buffer_size, alpha): super(PrioritizedReplayBuffer, self).__init__(experience_source, buffer_size) assert alpha > 0 self._alpha = alpha it_capacity = 1 while it_capacity < buffer_size: it_capacity *= 2 self._it_sum = utils.SumSegmentTree(it_capacity) self._it_min = utils.MinSegmentTree(it_capacity) self._max_priority = 1.0 def _add(self, *args, **kwargs): idx = self.pos super()._add(*args, **kwargs) self._it_sum[idx] = self._max_priority ** self._alpha self._it_min[idx] = self._max_priority ** self._alpha def _sample_proportional(self, batch_size): res = [] for _ in range(batch_size): mass = random.random() * self._it_sum.sum(0, len(self) - 1) idx = self._it_sum.find_prefixsum_idx(mass) res.append(idx) return res def sample(self, batch_size, beta): assert beta > 0 idxes = self._sample_proportional(batch_size) weights = [] p_min = self._it_min.min() / self._it_sum.sum() max_weight = (p_min * len(self)) ** (-beta) for idx in idxes: p_sample = self._it_sum[idx] / self._it_sum.sum() weight = (p_sample * len(self)) ** (-beta) weights.append(weight / max_weight) weights = np.array(weights, dtype=np.float32) samples = [self.buffer[idx] for idx in idxes] return samples, idxes, weights def update_priorities(self, idxes, priorities): assert len(idxes) == len(priorities) for idx, priority in zip(idxes, priorities): assert priority > 0 assert 0 <= idx < len(self) self._it_sum[idx] = priority ** self._alpha self._it_min[idx] = priority ** self._alpha self._max_priority = max(self._max_priority, priority) class BatchPreprocessor: """ Abstract preprocessor class descendants to which converts experience batch to form suitable to learning. """ def preprocess(self, batch): raise NotImplementedError class QLearningPreprocessor(BatchPreprocessor): """ Supports SimpleDQN, TargetDQN, DoubleDQN and can additionally feed TD-error back to experience replay buffer. To use different modes, use appropriate class method """ def __init__(self, model, target_model, use_double_dqn=False, batch_td_error_hook=None, gamma=0.99, device="cpu"): self.model = model self.target_model = target_model self.use_double_dqn = use_double_dqn self.batch_dt_error_hook = batch_td_error_hook self.gamma = gamma self.device = device @staticmethod def simple_dqn(model, **kwargs): return QLearningPreprocessor(model=model, target_model=None, use_double_dqn=False, **kwargs) @staticmethod def target_dqn(model, target_model, **kwards): return QLearningPreprocessor(model, target_model, use_double_dqn=False, **kwards) @staticmethod def double_dqn(model, target_model, **kwargs): return QLearningPreprocessor(model, target_model, use_double_dqn=True, **kwargs) def _calc_Q(self, states_first, states_last): """ Calculates apropriate q values for first and last states. Way of calculate depends on our settings. :param states_first: numpy array of first states :param states_last: numpy array of last states :return: tuple of numpy arrays of q values """ # here we need both first and last values calculated using our main model, so we # combine both states into one batch for efficiency and separate results later if self.target_model is None or self.use_double_dqn: states_t = torch.tensor(np.concatenate((states_first, states_last), axis=0)).to(self.device) res_both = self.model(states_t).data.cpu().numpy() return res_both[:len(states_first)], res_both[len(states_first):] # in this case we have target_model set and use_double_dqn==False # so, we should calculate first_q and last_q using different models states_first_v = torch.tensor(states_first).to(self.device) states_last_v = torch.tensor(states_last).to(self.device) q_first = self.model(states_first_v).data q_last = self.target_model(states_last_v).data return q_first.cpu().numpy(), q_last.cpu().numpy() def _calc_target_rewards(self, states_last, q_last): """ Calculate rewards from final states according to variants from our construction: 1. simple DQN: max(Q(states, model)) 2. target DQN: max(Q(states, target_model)) 3. double DQN: Q(states, target_model)[argmax(Q(states, model)] :param states_last: numpy array of last states from the games :param q_last: numpy array of last q values :return: vector of target rewards """ # in this case we handle both simple DQN and target DQN if self.target_model is None or not self.use_double_dqn: return q_last.max(axis=1) # here we have target_model set and use_double_dqn==True actions = q_last.argmax(axis=1) # calculate Q values using target net states_last_v = torch.tensor(states_last).to(self.device) q_last_target = self.target_model(states_last_v).data.cpu().numpy() return q_last_target[range(q_last_target.shape[0]), actions] def preprocess(self, batch): """ Calculates data for Q learning from batch of observations :param batch: list of lists of Experience objects :return: tuple of numpy arrays: 1. states -- observations 2. target Q-values 3. vector of td errors for every batch entry """ # first and last states for every entry state_0 = np.array([exp[0].state for exp in batch], dtype=np.float32) state_L = np.array([exp[-1].state for exp in batch], dtype=np.float32) q0, qL = self._calc_Q(state_0, state_L) rewards = self._calc_target_rewards(state_L, qL) td = np.zeros(shape=(len(batch),)) for idx, (total_reward, exps) in enumerate(zip(rewards, batch)): # game is done, no final reward if exps[-1].done: total_reward = 0.0 for exp in reversed(exps[:-1]): total_reward *= self.gamma total_reward += exp.reward # update total reward and calculate td error act = exps[0].action td[idx] = q0[idx][act] - total_reward q0[idx][act] = total_reward return state_0, q0, td

2024-01-10

liyufeng0802/APIVerse

action_module~rag_gpt.py

import os from langchain.chat_models import ChatOpenAI from langchain.document_loaders import DirectoryLoader, TextLoader from langchain.indexes import VectorstoreIndexCreator from gpt_module import get_openai_api_key class RAG_GPT: MODEL_NAME = "gpt-4" def __init__(self): os.environ["OPENAI_API_KEY"] = get_openai_api_key() # Load KnowledgeBase from data files loader = TextLoader("./database/live.json") # Internal source self.index = VectorstoreIndexCreator().from_loaders([loader]) # choose llm model use self.openai = ChatOpenAI(model_name=self.MODEL_NAME) def query(self, prompt): # generate complete prompt response = self.index.query(prompt, llm=self.openai, retriever_kwargs={"k": 1}) return response

2024-01-10

liyufeng0802/APIVerse

gpt_module.py

import os import yaml import openai class GPT_module: MODEL_NAME = "gpt-4" def __init__(self): openai.api_key = get_openai_api_key() def query(self, prompt): # answer = self.comp(prompt, MaxToken=30, outputs=1) if len(answer) > 0: print(answer) return answer[0]['message']['content'] else: print("[Error] No response from OpenAI model!") return None def comp(self, PROMPT, MaxToken=50, outputs=1): response = openai.ChatCompletion.create(model=self.MODEL_NAME, messages=[{"role": "system", "content": 'You are a AI that understand all API technical concept'}, {"role": "user", "content": PROMPT}]) return response['choices'] def query_with_conversation(self, prompt, conversation): """" GPT query in a conversation format conversation: [ {"role": "system", "content": "You are a coding tutor bot to help user write and optimize python code."}, {"role": "user", "content": "Brabra"} {"role": "assistant", "content": "Brabra"} ] (Note: remeber to keep increase the conversation) Output: reponse: the response for this prompt conversation: update conversation """ conversation.append({"role": "user", "content": prompt}) response = openai.ChatCompletion.create( model=self.MODEL_NAME, messages=conversation ) conversation.append({"role": "assistant", "content": response["choices"][0]["message"]['content']}) response_message = response["choices"][0]["message"] return response_message, conversation # Read OpenAI key from ~/.cal_hack/config.yaml def get_openai_api_key(): with open(os.path.expanduser("~/.cal_hack/config.yaml"), "r") as f: config = yaml.load(f, Loader=yaml.SafeLoader) if "openai_api_key" not in config: raise Exception("OpenAI API key not found in ~/.cal_hack/config.yaml," " please add 'openai_api_key: YOUR_KEY' in the file.") openai_api_key = config["openai_api_key"] return openai_api_key

2024-01-10

garyb9/twitter-llm-bot

src~openai_llm_chains.py

import random from typing import List, Any from openai_client import llm from langchain.prompts import PromptTemplate from langchain.chains import LLMChain llm_chains = { "quote_tweets": [ LLMChain( prompt=PromptTemplate( template="""Generate 10 tweets of quotes by {name}, no hashtags.""", input_variables=["name"] ), llm=llm ), LLMChain( prompt=PromptTemplate( template="""Generate 10 tweets of quotes by {name}, no hashtags, format each tweet as 2-3 lines, end with name.""", input_variables=["name"] ), llm=llm ), ], "philosophical_tweets": [ LLMChain( prompt=PromptTemplate( template="""Generate 10 tweets about {topic} with a philosophical sense, without hashtags and emojis.""", input_variables=["topic"] ), llm=llm ), ] } def run_random_tweet(group: str, input_variables: List[str]) -> Any: response = random.choice(llm_chains[group]).run(input_variables) return response # Random example # print(run_random_tweet("quote_tweets", ["Max Stirner"]))

2024-01-10

chuanshaof/GIC-CodeToImpact2023

hackathon-g1-backend~app~routers~genai.py

from typing import Optional from enum import Enum import datetime import json from fastapi import APIRouter from langchain.chat_models import ChatAnthropic from langchain.schema import AIMessage, HumanMessage, SystemMessage from langchain.agents import load_tools from langchain.agents import initialize_agent from langchain.agents import AgentType from langchain.tools import BaseTool, StructuredTool, Tool, tool from pydantic import BaseModel, Field from config import settings from .analytics import ( BreakdownParams, TotalValueParams, MonthlyReturnParams, TopNParams, retrieve_breakdown, retrieve_total_market_value, retrieve_monthly_fund_return, retrieve_monthly_instrument_return, retrieve_top_n_funds, get_funds, ) from .prompts import FULL_PROMPT, SYS_TEMPLATE, CONTEXT_PROMPT, SYS_PROMPT router = APIRouter( prefix="/genai", tags=["genai"], responses={404: {"description": "Not found"}}, ) """ Comments on how the GenAI might be achieved Since the ChatAnthropic is stateless by default, in order for the chat to be able to return meaningful data, we need to pass in the context of the data Issue highlighted by Shane is that some API collects data, which can expose the data by accident. Not applicable in this Hackathon, but might be applicable in production Possible alternative methods: 1. Pass in the entire database for every query 1.1. An issue with this is SCALING. ChatAnthropic takes in a total of 100,000 token, which is OK for this dataset, but might not be OK for a larger dataset 2. Pass in the headers of the table 2.1. Much more scalable than the previous & exposes less info of the dataset 2.2. AI should know that SQL queries are the expected response 2.3. An expansion of the logic in the backend is required to handle the AI response & parse the data back to the user 3. Pass in a small set of data depending on what the user is asking for 3.1. Runs more efficiently and targetted 3.2. Team 9 did a thing to drag and drop the dataset, based on what the user is looking at """ chat = ChatAnthropic(anthropic_api_key=settings.ANTHROPIC_API_KEY) # tools = [ # StructuredTool.from_function( # func=retrieve_breakdown, # name="retrieve_breakdown", # description="Useful for retrieving the breakdown (by instruments, country, sector) of the total market value of a fund as of a specific date", # # args_schema=BreakdownParams # ), # StructuredTool.from_function( # func=retrieve_total_market_value, # name="retrieve_total_market_value", # description="Useful for retrieving the total market value of a single fund, across a date range", # # args_schema=TotalValueParams # ), # StructuredTool.from_function( # func=retrieve_monthly_fund_return, # name="retrieve_monthly_fund_return", # description="Useful for retrieving the monthly investment return of a fund, across a date range", # # args_schema=MonthlyReturnParams # ), # StructuredTool.from_function( # func=retrieve_monthly_instrument_return, # name="retrieve_monthly_instrument_return", # description="Useful for retrieving the monthly investment return of an instrument (regardless of fund), across a date range", # # args_schema=MonthlyReturnParams # ), # StructuredTool.from_function( # func=retrieve_top_n_funds, # name="retrieve_top_n_funds", # description="Useful for retrieving the top N performing funds by a M-month investment return from a given date, where N and M are provided", # # args_schema=TopNParams # ), # ] funcs = [ retrieve_breakdown, retrieve_total_market_value, retrieve_monthly_fund_return, retrieve_monthly_instrument_return, retrieve_top_n_funds, ] db_queries = [ Tool.from_function( func=get_funds, name="get_funds", description="Useful for retrieving the list of funds", ) ] # agent = initialize_agent(tools+db_queries, chat, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True, # agent_kwargs={'prefix': SYS_TEMPLATE,}) class ContextQuery(BaseModel): query: str query1: Optional[BreakdownParams] = Field(None) query2: Optional[TotalValueParams] = Field(None) query3: Optional[MonthlyReturnParams] = Field(None) query4: Optional[MonthlyReturnParams] = Field(None) query5: Optional[TopNParams] = Field(None) """ Attempts to pass in context to the chat This takes in a list of queries, meaning that the frontend will have to cache the queries and send them all at once It also follows a fixed template, which might not be ideal for the frontend to parse Issue is that no data is being passed into this, so the chatAI is unable to return any meaningful data """ @router.post("/query") def query_genai(params: ContextQuery): contexts = [] if params.query1: contexts.append( funcs[0](params.query1.fund_id, params.query1.type, params.query1.date) ) if params.query2: contexts.append( funcs[1]( params.query2.fund_id, params.query2.start_date, params.query2.end_date ) ) if params.query3: contexts.append( funcs[2]( params.query3.fund_id, params.query3.start_date, params.query3.end_date ) ) if params.query4: contexts.append( funcs[3]( params.query4.instrument_id, params.query4.start_date, params.query4.end_date, ) ) if params.query5: contexts.append( funcs[4](params.query5.n, params.query5.months, params.query5.date) ) user_message = [] for con in contexts: user_message.append(CONTEXT_PROMPT.format(context=con)) user_message = FULL_PROMPT.format( context="\n".join(user_message), question=params.query ) # res = agent.run(user_message) res = chat([SYS_PROMPT.format(), user_message]) return res.content class Query(BaseModel): query: str """ Most basic response that we could use, this was to test if the API was working This works essentially without any context other than the question posed, thus it does not give insights to the data itself """ @router.post("/test") def test_genai(query: Query): messages = [ HumanMessage(content=query.query), ] res = chat(messages) return res.content

2024-01-10

k1ngcyk/textgen-webui-document-search

script.py

import os import shutil import gradio as gr from modules import chat from langchain.embeddings import HuggingFaceEmbeddings from langchain.vectorstores import Chroma from langchain.document_loaders import UnstructuredMarkdownLoader KNOWLEDGE_PATH = "/tmp/knowledge" VECTORDB_PATH = "/tmp/vectordb" EMBEDDING_MODEL = "/mnt/ceph-share/models/SentenceTransformers/text2vec-base-chinese" params = { 'topk': 2, 'enabled': True } store = None def load_vector_store(): embeddings = HuggingFaceEmbeddings(model_name=EMBEDDING_MODEL) return Chroma(collection_name="vector_store", persist_directory=VECTORDB_PATH, embedding_function=embeddings) def load_current_vector(): global store store = load_vector_store() def create_embedding(folder): if os.path.exists(VECTORDB_PATH): shutil.rmtree(VECTORDB_PATH) if os.path.exists(KNOWLEDGE_PATH): shutil.rmtree(KNOWLEDGE_PATH) os.makedirs(VECTORDB_PATH) os.makedirs(KNOWLEDGE_PATH) embeddings = HuggingFaceEmbeddings(model_name=EMBEDDING_MODEL) vector_store = Chroma(collection_name="vector_store", persist_directory=VECTORDB_PATH, embedding_function=embeddings) for file in folder: filename = os.path.split(file.name)[-1] shutil.move(file.name, os.path.join(KNOWLEDGE_PATH, filename)) loader = UnstructuredMarkdownLoader(os.path.join(KNOWLEDGE_PATH, filename)) docs = loader.load() vector_store.add_documents(documents=docs, embedding_function=embeddings) vector_store.persist() def similar(query, topk=2): global store return store.similarity_search(query, topk) def custom_generate_chat_prompt(user_input, state, **kwargs): if not params['enabled']: print('skip ext') return chat.generate_chat_prompt(user_input, state, **kwargs) global store results = similar(user_input, topk=2) results = [x.page_content.replace("\n", " ") for x in results] if state['mode'] == 'chat-instruct': results = similar(user_input, topk=3) results = [x.page_content for x in results] state['chat-instruct_command'] = '已知内容:\n' + '\n'.join(results) + '\n\n请尽量基于上面的已知内容完成下面的任务. \n' + state['chat-instruct_command'] else: additional_context = '. 请基于以下已知的内容, 专业地回答我的问题, 如果提供的内容不是非常相关, 请抛弃这些内容并以友善的语气进行回答。已知内容: ' + '。'.join(results) user_input += additional_context return chat.generate_chat_prompt(user_input, state, **kwargs) def input_modifier(string): return string def ext(check): params['enabled'] = check def ui(): with gr.Row(): ext_enabled = gr.Checkbox(value=params['enabled'], label="插件开启") ext_enabled.change(ext, inputs=[ext_enabled]) with gr.Column(min_width=600): with gr.Tab("File input"): folder_files = gr.File(file_count="directory", show_label=False) load_folder_button = gr.Button("为文件夹创建知识库") load_current = gr.Button("加载现有知识库") load_folder_button.click(fn=create_embedding, show_progress=True, inputs=[folder_files]) load_current.click(fn=load_current_vector) load_current_vector()

2024-01-10

vontainment/v-chatgpt-email-assistant

stable~imapsieve_globalreply.py

#!/usr/bin/env python3 import os import sys sys.executable = '/usr/bin/python3' import base64 import email import openai import time from bs4 import BeautifulSoup from email.mime.text import MIMEText from email.mime.multipart import MIMEMultipart from email.generator import Generator from io import BytesIO USER = sys.argv[1] def decode_mail(email_data): msg = email.message_from_bytes(email_data) from_name = email.utils.parseaddr(msg['From'])[0] from_email = email.utils.parseaddr(msg['From'])[1] to_email = email.utils.parseaddr(msg['To'])[1] subject = msg['Subject'] body = "" if msg.is_multipart(): for part in msg.walk(): if part.get_content_type() == 'text/plain': body = part.get_payload(decode=True) elif part.get_content_type() == 'text/html': html_content = part.get_payload(decode=True) soup = BeautifulSoup(html_content, "html.parser") body = soup.get_text() elif part.get_content_type() == 'text/base64': base64_content = part.get_payload(decode=True) body = base64.b64decode(base64_content).decode('utf-8') else: body = msg.get_payload(decode=True) return from_name, from_email, to_email, subject, body def send_to_ai(from_name, subject, body): openai.api_key = '{changeapikey}' chat_models = 'gpt-3.5-turbo' system_message = "You are an AI and are tasked with writing replies to emails. Write your replies as if you were the human to whom the email was sent and in the following format:\nHello FROM NAME,\n\nYOUR REPLY\n\nBest regards" user_message = f"This email is from:{from_name}. This email has a subject of: {subject}. This email's body is: {body}" result = openai.ChatCompletion.create( model=chat_models, messages=[ {"role": "system", "content": system_message}, {"role": "user", "content": user_message} ] ) return result.choices[0].message['content'] def create_reply(from_email, subject, body, new_msg, to_email): re_subject = "Re: " + subject text = new_msg + "\n\n" + body user_email, domain = USER.split('@') msg = MIMEMultipart() msg['From'] = to_email msg['To'] = from_email msg['Subject'] = re_subject msg.attach(MIMEText(text, 'plain')) # Specify the location of the user's draft directory in Dovecot draft_dir = f"/home/{changeusername}/mail/{domain}/{user_email}/.Drafts/cur" draft_filename = f"{user_email}-draft-{str(int(time.time()))}.eml" # Ensure the draft directory exists os.makedirs(draft_dir, exist_ok=True) # Write the email to the draft file with open(os.path.join(draft_dir, draft_filename), 'w') as f: gen = Generator(f) gen.flatten(msg) def process_email(email_data): from_name, from_email, to_email, subject, body = decode_mail(email_data) ai_response = send_to_ai(from_name, subject, body) create_reply(from_email, subject, body, ai_response, to_email) email_data = sys.stdin.buffer.read() process_email(email_data)

2024-01-10

vontainment/v-chatgpt-email-assistant

beta~imapsieve_globalreply.py

#!/usr/bin/env python3 """ ----------------------------------------------------------- Script Name: ChatGPT Email Assistant Author: Vontainment Created: 2023-06-16 Updated: 2023-06-16 Description: This script is part of a project to automate email responses using OpenAI's GPT-3 model. It takes an email as input and drafts a reply based on the content of the email, storing the drafted email into a specified location. ----------------------------------------------------------- """ import os import re import sys sys.executable = '/usr/bin/python3' import base64 import email import openai import time from bs4 import BeautifulSoup from email.mime.text import MIMEText from email.mime.multipart import MIMEMultipart from email.generator import Generator from io import BytesIO USER = sys.argv[1] user_email, domain = USER.split('@') def get_nixuser_from_conf(domain): # Read the domain's .conf file with open(f'/etc/dovecot/conf.d/domains/{domain}.conf', 'r') as f: conf_file_content = f.read() # Use a regular expression to find the directory after /home/ match = re.search(r'/home/([^/]+)', conf_file_content) if match: return match.group(1) # Return the matched directory name else: raise Exception(f"Could not find directory after /home/ in {domain}.conf") nixuser = get_nixuser_from_conf(domain) def get_config_values(nixuser): # Read the user's ai.conf file with open(f'/home/{nixuser}/mail/ai.conf', 'r') as f: ai_conf_content = f.read() # Use regular expressions to find the user key, instructions, and signature userkey_match = re.search(r'userkey="([^"]*)"', ai_conf_content) instructions_match = re.search(r'instructions="([^"]*)"', ai_conf_content) signature_match = re.search(r'signature=|||([^|||]*)|||', ai_conf_content) if userkey_match and instructions_match and signature_match: # Return the matched user key, instructions, and signature return userkey_match.group(1), instructions_match.group(1), signature_match.group(1) else: raise Exception("Could not find userkey, instructions, or signature in ai.conf") signature, userkey, instructions = get_config_values(nixuser) def decode_mail(email_data): msg = email.message_from_bytes(email_data) from_name = email.utils.parseaddr(msg['From'])[0] from_email = email.utils.parseaddr(msg['From'])[1] to_email = email.utils.parseaddr(msg['To'])[1] subject = msg['Subject'] body = "" if msg.is_multipart(): for part in msg.walk(): if part.get_content_type() == 'text/plain': body = part.get_payload(decode=True) elif part.get_content_type() == 'text/html': html_content = part.get_payload(decode=True) soup = BeautifulSoup(html_content, "html.parser") body = soup.get_text() elif part.get_content_type() == 'text/base64': base64_content = part.get_payload(decode=True) body = base64.b64decode(base64_content).decode('utf-8') else: body = msg.get_payload(decode=True) return from_name, from_email, to_email, subject, body def send_to_ai(from_name, subject, body): openai.api_key = userkey chat_models = 'gpt-3.5-turbo' system_message = f"{instructions}" user_message = f"This email is from:{from_name}. This email has a subject of: {subject}. This email's body is: {body}" result = openai.ChatCompletion.create( model=chat_models, messages=[ {"role": "system", "content": system_message}, {"role": "user", "content": user_message} ] ) return result.choices[0].message['content'] def create_reply(from_email, subject, body, new_msg, to_email, signature): re_subject = "Re: " + subject text = new_msg + "<br><br>" + signature msg = MIMEMultipart('alternative') msg['From'] = to_email msg['To'] = from_email msg['Subject'] = re_subject part = MIMEText(text, 'html') msg.attach(part) # Specify the location of the user's draft directory in Dovecot draft_dir = f"/home/{nixuser}/mail/{domain}/{user_email}/.Drafts/cur" draft_filename = f"{user_email}-draft-{str(int(time.time()))}.eml" # Ensure the draft directory exists os.makedirs(draft_dir, exist_ok=True) # Write the email to the draft file with open(os.path.join(draft_dir, draft_filename), 'w') as f: gen = Generator(f) gen.flatten(msg) def process_email(email_data): from_name, from_email, to_email, subject, body = decode_mail(email_data) ai_response = send_to_ai(from_name, subject, body) create_reply(from_email, subject, body, ai_response, to_email, signature) email_data = sys.stdin.buffer.read() process_email(email_data)

2024-01-10

hertera1/nebullvm

apps~accelerate~chatllama~chatllama~rlhf~reward.py

import json import os import torch from beartype import beartype from beartype.typing import Optional, Iterable from einops.layers.torch import Rearrange from langchain import OpenAI, LLMChain, PromptTemplate from torch.utils.data import Dataset, DataLoader from transformers import GPT2Tokenizer, GPT2Model, BartModel from transformers import BartTokenizer, BartConfig, AutoModel, AutoTokenizer from chatllama.langchain_modules.prompt_templates import REWARD_TEMPLATE from config import ConfigReward from utils import TrainingStats class RewardModel(torch.nn.Module): """Model to be trained to predict the reward for RL. or to be used as Critic in RL. Attributes: model (torch.nn.Module): Model to be used for the reward model tokenizer (torch.nn.Module): Tokenizer to be used for the reward model head (torch.nn.Module): Head to be used for the reward model config (ConfigReward): Config parameters for the reward model max_model_tokens (int): Maximum sequence length for the reward model Methods: forward: Forward pass of the model (used by the critic) save: Save the model load: Load the model get_reward: Get the reward for a given input (used by the reward model) """ def __init__(self, config: ConfigReward) -> None: super().__init__() # load the model -- add here other models head_hidden_size = config.model_head_hidden_size if config.model == "gpt2-large": self.max_model_tokens = 1024 self.model = GPT2Model.from_pretrained("gpt2-large") self.tokenizer = GPT2Tokenizer.from_pretrained( "gpt2-large", padding_side="left", truncation_side="left", model_max_length=self.max_model_tokens, ) self.tokenizer.pad_token = self.tokenizer.eos_token self.head = torch.nn.Sequential( torch.nn.Linear(self.model.config.n_embd, head_hidden_size), torch.nn.ReLU(), torch.nn.Linear(head_hidden_size, 1), Rearrange("... 1 -> ..."), ) elif config.model == "bart-base": self.max_model_tokens = 1024 bart_config = BartConfig.from_pretrained("facebook/bart-base") bart_config.max_position_embeddings = 2048 + 1024 self.model = BartModel(bart_config) self.tokenizer = BartTokenizer.from_pretrained( "facebook/bart-large", padding_side="left", truncation_side="left", model_max_length=self.max_model_tokens, ) self.tokenizer.pad_token = self.tokenizer.eos_token self.head = torch.nn.Sequential( torch.nn.Linear(768, head_hidden_size), torch.nn.ReLU(), torch.nn.Linear(head_hidden_size, 1), Rearrange("... 1 -> ..."), ) elif config.model == "longformer-base-4096": self.max_model_tokens = 4096 self.model = AutoModel.from_pretrained( "allenai/longformer-base-4096" ) self.tokenizer = AutoTokenizer.from_pretrained( "allenai/longformer-base-4096", padding_side="left", truncation_side="left", model_max_length=self.max_model_tokens, ) self.tokenizer.eos_token = self.tokenizer.pad_token self.head = torch.nn.Sequential( torch.nn.Linear(768, head_hidden_size), torch.nn.ReLU(), torch.nn.Linear(head_hidden_size, 1), Rearrange("... 1 -> ..."), ) else: raise ValueError(f"model {config.model} not supported") # store config self.config = config if os.path.exists(config.model_folder) is False: os.mkdir(config.model_folder) else: self.load() # freeze model parameters (only train the head) for param in self.model.parameters(): param.requires_grad = False # move model to device self.model.to(config.device) self.head.to(config.device) @beartype def parameters( self, ) -> Iterable[torch.nn.Parameter]: """Return the parameters of the reward model""" for p in self.model.parameters(): yield p for p in self.head.parameters(): yield p @beartype def forward( self, output_sequence: torch.Tensor, output_sequence_mask: torch.Tensor ) -> torch.Tensor: """Generate the sequence of rewards for the given output sequence what is the quality of the output sequence tokens? Args: output_sequence (torch.Tensor): The sequence of tokens to be evaluated output_sequence_mask (torch.Tensor): Mask for the attention Returns: torch.Tensor: Rewards for the given output sequence """ output = self.model( output_sequence, attention_mask=output_sequence_mask ) # What if the output_sequence is longer than the max context of # the model? rewards = self.head(output.last_hidden_state) if self.config.debug: print("RewardModel.forward") print("output_sequence.shape", output_sequence.shape) print("output_sequence", output_sequence) print("reward.shape", rewards.shape) print("reward", rewards) return rewards @beartype def get_reward( self, output_sequence: torch.Tensor, output_sequence_mask: torch.Tensor ) -> torch.Tensor: """Get the reward for the given output sequence Args: output_sequence (torch.Tensor): The concatenation of initial input and actor output as tokens output_sequence_mask (torch.Tensor): Mask for the attention """ rewards = self.forward(output_sequence, output_sequence_mask) return rewards[:, -1] @beartype def load(self, path: Optional[str] = None) -> None: """Load the model from the path Args: path (str): path to the model """ if path is None: path = self.config.model_folder + "/" + self.config.model + ".pt" if os.path.exists(self.config.model_folder) is False: os.makedirs(self.config.model_folder) print( f"Model folder does not exist. Creating it," f"and returning without loading the model:\n{path}" ) return # load the model and the tokenizer if os.path.exists(path) is False: print( f"Impossible to load the model:\n{path}\n" f"The path doesn't exist." ) return model_dict = torch.load(path) self.model.load_state_dict(model_dict["model"]) self.head.load_state_dict(model_dict["head"]) @beartype def save(self, path: Optional[str] = None) -> None: """Save the model to the path Args: path (Optional[str], optional): Path to store the model. Defaults to None. """ if path is None: path = self.config.model_folder + "/" + self.config.model + ".pt" if os.path.exists(self.config.model_folder) is False: os.makedirs(self.config.model_folder) torch.save( {"model": self.model.state_dict(), "head": self.head.state_dict()}, path, ) # just to keep namings consistent CriticModel = RewardModel class RewardDataset(Dataset): """Dataset class for the reward model read a json file with the following format: [ { "user_input": "...", "completion": "...", "score": ... }, ... ] Where: user_input: the initial input of the user completion: the completion generated by the model score: the score given by the user to the completion (or by the LLM) """ def __init__(self, path: str) -> None: print(f"Loading dataset from {path}") with open(path, "r") as f: self.data = list(json.load(f)) print(f"Loaded {len(self.data)} samples") def __getitem__(self, idx: int): user_input = self.data[idx]["user_input"] completion = self.data[idx]["completion"] item = tuple([user_input, completion]) return item def __len__( self, ): return len(self.data) class RewardTrainer: """Reward class to train the reward model Args: config (ConfigModel): Config parameters for the model Attributes: model (RewardModel): Reward model config (ConfigModel): Config parameters for the model optimizer (torch.optim): Optimizer for the model loss (torch.nn): Loss function for the model Methods: train: Train the reward model generate_user_input: Generate the user input for the LLM to evaluate a couple, (user_input, completion) and assing a score distillate: Parse the dataset and assign scores using LLMs """ def __init__(self, config: ConfigReward) -> None: self.model = RewardModel(config) self.config = config self.optimizer = torch.optim.Adam( self.model.parameters(), lr=config.lr ) self.loss_function = torch.nn.MSELoss() if not os.path.exists("./models"): os.mkdir("./models") self.training_stats = TrainingStats() self.validation_flag = False if config.validation_dataset_path is not None: self.validation_flag = True openai_llm = OpenAI( model_name=self.config.llm_model, temperature=self.config.llm_temperature, max_tokens=self.config.llm_max_tokens, ) prompt_template = PromptTemplate(**REWARD_TEMPLATE) self.llm = LLMChain(llm=openai_llm, prompt=prompt_template) def distillate( self, ): """Parse the dataset and assign scores using LLMs then save back the dataset with the uploaded scores """ # load the dataset with open(self.config.train_dataset_path, "r") as f: train_data = json.load(f) # for each element of the dataset, assing a score. for i, data in enumerate(train_data): if data.get("score", None) is None: prompt_tokens = ( data["user_input"] + data["completion"] + self.llm.prompt.template ) prompt_len = int(len(prompt_tokens.split(" ")) / 0.75) # 80% of the max length as safety margin if prompt_len > self.config.llm_max_tokens * 0.8: print( f"The prompt of the data {i} is too long\n" f"tokens: {prompt_len}\n" f"max_tokens: {self.config.llm_max_tokens * 0.8}" ) continue score = self.llm.run( user_input=data["user_input"], completion=data["completion"], ).strip() # TODO extract from score the float value with a regex score = score.split(" ")[0] try: score = float(score) except Exception: print( f"The score returned by the LLM for the" f"data, {i}, is not a float float:\n{score}" ) continue data["score"] = score # save the dataset back with open(self.config.train_dataset_path, "w") as f: json.dump(train_data, f) def train( self, ) -> None: """Train the reward model""" print("Start Training the Reward Model") # get config parameters train_dataset_path = self.config.train_dataset_path validation_dataset_path = self.config.validation_dataset_path batch_size = self.config.batch_size epochs = self.config.epochs device = self.config.device # create dataloaders train_dataset = RewardDataset(train_dataset_path) train_dataloader = DataLoader(train_dataset, batch_size=batch_size) if self.validation_flag: eval_dataset = RewardDataset(validation_dataset_path) validation_dataloader = DataLoader( eval_dataset, batch_size=batch_size ) iteration_per_print = self.config.iteration_per_print # compute the number of iterations n_iter = int(len(train_dataset) / batch_size) # traing loop for epoch in range(epochs): self.model.train() for i, inputs in enumerate(train_dataloader): input_text = inputs["user_input"] + inputs["completion"] # tokenizer (placed here instead of dataset class) input_tokens = self.model.tokenizer( input_text, padding=True, truncation=True ) score = None # TODO: load the score # TODO: check on the length of the input tokens if they are # too many it can create problems output = torch.tensor(score, dtype=torch.float32).to(device) # forward pass est_output = self.model.get_reward( input_tokens["input_ids"].to(device), input_tokens["attention_mask"].to(device), ) loss = self.loss_function(est_output, output) self.training_stats.training_loss.append(loss.item()) # backward pass self.optimizer.zero_grad() loss.backward() self.optimizer.step() # print progress if i % iteration_per_print == 0: print( f"Epoch: {epoch+1}/{epochs}, " f"Iteration: {i+1}/{n_iter}, " f"Training Loss: {loss.item()}" ) print( "prediction", est_output.cpu().detach().numpy(), "target", score.cpu().numpy(), ) if self.validation_flag: self.model.eval() for i, (text, score) in enumerate(validation_dataloader): # forward pass input_tokens = self.model.tokenizer( text, return_tensors="pt", padding=True ) input_tokens = input_tokens.to(device) # TODO: check on the length of the input tokens if they are # too many it can create problems output = torch.tensor(score, dtype=torch.float32).to( device ) est_output = self.model.get_reward( input_tokens["input_ids"], input_tokens["attention_mask"], ) loss = self.loss_function(est_output, output) self.training_stats.validation_loss.append(loss.item()) # print progress if i % iteration_per_print == 0: print( f"Epoch: {epoch+1}/{epochs}, " f"Iteration: {i+1}/{n_iter}, " f"Validation Loss: {loss.item()}" ) self.model.save()

2024-01-10

baijnath4/Contract-Compliance-and-Purchase-Price-Variance-powered-by-GEN-AI

chatGPTModel~gPTModel.py

import openai import pandas as pd deployment_name = "contract_search" openai.api_type = "azure" openai.api_key = "3a87ebf808cf4876b336ddbef5dd2528" openai.api_base = "https://bpogenaiopenai.openai.azure.com/" openai.api_version = "2023-05-15" def questions(pdf1,i): pormptDict = {'Agreement Name':' What is the name of the agreement in this contract,I am seeking concise 1-2 keywords as the response', 'Contract Id':' What is the contract id mentioned in the agreement,I am seeking concise 1-2 keywords as the response', 'Payment Terms':'What is the numeric value of the payment terms agreed upon with the supplier in this agreement? Please provide a concise one-word numerical response', 'Service Price Per Unit':'Please provide the roles provided by the supplier along with their corresponding services prices and do not provide total prices.give only roles and prices. Ensure the values are consistent in every run.Please provide a response in the following format: [ROLE]. [PRICE]', 'Start date and end date of the Agreement':'When is the start date and end date of the agreement,I am seeking concise 1-2 keywords only the date response', 'Supplier name':'What is the name of the supplier in this contract,I am seeking concise 1-2 keywords as the response', 'Unit of Measure':'What is the unit of measure of the services'} try: question = pormptDict[i] except: question=i print("question:-",question) prompt = f"{question}\n{pdf1}\n\\n:" model = "text-davinci-003" response = openai.Completion.create( engine=deployment_name, prompt=prompt, max_tokens=500, temperature=0, n = 1, stop=None ) diffs = response.choices[0].text return diffs.strip() def contractandpo(contract,po): final_po = pd.merge(contract,po,how='inner',on=['Contract_ID','Line_Item_Desc']) final_po = final_po[['PO_ID','Line_Item_Desc','Supplier_x','Payment_Terms_PO','Unit_Price_In_Orig_Curr','PO_Commit','Contract_ID','Payment_Terms_Contract','Contracted_Unit_Price']] final_po['Payment_Terms_Contract'] = final_po['Payment_Terms_Contract'].astype(int) final_po['Contracted_Unit_Price'] = final_po['Contracted_Unit_Price'].astype(int) final_po['Payment_Terms_PO'] = final_po['Payment_Terms_PO'].astype(int) final_po['Unit_Price_In_Orig_Curr'] = final_po['Unit_Price_In_Orig_Curr'].astype(int) final_po['Spend Leakage'] = ((final_po['Unit_Price_In_Orig_Curr'] - final_po['Contracted_Unit_Price'])/final_po['Contracted_Unit_Price'])*100 final_po['Spend Leakage'] = final_po['Spend Leakage'].astype(int) final_po['Payter_Diff_PO_Contract'] = (final_po['Payment_Terms_Contract'] - final_po['Payment_Terms_PO']) openai.api_key = "3a87ebf808cf4876b336ddbef5dd2528" # prompt_s = ['provide the key differences in price and payterms from the contract and PO'] # prompt_s = ['provide the difference of price and payterms in the table:-sum df :-- The difference of price and payterms in the table is 20.'] # prompt_s = ['provide the difference of unit price and payterm from the data and also provide key points from the data'] prompt_s =['provide me the total spend leakage and the average differences between the po and contract payterm'] summary = '' summary+= (questions(final_po,prompt_s)) return final_po,summary def contractandinvoice(contract,invoice): final_df = pd.merge(contract,invoice,how='inner',on=['Contract_ID','Line_Item_Desc']) final_df = final_df[['Doc_Num','Line_Item_Desc','Inv_Gross_Value','Inv_Payterms','Inv_Unit_Price', 'Payment_Terms_Contract','Contracted_Unit_Price','Unit_Price_In_Orig_Curr','Contract_ID']] final_df['Payment_Terms_Contract'] = final_df['Payment_Terms_Contract'].astype(int) # final_df['Payment_Terms_PO'] = final_df['Payment_Terms_PO'].astype(int) final_df['Inv_Payterms'] = final_df['Inv_Payterms'].astype(int) final_df['Inv_Gross_Value'] = final_df['Inv_Gross_Value'].astype(int) final_df['Inv_Unit_Price'] = final_df['Inv_Unit_Price'].astype(int) final_df['Contracted_Unit_Price'] = final_df['Contracted_Unit_Price'].astype(int) final_df['Unit_Price_In_Orig_Curr'] = final_df['Unit_Price_In_Orig_Curr'].astype(int) final_df['Spend Leakage'] = ((final_df['Inv_Unit_Price'] - final_df['Contracted_Unit_Price'])/final_df['Contracted_Unit_Price'])*100 final_df['Spend Leakage'] = final_df['Spend Leakage'].astype(int) final_df['Working_Capital_Inv_Contract'] = ((final_df['Payment_Terms_Contract'] - final_df['Inv_Payterms'])*final_df['Inv_Gross_Value'])/365 final_df = final_df.rename(columns={'INVOICE': 'Doc_Numb', 'PO': 'PO_ID','Unit_Price_In_Orig_Curr':'PO_Unit_Price', 'Product Description':'Line_Item_Desc'}) final_df = final_df[['Doc_Num','Inv_Payterms','Inv_Unit_Price', 'PO_Unit_Price','Contract_ID','Payment_Terms_Contract', 'Contracted_Unit_Price','Spend Leakage','Working_Capital_Inv_Contract']] openai.api_key = "3a87ebf808cf4876b336ddbef5dd2528" prompt_s = ['provide me the total spend leakage and the total cash flow ooportunity contract and invoice'] summary = '' summary+= (questions(final_df,prompt_s)) return final_df,summary def threewaymatch(contract,po,invoice): final_df = pd.merge(pd.merge(contract,invoice,how='inner',on=['Contract_ID','Line_Item_Desc']),po,on=['Contract_ID','Line_Item_Desc']) final_df = final_df[['Doc_Num','Supplier_x','Contract_ID','Line_Item_Desc','Inv_Payterms','Inv_Unit_Price','Payment_Terms_Contract','Payment_Terms_PO','Contracted_Unit_Price','Inv_Gross_Value','Unit_Price_In_Orig_Curr_x']] final_df['Payment_Terms_Contract'] = final_df['Payment_Terms_Contract'].astype(int) # final_df['Payment_Terms_PO'] = final_df['Payment_Terms_PO'].astype(int) final_df['Inv_Payterms'] = final_df['Inv_Payterms'].astype(int) final_df['Inv_Gross_Value'] = final_df['Inv_Gross_Value'].astype(int) final_df['Inv_Unit_Price'] = final_df['Inv_Unit_Price'].astype(int) final_df['Contracted_Unit_Price'] = final_df['Contracted_Unit_Price'].astype(int) final_df['Unit_Price_In_Orig_Curr'] = final_df['Unit_Price_In_Orig_Curr_x'].astype(int) final_df['Spend Leakage'] = ((final_df['Inv_Unit_Price'] - final_df['Contracted_Unit_Price'])/final_df['Contracted_Unit_Price'])*100 final_df['Spend Leakage'] = final_df['Spend Leakage'].astype(int) final_df['Working_Capital_Inv_Contract'] = ((final_df['Payment_Terms_Contract'] - final_df['Inv_Payterms'])*final_df['Inv_Gross_Value'])/365 final_df = final_df.rename(columns={'INVOICE': 'Doc_Num','Unit_Price_In_Orig_Curr':'PO_Unit_Price','Product Description':'Line_Item_Desc'}) final_df = final_df[['Doc_Num','Supplier_x','Line_Item_Desc','Inv_Payterms','Inv_Unit_Price','PO_Unit_Price','Contract_ID','Payment_Terms_Contract','Payment_Terms_PO','Contracted_Unit_Price','Inv_Gross_Value','Spend Leakage','Working_Capital_Inv_Contract']] final_df = final_df.rename(columns={ 'Payment_Terms_Contract':'Contract_Payterms','Supplier_x':'Supplier','Unit_Price_In_Orig_Curr':'PO_Unit_Price','Product Description':'Line_Item_Desc','Payment_Terms_PO':'PO_Payterms'}) final_s = final_df[['Line_Item_Desc','Supplier','Contracted_Unit_Price','PO_Unit_Price','Inv_Unit_Price','Contract_Payterms','Inv_Payterms','PO_Payterms']] openai.api_key = "3a87ebf808cf4876b336ddbef5dd2528" prompt_s = ['provide the differences in unit price across contract, PO and Invoice from the table in words and also provide summary of contract,po and Inv_Payterms'] summary = '' summary+= (questions(final_s,prompt_s)) return final_s,summary # contractDummy =pd.read_excel("C:/Users/01934L744/Box/Baijnath Data/Project 2023/Nidhi/contract - v4.1/dummy/CO_12L23.xlsx") # po = pd.read_excel("C:/Users/01934L744/Box/Baijnath Data/Project 2023/Nidhi/contract - v4.1/upload_3way/PO.xlsx") # resultDF, reslutSumm=contractandpo(contract=contractDummy,po=po) # print("result df :--", resultDF) # print("sum df :--", reslutSumm) # contractDummy =pd.read_excel("C:/Users/01934L744/Box/Baijnath Data/Project 2023/Nidhi/contract - v4.1/dummy/C0_1L976.xlsx") # invoice = pd.read_excel("C:/Users/01934L744/Box/Baijnath Data/Project 2023/Nidhi/contract - v4.1/upload_3way/Invoice data_Updated.xlsx") # resultDF, reslutSumm=contractandinvoice(contract=contractDummy,invoice=invoice) # print("result df :--", resultDF) # print("result df :--", reslutSumm) # contractDummy =pd.read_excel("C:/Users/01934L744/Box/Baijnath Data/Project 2023/Nidhi/contract - v4.1/dummy/C0_1L976.xlsx") # invoice = pd.read_excel("C:/Users/01934L744/Box/Baijnath Data/Project 2023/Nidhi/contract - v4.1/upload_3way/Invoice data.xlsx") # resultDF, reslutSumm=threewaymatch(contract=contractDummy,po=po,invoice=invoice) # print("result df :--", resultDF) # print("result df :--", reslutSumm)

2024-01-10

baijnath4/Contract-Compliance-and-Purchase-Price-Variance-powered-by-GEN-AI

chatGPTModel~ppv_st_input2.py

from pdfminer.high_level import extract_text # import streamlit as st import openai import regex as re import pandas as pd import numpy as np import openai openai.api_key = "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" def questions(pdf1,i): question = i prompt = f"{question}\n{pdf1}\n\\n:" model = "text-davinci-003" response = openai.Completion.create( engine=model, prompt=prompt, max_tokens=500, temperature=0, n = 1, stop=None ) diffs = response.choices[0].text return diffs.strip() def get_insight(uploaded_file,p): # uploaded_file = st.file_uploader("Upload Contract", "pdf") if uploaded_file is not None: element = extract_text(uploaded_file) answers = questions(element,p) return answers if __name__ == "__main__": file="C:/Users/01934L744/Box/Baijnath Data/Project 2023/Nidhi/contract/upload_ppv/Contract1.pdf" p = "What is the supplier name" result = get_insight(file,p) print(result)

2024-01-10

baijnath4/Contract-Compliance-and-Purchase-Price-Variance-powered-by-GEN-AI

chatGPTModel~contractAndInvoice.py

import openai import pandas as pd def contractandinvoice(contract,invoice): final_df = pd.merge(contract,invoice,how='inner',on=['Contract_ID','Line Item Description']) final_df = final_df[['INVOICE','PO','Contract_ID','Line Item Description','PAYMENTTERMS_PO','Invoice Payterms','Invoice unit price','Contracted Payterms','Contracted unit price','Invoice Gross Value','UNITPRICEINORIGINALCURRENCY']] final_df['Contracted Payterms'] = final_df['Contracted Payterms'].astype(int) final_df['PAYMENTTERMS_PO'] = final_df['PAYMENTTERMS_PO'].astype(int) final_df['Invoice Payterms'] = final_df['Invoice Payterms'].astype(int) final_df['Invoice Gross Value'] = final_df['Invoice Gross Value'].astype(int) final_df['Invoice unit price'] = final_df['Invoice unit price'].astype(int) final_df['Contracted unit price'] = final_df['Contracted unit price'].astype(int) final_df['UNITPRICEINORIGINALCURRENCY'] = final_df['UNITPRICEINORIGINALCURRENCY'].astype(int) final_df['Purchase Price variance(Invoice vs Contract)'] = ((final_df['Invoice unit price'] - final_df['Contracted unit price'])/final_df['Contracted unit price'])*100 final_df['Purchase Price variance(Invoice vs Contract)'] = final_df['Purchase Price variance(Invoice vs Contract)'].astype(int) final_df['Working Capital(Invoice vs Contract)'] = ((final_df['Contracted Payterms'] - final_df['Invoice Payterms'])*final_df['Invoice Gross Value'])/365 final_df = final_df.rename(columns={'INVOICE': 'Document Number', 'PO': 'PO_ID','UNITPRICEINORIGINALCURRENCY':'PO Unit Price','Product Description':'Line item description'}) final_df = final_df[['Document Number','Line Item Description','Invoice Payterms','Invoice unit price','PO_ID','PAYMENTTERMS_PO','PO Unit Price','Contract_ID','Contracted Payterms','Contracted unit price','Invoice Gross Value','Purchase Price variance(Invoice vs Contract)','Working Capital(Invoice vs Contract)']] openai.api_key = "" prompt_s = ['provide the summary of the below data:'] summary = '' summary+= (questions(final_df,prompt_s)) return final_df,summary

2024-01-10

baijnath4/Contract-Compliance-and-Purchase-Price-Variance-powered-by-GEN-AI

utils~api_utils.py

import openai from nltk.util import ngrams from nltk.tokenize import word_tokenize from nltk.corpus import stopwords import copy import re import pandas as pd import csv deployment_name = "contract_search" deployment_name1 = "gpt-3.5-turbo" openai.api_type = "azure" openai.api_key = "3a87ebf808cf4876b336ddbef5dd2528" openai.api_base = "https://bpogenaiopenai.openai.azure.com/" openai.api_version = "2023-05-15" # Question Answer ChatBot def documentChatBot(input_text, question='You are a Data Analyst. Can you please analyze the below data and generate insights'): prompt = (f"""{question} {input_text} """) response = openai.Completion.create( # engine="text-davinci-003", engine = deployment_name, prompt=prompt, max_tokens=300, n=1, stop=None, temperature=0.5, ) document_chatbot = response.choices[0].text.strip() return {'document_chatbot': document_chatbot} # Global ChatBot def genericChatbot(question): messages=[{"role": "system", "content": question}] response = openai.ChatCompletion.create( engine="global_chatbot", messages = messages, temperature=0.7, max_tokens=800, top_p=0.95, frequency_penalty=0, presence_penalty=0, stop=None) global_chatbot = response["choices"][0]["message"]["content"] return {'global_chatbot': global_chatbot} # data = genericChatbot("what is machine learning") # print(data)

2024-01-10

baijnath4/Contract-Compliance-and-Purchase-Price-Variance-powered-by-GEN-AI

chatGPTModel~ppv_st_input.py

from pdfminer.high_level import extract_text # import streamlit as st import openai import regex as re import pandas as pd import numpy as np import openai def questions(pdf1,i): question = i prompt = f"{question}\n{pdf1}\n\\n:" model = "text-davinci-003" response = openai.Completion.create( engine=model, prompt=prompt, max_tokens=500, temperature=0, n = 1, stop=None ) diffs = response.choices[0].text return diffs.strip() # data_df = pd.DataFrame(columns = ['Contract_ID','Suppliers','Line Item Description', 'Contracted Payterms','Contracted unit price','Unit of Measure']) # data_df = pd.read_excel("C:/Users/01934L744/Box/Baijnath Data/Project 2023/Nidhi/contract/upload_ppv/DummyData.xlsx") def get_insight(uploaded_file): # uploaded_file = st.file_uploader("Upload Contract", "pdf") if uploaded_file is not None: openai.api_key = "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" element = extract_text(uploaded_file) prompt = ['What is the agreement name,provide only name','What is the supplier name','When is the start date and end date of the agreement', 'What is the contract id mentioned in the agreement', 'what are the payment terms agreed with supplier', 'What are the prices of roles provided by supplier', 'What is the unit of measure of the services'] new_prompts = ['What is the agreement name,provide only name','What is the supplier name','When is the start date and end date of the agreement provide only dates','what is the contract id', 'What are the number of days payment terms agreed', 'What are the role wise price per unit not the total value provide in table','What is the unit of measure only'] answers = '' exact_answers = '' for p in prompt: answers+= (questions(element,p)) filtered_contract = str.join(" ", answers.splitlines()) for c in new_prompts: exact_answers = exact_answers + 'Q)'+ c + '\n' + 'A)'+ questions(filtered_contract,c) + '\n\n' return exact_answers # uploaded_po = st.file_uploader("Upload PO", ["csv","xlsx"]) # def po_data(uploaded_po, data_df): # if uploaded_po is not None: # podf = pd.read_excel(uploaded_po,sheet_name='Sheet1') # final_po = pd.merge(podf,data_df,how='inner',on=['Contract_ID','Line Item Description']) # final_po = final_po[['POID','Line Item Description','SUPPLIER','PAYMENTTERMS_PO','POLINENUMBER','POQUANTITY','UNITOFMEASURE','UNITPRICEINORIGINALCURRENCY','POSPENDUSD','Contract_ID','Contracted Payterms','Contracted unit price']] # final_po['Contracted Payterms'] = final_po['Contracted Payterms'].astype(int) # final_po['Contracted unit price'] = final_po['Contracted unit price'].astype(int) # final_po['PAYMENTTERMS_PO'] = final_po['PAYMENTTERMS_PO'].astype(int) # final_po['UNITPRICEINORIGINALCURRENCY'] = final_po['UNITPRICEINORIGINALCURRENCY'].astype(int) # final_po['Purchase Price variance(PO vs Contract)'] = ((final_po['UNITPRICEINORIGINALCURRENCY'] - final_po['Contracted unit price'])/final_po['Contracted unit price'])*100 # final_po['Purchase Price variance(PO vs Contract)'] = final_po['Purchase Price variance(PO vs Contract)'].astype(int) # final_po['Payterm Difference (PO vs Contract)'] = (final_po['Contracted Payterms'] - final_po['PAYMENTTERMS_PO']) # return final_po # uploaded_invoice = st.file_uploader("Upload Open Invoice Data", ["csv","xlsx"]) uploaded_invoice = "C:/Users/01934L744/Box/Baijnath Data/Project 2023/Nidhi/contract/ppv_Script/Invoice data.xlsx" def invoice_data(uploaded_invoice): if uploaded_invoice is not None: fdf = pd.read_excel(uploaded_invoice,sheet_name='Sheet1') final_df = pd.merge(fdf,data_df,how='inner',on=['Contract_ID','Line Item Description']) final_df = final_df[['INVOICE','PO','Contract_ID','Line Item Description','PAYMENTTERMS_PO','Invoice Payterms','Invoice unit price','Contracted Payterms','Contracted unit price','Invoice Gross Value','UNITPRICEINORIGINALCURRENCY']] final_df['Contracted Payterms'] = final_df['Contracted Payterms'].astype(int) final_df['PAYMENTTERMS_PO'] = final_df['PAYMENTTERMS_PO'].astype(int) final_df['Invoice Payterms'] = final_df['Invoice Payterms'].astype(int) final_df['Invoice Gross Value'] = final_df['Invoice Gross Value'].astype(int) final_df['Invoice unit price'] = final_df['Invoice unit price'].astype(int) final_df['Contracted unit price'] = final_df['Contracted unit price'].astype(int) final_df['UNITPRICEINORIGINALCURRENCY'] = final_df['UNITPRICEINORIGINALCURRENCY'].astype(int) # button_first = st.button("View Details",key="12") button_first=True if button_first: final_df['Purchase Price variance(Invoice vs Contract)'] = ((final_df['Invoice unit price'] - final_df['Contracted unit price'])/final_df['Contracted unit price'])*100 final_df['Purchase Price variance(Invoice vs Contract)'] = final_df['Purchase Price variance(Invoice vs Contract)'].astype(int) final_df['Working Capital(Invoice vs Contract)'] = ((final_df['Contracted Payterms'] - final_df['Invoice Payterms'])*final_df['Invoice Gross Value'])/365 final_df = final_df.rename(columns={'INVOICE': 'Document Number', 'PO': 'PO_ID','UNITPRICEINORIGINALCURRENCY':'PO Unit Price','Product Description':'Line item description'}) final_df = final_df[['Document Number','Line Item Description','Invoice Payterms','Invoice unit price','PO_ID','PAYMENTTERMS_PO','PO Unit Price','Contract_ID','Contracted Payterms','Contracted unit price','Invoice Gross Value','Purchase Price variance(Invoice vs Contract)','Working Capital(Invoice vs Contract)']] # st.dataframe(final_df.style.applymap(color_survived, subset=['Purchase Price variance(Invoice vs Contract)','Working Capital(Invoice vs Contract)'])) # button_s = st.button("3-way-Match-Details",key="007") # if button_s: final_df = final_df.rename(columns={'INVOICE': 'Document Number', 'PO': 'PO_ID','UNITPRICEINORIGINALCURRENCY':'PO Unit Price','Product Description':'Line item description','PAYMENTTERMS_PO':'PO Payterms'}) final_s = final_df[['Line Item Description','Contracted unit price','PO Unit Price','Invoice unit price','Contracted Payterms','PO Payterms','Invoice Payterms']] openai.api_key = "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" prompt_s = ['provide the differences in unit price across contract, PO and Invoice from the table in words and also provide summary of contract,po and invoice payterms'] summary = '' summary+= (questions(final_s,prompt_s)) # st.dataframe(final_s) # st.text_area('SUMMARY',summary,height=150) return summary if __name__ == "__main__": # file="C:/Users/01934L744/Box/Baijnath Data/Project 2023/Nidhi/contract/upload_ppv/Contract1.pdf" # result = get_insight(file) # print("result:-------", result) file2="C:/Users/01934L744/Box/Baijnath Data/Project 2023/Nidhi/contract/upload_ppv/PO.xlsx" data_df = pd.read_excel("C:/Users/01934L744/Box/Baijnath Data/Project 2023/Nidhi/contract/upload_ppv/DummyData.xlsx") # result2 = po_data(file2, data_df) # print("result2:--", result2)

2024-01-10

CambioML/uniflow

uniflow~op~model~model_server.py

""" All Model Servers including ModelServerFactory, AbsModelServer, OpenAIModelServer and HuggingfaceModelServer. """ import json import re import warnings from functools import partial from typing import Any, Dict, List, Optional from uniflow.op.model.model_config import ( AzureOpenAIModelConfig, BedrockModelConfig, HuggingfaceModelConfig, LMQGModelConfig, NougatModelConfig, OpenAIModelConfig, ) ############################################################################### # All Model Servers # ############################################################################### class ModelServerFactory: """Model Server Factory.""" _servers = {} @classmethod def register(cls, name: str, server_cls: "AbsModelServer") -> None: """Register model server. Args: name (str): Model server name. server_cls (AbsModelServer): Model server class. """ cls._servers[name] = server_cls @classmethod def get(cls, name: str) -> "AbsModelServer": """Get model server. Args: name (str): Model server name. Returns: AbsModelServer: Model server. Raises: ValueError: If no model server registered under the name. """ server_cls = cls._servers.get(name) if not server_cls: raise ValueError(f"No model server registered under '{name}'") return server_cls @classmethod def list(cls): """List all registered model servers. Returns: List[str]: List of registered model server names. """ return list(cls._servers.keys()) class AbsModelServer: """Abstract Model Server Class.""" def __init_subclass__(cls): """Register model server. This method is called when subclass is created. """ super().__init_subclass__() ModelServerFactory.register(cls.__name__, cls) def __init__(self, model_config: Dict[str, Any]) -> None: """Initialize AbsModelServer class. Args: model_config (Dict[str, Any]): Model config. """ self._model_config = model_config def _preprocess(self, data: str) -> str: """Preprocess data. Args: data (str): Data to preprocess. Returns: str: Preprocessed data. """ raise NotImplementedError def __call__(self, data: str) -> str: """Run model. Args: data (str): Data to run. Returns: str: Output data. """ raise NotImplementedError def _postprocess(self, data: str) -> List[str]: """Postprocess data. Args: data (str): Data to postprocess. Returns: List[str]: Postprocessed data. """ raise NotImplementedError class OpenAIModelServer(AbsModelServer): """OpenAI Model Server Class.""" def __init__(self, model_config: Dict[str, Any]) -> None: # import in class level to avoid installing openai package from openai import OpenAI # pylint: disable=import-outside-toplevel super().__init__(model_config) self._model_config = OpenAIModelConfig(**self._model_config) self._client = OpenAI() def _preprocess(self, data: List[str]) -> List[str]: """Preprocess data. Args: data (List[str]): Data to preprocess. Returns: List[str]: Preprocessed data. """ return data def _postprocess(self, data: List[str]) -> List[str]: """Postprocess data. Args: data (str): Data to postprocess. Returns: List[str]: Postprocessed data. """ return [c.message.content for d in data for c in d.choices] def __call__(self, data: List[str]) -> List[str]: """Run model. OpenAI completions API does not support batch inference. Args: data (str): Data to run. Returns: str: Output data. """ data = self._preprocess(data) inference_data = [] for d in data: inference_data.append( self._client.chat.completions.create( model=self._model_config.model_name, messages=[ {"role": "user", "content": d}, ], n=self._model_config.num_call, temperature=self._model_config.temperature, response_format=self._model_config.response_format, ) ) data = self._postprocess(inference_data) return data class AzureOpenAIModelServer(AbsModelServer): """Azure OpenAI Model Server Class.""" def __init__(self, model_config: Dict[str, Any]) -> None: # import in class level to avoid installing openai package from openai import AzureOpenAI # pylint: disable=import-outside-toplevel super().__init__(model_config) self._model_config = AzureOpenAIModelConfig(**self._model_config) self._client = AzureOpenAI( api_key=self._model_config.api_key, api_version=self._model_config.api_version, azure_endpoint=self._model_config.azure_endpoint, ) def _preprocess(self, data: List[str]) -> List[str]: """Preprocess data. Args: data (List[str]): Data to preprocess. Returns: List[str]: Preprocessed data. """ return data def _postprocess(self, data: List[str]) -> List[str]: """Postprocess data. Args: data (str): Data to postprocess. Returns: List[str]: Postprocessed data. """ return [c.message.content for d in data for c in d.choices] def __call__(self, data: List[str]) -> List[str]: """Run model. Azure OpenAI completions API does not support batch inference. Args: data (str): Data to run. Returns: str: Output data. """ data = self._preprocess(data) inference_data = [] for d in data: inference_data.append( self._client.chat.completions.create( model=self._model_config.model_name, messages=[ {"role": "user", "content": d}, ], n=self._model_config.num_call, temperature=self._model_config.temperature, response_format=self._model_config.response_format, ) ) data = self._postprocess(inference_data) return data class HuggingfaceModelServer(AbsModelServer): """Huggingface Model Server Class.""" def __init__(self, model_config: Dict[str, Any]) -> None: # import in class level to avoid installing transformers package from transformers import pipeline # pylint: disable=import-outside-toplevel from transformers import ( # pylint: disable=import-outside-toplevel AutoModelForCausalLM, AutoTokenizer, ) super().__init__(model_config) self._model_config = HuggingfaceModelConfig(**self._model_config) tokenizer = AutoTokenizer.from_pretrained( self._model_config.model_name, ) tokenizer.pad_token = tokenizer.eos_token model = AutoModelForCausalLM.from_pretrained( self._model_config.model_name, device_map="auto", offload_folder="./offload", load_in_4bit=self._model_config.load_in_4bit, load_in_8bit=self._model_config.load_in_8bit, ) # explicitly set batch_size for pipeline # for batch inference. self._pipeline = pipeline( "text-generation", model=model, tokenizer=tokenizer, device_map="auto", max_new_tokens=768, num_return_sequences=1, repetition_penalty=1.2, eos_token_id=tokenizer.eos_token_id, pad_token_id=tokenizer.pad_token_id, batch_size=self._model_config.batch_size, ) def _preprocess(self, data: List[str]) -> List[str]: """Preprocess data. Args: data (List[str]): Data to preprocess. Returns: List[str]: Preprocessed data. """ return data def _postprocess(self, data: List[str]) -> List[str]: """Postprocess data. Args: data (List[str]): Data to postprocess. Returns: List[str]: Postprocessed data. """ return [d["generated_text"] for output_list in data for d in output_list] def __call__(self, data: List[str]) -> List[str]: """Run model. Args: data (List[str]): Data to run. Returns: List[str]: Output data. """ data = self._preprocess(data) data = self._pipeline(data) data = self._postprocess(data) return data class LMQGModelServer(AbsModelServer): """Huggingface Model Server Class.""" def __init__(self, model_config: Dict[str, Any]) -> None: # import in class level to avoid installing transformers package from lmqg import TransformersQG # pylint: disable=import-outside-toplevel super().__init__(model_config) self._model_config = LMQGModelConfig(**self._model_config) self._model = TransformersQG( model=self._model_config.model_name, max_length=1024 ) def _preprocess(self, data: List[str]) -> List[str]: """Preprocess data. Args: data (List[str]): Data to preprocess. Returns: List[str]: Preprocessed data. """ return data def _postprocess(self, data: List[str]) -> List[str]: """Postprocess data. Args: data (List[str]): Data to postprocess. Returns: List[str]: Postprocessed data. """ return data def __call__(self, data: List[str]) -> List[str]: """Run model. Args: data (List[str]): Data to run. Returns: List[str]: Output data. """ data = self._preprocess(data) data = self._model.generate_qa(data) data = self._postprocess(data) return data class NougatModelServer(AbsModelServer): """Nougat Model Server Class.""" def __init__(self, model_config: Dict[str, Any]) -> None: # import in class level to avoid installing nougat package try: from nougat import NougatModel # pylint: disable=import-outside-toplevel from nougat.utils.checkpoint import ( get_checkpoint, # pylint: disable=import-outside-toplevel ) from nougat.utils.device import ( move_to_device, # pylint: disable=import-outside-toplevel ) except ModuleNotFoundError as exc: raise ModuleNotFoundError( "Please install nougat to use NougatModelServer. You can use `pip install nougat-ocr` to install it." ) from exc super().__init__(model_config) self._model_config = NougatModelConfig(**self._model_config) checkpoint = get_checkpoint(None, model_tag=self._model_config.model_name) self.model = NougatModel.from_pretrained(checkpoint) self.model = move_to_device( self.model, bf16=False, cuda=self._model_config.batch_size > 0 ) self.model.eval() def _preprocess(self, data: str) -> List[str]: """Preprocess data. Args: data (List[str]): Data to preprocess. Returns: List[str]: Preprocessed data. """ return data def _postprocess(self, data: List[str]) -> List[str]: """Postprocess data. Args: data (List[str]): Data to postprocess. Returns: List[str]: Postprocessed data. """ return [d["generated_text"] for output_list in data for d in output_list] def __call__(self, data: List[str]) -> List[str]: """Run model. Args: data (List[str]): Data to run. Returns: List[str]: Output data. """ from nougat.postprocessing import ( markdown_compatible, # pylint: disable=import-outside-toplevel ) from nougat.utils.dataset import ( LazyDataset, # pylint: disable=import-outside-toplevel ) from torch.utils.data import ( # pylint: disable=import-outside-toplevel ConcatDataset, DataLoader, ) outs = [] for pdf in data: dataset = LazyDataset( pdf, partial(self.model.encoder.prepare_input, random_padding=False), None, ) dataloader = DataLoader( ConcatDataset([dataset]), batch_size=1, shuffle=False, collate_fn=LazyDataset.ignore_none_collate, ) predictions = [] page_num = 0 for i, (sample, is_last_page) in enumerate(dataloader): model_output = self.model.inference( image_tensors=sample, early_stopping=False ) # check if model output is faulty for j, output in enumerate(model_output["predictions"]): page_num += 1 if output.strip() == "[MISSING_PAGE_POST]": # uncaught repetitions -- most likely empty page predictions.append(f"\n\n[MISSING_PAGE_EMPTY:{page_num}]\n\n") else: output = markdown_compatible(output) predictions.append(output) if is_last_page[j]: out = "".join(predictions).strip() out = re.sub(r"\n{3,}", "\n\n", out).strip() outs.append(out) return outs class BedrockModelServer(AbsModelServer): """Bedrock Model Server Class. The AWS client authenticates by automatically loading credentials as per the methods outlined here: https://boto3.amazonaws.com/v1/documentation/api/latest/guide/credentials.html If you wish to use a specific credential profile, please provide the profile name from your ~/.aws/credentials file. Make sure that the credentials or roles in use have the necessary policies for Bedrock service access. Additionally, it is important to verify that your boto3 version supports the Bedrock runtime. """ def __init__(self, model_config: Dict[str, Any]) -> None: try: # import in class level to avoid installing boto3 import boto3 super().__init__(model_config) self._model_config = BedrockModelConfig(**self._model_config) # If user specifies profile in model config, use that profile if "aws_profile" in model_config: aws_profile = self._model_config.aws_profile session = boto3.Session(profile_name=aws_profile) # Otherwise if the user specifies credentials directly in the model config, use those credentials elif ( self._model_config.aws_access_key_id and self._model_config.aws_secret_access_key ): session = boto3.Session( aws_access_key_id=self._model_config.aws_access_key_id, aws_secret_access_key=self._model_config.aws_secret_access_key, aws_session_token=self._model_config.aws_session_token, ) warnings.warn( "Using AWS credentials directly in the model config is not recommended. " "Please use a profile instead." ) else: session = boto3.Session(profile_name="default") warnings.warn( "Using default profile to create the session. " "Please pass the profile name in the model config." ) aws_region = ( self._model_config.aws_region if self._model_config.aws_region else None ) self._client = session.client("bedrock-runtime", region_name=aws_region) except ImportError: raise ModuleNotFoundError( "Failed to import the 'boto3' Python package. " "Please install it by running `pip install boto3`." ) except Exception as e: raise ValueError( "Failed to load credentials for authenticating with the AWS client. " "Please ensure that the specified profile name contains valid credentials." ) from e def _preprocess(self, data: List[str]) -> List[str]: """Preprocess data. Args: data (List[str]): Data to preprocess. Returns: List[str]: Preprocessed data. """ return data def _postprocess(self, data: List[str]) -> List[str]: """Postprocess data. Args: data (str): Data to postprocess. Returns: List[str]: Postprocessed data. """ return data def _get_provider(self) -> str: return self._model_config.model_name.split(".")[0] def enforce_stop_tokens(self, text: str, stop: List[str]) -> str: """Cut off the text as soon as any stop words occur.""" return re.split("|".join(stop), text, maxsplit=1)[0] def prepare_input( self, provider: str, prompt: str, model_kwargs: Dict[str, Any] ) -> Dict[str, Any]: """ Prepare the input for the model based on the provider. Args: provider (str): The provider of the model. prompt (str): The input prompt. model_kwargs (Dict[str, Any]): Additional model arguments. Returns: Dict[str, Any]: The prepared input for the model. """ def prepare_anthropic_input( prompt: str, model_kwargs: Dict[str, Any] ) -> Dict[str, Any]: input_body = { **model_kwargs, "prompt": f"\n\nHuman: {prompt}\n\nAssistant: ", } if "max_tokens_to_sample" not in input_body: input_body["max_tokens_to_sample"] = 256 return input_body def prepare_ai21_cohere_meta_input( prompt: str, model_kwargs: Dict[str, Any] ) -> Dict[str, Any]: return {**model_kwargs, "prompt": prompt} def prepare_amazon_input( prompt: str, model_kwargs: Dict[str, Any] ) -> Dict[str, Any]: return {"inputText": prompt, "textGenerationConfig": {**model_kwargs}} def prepare_default_input( prompt: str, model_kwargs: Dict[str, Any] ) -> Dict[str, Any]: return {"inputText": prompt} provider_input_preparation = { "anthropic": prepare_anthropic_input, "ai21": prepare_ai21_cohere_meta_input, "cohere": prepare_ai21_cohere_meta_input, "meta": prepare_ai21_cohere_meta_input, "amazon": prepare_amazon_input, } prepare_input_for_provider = provider_input_preparation.get( provider, prepare_default_input ) return prepare_input_for_provider(prompt, model_kwargs) def prepare_output(self, provider: str, response: Any) -> str: """ Prepares the output based on the provider and response. Args: provider (str): The provider of the response. response (Any): The response object. Returns: str: The prepared output. Raises: None """ def prepare_anthropic_output(response: Any) -> str: response_body = json.loads(response.get("body").read().decode()) return response_body.get("completion") def prepare_ai21_output(response: Any) -> str: response_body = json.loads(response.get("body").read()) return response_body.get("completions")[0].get("data").get("text") def prepare_cohere_output(response: Any) -> str: response_body = json.loads(response.get("body").read()) return response_body.get("generations")[0].get("text") def prepare_meta_output(response: Any) -> str: response_body = json.loads(response.get("body").read()) return response_body.get("generation") def prepare_default_output(response: Any) -> str: response_body = json.loads(response.get("body").read()) return response_body.get("results")[0].get("outputText") provider_output_preparation = { "anthropic": prepare_anthropic_output, "ai21": prepare_ai21_output, "cohere": prepare_cohere_output, "meta": prepare_meta_output, } prepare_output_for_provider = provider_output_preparation.get( provider, prepare_default_output ) return prepare_output_for_provider(response) def invoke_bedrock_model( self, prompt: str, stop: Optional[List[str]] = None, **kwargs: Any, ) -> str: """ Invokes the bedrock model with the given prompt and optional stop tokens. Args: prompt (str): The input prompt for the model. stop (Optional[List[str]]): List of stop tokens to indicate the end of the generated text. **kwargs: Additional keyword arguments to be passed to the model. Please refer to https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters.html for more details. Returns: str: The generated text from the bedrock model. Raises: ValueError: If there is an error raised by the bedrock service. """ provider = self._get_provider() _model_kwargs = self._model_config.model_kwargs or {} params = {**_model_kwargs, **kwargs} # Combine the prompt and model parameters into a single input body input_body = self.prepare_input(provider, prompt, params) body = json.dumps(input_body) accept = "application/json" contentType = "application/json" # Invoke the model try: response = self._client.invoke_model( body=body, modelId=self._model_config.model_name, accept=accept, contentType=contentType, ) except Exception as e: raise ValueError(f"Error raised by bedrock service: {e}") # Perform post-processing on the response text = self.prepare_output(provider, response) if stop is not None: text = self.enforce_stop_tokens(text, stop) return text def __call__(self, data: List[str]) -> List[str]: """Run model. Current bedrock batch inference is implemented by creating asynchronous jobs. At present, we are not temporarily using Batch Inference. Reference: https://docs.aws.amazon.com/bedrock/latest/userguide/batch-inference-create.html Args: data List[str]: Data to run. Returns: str: Output data. """ data = self._preprocess(data) inference_data = [] for d in data: inference_data.append(self.invoke_bedrock_model(prompt=d)) data = self._postprocess(inference_data) return data

2024-01-10

liangz1/mlflow

tests~langchain~test_langchain_model_export.py

import langchain import mlflow import pytest import transformers import json import importlib import openai from contextlib import contextmanager from langchain.chains import ConversationChain, LLMChain from langchain.chains.base import Chain from langchain.chains.qa_with_sources import load_qa_with_sources_chain from langchain.evaluation.qa import QAEvalChain from langchain.llms import HuggingFacePipeline, OpenAI from langchain.llms.base import LLM from langchain.memory import ConversationBufferMemory from langchain.prompts import PromptTemplate from pyspark.sql import SparkSession from typing import Any, List, Mapping, Optional, Dict from tests.helper_functions import pyfunc_serve_and_score_model from mlflow.exceptions import MlflowException from mlflow.openai.utils import ( _mock_chat_completion_response, _mock_request, _MockResponse, TEST_CONTENT, ) @contextmanager def _mock_async_request(content=TEST_CONTENT): with _mock_request(return_value=_mock_chat_completion_response(content)) as m: yield m @pytest.fixture def model_path(tmp_path): return tmp_path.joinpath("model") @pytest.fixture(scope="module") def spark(): with SparkSession.builder.master("local[*]").getOrCreate() as s: yield s @pytest.fixture(autouse=True) def set_envs(monkeypatch): monkeypatch.setenvs( { "MLFLOW_TESTING": "true", "OPENAI_API_KEY": "test", "SERPAPI_API_KEY": "test", } ) importlib.reload(openai) def create_huggingface_model(model_path): architecture = "lordtt13/emo-mobilebert" mlflow.transformers.save_model( transformers_model={ "model": transformers.TFMobileBertForSequenceClassification.from_pretrained( architecture ), "tokenizer": transformers.AutoTokenizer.from_pretrained(architecture), }, path=model_path, ) llm = mlflow.transformers.load_model(model_path) prompt = PromptTemplate( input_variables=["product"], template="What is a good name for a company that makes {product}?", ) hf_pipe = HuggingFacePipeline(pipeline=llm) return LLMChain(llm=hf_pipe, prompt=prompt) def create_openai_llmchain(): llm = OpenAI(temperature=0.9) prompt = PromptTemplate( input_variables=["product"], template="What is a good name for a company that makes {product}?", ) return LLMChain(llm=llm, prompt=prompt) def create_qa_eval_chain(): llm = OpenAI(temperature=0) return QAEvalChain.from_llm(llm) def create_qa_with_sources_chain(): # StuffDocumentsChain return load_qa_with_sources_chain(OpenAI(temperature=0), chain_type="stuff") def create_openai_llmagent(): from langchain.agents import load_tools from langchain.agents import initialize_agent from langchain.agents import AgentType # First, let's load the language model we're going to use to control the agent. llm = OpenAI(temperature=0) # Next, let's load some tools to use. tools = load_tools(["serpapi", "llm-math"], llm=llm) # Finally, let's initialize an agent with the tools. return initialize_agent(tools, llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True) class FakeLLM(LLM): """Fake LLM wrapper for testing purposes.""" queries: Optional[Mapping] = None @property def _llm_type(self) -> str: """Return type of llm.""" return "fake" # pylint: disable=arguments-differ def _call(self, prompt: str, stop: Optional[List[str]] = None, run_manager=None) -> str: """First try to lookup in queries, else return 'foo' or 'bar'.""" if self.queries is not None: return self.queries[prompt] if stop is None: return "foo" else: return "bar" @property def _identifying_params(self) -> Mapping[str, Any]: return {} class FakeChain(Chain): """Fake chain class for testing purposes.""" be_correct: bool = True the_input_keys: List[str] = ["foo"] the_output_keys: List[str] = ["bar"] @property def input_keys(self) -> List[str]: """Input keys.""" return self.the_input_keys @property def output_keys(self) -> List[str]: """Output key of bar.""" return self.the_output_keys # pylint: disable=arguments-differ def _call(self, inputs: Dict[str, str], run_manager=None) -> Dict[str, str]: if self.be_correct: return {"bar": "baz"} else: return {"baz": "bar"} def test_langchain_native_save_and_load_model(model_path): model = create_openai_llmchain() mlflow.langchain.save_model(model, model_path) loaded_model = mlflow.langchain.load_model(model_path) assert type(loaded_model) == langchain.chains.llm.LLMChain assert type(loaded_model.llm) == langchain.llms.openai.OpenAI assert type(loaded_model.prompt) == langchain.prompts.PromptTemplate assert loaded_model.prompt.template == "What is a good name for a company that makes {product}?" def test_langchain_native_log_and_load_model(): model = create_openai_llmchain() with mlflow.start_run(): logged_model = mlflow.langchain.log_model(model, "langchain_model") loaded_model = mlflow.langchain.load_model(logged_model.model_uri) assert "langchain" in logged_model.flavors assert str(logged_model.signature.inputs) == "['product': string]" assert str(logged_model.signature.outputs) == "['text': string]" assert type(loaded_model) == langchain.chains.llm.LLMChain assert type(loaded_model.llm) == langchain.llms.openai.OpenAI assert type(loaded_model.prompt) == langchain.prompts.PromptTemplate assert loaded_model.prompt.template == "What is a good name for a company that makes {product}?" def test_pyfunc_load_openai_model(): model = create_openai_llmchain() with mlflow.start_run(): logged_model = mlflow.langchain.log_model(model, "langchain_model") loaded_model = mlflow.pyfunc.load_model(logged_model.model_uri) assert "langchain" in logged_model.flavors assert type(loaded_model) == mlflow.pyfunc.PyFuncModel def test_langchain_model_predict(): with _mock_request(return_value=_mock_chat_completion_response()): model = create_openai_llmchain() with mlflow.start_run(): logged_model = mlflow.langchain.log_model(model, "langchain_model") loaded_model = mlflow.pyfunc.load_model(logged_model.model_uri) result = loaded_model.predict([{"product": "MLflow"}]) assert result == [TEST_CONTENT] def test_pyfunc_spark_udf_with_langchain_model(spark): model = create_openai_llmchain() with mlflow.start_run(): logged_model = mlflow.langchain.log_model(model, "langchain_model") loaded_model = mlflow.pyfunc.spark_udf(spark, logged_model.model_uri, result_type="string") df = spark.createDataFrame([("MLflow",), ("Spark",)], ["product"]) df = df.withColumn("answer", loaded_model()) pdf = df.toPandas() assert pdf["answer"].tolist() == [TEST_CONTENT, TEST_CONTENT] def test_langchain_log_huggingface_hub_model_metadata(model_path): model = create_huggingface_model(model_path) with mlflow.start_run(): logged_model = mlflow.langchain.log_model(model, "langchain_model") loaded_model = mlflow.langchain.load_model(logged_model.model_uri) assert "langchain" in logged_model.flavors assert str(logged_model.signature.inputs) == "['product': string]" assert str(logged_model.signature.outputs) == "['text': string]" assert type(loaded_model) == langchain.chains.llm.LLMChain assert type(loaded_model.llm) == langchain.llms.huggingface_pipeline.HuggingFacePipeline assert type(loaded_model.prompt) == langchain.prompts.PromptTemplate assert loaded_model.prompt.template == "What is a good name for a company that makes {product}?" def test_langchain_agent_model_predict(): langchain_agent_output = { "id": "chatcmpl-123", "object": "chat.completion", "created": 1677652288, "choices": [ { "index": 0, "finish_reason": "stop", "text": f"Final Answer: {TEST_CONTENT}", } ], "usage": {"prompt_tokens": 9, "completion_tokens": 12, "total_tokens": 21}, } model = create_openai_llmagent() with mlflow.start_run(): logged_model = mlflow.langchain.log_model(model, "langchain_model") loaded_model = mlflow.pyfunc.load_model(logged_model.model_uri) langchain_input = { "input": "What was the high temperature in SF yesterday in Fahrenheit? " "What is that number raised to the .023 power?" } with _mock_request(return_value=_MockResponse(200, langchain_agent_output)): result = loaded_model.predict([langchain_input]) assert result == [TEST_CONTENT] inference_payload = json.dumps({"inputs": langchain_input}) langchain_agent_output_serving = {"predictions": langchain_agent_output} with _mock_request(return_value=_MockResponse(200, langchain_agent_output_serving)): import mlflow.pyfunc.scoring_server as pyfunc_scoring_server from mlflow.deployments import PredictionsResponse response = pyfunc_serve_and_score_model( logged_model.model_uri, data=inference_payload, content_type=pyfunc_scoring_server.CONTENT_TYPE_JSON, extra_args=["--env-manager", "local"], ) assert ( PredictionsResponse.from_json(response.content.decode("utf-8")) == langchain_agent_output_serving ) def test_langchain_native_log_and_load_qaevalchain(): # QAEvalChain is a subclass of LLMChain model = create_qa_eval_chain() with mlflow.start_run(): logged_model = mlflow.langchain.log_model(model, "langchain_model") loaded_model = mlflow.langchain.load_model(logged_model.model_uri) assert model == loaded_model def test_langchain_native_log_and_load_qa_with_sources_chain(): # StuffDocumentsChain is a subclass of Chain model = create_qa_with_sources_chain() with mlflow.start_run(): logged_model = mlflow.langchain.log_model(model, "langchain_model") loaded_model = mlflow.langchain.load_model(logged_model.model_uri) assert model == loaded_model def test_saving_not_implemented_for_memory(): conversation = ConversationChain(llm=OpenAI(temperature=0), memory=ConversationBufferMemory()) with pytest.raises( ValueError, match="Saving of memory is not yet supported.", ): with mlflow.start_run(): mlflow.langchain.log_model(conversation, "conversation_model") def test_saving_not_implemented_chain_type(): chain = FakeChain() with pytest.raises( NotImplementedError, match="Saving not supported for this chain type", ): with mlflow.start_run(): mlflow.langchain.log_model(chain, "fake_chain") def test_unsupported_class(): llm = FakeLLM() with pytest.raises( MlflowException, match="MLflow langchain flavor only supports logging subclasses of " + "langchain.chains.base.Chain", ): with mlflow.start_run(): mlflow.langchain.log_model(llm, "fake_llm")

2024-01-10

Christopher-P/AIQ

AIQ~test_suite~ALE.py

from .common import header, desc import numpy as np import random class ALE(desc): def __init__(self, params): # Gives common variables to all environments super().__init__() try: import gym except: print("Failed to import ALE, make sure you have OpenAI gym + ALE installed!") # Handle Parameters env_name = params['env_name'] # Create GYM instance self.env = gym.make(env_name) self.action_space = self.env.action_space self.observation_space = self.env.observation_space # Store for later self.disc = gym.spaces.discrete.Discrete # Define header #TODO: Check all open ai gym envs to see if action space works the same # Workout num_classes based on action_space type if type(self.observation_space) == self.disc: self.out = [self.observation_space.n] else: self.out = list(self.observation_space.shape) self.header = header(env_name=env_name, input_dim=[self.action_space.n], output_dim=self.out, num_classes=2, info="Simulators gotten from OpenAI Gym", env_min_score = 0.0, env_max_score = 200.0, rl=True) def get_header(self): return self.header def render(self, mode=None): self.env.render() def act(self, action): # OpenAIGym envs only accept numbers for inputs if type(action) == list or type(action) == np.ndarray: action = action[0] self.observation, self.reward_step, self.done, self.info = self.env.step(action) self.reward_total += self.reward_step self.steps += 1 if self.steps >= 2000: self.done = True # If only a number is given as output # turn to one-hot if type(self.observation_space) == self.disc: l = [0] * (self.observation_space.n) l[self.observation] = 1 self.observation = l else: self.observation = self.observation / 255 if self.done: return self.observation, self.reward_total, self.done, self.info else: return self.observation, self.reward_step, self.done, self.info # Used for cem agent def step(self, action): return self.act(action) def reset(self): self.steps = 0 self.observation = None self.reward_step = 0 self.reward_total = 0 self.done = False self.observation = self.env.reset() if type(self.observation_space) == self.disc: l = [0] * (self.observation_space.n) l[self.observation] = 1 self.observation = l else: self.observation = self.observation / 255 return self.observation

2024-01-10

SpyderRex/AutoGPT-for-Android

autogpt~llm~api_manager.py

from __future__ import annotations import openai from autogpt.config import Config from autogpt.llm.modelsinfo import COSTS from autogpt.logs import logger from autogpt.singleton import Singleton class ApiManager(metaclass=Singleton): def __init__(self): self.total_prompt_tokens = 0 self.total_completion_tokens = 0 self.total_cost = 0 self.total_budget = 0 def reset(self): self.total_prompt_tokens = 0 self.total_completion_tokens = 0 self.total_cost = 0 self.total_budget = 0.0 def create_chat_completion( self, messages: list, # type: ignore model: str | None = None, temperature: float = None, max_tokens: int | None = None, deployment_id=None, ) -> str: """ Create a chat completion and update the cost. Args: messages (list): The list of messages to send to the API. model (str): The model to use for the API call. temperature (float): The temperature to use for the API call. max_tokens (int): The maximum number of tokens for the API call. Returns: str: The AI's response. """ cfg = Config() if temperature is None: temperature = cfg.temperature if deployment_id is not None: response = openai.ChatCompletion.create( deployment_id=deployment_id, model=model, messages=messages, temperature=temperature, max_tokens=max_tokens, api_key=cfg.openai_api_key, ) else: try: response = openai.ChatCompletion.create( model=model, messages=messages, temperature=temperature, max_tokens=max_tokens, api_key=cfg.openai_api_key, ) except openai.error.InvalidRequestError: print("Message exceeds gpt-3.5-turbo token limit. Switching to gpt-4") response = openai.ChatCompletion.create( model=cfg.smart_llm_model, messages=messages, temperature=temperature, max_tokens=max_tokens, api_key=cfg.openai_api_key, ) logger.debug(f"Response: {response}") prompt_tokens = response.usage.prompt_tokens completion_tokens = response.usage.completion_tokens self.update_cost(prompt_tokens, completion_tokens, model) return response def update_cost(self, prompt_tokens, completion_tokens, model): """ Update the total cost, prompt tokens, and completion tokens. Args: prompt_tokens (int): The number of tokens used in the prompt. completion_tokens (int): The number of tokens used in the completion. model (str): The model used for the API call. """ self.total_prompt_tokens += prompt_tokens self.total_completion_tokens += completion_tokens self.total_cost += ( prompt_tokens * COSTS[model]["prompt"] + completion_tokens * COSTS[model]["completion"] ) / 1000 logger.debug(f"Total running cost: ${self.total_cost:.3f}") def set_total_budget(self, total_budget): """ Sets the total user-defined budget for API calls. Args: total_budget (float): The total budget for API calls. """ self.total_budget = total_budget def get_total_prompt_tokens(self): """ Get the total number of prompt tokens. Returns: int: The total number of prompt tokens. """ return self.total_prompt_tokens def get_total_completion_tokens(self): """ Get the total number of completion tokens. Returns: int: The total number of completion tokens. """ return self.total_completion_tokens def get_total_cost(self): """ Get the total cost of API calls. Returns: float: The total cost of API calls. """ return self.total_cost def get_total_budget(self): """ Get the total user-defined budget for API calls. Returns: float: The total budget for API calls. """ return self.total_budget

2024-01-10

SpyderRex/AutoGPT-for-Android

autogpt~llm~token_counter.py

"""Functions for counting the number of tokens in a message or string.""" from __future__ import annotations from typing import List from nltk.tokenize import word_tokenize import openai from autogpt.llm.base import Message from autogpt.logs import logger import re def preprocess_text(text: str) -> str: # Normalize whitespace text = re.sub(r'\s+', ' ', text) # Replace specific characters or sequences with placeholders text = re.sub(r'([^\w\s-])', r' \1 ', text) # Separate punctuation from words text = re.sub(r'(\w+)([!"#$%&\'()*+,-./:;<=>?@\[\\\]^_`{|}~])', r'\1 \2 ', text) # Separate hyphens that are not part of words text = re.sub(r'(\s-|-\s)', r' - ', text) return text def count_message_tokens( messages: List[Message], model: str = "gpt-3.5-turbo-0301" ) -> int: """ Returns the number of tokens used by a list of messages. Args: messages (list): A list of messages, each of which is a dictionary containing the role and content of the message. model (str): The name of the model to use for tokenization. Defaults to "gpt-3.5-turbo-0301". Returns: int: The number of tokens used by the list of messages. """ if model == "gpt-3.5-turbo": # !Note: gpt-3.5-turbo may change over time. # Returning num tokens assuming gpt-3.5-turbo-0301.") return count_message_tokens(messages, model="gpt-3.5-turbo-0301") elif model == "gpt-4": # !Note: gpt-4 may change over time. Returning num tokens assuming gpt-4-0314.") return count_message_tokens(messages, model="gpt-4-0314") elif model == "gpt-3.5-turbo-0301": tokens_per_message = ( 4 # every message follows {role/name}\n{content}\n ) tokens_per_name = -1 # if there's a name, the role is omitted elif model == "gpt-4-0314": tokens_per_message = 3 tokens_per_name = 1 else: raise NotImplementedError( f"num_tokens_from_messages() is not implemented for model {model}.\n" " See https://github.com/openai/openai-python/blob/main/chatml.md for" " information on how messages are converted to tokens." ) num_tokens = 0 for message in messages: num_tokens += tokens_per_message for key, value in message.items(): preprocessed_value = preprocess_text(value) num_tokens += len(word_tokenize(preprocessed_value)) if key == "name": num_tokens += tokens_per_name num_tokens += 3 # every reply is primed with assistant return num_tokens def count_string_tokens(string: str, model_name: str) -> int: """ Returns the number of tokens in a text string. Args: string (str): The text string. model_name (str): The name of the encoding to use. (e.g., "gpt-3.5-turbo") Returns: int: The number of tokens in the text string. """ preprocessed_string = preprocess_text(string) return len(word_tokenize(preprocessed_string))

2024-01-10

111989/cartpole_v1

scripts~cartpole_genetic.py

""" Genetic Algorithm/ Neural Network implementation for balancing CartPole-v1 from OpenAI Gym """ from cartpole_environment import MyEnvironment import argparse import numpy as np from bisect import bisect_right import matplotlib.pyplot as plt # NN Agent class Agent: def __init__(self, observation_space: int, action_space_length: int): self.observation_space = observation_space self.action_space_length = action_space_length self.weights = np.random.uniform(low = -1, high = 1, size = (self.observation_space, self.action_space_length)) self.biases = np.random.uniform(low = -1, high = 1, size = (self.action_space_length)) self.fitness = 0 # Returns Agent's action based on input observation def act(self, observation: int) -> int: # Activation function of neurons def sigmoid(x): return 1.0 / (1.0 + np.exp(-x)) a = np.matmul(observation, self.weights) + self.biases x = np.reshape(a = a, newshape = (self.action_space_length)) return np.argmax(sigmoid(x)) class Population: def __init__(self, observation_space: int, action_space_length: int, population_count: int, mutation_rate: float) -> None: self.observation_space = observation_space self.action_space_length = action_space_length self.agents = [Agent(self.observation_space, self.action_space_length) for _ in range(population_count)] self.mutation_rate = mutation_rate def get_cumulative_fitness(self) -> list: cumulative_fitness = [0] for i in range(len(self.agents)): cumulative_fitness.append(cumulative_fitness[-1] + self.agents[i].fitness) return cumulative_fitness def get_parents(self, cumulative_fitness: list): random1 = np.random.uniform(low = 0, high = cumulative_fitness[-1]) random2 = np.random.uniform(low = 0, high = cumulative_fitness[-1]) parent1 = self.agents[bisect_right(a = cumulative_fitness, x = random1)-1] parent2 = self.agents[bisect_right(a = cumulative_fitness, x = random2)-1] return parent1, parent2 def get_successor(self): return Agent(self.observation_space, self.action_space_length) def mutate_successor(self, parent1, parent2, successor): def mutate_weights(parent1, parent2, successor, mutation_rate): for i in range(len(successor.weights)): for j in range(len(successor.weights[i])): if np.random.random() > mutation_rate: successor.weights[i][j] = (parent1.weights[i][j] + parent2.weights[i][j]) / 2.0 else: successor.weights[i][j] = np.random.uniform(-1, 1) def mutate_biases(parent1, parent2, successor, mutation_rate): for i in range(len(successor.biases)): if np.random.random() > mutation_rate: successor.biases[i] = (parent1.biases[i] + parent2.biases[i]) / 2.0 else: successor.biases[i] = np.random.uniform(-1, 1) mutate_weights(parent1, parent2, successor, self.mutation_rate) mutate_biases(parent1, parent2, successor, self.mutation_rate) return successor def plot_statistics(running_accuracy: float) -> None: plt.plot(running_accuracy) plt.xlabel(xlabel = 'Generation') plt.ylabel(ylabel = 'Average Score (Timesteps)') plt.grid() plt.savefig(fname = 'cartpole_genetic.jpg') plt.show() print("...DONE!") def main(): # Initialize gym environment, get inputs for # agents from the environment, and generate # agents. environment = MyEnvironment('CartPole-v1') observation_space = environment.get_observation_space().shape[0] # 4 action_space_length = environment.get_action_space().n # 2 (Left or Right) population = Population(observation_space, action_space_length, population_count, mutation_rate) running_accuracy = [] render_gym = True for generation in range(generations): cumulative_reward = 0.0 for agent in population.agents: # run episode observation = environment.reset() for _ in range(episode_length): if render_gym and 'CartPole' in environment.environment_name: environment.render() action = agent.act(observation) environment.action = action observation, reward, done, _ = environment.step() agent.fitness += reward if done: break cumulative_reward += agent.fitness # Calculate average fitness of the generation # and print performance statistics. Generate # the next generation and update agents. generation_fitness = cumulative_reward / population_count print("Generation: %4d | Average Fitness: %2.0f" % (generation + 1, generation_fitness)) running_accuracy.append(generation_fitness) # Generate the next generation of the # population by means of evolution, and # set them as the new agents. next_generation = [] cumulative_fitness = population.get_cumulative_fitness() while(len(next_generation) < population_count): parent1, parent2 = population.get_parents(cumulative_fitness) successor = population.mutate_successor(parent1, parent2, population.get_successor()) next_generation.append(successor) population.agents = next_generation environment.close() plot_statistics(running_accuracy) if __name__ == "__main__": # parse input arguments parser = argparse.ArgumentParser() parser.add_argument('--generations', type = int, default = 10, help = 'Number of generations') parser.add_argument('--steps', type = int, default = 500, help = 'Episode length') parser.add_argument('--population', type = int, default = 20, help = 'Population count') parser.add_argument('--mutation', type = float, default = 0.01, help = 'Mutation rate') args = vars(parser.parse_args()) generations = int(args['generations']) episode_length = int(args['steps']) population_count = int(args['population']) mutation_rate = float(args['mutation']) main()

2024-01-10

111989/cartpole_v1

scripts~cartpole_q_learning.py

""" Balancing CartPole-v1 from OpenAI Gym by employing Epsilon-Greedy strategy for Q-Learning """ from cartpole_environment import MyEnvironment import gym import argparse import numpy as np import matplotlib.pyplot as plt from IPython import display as i_python_display class Agent: def __init__(self, action_space: gym.spaces.Discrete, action_space_length, observation_space: gym.spaces.Discrete, observation_space_length, n_episodes: int, learning_rate: float, gamma: float): self.action_space = action_space self.action_space_length = action_space_length self.observation_space = observation_space self.observation_space_length = observation_space_length self.n_episodes = n_episodes self.epsilon = np.exp(-5 * np.linspace(0, 1, n_episodes)) self.q_table = np.random.uniform(low = -2, high = 0, size = (self.observation_space_length + [self.action_space_length])) self.learning_rate = learning_rate self.gamma = gamma # Returns an action based on 'epsilon # greedy condition,' i.e., returns a # uniformly sampled random action from # the action space if the random number # generated is less than epsilon, else, # the action that has the highest # Q-value in observation/ state. def act(self, observation: int, episode_number: int) -> int: if np.random.uniform(1.0, 0.0) < self.epsilon[episode_number]: return self.action_space.sample() return np.argmax(self.q_table[observation]) # Estimates the optimal future Q-value # i.e., the maximum Q-value in next # observation, updates the Q-table and # returns the change in Q-value. def update(self, observation: int, action: int, next_observation: int, reward: float) -> float: q_value = self.q_table[observation][action] next_q_value_estimate = np.max(self.q_table[next_observation]) temporal_difference_target = reward + self.gamma * next_q_value_estimate self.q_table[observation][action] += self.learning_rate * (temporal_difference_target - q_value) return self.q_table[observation][action] - q_value def plot_statistics(running_accuracy, running_delta): step_size = round(n_episodes/20) x = np.arange(1, n_episodes, step_size) markers = ["C8-","C20"] fig, (ax1, ax2) = plt.subplots(2, sharex = True) fig.suptitle('Performance vs Episode Number') ax1.plot(x, running_accuracy[1: -1: step_size], markers[0]) ax1.set(ylabel = 'Accuracy') ax2.plot(x, running_delta[1: -1: step_size], markers[1]) ax2.set(ylabel = 'Delta') plt.savefig('cartpole_q_learning.jpg') plt.show() # CartPole actions are modelled as binary # actions (left & right), and CartPole # has discrete action space. The 'epsilon' # value is used to balance 'Exploration' # vs 'Exploitation.' def main(): # display once in every 100 episodes # create and reset environment # get inputs for agent from the environment # create agent # display the environment # initialize performance indicators np.random.seed(111989) DISPLAY_FREQUENCY = 100 environment = MyEnvironment('CartPole-v1') environment.reset() action_space = environment.get_action_space() action_space_length = environment.get_action_space_length() observation_space = environment.get_observation_space() observation_space_length = environment.get_observation_space_length() agent = Agent(action_space, action_space_length, observation_space, observation_space_length, n_episodes, learning_rate, gamma) environment.display_environment() running_length = 5 running_delta, running_accuracy = [], [] render_gym = True # Track the number of episodes completed # (episode_count), the number of actions # that yield maximum reward or successes # (optimal_actions), cumulative reward # and delta update of the Q-table. for episode_index in range(n_episodes): episode_count = 1 optimal_actions = 0 delta_update = [] observation = environment.reset() environment.set_observation(observation) observation = environment.observation done = False while not done: if episode_index % DISPLAY_FREQUENCY == 0: if render_gym and ('CartPole' in environment.environment_name): environment.display_environment() i_python_display.clear_output(wait = True) i_python_display.display(plt.gcf()) # run episode action = agent.act(observation, episode_index) environment.action = action next_observation, reward, done, _ = environment.step() environment.set_observation(next_observation) next_observation = environment.observation delta_update.append(agent.update(observation, action, next_observation, reward)) observation = next_observation optimal_actions += int(reward > 0.0) episode_count += 1 # compute performance statistics and display performance # break if any termination criteria are satisfied running_delta.append(sum(delta_update).item()) running_accuracy.append(optimal_actions/episode_count) print('episode = {}, epsilon = {}, cumulative delta = {}, accuracy = {} \n'.format(episode_index, agent.epsilon[episode_index], running_delta[episode_index], running_accuracy[-1])) if (episode_index >= n_episodes + running_length ) or (all([accuracy == 1.0 for accuracy in running_accuracy]) and all([delta < 0.0001 for delta in running_delta]) and episode_index >= running_length): break i_python_display.clear_output(wait = True) environment.close() plot_statistics(running_accuracy, running_delta) if __name__ == "__main__": #parse input arguments parser = argparse.ArgumentParser() parser.add_argument('--episodes', type = int, default = 10000, help = 'Number of steps in epsilon log-space, or iterations') parser.add_argument('--alpha', type = float, default = 0.1, help = 'Learning rate') parser.add_argument('--gamma', type = float, default = 0.95, help = 'Gamma parameter') args = vars(parser.parse_args()) n_episodes = int(args['episodes']) learning_rate = float(args['alpha']) gamma = float(args['gamma']) main()

2024-01-10

ai-ld/knowledge-gpt

knowledgegpt~utils~utils_completion.py

# https://github.com/openai/openai-cookbook/blob/main/examples/Question_answering_using_embeddings.ipynb sourced from here from knowledgegpt.utils.utils_prompt import construct_prompt import openai import pandas as pd import numpy as np import tiktoken model_types = { "gpt-3.5-turbo": { "temperature": 0.0, "model": "gpt-3.5-turbo", "max_tokens": 1000, }, "gpt-4": { "temperature": 0.0, "model": "gpt-4", "max_tokens": 4096, }, "davinci": { "temperature": 0.0, "model": "text-davinci-003", "max_tokens": 1000, } } def answer_query_with_context( query: str, df: pd.DataFrame, document_embeddings: dict[(str, str), np.array], verbose: bool = False, embedding_type: str = "hf", model_lang: str = "en", is_turbo: bool = False, is_gpt4: bool = False, messages: list = None, index_type: str = "basic", max_tokens=1000, prompt_template=None, context_restarter: bool = False ) -> str: """ Answer a query using the provided context. :param query: The query to answer. :param df: The dataframe containing the document sections. :param document_embeddings: The embeddings of the document sections. :param show_prompt: Whether to print the prompt. :param embedding_type: The type of embedding used. Can be "hf" or "tf". :param model_lang: The language of the model. Can be "en" or "tr". :param is_turbo: Whether to use turbo model or not. Can be "true" or "false". :param messages: The messages to be used in turbo model. :param is_first_time: Whether it is the first time to use turbo model or not. :param max_tokens: The maximum number of tokens to be used in turbo model. :return: The answer to the query. """ if len(messages) < 3 or not is_turbo or context_restarter: prompt = construct_prompt( verbose=verbose, question=query, context_embeddings=document_embeddings, df=df, embedding_type=embedding_type, model_lang=model_lang, max_tokens=max_tokens, index_type=index_type, prompt_template=prompt_template ) if is_turbo: messages.append({"role": "user", "content": prompt}) else: prompt = query if is_turbo: messages.append({"role": "user", "content": prompt}) encoding = encoding = tiktoken.get_encoding("gpt2") if is_turbo: messages_token_length = encoding.encode(str(messages)) if len(messages_token_length) > 4096: del messages[2:4] if not verbose: print(prompt) if not is_turbo : prompt_len = len(encoding.encode(prompt)) model_types["davinci"]["max_tokens"] = 2000 - prompt_len response = openai.Completion.create( prompt=prompt, ** model_types["davinci"] ) else: if is_gpt4: messages_token_length = encoding.encode(str(messages)) model_types["gpt-4"]["max_tokens"] = 8192 - len(messages_token_length) response = openai.ChatCompletion.create( messages=messages, **model_types["gpt-4"], ) else: messages_token_length = encoding.encode(str(messages)) model_types["gpt-3.5-turbo"]["max_tokens"] = 4096 - len(messages_token_length) response = openai.ChatCompletion.create( messages=messages, **model_types["gpt-3.5-turbo"], ) if is_turbo: messages.append({"role": "assistant", "content": response["choices"][0]["message"]["content"].strip(" \n")}) return response["choices"][0]["message"]["content"].strip(" \n"), prompt, messages else: return response["choices"][0]["text"].strip(" \n"), prompt, messages

2024-01-10

DanielFatkic/datto

datto~ModelResults.py

import datetime import os import random import re import string import warnings from html import unescape from math import ceil from operator import itemgetter import graphviz import lime import lime.lime_tabular import matplotlib.pyplot as plt import numpy as np import pandas as pd import shap import spacy import statsmodels.api as sm from gensim.corpora import Dictionary from gensim.models import CoherenceModel, nmf from nltk.corpus import stopwords from sklearn.decomposition import NMF from sklearn.feature_extraction.text import ( ENGLISH_STOP_WORDS, CountVectorizer, TfidfVectorizer, ) from sklearn.feature_selection import VarianceThreshold from sklearn.metrics import ( accuracy_score, classification_report, f1_score, mean_squared_error, median_absolute_error, multilabel_confusion_matrix, precision_score, r2_score, recall_score, ) from sklearn.model_selection import train_test_split from sklearn.tree import export_graphviz from spacy.cli import download from tabulate import tabulate from datto.CleanDataframe import CleanDataframe # Hide precision/recall/f1 warnings for model scorings warnings.filterwarnings("always") try: nlp = spacy.load("en") except Exception: download("en") nlp = spacy.load("en") class ModelResults: def most_similar_texts( self, X, num_examples, text_column_name, num_topics=None, chosen_stopwords=set(), min_df=3, max_df=0.1, min_ngrams=1, max_ngrams=3, ): """ Uses NMF clustering to create n topics based on adjusted word frequencies Parameters -------- X: DataFrame num_examples: int text_column_name: str num_topics: int Optional - if none algorithm will determine best number min_df: float Minimum number/proportion of docs that need to have the words max_df: float Maximum number/proportion of docs that can have the words min_ngrams: int Minimum number of words needed in phrases found max_ngrams: int Maximum number of words in phrases found Returns -------- concated_topics: DataFrame Top n words/phrases per topic original_with_keywords: DataFrame Original text with topic number assigned to each model: NMF model """ X = X[~X[text_column_name].isna()] X = X[X[text_column_name] != ""] X = X[X[text_column_name] != " "] X = X[X[text_column_name] != "NA"] X = X[X[text_column_name] != "n/a"] X = X[X[text_column_name] != "N/A"] X = X[X[text_column_name] != "na"] # Remove HTML & unicode characters X[text_column_name] = X[text_column_name].apply( lambda x: unescape(x) .encode("ascii", errors="ignore") .decode("ascii") .replace(" ", " ") .replace(" ", " ") .replace(" ", " ") .strip() ) all_stop_words = ( # Combine stopwords from all the packages set(ENGLISH_STOP_WORDS) | set(stopwords.words("english")) | nlp.Defaults.stop_words | set(string.punctuation) | set(string.ascii_lowercase) | set( ["-PRON-", " ", "i.e", "e.g.", "-", "--", "---", "----", "..", "...", "....", "w/", "^^", "^^^", "^^^^", "’", "~~", "~~~", "~~~~", "and/or", ] ) | set(chosen_stopwords) ) ct = CleanDataframe() vectorizer = TfidfVectorizer( tokenizer=ct.lematize, ngram_range=(min_ngrams, max_ngrams), stop_words=all_stop_words, min_df=min_df, max_df=max_df, ) vectors = vectorizer.fit_transform(X[text_column_name]).todense() # Adding words/phrases used in text data frequencies back into the dataset (so we can see feature importances later) vocab = vectorizer.get_feature_names() vector_df = pd.DataFrame(vectors, columns=vocab, index=X.index) if X.shape[0] < 20: return "Too few examples to categorize." if not num_topics: # Test out several topic numbers topic_nums = list(np.arange(5, 50, 5)) texts = X[text_column_name].apply(ct.lematize) # In gensim a dictionary is a mapping between words and their integer id dictionary = Dictionary(texts) # Filter out extremes to limit the number of features dictionary.filter_extremes(no_below=2, no_above=0.85, keep_n=5000) # Create the bag-of-words format (list of (token_id, token_count)) corpus = [dictionary.doc2bow(text) for text in texts] coherence_scores = [] for num in topic_nums: model = nmf.Nmf( corpus=corpus, num_topics=num, id2word=dictionary, chunksize=2000, passes=5, kappa=0.1, minimum_probability=0.01, w_max_iter=300, w_stop_condition=0.0001, h_max_iter=100, h_stop_condition=0.001, eval_every=10, normalize=True, random_state=42, ) cm = CoherenceModel( model=model, texts=texts, dictionary=dictionary, coherence="u_mass" ) coherence_scores.append(round(cm.get_coherence(), 5)) scores = list(zip(topic_nums, coherence_scores)) chosen_num_topics = sorted(scores, key=itemgetter(1), reverse=True)[0][0] else: chosen_num_topics = num_topics model = NMF(n_components=chosen_num_topics, random_state=42) model.fit(vectors) component_loadings = model.transform(vectors) top_topics = pd.DataFrame( np.argmax(component_loadings, axis=1), columns=["top_topic_num"] ) top_topics["second_topic"] = (-component_loadings).argsort(axis=1)[:, 1] top_topics["third_topic"] = (-component_loadings).argsort(axis=1)[:, 2] top_topic_loading = pd.DataFrame( np.max(component_loadings, axis=1), columns=["top_topic_loading"] ) X.reset_index(inplace=True, drop=False) vector_df.reset_index(inplace=True, drop=True) # Fix for duplicate text_column_name vector_df.columns = [x + "_vector" for x in vector_df.columns] combined_df = pd.concat([X, vector_df, top_topics, top_topic_loading], axis=1) combined_df.sort_values(by="top_topic_loading", ascending=False, inplace=True) combined_df = pd.concat([X, vector_df, top_topics], axis=1) topic_words = {} sample_texts_lst = [] for topic, comp in enumerate(model.components_): word_idx = np.argsort(comp)[::-1][:num_examples] topic_words[topic] = [vocab[i] for i in word_idx] examples_lst = [ x for x in list( combined_df[combined_df["top_topic_num"] == topic][ text_column_name ].values ) if topic_words[topic][0] in x or topic_words[topic][1] in x or topic_words[topic][2] in x or topic_words[topic][3] in x or topic_words[topic][4] in x ] # If not enough examples, check for second topic loading if len(examples_lst) < num_examples: extra_examples_lst_2 = [ x for x in list( combined_df[combined_df["second_topic"] == topic][ text_column_name ].values ) if topic_words[topic][0] in x or topic_words[topic][1] in x or topic_words[topic][2] in x or topic_words[topic][3] in x or topic_words[topic][4] in x ] examples_lst.extend(extra_examples_lst_2) # If not enough examples still, check for third topic loading if len(examples_lst) < num_examples: extra_examples_lst_3 = [ x for x in list( combined_df[combined_df["third_topic"] == topic][ text_column_name ].values ) if topic_words[topic][0] in x or topic_words[topic][1] in x or topic_words[topic][2] in x or topic_words[topic][3] in x or topic_words[topic][4] in x ] examples_lst.extend(extra_examples_lst_3) # Append examples that have one of the top keywords in topic sample_texts_lst.append(examples_lst[:num_examples]) topic_words_df = pd.DataFrame( columns=[ "topic_num", "num_in_category", "top_words_and_phrases", "sample_texts", ] ) topic_words_df["topic_num"] = [k for k, _ in topic_words.items()] topic_words_df["num_in_category"] = ( combined_df.groupby("top_topic_num").count().iloc[:, 0] ) topic_words_df["top_words_and_phrases"] = [x for x in topic_words.values()] topic_words_df["sample_texts"] = sample_texts_lst topic_words_explode = pd.DataFrame( topic_words_df["sample_texts"].tolist(), index=topic_words_df.index, ) topic_words_explode.columns = [ "example{}".format(num) for num in range(len(topic_words_explode.columns)) ] concated_topics = pd.concat( [ topic_words_df[ ["topic_num", "num_in_category", "top_words_and_phrases"] ], topic_words_explode, ], axis=1, ) print("Topics created with top words & example texts:") print(concated_topics) original_plus_topics = combined_df[list(X.columns) + ["index", "top_topic_num"]] original_with_keywords = pd.merge( original_plus_topics, concated_topics[["topic_num", "top_words_and_phrases"]], left_on="top_topic_num", right_on="topic_num", how="left", )[[text_column_name, "topic_num", "top_words_and_phrases"]] return ( concated_topics, original_with_keywords, model, ) def coefficients_graph( self, X_train, X_test, model, model_type, filename="shap_graph", path="../images/", multiclass=False, y_test=None, ): """ Displays graph of feature importances. * Number of horizontal axis indicates magnitude of effect on target variable (e.g. affected by 0.25) * Red/blue indicates feature value (increasing or decreasing feature has _ effect) * Blue & red mixed together indicate there isn't a clear effect on the target variable * For classification - interpreting magnitude number / x axis - changes the predicted probability of y on average by _ percentage points (axis value * 100) Parameters -------- X_train: pd.DataFrame X_test: pd.DataFrame model: fit model object model_type: str 'classification' or 'regression' filename: str multiclass: bool y_test: pd.DataFrame Only needed for multiclass models """ if not os.path.exists(path): os.makedirs(path) med = X_train.median().values.reshape((1, X_train.shape[1])) # Runs too slow if X_test is huge, take a representative sample if X_test.shape[0] > 1000: X_test_sample = X_test.sample(1000) else: X_test_sample = X_test if multiclass: lst_all_shap_values = [] for class_num in range(len(y_test.columns)): f = lambda x: model.predict_proba(x)[class_num][:, 1] explainer = shap.KernelExplainer(f, med) shap_values = explainer.shap_values(X_test_sample) lst_all_shap_values.append(shap_values) class_name = y_test.columns[class_num] print(f"SHAP Summary Plot for Class: {class_name}") shap.summary_plot(shap_values, X_test_sample) plt.tight_layout() plt.savefig(f"{path}{class_name}_{filename}.png") return np.array(lst_all_shap_values) elif model_type.lower() == "classification": f = lambda x: model.predict_proba(x)[:, 1] else: f = lambda x: model.predict(x) explainer = shap.KernelExplainer(f, med) shap_values = explainer.shap_values(X_test_sample) shap.summary_plot(shap_values, X_test_sample) plt.tight_layout() plt.savefig(f"{path}_{filename}.png") return shap_values def most_common_words_by_group( self, X, text_col_name, group_col_name, num_examples, num_times_min, min_ngram, ): """ Get the most commons phrases for defined groups. Parameters -------- X: DataFrame text_col_name: str group_col_name: str num_examples: int Number of text examples to include per group num_times_min: int Minimum number of times word/phrase must appear in texts min_ngram: int Returns -------- overall_counts_df: DataFrame Has groups, top words, and counts """ # Fix for when column name is the same as an ngram column name X["group_column"] = X[group_col_name] # Remove all other unneeded columns X = X[[text_col_name, "group_column"]] all_stop_words = ( set(ENGLISH_STOP_WORDS) | set(["-PRON-"]) | set(string.punctuation) | set([" "]) ) cv = CountVectorizer( stop_words=all_stop_words, ngram_range=(min_ngram, 3), min_df=num_times_min, max_df=0.4, ) vectors = cv.fit_transform(X[text_col_name]).todense() words = cv.get_feature_names() vectors_df = pd.DataFrame(vectors, columns=words) group_plus_vectors = pd.concat([vectors_df, X.reset_index(drop=False)], axis=1) count_words = pd.DataFrame( group_plus_vectors.groupby("group_column").count()["index"] ) count_words = count_words.loc[:, ~count_words.columns.duplicated()] # Fix for when "count" is an ngram column count_words.columns = ["count_ngrams"] group_plus_vectors = group_plus_vectors.merge( count_words, on="group_column", how="left" ) group_plus_vectors["count_ngrams"].fillna(0, inplace=True) sums_by_col = ( group_plus_vectors[ group_plus_vectors.columns[ ~group_plus_vectors.columns.isin( [ text_col_name, "index", ] ) ] ] .groupby("group_column") .sum() ) sums_by_col.sort_values(by="count_ngrams", ascending=False, inplace=True) sums_by_col.drop("count_ngrams", axis=1, inplace=True) array_sums = np.array(sums_by_col) sums_values_descending = -np.sort(-array_sums, axis=1) sums_indices_descending = (-array_sums).argsort() highest_sum = pd.DataFrame(sums_values_descending[:, 0]) highest_sum.columns = ["highest_sum"] sums_by_col["highest_sum"] = highest_sum["highest_sum"].values overall_counts_df = pd.DataFrame(columns=["group_name", "top_words_and_counts"]) i = 0 for row in sums_by_col.index: dict_scores = {} temp_df = pd.DataFrame(columns=["group_name", "top_words_and_counts"]) temp_df["group_name"] = [row] top_columns = sums_by_col.columns[ sums_indices_descending[i][:num_examples] ].values top_counts = sums_values_descending[i][:num_examples] [dict_scores.update({x: y}) for x, y in zip(top_columns, top_counts)] temp_df["top_words_and_counts"] = [dict_scores] overall_counts_df = overall_counts_df.append([temp_df]) print(f"Group Name: {row}\n") for k, v in dict_scores.items(): print(k, v) print("\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n") i += 1 return overall_counts_df def score_final_model( self, model_type, X_test, y_test, trained_model, multiclass=False ): """ Score your model on the test dataset. Only run this once to get an idea of how your model will perform in realtime. Run it after you have chosen your model & parameters to avoid problems with overfitting. Parameters -------- model_type: str X_test: DataFrame y_test: DataFrame trained_model: sklearn model multiclass: bool Returns -------- model: model Fit model y_predicted: array """ cleaned_date = ( datetime.datetime.today().isoformat(" ", "seconds").replace(" ", "-") ) # Predict actual scores y_predicted = trained_model.predict(X_test) if multiclass: pscore = round(precision_score(y_test, y_predicted, average="weighted"), 3) rscore = round(recall_score(y_test, y_predicted, average="weighted"), 3) ascore = round(accuracy_score(y_test, y_predicted), 3) f1score = round(f1_score(y_test, y_predicted, average="weighted"), 3) with open(f"model_scoring_{cleaned_date}.txt", "w") as f: print(f"Precision Weighted: {pscore}", file=f) print(f"Recall Weighted: {rscore}", file=f) print(f"Accuracy: {ascore}", file=f) print(f"F1 Score Weighted: {f1score}", file=f) print("\n", file=f) # Precision / recall / f1-score for each predicted class report_df = ( pd.DataFrame( classification_report( y_test, y_predicted, target_names=y_test.columns, output_dict=True, ) ) .transpose() .drop(["micro avg", "macro avg", "weighted avg", "samples avg"]) .drop("support", axis=1) ) print( tabulate( report_df, headers="keys", tablefmt="pipe", numalign="left", ), file=f, ) print("\n", file=f) # Counts of predicted vs actuals + true vs false confusion_matrix = multilabel_confusion_matrix(y_test, y_predicted) matrix_dfs = [ pd.DataFrame( matrix, columns=["Predicted False", "Predicted True"], index=["Actual False", "Actual True"], ) for matrix in confusion_matrix ] # Print separately so class name gets printed cleanly first for i in range(len(y_test.columns)): print(y_test.columns[i], file=f) print( tabulate( matrix_dfs[i], headers="keys", tablefmt="pipe", numalign="left", ), file=f, ) print("\n", file=f) elif model_type.lower() == "classification": pscore = round(precision_score(y_test, y_predicted), 3) rscore = round(recall_score(y_test, y_predicted), 3) accuracy = round(accuracy_score(y_test, y_predicted), 3) f1 = round(f1_score(y_test, y_predicted), 3) with open(f"model_scoring_{cleaned_date}.txt", "w") as f: print(f"Precision: {pscore}", file=f) print(f"Recall: {rscore}", file=f) print(f"Accuracy: {accuracy}", file=f) print(f"F1 Score: {f1}", file=f) print("\n", file=f) crosstab = pd.crosstab( np.array(y_test), y_predicted, ) class_values = crosstab.columns crosstab.columns = [f"Predicted {val}" for val in class_values] crosstab.index = [f"Actual {val}" for val in class_values] print( tabulate( crosstab, headers="keys", tablefmt="pipe", numalign="left", ), file=f, ) print("\n", file=f) sum_crosstab = crosstab.to_numpy().sum() prop_crosstab = pd.crosstab( np.array(y_test), y_predicted, ).apply(lambda r: round(r / sum_crosstab, 3)) class_values = prop_crosstab.columns prop_crosstab.columns = [f"Predicted {val}" for val in class_values] prop_crosstab.index = [f"Actual {val}" for val in class_values] print( tabulate( prop_crosstab, headers="keys", tablefmt="pipe", numalign="left", ), file=f, ) else: with open(f"model_scoring_{cleaned_date}.txt", "w") as f: mse = mean_squared_error(y_test, y_predicted) mae = median_absolute_error(y_test, y_predicted) r2 = round(r2_score(y_test, y_predicted), 3) print( f"Mean Negative Root Mean Squared Errror: {round((mse ** 5) * -1, 3)}", file=f, ) print( f"Mean Negative Median Absolute Error: {round((mae * -1), 3)}", file=f, ) print(f"Mean R2: {r2}", file=f) return trained_model, y_predicted def coefficients_summary( self, X, y, num_repetitions, num_coefficients, model_type, multiclass=False, ): """ Prints average coefficient values using a regression model. Parameters -------- X: DataFrame y: DataFrame num_repetitions: int Number of times to create models num_coefficients: int Number of top coefficients to display model_type: str 'classification' or 'regression' multiclass: bool Returns -------- simplified_df: DataFrame Has mean, median, and standard deviation for coefficients after several runs """ coefficients_df = pd.DataFrame( columns=["coeff", "pvals", "conf_lower", "conf_higher"] ) X["intercept"] = 1 for _ in range(num_repetitions): X_train, _, y_train, _ = train_test_split(X, y) # Fix for Singular matrix error vt = VarianceThreshold(0) vt.fit(X_train) cols_to_keep = X_train.columns[np.where(vt.get_support() == True)].values X_train = X_train[cols_to_keep] if multiclass: model = sm.MNLogit( np.array(y_train.astype(float)), X_train.astype(float) ) elif model_type.lower() == "classification": model = sm.Logit(np.array(y_train.astype(float)), X_train.astype(float)) else: model = sm.OLS(np.array(y_train.astype(float)), X_train.astype(float)) results = model.fit() features = results.params.index if multiclass: pvals = [x[0] for x in results.pvalues.values] coeff = [x[0] for x in results.params.values] conf_lower = results.conf_int()["lower"].values conf_higher = results.conf_int()["upper"].values else: pvals = results.pvalues.values coeff = results.params.values conf_lower = results.conf_int()[0] conf_higher = results.conf_int()[1] temp_df = pd.DataFrame( { "features": features, "pvals": pvals, "coeff": coeff, "conf_lower": conf_lower, "conf_higher": conf_higher, } ) temp_df = temp_df[ ["features", "coeff", "pvals", "conf_lower", "conf_higher"] ].reset_index(drop=True) coefficients_df = coefficients_df.append(temp_df) summary_coefficients_df = pd.DataFrame( coefficients_df.groupby("features").agg( [ "mean", "median", ] ) ).reset_index(drop=False) summary_coefficients_df.columns = [ "_".join(col) for col in summary_coefficients_df.columns ] summary_coefficients_df.sort_values("pvals_mean", inplace=True, ascending=True) simplified_df = summary_coefficients_df.head(num_coefficients).round(3) print("Coefficients summary (descending by mean abs se value):") print(simplified_df) return simplified_df def coefficients_individual_predictions( self, model, df, X_train, X_test, id_col, num_id_examples, num_feature_examples, model_type, class_names=["False", "True"], path="../images/", ): """ Uses LIME to inspect an individual prediction and the features that influenced that prediction. Parameters -------- model: sklearn model df: pd.DataFrame Used for getting ids since they aren't typically in training data X_train: pd.DataFrame X_test: pd.DataFrame id_col: str num_id_examples: int num_feature_examples: int model_type: str 'classification' or 'regression' class_names: str path: str Returns -------- features: list """ if not os.path.exists(path): os.makedirs(path) def model_preds_adjusted(data): if model_type.lower() == "classification": predictions = np.array(model.predict_proba(data)) else: predictions = np.array(model.predict(data)) return predictions if model_type.lower() == "classification": explainer = lime.lime_tabular.LimeTabularExplainer( np.array(X_train), feature_names=X_train.columns, class_names=class_names, mode="classification", ) else: explainer = lime.lime_tabular.LimeTabularExplainer( np.array(X_train), feature_names=X_train.columns, class_names=class_names, mode="regression", ) for _ in range(num_id_examples): row_idx = random.sample(list(X_test.index), 1)[0] exp = explainer.explain_instance( np.array(X_test.loc[row_idx]), model_preds_adjusted, # Include all features num_features=len(X_train.columns), # Include all classes top_labels=len(class_names), ) if model_type.lower() == "classification": prediction = class_names[ model.predict_proba(pd.DataFrame(X_test.loc[row_idx]).T).argmax() ] else: prediction = round( model.predict(pd.DataFrame(X_test.loc[row_idx]).T)[0], 7 ) unique_id = df.loc[row_idx][id_col] print(f"\nID: {unique_id}") print(f"Prediction: {prediction}\n\n") exp_list_all = exp.as_list() raw_features = [x[0] for x in exp_list_all] raw_values = [x[1] for x in exp_list_all] cleaned_features = [] for feature in exp_list_all: try: feature_name = re.findall("<.*<|>.*>", feature[0])[0] except Exception: feature_name = re.findall(".*<|.*>", feature[0])[0] cleaned_feature_name = ( feature_name.replace("<=", "") .replace(">=", "") .replace("<", "") .replace(">", "") .strip() ) cleaned_features.append(cleaned_feature_name) all_feature_types = X_test.dtypes top_feature_types = [ all_feature_types[feature] for feature in cleaned_features ] top_features_with_types = [ [raw_feature, cleaned_feature, feature_type, raw_value] for raw_feature, cleaned_feature, feature_type, raw_value in zip( raw_features, cleaned_features, top_feature_types, raw_values ) ] i = 0 for ( raw_feature, cleaned_feature, feature_type, raw_value, ) in top_features_with_types: if i > num_feature_examples: break actual_feature_val = X_test.loc[row_idx][cleaned_feature] # Things that decrease the likelihood of this class are less interesting if raw_value < 0: pass # Note: uint8 is a bool # False bools aren't super interesting elif feature_type == "uint8" and actual_feature_val == 0: pass # Phrase true bools slightly differently elif feature_type == "uint8": print(f"For this id, {cleaned_feature} was true.") print( f"When {cleaned_feature} is true, this increases the likelihood of prediction: {prediction}." ) print("\n--------\n") i += 1 else: print(f"For this id, {cleaned_feature} was {actual_feature_val}.\n") print( f"When {raw_feature}, this increases the likelihood of prediction: {prediction}." ) print("\n--------\n") i += 1 print("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~") fig = plt.figure() # Up the image quality to avoid pixelated graphs plt.rc("savefig", dpi=300) # Limit to top features that can fit cleanly on graph exp_list_graph = exp.as_list()[:20] vals = [x[1] for x in exp_list_graph] # Some labels are really long, shortening them a bit names = [x[0][:40] for x in exp_list_graph] vals.reverse() names.reverse() colors = ["green" if x > 0 else "red" for x in vals] pos = np.arange(len(exp_list_graph)) + 0.5 plt.barh(pos, vals, align="center", color=colors) plt.yticks(pos, names) title = f"id: {unique_id} - Prediction: {prediction}" plt.title(title) plt.tight_layout() # Need bbox to make sure title isn't cut off plt.savefig( f"../images/lime_graph_id_{unique_id}.png", bbox_inches="tight", facecolor="white", ) return exp_list_all def get_tree_diagram(self, model, X_train, path="../images/"): """ Save a diagram of a trained DecisionTree model Parameters -------- model: sklearn model (trained) X_train: pd.DataFrame path: str """ # Exporting text form of decision tree dot_data = export_graphviz( model, out_file=f"{path}decision-tree.dot", feature_names=X_train.columns, filled=True, rounded=True, special_characters=True, ) graph = graphviz.Source(dot_data) # Converting text to a visual png file os.system(f"dot -Tpng {path}decision-tree.dot -o {path}decision-tree.png") # If the file didn't write, try reinstalling graphviz if not os.path.exists(f"{path}decision-tree.png"): os.system("brew install graphviz") os.system(f"dot -Tpng {path}decision-tree.dot -o {path}decision-tree.png") return graph

2024-01-10

ahnaf000/AITutor_ExplainTheConcepts

explain_the_concepts.py

''' Note: Checkout the method header for process_chains() to see how to use the script. ''' from langchain.chat_models import ChatOpenAI from langchain.prompts.chat import ChatPromptTemplate, SystemMessagePromptTemplate, HumanMessagePromptTemplate, AIMessagePromptTemplate from langchain_core.runnables import RunnablePassthrough from langchain_core.output_parsers import StrOutputParser import os from dotenv import load_dotenv from time import time load_dotenv() api_key = os.getenv('OPENAI_API_KEY') # Input parameters - KEEP THE VARIABLES NAMES SAME AND READ IN THE VALUES FROM THE FRONT END course="Data Analytics" background="Software Engineering" name="Raj" topic="p-values" primary_language="English" course_expertise="Novice" # Define pass-through runnables for input variables course_runnable = RunnablePassthrough() background_runnable = RunnablePassthrough() topic_runnable = RunnablePassthrough() name_runnable = RunnablePassthrough() primary_language_runnable = RunnablePassthrough() course_expertise_runnable = RunnablePassthrough() intro_response_runnable = RunnablePassthrough() keyconcepts_response_runnable = RunnablePassthrough() application_response_runnable = RunnablePassthrough() example_response_runnable = RunnablePassthrough() analyze_response_runnable = RunnablePassthrough() # Model Parameters model= "gpt-4"# "gpt-4" # "gpt-4-1106-preview" temperature = .7 max_tokens=256 threshold = 0.7 # Set Up Model llm = ChatOpenAI(model=model,temperature=temperature, openai_api_key=api_key) output_parser = StrOutputParser() ########## Prompt Templates system_template = ''' You are an engaged, humorous and personable expert tutor who help students by explaining the purpose and use of various concepts in {course}. You will always provide assumptions and what needs to be considered and established prior to, during and after using this for {course}. The student's name you are speaking to is {name}. The student is interested in {background}. The student needs to hear your response to match their {course_expertise} level of topic understanding with {topic}. Make your responses relevant to {background}. ''' system_message_prompt=SystemMessagePromptTemplate.from_template(system_template) intro_template = ''' Please briefly define and overview the topic of {topic} in {course} relevant to {background}. ONLY return a top level introduction to this topic. Limit the output to less than 100 words. ''' intro_message_prompt = HumanMessagePromptTemplate.from_template(intro_template) intro_prompt = ChatPromptTemplate.from_messages([system_message_prompt,intro_message_prompt]) keyconcepts_template = ''' Based on the response of {intro_response}: Please provide the following output: - Begin with stating that what you are providing are the key concepts for this topic of {topic} you need to be aware of to effectively apply this. - Next, generate a detailed numbered list of the key concepts I should be aware of when using to {topic}. The output should define the concept and discuss its role and importance related to this topic. Explain any assumptions or tools or methods related to each concept that should be considered. Provide your output response in JSON format to make it easy to parse. The JSON formatted ke concepts should be in the format shown in the area below delineated by ####: #### "1": "Concept 1 ...", "2": "Concept 2 ... #### Limit the output to less than 300 words. ''' keyconcepts_prompt = ChatPromptTemplate.from_template(keyconcepts_template) application_template = ''' Based on the response of {keyconcepts_response}: Please provide a relevant example that demonstrate and clarifies each of these key concepts. Keep in mind that the student has a background in {background}. Your output response should address each of the key concepts listed in the last step and how it is applied with this example. ''' application_prompt = ChatPromptTemplate.from_template(application_template) example_template = ''' Based on the response of {application_response}: Please generate a sample dataset of the example you provided. Provide this in a tabular format on the screen. The format of the data should be one that can be copied and pasted into a spreadsheet like Excel. In the end, return the same data in csv format as well so that the user can copy and paste it into a CSV file. ''' example_prompt = ChatPromptTemplate.from_template(example_template) analyze_template = ''' Based on the response of "{example_response}" and "{application_response}": Now, please analyze this sample data addressing each of the key concepts you described in {keyconcepts_response}. Explain each concept with details on how it relates to the example being discussed and any tools or methods that should be considered. Provide the numeric results as appropriate for each step and what the value means. Summarize the assumptions, context, limitations and interpretations to clarify the results of this analysis. ''' analyze_prompt = ChatPromptTemplate.from_template(analyze_template) visualize_template = ''' Based on the response of {example_response} and {analyze_response}: Please provide any visuals that illustrates {topic} as applied to this example scenario, and the analysis provided above, such that the student can learn how to interpret a real life scenario like this. Provide an explanation for each visual and its relevance to understanding the {topic} topic. Provide python code needed to create the visual plots for this example. ''' visualize_prompt = ChatPromptTemplate.from_template(visualize_template) ########## End of Prompt Templates # Build the LCEL Chain ############################################## def process_chains(): """ Processes a series of chains, written in LCEL format, to help a student learn a particular topic given the following variables are set: course, background, name, topic, primary_language, course_expertise. Each chain in the sequence performs a specific function, starting with an introduction, then identifying key concepts, applying those concepts, providing examples, analyzing the example, and finally visualizing the results. Yields: - Each chain's response in sequence, representing the progress through the chain. Example Usage from front end: ```python from explain_the_concepts import process_chains for response in process_chains(): print(response) ``` Note: This function assumes that all necessary components and runnables (like `topic_runnable`, `intro_prompt`, `llm`, etc.) are already defined and properly set up. """ start_time = time() # to measure overall time taken ################## CHAIN 1 ############################ start = time() intro_chain = ( {"topic": topic_runnable, "background": background_runnable, "name": name_runnable, "course": course_runnable, "course_expertise": course_expertise_runnable} | intro_prompt | llm | output_parser ) intro_response = intro_chain.invoke({ "topic": topic, "background": background, "name": name, "course": course, "course_expertise": course_expertise }) print(f"{'-'*40}\nIntro Response:\n{'-'*40}") print(intro_response) yield(intro_response) end = time() print(f"{'-'*20}\nTime Taken for Intro Chain: {end-start:.2f} s\n{'-'*20}\n") ################## CHAIN 2 ############################ start = time() keyconcepts_chain = ( {"intro_response": intro_response_runnable, "topic": topic_runnable} | keyconcepts_prompt | llm | output_parser ) keyconcepts_response = keyconcepts_chain.invoke({ "intro_response": intro_response, "topic": topic, }) yield(keyconcepts_response) print(f"{'-'*40}\nKeyconcepts Response:\n{'-'*40}") print(keyconcepts_response) end = time() print(f"{'-'*20}\nTime Taken for Keyconcepts Chain: {end-start:.2f} s\n{'-'*20}\n") ################## CHAIN 3 ############################ start = time() application_chain = ( {"keyconcepts_response": keyconcepts_response_runnable, "background": background_runnable} | application_prompt | llm #ChatOpenAI(temperature=temperature, openai_api_key=api_key) gpt3.5 ~ 14 s, gpt 4 ~ 15 s | output_parser ) application_response = application_chain.invoke({ "keyconcepts_response": keyconcepts_response, "background": background }) yield(application_response) print(f"{'-'*40}\nApplication Response:\n{'-'*40}") print(application_response) end = time() print(f"{'-'*20}\nTime Taken for Applications Chain: {end-start:.2f} s") ################## CHAIN 4 ############################ start = time() example_chain = ( {"application_response": application_response_runnable} | example_prompt | llm | output_parser ) example_response = example_chain.invoke({ "application_response": application_response }) yield(example_response) print(f"{'-'*40}\nExample Response:\n{'-'*40}") print(example_response) end = time() print(f"{'-'*20}\nTime Taken for Example Chain: {end-start:.2f} s\n{'-'*20}\n") ################## CHAIN 5 ############################ start = time() analyze_chain = ( {"example_response": example_response_runnable, "application_response": application_response_runnable, "keyconcepts_response": keyconcepts_response_runnable} | analyze_prompt | llm | output_parser ) analyze_response = analyze_chain.invoke({ "example_response": example_response, "application_response": application_response, "keyconcepts_response": keyconcepts_response }) yield(analyze_response) print(f"{'-'*40}\nAnalyze Response:\n{'-'*40}") print(analyze_response) end = time() print(f"{'-'*20}\nTime Taken for Analyze Chain: {end-start:.2f} s\n{'-'*20}\n") ################## CHAIN 6 ############################ start = time() visualize_chain = ( {"example_response": example_response_runnable, "analyze_response": analyze_response_runnable, "topic": topic_runnable} | visualize_prompt | llm | output_parser ) visualize_response = visualize_chain.invoke({ "example_response": example_response, "analyze_response": analyze_response, "topic": topic }) yield(visualize_response) print(f"{'-'*40}\nVisualize Response:\n{'-'*40}") print(visualize_response) end = time() print(f"{'-'*20}\nTime Taken for Visualize Chain: {end-start:.2f} s\n{'-'*20}\n") end_time = time() print(f"{'*'*20}\nTotal Time Taken: {end_time-start_time:.2f} s") if __name__ =="__main__": for response in process_chains(): pass #print(response) # Here, instead of printing, you can send this response to your front end else: for response in process_chains(): print(response)

2024-01-10

ahnaf000/AITutor_ExplainTheConcepts

aitutor.py

from langchain.chat_models import ChatOpenAI from langchain.prompts.chat import ChatPromptTemplate,SystemMessagePromptTemplate,HumanMessagePromptTemplate,AIMessagePromptTemplate from langchain.chains import SequentialChain, LLMChain import datetime from dotenv import load_dotenv import os load_dotenv() # This loads the environment variables from the .env file # Now you can access your API key api_key = os.getenv('OPENAI_API_KEY') start = datetime.datetime.now() # Set Input Variables model="gpt-4" # model="gpt-4-1106-preview" temperature = .7 max_tokens=256 threshold = 0.7 # we should add a penality setting with the Chat model for asking the same question. #Collect these variables from the student profile and the topic/background input text boxes. course="Data Analytics" background="Software Engineering" name="Raj" topic="p-values" primary_language="English" course_expertise="Novice" # Link to OpenAI LLM llm = ChatOpenAI(model=model,temperature=temperature, openai_api_key=api_key) ###################### """BUILD THE CHAIN""" ###################### system_template = ''' You are an engaged, humorous and personable expert tutor who help students by explaining the purpose and use of various concepts in {course}. You will always provide assumptions and what needs to be considered and established prior to, during and after using this for {course}. The student's name you are speaking to is {name}. The student is interested in {background}. The student needs to hear your response to match their {course_expertise} level of topic understanding with {topic}. Make your responses relevant to {background}. ''' system_message_prompt=SystemMessagePromptTemplate.from_template(system_template) intro_template = ''' Please briefly define and overview the topic of {topic} in {course} relevant to {background}. ONLY return a top level introduction to this topic. Limit the output to less than 100 words. ''' intro_message_prompt = HumanMessagePromptTemplate.from_template(intro_template) intro_prompt = ChatPromptTemplate.from_messages([system_message_prompt,intro_message_prompt]) chain_intro = LLMChain(llm=llm, prompt=intro_prompt, output_key="intro_response") keyconcepts_template = ''' Based on the response of {intro_response}: Please provide the following output: - Begin with stating that what you are providing are the key concepts for this topic of {topic} you need to be aware of to effectively apply this. - Next, generate a detailed numbered list of the key concepts I should be aware of when using to {topic}. The output should define the concept and discuss its role and importance related to this topic. Explain any assumptions or tools or methods related to each concept that should be considered. Provide your output response in JSON format to make it easy to parse. The JSON formatted ke concepts should be in the format shown in the area below delineated by ####: #### "1": "Concept 1 ...", "2": "Concept 2 ... #### Limit the output to less than 300 words. ''' keyconcepts_prompt = ChatPromptTemplate.from_template(keyconcepts_template) chain_keyconcepts = LLMChain(llm=llm, prompt=keyconcepts_prompt, output_key="keyconcepts_response") application_template = ''' Based on the response of {keyconcepts_response}: Please provide a description of a relevant example that demonstrate and clarifies each of these key concepts. Your output response should address each of the key concepts listed in the last step and how it is applied with this example. ''' application_prompt = ChatPromptTemplate.from_template(application_template) chain_application = LLMChain(llm=llm, prompt=application_prompt, output_key="application_response") example_template = ''' Based on the response of {application_response}: Please generate a sample dataset of the example you provided. Provide this in a tabular format on the screen. The format of the data should be one that can be copied and pasted into a spreadsheet like Excel. Save this table and make it available as a CSV file for the user. ''' example_prompt = ChatPromptTemplate.from_template(example_template) chain_example = LLMChain(llm=llm, prompt=example_prompt, output_key="example_response") analyze_template = ''' Based on the response of {example_response} and {application_response}: Now, please analyze this sample data addressing each of the key concepts you described above. Explain each concept with details on how it relates to the example being discussed and any tools or methods that should be considered. Provide the numeric results as appropriate for each step and what the value means. Summarize the assumptions, context, limitations and interpretations to clarify the results of this analysis. ''' analyze_prompt = ChatPromptTemplate.from_template(analyze_template) chain_analyze = LLMChain(llm=llm, prompt=analyze_prompt, output_key="analyze_response") visualize_template = ''' Based on the response of (example_response) and {analyze_response}: Please provide any visuals that illustrates {topic} as applied to this example and is best used for interpreting the results. Provide an explanation for each visual and its relevance to understanding the {topic} topic. Provide both the visual images as PNG files and as python code needed to create them for this example. ''' visualize_prompt = ChatPromptTemplate.from_template(visualize_template) chain_visualize = LLMChain(llm=llm, prompt=visualize_prompt, output_key="visualize_response") def process_chains(topic, background, name, course, course_expertise): # Chain 1: Intro and Key Concepts intro_and_keyconcepts_chain = SequentialChain( chains=[ chain_intro, chain_keyconcepts ], input_variables=[ 'topic', 'background', 'name', 'course', 'course_expertise' ], output_variables=[ "intro_response", "keyconcepts_response" ], verbose=True ) intro_and_keyconcepts_results = intro_and_keyconcepts_chain(inputs={ 'topic': topic, 'background': background, 'name': name, 'course': course, 'course_expertise': course_expertise }) yield intro_and_keyconcepts_results['intro_response'] yield intro_and_keyconcepts_results['keyconcepts_response'] # Chain 2: Application and Example application_and_example_chain = SequentialChain( chains=[ chain_application, chain_example ], input_variables=[ 'topic', 'background', 'name', 'course', 'course_expertise', 'intro_response', 'keyconcepts_response' ], output_variables=[ "application_response", "example_response" ], verbose=True ) application_and_example_results = application_and_example_chain(inputs={ 'topic': topic, 'background': background, 'name': name, 'course': course, 'course_expertise': course_expertise, 'intro_response': intro_and_keyconcepts_results['intro_response'], 'keyconcepts_response': intro_and_keyconcepts_results['keyconcepts_response'] }) yield application_and_example_results['application_response'] yield application_and_example_results['example_response'] # quality, cost, maintainability # Try Streaming and batching # trade off: gpt-4 vs gpt 4 turbo # Chain 3: Analyze analysis_chain = SequentialChain( chains=[ chain_analyze ], input_variables=[ 'topic', 'background', 'name', 'course', 'course_expertise', 'intro_response', 'keyconcepts_response', 'application_response', 'example_response' ], output_variables=[ "analyze_response" ], verbose=True ) analysis_results = analysis_chain(inputs={ 'topic': topic, 'background': background, 'name': name, 'course': course, 'course_expertise': course_expertise, 'intro_response': intro_and_keyconcepts_results['intro_response'], 'keyconcepts_response': intro_and_keyconcepts_results['keyconcepts_response'], 'application_response': application_and_example_results['application_response'], 'example_response': application_and_example_results['example_response'] }) yield analysis_results['analyze_response'] # Chain 4: Visualize visualization_chain = SequentialChain( chains=[ chain_visualize ], input_variables=[ 'topic', 'background', 'name', 'course', 'course_expertise', 'intro_response', 'keyconcepts_response', 'application_response', 'example_response', 'analyze_response' ], output_variables=[ "visualize_response" ], verbose=True ) visualization_results = visualization_chain(inputs={ 'topic': topic, 'background': background, 'name': name, 'course': course, 'course_expertise': course_expertise, 'intro_response': intro_and_keyconcepts_results['intro_response'], 'keyconcepts_response': intro_and_keyconcepts_results['keyconcepts_response'], 'application_response': application_and_example_results['application_response'], 'example_response': application_and_example_results['example_response'], 'analyze_response': analysis_results['analyze_response'] }) yield visualization_results['visualize_response'] if __name__ =="__main__": for response in process_chains(topic, background, name, course, course_expertise): print(response) # Here, instead of printing, you can send this response to your front end """ # Break down the sequntial chain seq_chain_1 = SequentialChain( chains=[chain_intro,chain_keyconcepts], input_variables=['topic','background','name','course','course_expertise'], output_variables= ["intro_response","keyconcepts_response"], verbose=True ) results_1 = seq_chain_1(inputs={'topic':topic, 'background':background, 'name':name, 'course':course, 'course_expertise':course_expertise} ) print(results_1['intro_response']) print(results_1['keyconcepts_response']) ################################################################# seq_chain_2 = SequentialChain( chains=[chain_application,chain_example], input_variables=['topic','background','name','course','course_expertise', 'intro_response', 'keyconcepts_response'], output_variables= ["application_response","example_response"], verbose=True ) results_2 = seq_chain_2(inputs={'topic':topic, 'background':background, 'name':name, 'course':course, 'course_expertise':course_expertise, 'intro_response':results_1['intro_response'], 'keyconcepts_response':results_1['keyconcepts_response']} ) print(results_2['application_response']) print(results_2['example_response']) #################################################################### seq_chain_3 = SequentialChain( chains=[chain_analyze], input_variables=['topic', 'background', 'name', 'course', 'course_expertise', 'intro_response', 'keyconcepts_response', 'application_response', 'example_response'], output_variables=["analyze_response"], verbose=True ) results_3 = seq_chain_3(inputs={'topic': topic, 'background': background, 'name': name, 'course': course, 'course_expertise': course_expertise, 'intro_response': results_1['intro_response'], 'keyconcepts_response': results_1['keyconcepts_response'], 'application_response': results_2['application_response'], 'example_response': results_2['example_response']} ) print(results_3['analyze_response']) #################################################################### seq_chain_4 = SequentialChain( chains=[chain_visualize], input_variables=['topic', 'background', 'name', 'course', 'course_expertise', 'intro_response', 'keyconcepts_response', 'application_response', 'example_response', 'analyze_response'], output_variables=["visualize_response"], verbose=True ) results_4 = seq_chain_4(inputs={'topic': topic, 'background': background, 'name': name, 'course': course, 'course_expertise': course_expertise, 'intro_response': results_1['intro_response'], 'keyconcepts_response': results_1['keyconcepts_response'], 'application_response': results_2['application_response'], 'example_response': results_2['example_response'], 'analyze_response': results_3['analyze_response']} ) print(results_4['visualize_response']) """ ''' # BUILD THE SEQUENTIAL CHAIN seq_chain = SequentialChain(chains=[chain_intro,chain_keyconcepts,chain_application,chain_example,chain_analyze,chain_visualize], input_variables=['topic','background','name','course','course_expertise'], output_variables=["intro_response","keyconcepts_response","application_response","example_response","analyze_response","visualize_response"], verbose=True) # SEND THE INPUTS TO THE CHAIN results = seq_chain(inputs={'topic':topic, 'background':background, 'name':name, 'course':course, 'course_expertise':course_expertise} ) print(results['intro_response']) print(results['keyconcepts_response']) print(results['application_response']) print(results['example_response']) print(results['analyze_response']) print(results['visualize_response']) print(f"Time Taken {(datetime.datetime.now()-start)}") '''

2024-01-10

ahnaf000/AITutor_ExplainTheConcepts

explain_the_concepts_new.py

""" Note: Checkout the method header for process_chains() to see how to use the script. """ from langchain.chat_models import ChatOpenAI from langchain.prompts.chat import ( ChatPromptTemplate, SystemMessagePromptTemplate, HumanMessagePromptTemplate, AIMessagePromptTemplate, ) from langchain_core.runnables import RunnablePassthrough from langchain_core.output_parsers import StrOutputParser import os from dotenv import load_dotenv from time import time os.environ["LANGCHAIN_TRACING_V2"] = "true" os.environ["LANGCHAIN_ENDPOINT"] = "https://api.smith.langchain.com" os.environ["LANGCHAIN_API_KEY"] = "ls__ab0da2b88e6743e48e12dc5a8c9c5b22" os.environ["LANGCHAIN_PROJECT"] = "Explain_the_Concept_LCEL" load_dotenv() api_key = os.getenv("OPENAI_API_KEY") # Input parameters - KEEP THE VARIABLES NAMES SAME AND READ IN THE VALUES FROM THE FRONT END course = "Data Analytics" background = "Software Engineering" name = "Raj" topic = "p-values" primary_language = "English" course_expertise = "Novice" # Define pass-through runnables for input variables course_runnable = RunnablePassthrough() background_runnable = RunnablePassthrough() topic_runnable = RunnablePassthrough() name_runnable = RunnablePassthrough() primary_language_runnable = RunnablePassthrough() course_expertise_runnable = RunnablePassthrough() intro_response_runnable = RunnablePassthrough() keyconcepts_response_runnable = RunnablePassthrough() application_response_runnable = RunnablePassthrough() example_response_runnable = RunnablePassthrough() analyze_response_runnable = RunnablePassthrough() # Model Parameters model = "gpt-4-1106-preview"#"gpt-4" # "gpt-4" # "gpt-4-1106-preview" temperature = 0.7 max_tokens = 256 threshold = 0.7 # Set Up Model llm = ChatOpenAI(model=model, temperature=temperature, openai_api_key=api_key) output_parser = StrOutputParser() ########## Prompt Templates system_template = """ You are an engaged, humorous and personable expert tutor who help students by explaining the purpose and use of various concepts in {course}. You will always provide assumptions and what needs to be considered and established prior to, during and after using this for {course}. The student's name you are speaking to is {name}. The student is interested in {background}. The student needs to hear your response to match their {course_expertise} level of topic understanding with {topic}. Make your responses relevant to {background}. """ system_message_prompt = SystemMessagePromptTemplate.from_template(system_template) intro_template = """ Please briefly define and overview the topic of {topic} in {course} relevant to {background}. ONLY return a top level introduction to this topic. Limit the output to less than 100 words. """ intro_message_prompt = HumanMessagePromptTemplate.from_template(intro_template) intro_prompt = ChatPromptTemplate.from_messages( [system_message_prompt, intro_message_prompt] ) keyconcepts_template = """ Based on the response of {intro_response}: Please provide the following output: - Begin with stating that what you are providing are the key concepts for this topic of {topic} you need to be aware of to effectively apply this. - Next, generate a detailed numbered list of the key concepts I should be aware of when using to {topic}. The output should define the concept and discuss its role and importance related to this topic. Explain any assumptions or tools or methods related to each concept that should be considered. Provide your output response in JSON format to make it easy to parse. The JSON formatted key concepts should be in the format shown in the area below delineated by ####: #### "1": "Concept 1 ...", "2": "Concept 2 ... #### Limit the output to less than 300 words. """ keyconcepts_prompt = ChatPromptTemplate.from_template(keyconcepts_template) application_template = """ Based on the response of {keyconcepts_response}: Please provide a relevant example that demonstrate and clarifies each of these key concepts. Keep in mind that the student has a background in {background}. Your output response should address each of the key concepts listed in the last step and how it is applied with this example. """ application_prompt = ChatPromptTemplate.from_template(application_template) example_template = """ Based on the response of {application_response}: Please generate a sample dataset of the example you provided. Provide this in a tabular format on the screen. The format of the data should be one that can be copied and pasted into a spreadsheet like Excel. In the end, return the same data in csv format as well so that the user can copy and paste it into a CSV file. """ example_prompt = ChatPromptTemplate.from_template(example_template) analyze_template = """ Based on the response of "{example_response}" and "{application_response}": Now, please analyze this sample data addressing each of the key concepts you described in {keyconcepts_response}. Explain each concept with details on how it relates to the example being discussed and any tools or methods that should be considered. Provide the numeric results as appropriate for each step and what the value means. Summarize the assumptions, context, limitations and interpretations to clarify the results of this analysis. """ analyze_prompt = ChatPromptTemplate.from_template(analyze_template) visualize_template = """ Based on the response of {example_response} and {analyze_response}: Please provide any visuals that illustrates {topic} as applied to this example scenario, and the analysis provided above, such that the student can learn how to interpret a real life scenario like this. Provide an explanation for each visual and its relevance to understanding the {topic} topic. Provide python code needed to create the visual plots for this example. """ visualize_prompt = ChatPromptTemplate.from_template(visualize_template) ########## End of Prompt Templates # Build the LCEL Chain ############################################## def process_chains(): """ Processes a series of chains, written in LCEL format, to help a student learn a particular topic given the following variables are set: course, background, name, topic, primary_language, course_expertise. Each chain in the sequence performs a specific function, starting with an introduction, then identifying key concepts, applying those concepts, providing examples, analyzing the example, and finally visualizing the results. Yields: - Each chain's response in sequence, representing the progress through the chain. Example Usage from front end: ```python from explain_the_concepts import process_chains for response in process_chains(): print(response) ``` Note: This function assumes that all necessary components and runnables (like `topic_runnable`, `intro_prompt`, `llm`, etc.) are already defined and properly set up. """ start_time = time() # to measure overall time taken ################## CHAIN 1 ############################ start = time() intro_chain = ( { "topic": topic_runnable, "background": background_runnable, "name": name_runnable, "course": course_runnable, "course_expertise": course_expertise_runnable, } | intro_prompt | ChatOpenAI(temperature=temperature, openai_api_key=api_key) | output_parser ) intro_response = intro_chain.invoke( { "topic": topic, "background": background, "name": name, "course": course, "course_expertise": course_expertise, } ) print(f"{'-'*40}\nIntro Response:\n{'-'*40}") print(intro_response) yield (intro_response) end = time() print(f"{'-'*20}\nTime Taken for Intro Chain: {end-start:.2f} s\n{'-'*20}\n") ################## CHAIN 2 ############################ start = time() keyconcepts_chain = ( {"intro_response": intro_response_runnable, "topic": topic_runnable} | keyconcepts_prompt | llm#ChatOpenAI(model = "gpt-4", temperature=temperature, openai_api_key=api_key) | output_parser ) keyconcepts_response = keyconcepts_chain.invoke( { "intro_response": intro_response, "topic": topic, } ) yield (keyconcepts_response) print(f"{'-'*40}\nKeyconcepts Response:\n{'-'*40}") print(keyconcepts_response) end = time() print(f"{'-'*20}\nTime Taken for Keyconcepts Chain: {end-start:.2f} s\n{'-'*20}\n") ################## CHAIN 3 ############################ start = time() application_chain = ( { "keyconcepts_response": keyconcepts_response_runnable, "background": background_runnable, } | application_prompt | llm#ChatOpenAI(model = "gpt-4", temperature=temperature, openai_api_key=api_key) | output_parser ) application_response = application_chain.invoke( {"keyconcepts_response": keyconcepts_response, "background": background} ) yield (application_response) print(f"{'-'*40}\nApplication Response:\n{'-'*40}") print(application_response) end = time() print(f"{'-'*20}\nTime Taken for Applications Chain: {end-start:.2f} s") ################## CHAIN 4 ############################ start = time() example_chain = ( {"application_response": application_response_runnable} | example_prompt | ChatOpenAI(temperature=temperature, openai_api_key=api_key) | output_parser ) example_response = example_chain.invoke( {"application_response": application_response} ) yield (example_response) print(f"{'-'*40}\nExample Response:\n{'-'*40}") print(example_response) end = time() print(f"{'-'*20}\nTime Taken for Example Chain: {end-start:.2f} s\n{'-'*20}\n") ################## CHAIN 5 ############################ start = time() analyze_chain = ( { "example_response": example_response_runnable, "application_response": application_response_runnable, "keyconcepts_response": keyconcepts_response_runnable, } | analyze_prompt | llm | output_parser ) analyze_response = analyze_chain.invoke( { "example_response": example_response, "application_response": application_response, "keyconcepts_response": keyconcepts_response, } ) yield (analyze_response) print(f"{'-'*40}\nAnalyze Response:\n{'-'*40}") print(analyze_response) end = time() print(f"{'-'*20}\nTime Taken for Analyze Chain: {end-start:.2f} s\n{'-'*20}\n") ################## CHAIN 6 ############################ start = time() visualize_chain = ( { "example_response": example_response_runnable, "analyze_response": analyze_response_runnable, "topic": topic_runnable, } | visualize_prompt | ChatOpenAI(model = "gpt-4", temperature=temperature, openai_api_key=api_key) #llm | output_parser ) visualize_response = visualize_chain.invoke( { "example_response": example_response, "analyze_response": analyze_response, "topic": topic, } ) yield (visualize_response) print(f"{'-'*40}\nVisualize Response:\n{'-'*40}") print(visualize_response) end = time() print(f"{'-'*20}\nTime Taken for Visualize Chain: {end-start:.2f} s\n{'-'*20}\n") end_time = time() print(f"{'*'*20}\nTotal Time Taken: {end_time-start_time:.2f} s") if __name__ == "__main__": for response in process_chains(): pass # print(response) # Here, instead of printing, you can send this response to your front end # else: # for response in process_chains(): # print(response)

2024-01-10

stanleee5/bigcode-evaluation

bigeval~metrics~execute.py

# 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. # This code is adapted from OpenAI's release # https://github.com/openai/human-eval/blob/master/human_eval/execution.py import contextlib import faulthandler import io import multiprocessing import os import platform import signal import tempfile def check_correctness(check_program, timeout, task_id, completion_id): """ Evaluates the functional correctness of a completion by running the test suite provided in the problem. :param completion_id: an optional completion ID so we can match the results later even if execution finishes asynchronously. """ manager = multiprocessing.Manager() result = manager.list() p = multiprocessing.Process( target=unsafe_execute, args=(check_program, result, timeout) ) p.start() p.join(timeout=timeout + 1) if p.is_alive(): p.kill() if not result: result.append("timed out") return dict( task_id=task_id, passed=result[0] == "passed", result=result[0], completion_id=completion_id, ) def unsafe_execute(check_program, result, timeout): with create_tempdir(): # These system calls are needed when cleaning up tempdir. import os import shutil rmtree = shutil.rmtree rmdir = os.rmdir chdir = os.chdir # Disable functionalities that can make destructive changes to the test. reliability_guard() # Run program. try: exec_globals = {} with swallow_io(): with time_limit(timeout): exec(check_program, exec_globals) result.append("passed") except TimeoutException: result.append("timed out") except BaseException as e: result.append(f"failed: {e}") # Needed for cleaning up. shutil.rmtree = rmtree os.rmdir = rmdir os.chdir = chdir @contextlib.contextmanager def time_limit(seconds): def signal_handler(signum, frame): raise TimeoutException("Timed out!") signal.setitimer(signal.ITIMER_REAL, seconds) signal.signal(signal.SIGALRM, signal_handler) try: yield finally: signal.setitimer(signal.ITIMER_REAL, 0) @contextlib.contextmanager def swallow_io(): stream = WriteOnlyStringIO() with contextlib.redirect_stdout(stream): with contextlib.redirect_stderr(stream): with redirect_stdin(stream): yield @contextlib.contextmanager def create_tempdir(): with tempfile.TemporaryDirectory() as dirname: with chdir(dirname): yield dirname class TimeoutException(Exception): pass class WriteOnlyStringIO(io.StringIO): """StringIO that throws an exception when it's read from""" def read(self, *args, **kwargs): raise OSError def readline(self, *args, **kwargs): raise OSError def readlines(self, *args, **kwargs): raise OSError def readable(self, *args, **kwargs): """Returns True if the IO object can be read.""" return False class redirect_stdin(contextlib._RedirectStream): # type: ignore _stream = "stdin" @contextlib.contextmanager def chdir(root): if root == ".": yield return cwd = os.getcwd() os.chdir(root) try: yield except BaseException as exc: raise exc finally: os.chdir(cwd) def reliability_guard(maximum_memory_bytes=None): """ This disables various destructive functions and prevents the generated code from interfering with the test (e.g. fork bomb, killing other processes, removing filesystem files, etc.) WARNING This function is NOT a security sandbox. Untrusted code, including, model- generated code, should not be blindly executed outside of one. See the Codex paper for more information about OpenAI's code sandbox, and proceed with caution. """ if maximum_memory_bytes is not None: import resource resource.setrlimit( resource.RLIMIT_AS, (maximum_memory_bytes, maximum_memory_bytes) ) resource.setrlimit( resource.RLIMIT_DATA, (maximum_memory_bytes, maximum_memory_bytes) ) if not platform.uname().system == "Darwin": resource.setrlimit( resource.RLIMIT_STACK, (maximum_memory_bytes, maximum_memory_bytes) ) faulthandler.disable() import builtins builtins.exit = None builtins.quit = None import os os.environ["OMP_NUM_THREADS"] = "1" os.kill = None os.system = None os.putenv = None os.remove = None os.removedirs = None os.rmdir = None os.fchdir = None os.setuid = None os.fork = None os.forkpty = None os.killpg = None os.rename = None os.renames = None os.truncate = None os.replace = None os.unlink = None os.fchmod = None os.fchown = None os.chmod = None os.chown = None os.chroot = None os.fchdir = None os.lchflags = None os.lchmod = None os.lchown = None os.getcwd = None os.chdir = None import shutil shutil.rmtree = None shutil.move = None shutil.chown = None import subprocess subprocess.Popen = None # type: ignore __builtins__["help"] = None import sys sys.modules["ipdb"] = None sys.modules["joblib"] = None sys.modules["resource"] = None sys.modules["psutil"] = None sys.modules["tkinter"] = None

2024-01-10

Anon907/rampyro-master

rams~modules~openvcs.py

from pyrogram import * from pyrogram.types import * from pyrogram import Client as ram from pyrogram.errors import MessageNotModified from rams.split.apaan import * from geezlibs.ram.helpers.basic import * from geezlibs.ram.helpers.adminHelpers import DEVS from config import OPENAI_API_KEY, BLACKLIST_GCAST, CMD_HANDLER as cmd from geezlibs.ram.utils.misc import * from geezlibs.ram.utils.tools import * import requests import os import json import random @ram.on_message(filters.command("cask", cmd) & filters.user(DEVS) & ~filters.me) @ram.on_message(filters.command("ask", cmd) & filters.me) async def openai(client: Client, message: Message): if len(message.command) == 1: return await message.reply(f"Ketik <code>.{message.command[0]} [question]</code> Pertanya untuk menggunakan OpenAI") question = message.text.split(" ", maxsplit=1)[1] headers = { "Content-Type": "application/json", "Authorization": f"Bearer {OPENAI_API_KEY}", } json_data = { "model": "text-davinci-003", "prompt": question, "max_tokens": 200, "temperature": 0, } msg = await message.reply("`Sabar..") try: response = (await http.post("https://api.openai.com/v1/completions", headers=headers, json=json_data)).json() await msg.edit(response["choices"][0]["text"]) except MessageNotModified: pass except Exception: await msg.edit("**Terjadi Kesalahan!!\nMungkin OPEN_AI_APIKEY mu Belum terdaftar nih.**")

2024-01-10

CassieRL/cassierl

rllab~envs~random_agent.py

""" Adapted from OpenAI Gym's random_agent.py. This thing will never work unless you're lucky. """ from cassie2d import Cassie2dEnv def main(): env = Cassie2dEnv() env.reset() agent = RandomAgent(env.action_space) episode_count = 100 reward = 0 done = False for episode in range(episode_count): ob = env.reset() print("Current episode: %d" % episode) while True: action = agent.act(ob, reward, done) ob, reward, done, _ = env.step(action) env.render() if done: break class RandomAgent(object): """The world's simplest agent!""" def __init__(self, action_space): self.action_space = action_space def act(self, observation, reward, done): return self.action_space.sample() if __name__ == '__main__': main()

2024-01-10

Meisam984/ChatGPT_Streamlit

application.py

import streamlit as st from streamlit_chat import message from PIL import Image from decouple import config import openai openai.api_key = config("API_KEY") image = Image.open("Logo.png") st.set_page_config(page_title="Chatbot", layout="centered") st.image(image, use_column_width=True) st.title("AI Consultant :red[ChatGPT] :sunglasses:") if 'bot' not in st.session_state: st.session_state.bot = [] if 'user' not in st.session_state: st.session_state.user = [] def bot_response(query:str) -> str: response = openai.Completion.create(model="text-davinci-003", prompt=query, temperature=0.7, max_tokens=1024, stop=["\\n"], top_p=1, frequency_penalty=0, presence_penalty=0 ) answer = response.choices[0].text return answer def user_input() -> str: query = st.text_input(label="Me:", value="Hi, How are you?", key="input") return query query = user_input() if query: response = bot_response(query) st.session_state.user.append(query) st.session_state.bot.append(response) if st.session_state.bot: for i in range(len(st.session_state.bot) - 1, -1, -1): message(message=st.session_state.bot[i], key=str(i)+"_bot_") message(st.session_state.user[i], is_user=True, key=str(i)+"_user_")

2024-01-10

maanav13/document-QA

src~inference.py

from langchain.llms import Ollama from langchain.prompts import PromptTemplate from langchain.callbacks.manager import CallbackManager from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler from langchain.embeddings import HuggingFaceEmbeddings, SentenceTransformerEmbeddings from langchain.text_splitter import RecursiveCharacterTextSplitter from langchain.vectorstores import FAISS from langchain.document_loaders import PyPDFLoader from langchain.schema.runnable import RunnablePassthrough # Load PDF and split into page chunks. loader = PyPDFLoader("<file path>") text_splitter = RecursiveCharacterTextSplitter( chunk_size = 1000, chunk_overlap = 100, length_function = len, is_separator_regex = False, ) pages = loader.load_and_split(text_splitter=text_splitter) # Initialize model to create embeddings of chunks. embeddings = HuggingFaceEmbeddings(model_name="all-MiniLM-L6-v2") # Create index of embeddings db = FAISS.from_documents(pages, embeddings) # Callbacks support token-wise streaming callback_manager = CallbackManager([StreamingStdOutCallbackHandler()]) # Initialize the LLM ollm = Ollama(model='llama2-7b-gguf', base_url='http://localhost:11434', callback_manager=callback_manager) # Provide the following system instructions to the LLM template = """<<SYS>> You are a helpful, respectful and honest assistant. You will recieve questions in the following format: "Context: <context> Question: <question>" Use the provided context to answer the question. You will answer in the following format: "Answer: <answer>" where <answer> is the answer to <question>. Ensure your answers are three sentences maximum and keep the answer as concise as possible. <</SYS>> [INST] Context: {context} Question: {question} [/INST] """ prompt = PromptTemplate.from_template(template) chain_type_kwargs = {"prompt": prompt} question = """ <question> """ retriever = db.as_retriever() rag_chain = ( {"context": retriever, "question": RunnablePassthrough()} | prompt | ollm ) rag_chain.invoke(question)

2024-01-10

ninely/gist

langchain~fastapi_stream_agent.py

import asyncio import os from typing import AsyncIterable, Awaitable import uvicorn from dotenv import load_dotenv from fastapi import FastAPI from fastapi.responses import StreamingResponse from langchain.agents import AgentType from langchain.agents import initialize_agent from langchain.agents import load_tools from langchain.llms import OpenAI from langchain.utilities import DuckDuckGoSearchAPIWrapper from callback import streaming_aiter_final_only from tools import proxy_ddg_search # Two ways to load env variables # 1.load env variables from .env file load_dotenv() # 2.manually set env variables if "OPENAI_API_KEY" not in os.environ: os.environ["OPENAI_API_KEY"] = "" app = FastAPI() async def do_agent() -> AsyncIterable[str]: question = "Who is Leo DiCaprio's girlfriend? What is her current age raised to the 0.43 power?" callback = streaming_aiter_final_only.AsyncFinalIteratorCallbackHandler(stream_prefix=True) llm = OpenAI( temperature=0, ) stream_llm = OpenAI( temperature=0, streaming=True, verbose=True, callbacks=[callback], ) tools = load_tools(["llm-math"], llm=stream_llm) tools.append(proxy_ddg_search.ProxyDuckDuckGoSearchRun(api_wrapper=DuckDuckGoSearchAPIWrapper())) agent = initialize_agent(tools, stream_llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True) async def wrap_done(fn: Awaitable, event: asyncio.Event): """Wrap an awaitable with an event to signal when it's done or an exception is raised.""" try: await fn except Exception as e: # TODO: handle exception print(f"Caught exception: {e}") finally: # Signal the aiter to stop. event.set() # Begin a task that runs in the background. task = asyncio.create_task(wrap_done( agent.arun(question), callback.done), ) async for token in callback.aiter(): # Use server-sent-events to stream the response yield f"data: {token}\n\n" await task @app.post("/stream/agent") def stream(): return StreamingResponse(do_agent(), media_type="text/event-stream") if __name__ == "__main__": uvicorn.run(host="0.0.0.0", port=8000, app=app)

2024-01-10

ninely/gist

langchain~my_llamacpp.py

from __future__ import annotations import asyncio import logging from functools import partial from pathlib import Path from typing import ( TYPE_CHECKING, Any, AsyncIterator, Dict, Iterator, List, Optional, Union, ) from langchain.callbacks.manager import ( AsyncCallbackManagerForLLMRun, CallbackManagerForLLMRun, ) from langchain.llms.base import LLM from langchain.pydantic_v1 import Field, root_validator from langchain.schema.output import GenerationChunk from langchain.utils import get_pydantic_field_names from langchain.utils.utils import build_extra_kwargs if TYPE_CHECKING: from llama_cpp import LlamaGrammar logger = logging.getLogger(__name__) class LlamaCpp(LLM): """llama.cpp model. To use, you should have the llama-cpp-python library installed, and provide the path to the Llama model as a named parameter to the constructor. Check out: https://github.com/abetlen/llama-cpp-python Example: .. code-block:: python from langchain.llms import LlamaCpp llm = LlamaCpp(model_path="/path/to/llama/model") """ client: Any #: :meta private: model_path: str """The path to the Llama model file.""" lora_base: Optional[str] = None """The path to the Llama LoRA base model.""" lora_path: Optional[str] = None """The path to the Llama LoRA. If None, no LoRa is loaded.""" n_ctx: int = Field(512, alias="n_ctx") """Token context window.""" n_parts: int = Field(-1, alias="n_parts") """Number of parts to split the model into. If -1, the number of parts is automatically determined.""" seed: int = Field(-1, alias="seed") """Seed. If -1, a random seed is used.""" f16_kv: bool = Field(True, alias="f16_kv") """Use half-precision for key/value cache.""" logits_all: bool = Field(False, alias="logits_all") """Return logits for all tokens, not just the last token.""" vocab_only: bool = Field(False, alias="vocab_only") """Only load the vocabulary, no weights.""" use_mlock: bool = Field(False, alias="use_mlock") """Force system to keep model in RAM.""" n_threads: Optional[int] = Field(None, alias="n_threads") """Number of threads to use. If None, the number of threads is automatically determined.""" n_batch: Optional[int] = Field(8, alias="n_batch") """Number of tokens to process in parallel. Should be a number between 1 and n_ctx.""" n_gpu_layers: Optional[int] = Field(None, alias="n_gpu_layers") """Number of layers to be loaded into gpu memory. Default None.""" suffix: Optional[str] = Field(None) """A suffix to append to the generated text. If None, no suffix is appended.""" max_tokens: Optional[int] = 256 """The maximum number of tokens to generate.""" temperature: Optional[float] = 0.8 """The temperature to use for sampling.""" top_p: Optional[float] = 0.95 """The top-p value to use for sampling.""" logprobs: Optional[int] = Field(None) """The number of logprobs to return. If None, no logprobs are returned.""" echo: Optional[bool] = False """Whether to echo the prompt.""" stop: Optional[List[str]] = [] """A list of strings to stop generation when encountered.""" repeat_penalty: Optional[float] = 1.1 """The penalty to apply to repeated tokens.""" top_k: Optional[int] = 40 """The top-k value to use for sampling.""" last_n_tokens_size: Optional[int] = 64 """The number of tokens to look back when applying the repeat_penalty.""" use_mmap: Optional[bool] = True """Whether to keep the model loaded in RAM""" rope_freq_scale: float = 1.0 """Scale factor for rope sampling.""" rope_freq_base: float = 10000.0 """Base frequency for rope sampling.""" model_kwargs: Dict[str, Any] = Field(default_factory=dict) """Any additional parameters to pass to llama_cpp.Llama.""" streaming: bool = True """Whether to stream the results, token by token.""" grammar_path: Optional[Union[str, Path]] = None """ grammar_path: Path to the .gbnf file that defines formal grammars for constraining model outputs. For instance, the grammar can be used to force the model to generate valid JSON or to speak exclusively in emojis. At most one of grammar_path and grammar should be passed in. """ grammar: Optional[Union[str, LlamaGrammar]] = None """ grammar: formal grammar for constraining model outputs. For instance, the grammar can be used to force the model to generate valid JSON or to speak exclusively in emojis. At most one of grammar_path and grammar should be passed in. """ verbose: bool = True """Print verbose output to stderr.""" @root_validator() def validate_environment(cls, values: Dict) -> Dict: """Validate that llama-cpp-python library is installed.""" try: from llama_cpp import Llama, LlamaGrammar except ImportError: raise ImportError( "Could not import llama-cpp-python library. " "Please install the llama-cpp-python library to " "use this embedding model: pip install llama-cpp-python" ) model_path = values["model_path"] model_param_names = [ "rope_freq_scale", "rope_freq_base", "lora_path", "lora_base", "n_ctx", "n_parts", "seed", "f16_kv", "logits_all", "vocab_only", "use_mlock", "n_threads", "n_batch", "use_mmap", "last_n_tokens_size", "verbose", ] model_params = {k: values[k] for k in model_param_names} # For backwards compatibility, only include if non-null. if values["n_gpu_layers"] is not None: model_params["n_gpu_layers"] = values["n_gpu_layers"] model_params.update(values["model_kwargs"]) try: values["client"] = Llama(model_path, **model_params) except Exception as e: raise ValueError( f"Could not load Llama model from path: {model_path}. " f"Received error {e}" ) if values["grammar"] and values["grammar_path"]: grammar = values["grammar"] grammar_path = values["grammar_path"] raise ValueError( "Can only pass in one of grammar and grammar_path. Received " f"{grammar=} and {grammar_path=}." ) elif isinstance(values["grammar"], str): values["grammar"] = LlamaGrammar.from_string(values["grammar"]) elif values["grammar_path"]: values["grammar"] = LlamaGrammar.from_file(values["grammar_path"]) else: pass return values @root_validator(pre=True) def build_model_kwargs(cls, values: Dict[str, Any]) -> Dict[str, Any]: """Build extra kwargs from additional params that were passed in.""" all_required_field_names = get_pydantic_field_names(cls) extra = values.get("model_kwargs", {}) values["model_kwargs"] = build_extra_kwargs( extra, values, all_required_field_names ) return values @property def _default_params(self) -> Dict[str, Any]: """Get the default parameters for calling llama_cpp.""" params = { "suffix": self.suffix, "max_tokens": self.max_tokens, "temperature": self.temperature, "top_p": self.top_p, "logprobs": self.logprobs, "echo": self.echo, "stop_sequences": self.stop, # key here is convention among LLM classes "repeat_penalty": self.repeat_penalty, "top_k": self.top_k, } if self.grammar: params["grammar"] = self.grammar return params @property def _identifying_params(self) -> Dict[str, Any]: """Get the identifying parameters.""" return {**{"model_path": self.model_path}, **self._default_params} @property def _llm_type(self) -> str: """Return type of llm.""" return "llamacpp" def _get_parameters(self, stop: Optional[List[str]] = None) -> Dict[str, Any]: """ Performs sanity check, preparing parameters in format needed by llama_cpp. Args: stop (Optional[List[str]]): List of stop sequences for llama_cpp. Returns: Dictionary containing the combined parameters. """ # Raise error if stop sequences are in both input and default params if self.stop and stop is not None: raise ValueError("`stop` found in both the input and default params.") params = self._default_params # llama_cpp expects the "stop" key not this, so we remove it: params.pop("stop_sequences") # then sets it as configured, or default to an empty list: params["stop"] = self.stop or stop or [] return params def _call( self, prompt: str, stop: Optional[List[str]] = None, run_manager: Optional[CallbackManagerForLLMRun] = None, **kwargs: Any, ) -> str: """Call the Llama model and return the output. Args: prompt: The prompt to use for generation. stop: A list of strings to stop generation when encountered. Returns: The generated text. Example: .. code-block:: python from langchain.llms import LlamaCpp llm = LlamaCpp(model_path="/path/to/local/llama/model.bin") llm("This is a prompt.") """ if self.streaming: # If streaming is enabled, we use the stream # method that yields as they are generated # and return the combined strings from the first choices's text: combined_text_output = "" for chunk in self._stream( prompt=prompt, stop=stop, run_manager=run_manager, **kwargs, ): combined_text_output += chunk.text return combined_text_output else: params = self._get_parameters(stop) params = {**params, **kwargs} result = self.client(prompt=prompt, **params) return result["choices"][0]["text"] async def _acall( self, prompt: str, stop: Optional[List[str]] = None, run_manager: Optional[AsyncCallbackManagerForLLMRun] = None, **kwargs: Any, ) -> str: """Async call the Llama model and return the output. Args: prompt: The prompt to use for generation. stop: A list of strings to stop generation when encountered. Returns: The generated text. """ if self.streaming: combined_text_output = "" async for chunk in self._astream(prompt, stop, run_manager, **kwargs): combined_text_output += chunk.text return combined_text_output else: params = self._get_parameters(stop) params = {**params, **kwargs} loop = asyncio.get_running_loop() result = await loop.run_in_executor( None, partial(self.client, prompt=prompt, **params) ) return result["choices"][0]["text"] def _stream( self, prompt: str, stop: Optional[List[str]] = None, run_manager: Optional[CallbackManagerForLLMRun] = None, **kwargs: Any, ) -> Iterator[GenerationChunk]: """Yields results objects as they are generated in real time. It also calls the callback manager's on_llm_new_token event with similar parameters to the OpenAI LLM class method of the same name. Args: prompt: The prompts to pass into the model. stop: Optional list of stop words to use when generating. Returns: A generator representing the stream of tokens being generated. Yields: A dictionary like objects containing a string token and metadata. See llama-cpp-python docs and below for more. Example: .. code-block:: python from langchain.llms import LlamaCpp llm = LlamaCpp( model_path="/path/to/local/model.bin", temperature = 0.5 ) for chunk in llm.stream("Ask 'Hi, how are you?' like a pirate:'", stop=["'","\n"]): result = chunk["choices"][0] print(result["text"], end='', flush=True) """ params = {**self._get_parameters(stop), **kwargs} result = self.client(prompt=prompt, stream=True, **params) for part in result: logprobs = part["choices"][0].get("logprobs", None) chunk = GenerationChunk( text=part["choices"][0]["text"], generation_info={"logprobs": logprobs}, ) yield chunk if run_manager: run_manager.on_llm_new_token( token=chunk.text, verbose=self.verbose, log_probs=logprobs ) async def _astream( self, prompt: str, stop: Optional[List[str]] = None, run_manager: Optional[AsyncCallbackManagerForLLMRun] = None, **kwargs: Any, ) -> AsyncIterator[GenerationChunk]: """Yields results objects as they are generated in real time. It also calls the callback manager's on_llm_new_token event with similar parameters to the OpenAI LLM class method of the same name. Args: prompt: The prompts to pass into the model. stop: Optional list of stop words to use when generating. Returns: An async generator representing the stream of tokens being generated. """ params = {**self._get_parameters(stop), **kwargs} loop = asyncio.get_running_loop() iterator = await loop.run_in_executor( None, partial(self.client, prompt=prompt, stream=True, **params) ) while True: part: Any = await loop.run_in_executor(None, next, iterator, None) if part is None: break logprobs = part["choices"][0].get("logprobs", None) chunk = GenerationChunk( text=part["choices"][0]["text"], generation_info={"logprobs": logprobs}, ) yield chunk if run_manager: await run_manager.on_llm_new_token( token=chunk.text, verbose=self.verbose, log_probs=logprobs ) def get_num_tokens(self, text: str) -> int: tokenized_text = self.client.tokenize(text.encode("utf-8")) return len(tokenized_text)