import huggingface_hub import re class LlamaManager(): def __init__(self, llama_token = None, verbose = False): self.verbose = verbose if self.verbose: print("LlamaManager::__init__::Initializing LlamaManager") self.client = huggingface_hub.InferenceClient( "meta-llama/Meta-Llama-3.1-70B-Instruct", token=llama_token, ) if self.verbose: print("LlamaManager::__init__::Initialized LlamaManager") def __get_items_between_tags(self, input_string, tag1, tag2): pattern = r'' + tag1 + '(.*?)' + tag2 + '' return re.findall(pattern, input_string, re.DOTALL) def __preprocss_for_auto_generate_questions_categories(self, available_categories): if self.verbose: print("LlamaManager::__preprocss_for_auto_generate_questions_categories::Preprocessing") out = "" for available_category in available_categories: out += f"[A]{available_category}[/A]" return out def __postprocess_for_auto_generate_questions_categories(self, out): if self.verbose: print("LlamaManager::__postprocess_for_auto_generate_questions_categories::Postprocessing") out = self.__get_items_between_tags(out, r"\[L\]", r"\[/L\]")[0] if not out: if self.verbose: print("LlamaManager::__postprocess_for_auto_generate_questions_categories::No content found") return [] out = self.__get_items_between_tags(out, r"\[A\]", r"\[/A\]") if not out: if self.verbose: print("LlamaManager::__postprocess_for_auto_generate_questions_categories::No categories found") return [] return out def auto_generate_questions_categories( self, count = 20, available_categories = ["Variables"], seed = 123, temperature = 1.0, top_p = 0.9, frequency_penalty = 0.0 ): available_content_for_assistant = self.__preprocss_for_auto_generate_questions_categories(available_categories) if self.verbose: print("LlamaManager::auto_generate_questions_categories::Generating questions categories") message_content = [ {"role": "system", "content": "You are a synthetic data generator. You must only answer questions as a list. Each item of the list should be enclosed in [A] and [/A] tags. The list should be enclosed in [L] and [/L] tags."}, {"role": "user", "content": f"Write me {count} basic topics for python programming"}, {"role": "assistant", "content": f"[L]{available_content_for_assistant}"} ] out = self.client.chat_completion( messages = message_content, max_tokens = 1000, stream = False, seed = seed, temperature = temperature, top_p = top_p, frequency_penalty = frequency_penalty ) categories = self.__postprocess_for_auto_generate_questions_categories(out.choices[0].message.content) if self.verbose: print("LlamaManager::auto_generate_questions_categories::Generated questions Categories") return categories def __postprocess_for_auto_generate_shots_for_category(self, out): if self.verbose: print("LlamaManager::__postprocess_for_auto_generate_shots_for_category::Postprocessing") out = self.__get_items_between_tags(out, r"\[L\]", r"\[/L\]")[0] if not out: if self.verbose: print("LlamaManager::__postprocess_for_auto_generate_shots_for_category::No content found") return [] out = self.__get_items_between_tags(out, r"\[A\]", r"\[/A\]") if not out: if self.verbose: print("LlamaManager::__postprocess_for_auto_generate_shots_for_category::No questions found") return [] return out def auto_generate_shots_for_category( self, count, category, seed = 123, temperature = 1.0, top_p = 0.9, frequency_penalty = 0.0 ): if self.verbose: print("LlamaManager::auto_generate_shots_for_category::Generating shots for category") message_content = [ {"role": "system", "content": "You are a synthetic data generator. You must only answer questions as a list. Each item of the list should be enclosed in [A] and [/A] tags. The list should be enclosed in [L] and [/L] tags."}, {"role": "user", "content": f"Write me 2 programming questions on the topic of For Loop in Python. The question should be of medium and hard difficulty. The question should involve use of just one function"}, {"role": "assistant", "content": f"""[L] - [A]Write a program that takes a positive integer as input and computes the sum of its digits using a for loop.[/A] - [A]Write a program that generates a spiral matrix of size NxN, where N is always an odd number. Fill the spiral matrix with consecutive prime numbers in a clockwise spiral pattern, starting from the center of the matrix.[/A] """}, {"role": "user", "content": f"Write me {count} programming questions on the topic of {category} in Python. The question should be of medium and hard difficulty. The question should involve use of just one function"}, {"role": "assistant", "content": f"[L]"} ] out = self.client.chat_completion( messages = message_content, max_tokens = 1000, stream = False, seed = seed, temperature = temperature, top_p = top_p, frequency_penalty = frequency_penalty ) shots = self.__postprocess_for_auto_generate_shots_for_category(out.choices[0].message.content + "[/L]") if self.verbose: print(f"LlamaManager::auto_generate_shots_for_category::Generated {count} shots for {category}") return shots def __preprocess_for_auto_generate_questions_from_shots(self, shots): if self.verbose: print("LlamaManager::__preprocess_for_auto_generate_questions_from_shots::Preprocessing") out = "" for shot in shots: out += f"[A]{shot}[/A]" return out def __postprocess_for_auto_generate_questions_from_shots(self, out): if self.verbose: print("LlamaManager::__postprocess_for_auto_generate_questions_from_shots::Postprocessing") out = self.__get_items_between_tags(out, r"\[L\]", r"\[/L\]")[0] if not out: if self.verbose: print("LlamaManager::__postprocess_for_auto_generate_questions_from_shots::No content found") return [] out = self.__get_items_between_tags(out, r"\[A\]", r"\[/A\]") if not out: if self.verbose: print("LlamaManager::__postprocess_for_auto_generate_questions_from_shots::No questions found") return [] return out def auto_generate_questions_from_shots( self, count, category, shots, seed = 123, temperature = 1.0, top_p = 0.9, frequency_penalty = 0.0 ): available_content_for_assistant = self.__preprocess_for_auto_generate_questions_from_shots(shots) if self.verbose: print("LlamaManager::auto_generate_questions_from_shots::Generating questions from shots") message_content = [ {"role": "system", "content": "You are a synthetic data generator. You must only answer questions as a list. Each item of the list should be enclosed in [A] and [/A] tags. The list should be enclosed in [L] and [/L] tags."}, {"role": "user", "content": f"Write me {count} python programming questions which uses {category.lower()}"}, {"role": "assistant", "content": f"[L]{available_content_for_assistant}"} ] previous_iteration_questions_count = [] questions = [] token_count = 1000 while len(questions) < count: out = self.client.chat_completion( messages = message_content, max_tokens = token_count, stream = False, seed = seed, temperature = temperature, top_p = top_p, frequency_penalty = frequency_penalty ) questions = self.__postprocess_for_auto_generate_questions_from_shots(out.choices[0].message.content + "[/L]") available_content_for_assistant = self.__preprocess_for_auto_generate_questions_from_shots(questions) previous_iteration_questions_count.append(len(questions)) message_content = [ {"role": "system", "content": "You are a synthetic data generator. You must only answer questions as a list. Each item of the list should be enclosed in [A] and [/A] tags. The list should be enclosed in [L] and [/L] tags."}, {"role": "user", "content": f"Write me {count} python programming questions which uses {category.lower()}"}, {"role": "assistant", "content": f"[L]{available_content_for_assistant}"} ] token_count += 500 if len(previous_iteration_questions_count) > 3: if previous_iteration_questions_count[-1] == previous_iteration_questions_count[-2] == previous_iteration_questions_count[-3] == previous_iteration_questions_count[-4]: if self.verbose: print("LlamaManager::auto_generate_questions_from_shots::Generation could not be completed, stopping API calls") break if self.verbose: print("LlamaManager::auto_generate_questions_from_shots::Generated questions from shots") return questions def __postprocess_for_auto_generate_function_signature_from_question(self, out): if self.verbose: print("LlamaManager::__postprocess_for_auto_generate_function_signature_from_question::Postprocessing") out = self.__get_items_between_tags(out, r"\[A\]", r"\[/A\]")[0] function_name = self.__get_items_between_tags(out, r"\[F\]", r"\[/F\]")[0] input_parameters = self.__get_items_between_tags(out, r"\[I\]", r"\[/I\]") return_type = self.__get_items_between_tags(out, r"\[R\]", r"\[/R\]")[0] return function_name, input_parameters, return_type def auto_generate_function_signature_from_question( self, question, seed = 123, temperature = 1.0, top_p = 0.9, frequency_penalty = 0.0 ): if self.verbose: print("LlamaManager::auto_generate_function_signature_from_question::Generating function signature from question") message_content = [ {"role": "system", "content": """You are a synthetic data generator. You must answer the question between [A] and [/A] tags. The answer should include a function name, input parameters and return type. The function name should be between [F] and [/F] tags. Each input parameter should be between [I] and [/I] tags. The return type should be between [R] and [/R] tags. """}, {"role": "user", "content": f"""Write me a function signature, input parameters and return type for the following question: Write a program that takes two positive integers as input and computes the sum of their digits using a for loop."""}, {"role": "assistant", "content": f"[A][F]sum_of_digits[/F][I]num_1: int[/I][I]num_2: int[/I][R]int[/R][/A]"}, {"role": "user", "content": f"Write me a function signature, input parameters and return type for the following question: {question}"}, {"role": "assistant", "content": f"[A]"} ] out = self.client.chat_completion( messages = message_content, max_tokens = 1000, stream = False, seed = seed, temperature = temperature, top_p = top_p, frequency_penalty = frequency_penalty ) function_name, input_parameters, return_type = self.__postprocess_for_auto_generate_function_signature_from_question(out.choices[0].message.content) if self.verbose: print("LlamaManager::auto_generate_function_signature_from_question::Generated function signature from question") return function_name, input_parameters, return_type def __postprocess_for_auto_generate_answers_and_tests(self, out): if self.verbose: print("LlamaManager::__postprocess_for_auto_generate_answers_and_tests::Postprocessing") out = self.__get_items_between_tags(out, r"\[A\]", r"\[/A\]")[0] answer = self.__get_items_between_tags(out, r"\[F\]", r"\[/F\]")[0] test_cases = self.__get_items_between_tags(out, r"\[T\]", r"\[/T\]") return answer, test_cases def auto_generate_answers_and_tests( self, question, function_name, input_parameters, return_type, seed = 123, temperature = 1.0, top_p = 0.9, frequency_penalty = 0.0 ): if self.verbose: print("LlamaManager::auto_generate_answers_and_tests::Generating answers and test cases") function_signature = f"{function_name}({', '.join(input_parameters)}) -> {return_type}" message_content = [ {"role": "system", "content": """You are a synthetic data generator. Your must answer the question between [A] and [/A] tags. The answer should include a function implementation and test cases. The function implementation should be between [F] and [/F] tags. Each test cases should be between [T] and [/T] tags. Test cases must use assert statements. Do not comment on the code. No need to explain the solution. """}, {"role": "user", "content": f"""Write me a function implementation along with the test cases for the following question: {question}, The function has the following signature: {function_signature}"""} ] out = self.client.chat_completion( messages = message_content, max_tokens = 1000, stream = False, seed = seed, temperature = temperature, top_p = top_p, frequency_penalty = frequency_penalty ) answer, test_cases = self.__postprocess_for_auto_generate_answers_and_tests(out.choices[0].message.content) if self.verbose: print("LlamaManager::auto_generate_answers_and_tests::Generated answers and test cases") return answer, test_cases if __name__ == "__main__": llama_manager = LlamaManager("nope", True) categories = llama_manager.auto_generate_questions_categories(20) shots = llama_manager.auto_generate_shots_for_category(2, categories[3]) questions = llama_manager.auto_generate_questions_from_shots(10, categories[3], shots, temperature = 0.5)