revert back

app.py

@@ -10,119 +10,218 @@ from transformers import AutoModelForCausalLM, AutoTokenizer, AutoConfig, set_se
 
 import torch
 from transformers import AutoTokenizer, AutoModelForCausalLM, GenerationConfig
-from transformers import BitsAndBytesConfig
-from tqdm import tqdm
-import os 
 
+model_name = "deepseek-ai/deepseek-math-7b-instruct"
+tokenizer = AutoTokenizer.from_pretrained(model_name)
+model = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype=torch.bfloat16, device_map="auto")
+model.generation_config = GenerationConfig.from_pretrained(model_name)
+model.generation_config.pad_token_id = model.generation_config.eos_token_id
 
-USE_PAST_KEY = True
-import gc
-torch.backends.cuda.enable_mem_efficient_sdp(False)
 
-from transformers import (
-    AutoModelForCausalLM, 
-    AutoTokenizer, 
-    AutoConfig,
-    StoppingCriteria,
-    set_seed
-)
 
-n_repetitions = 1 
-TOTAL_TOKENS = 2048 
 
-MODEL_PATH = "Pra-tham/quant_deepseekmath"
-    #"/kaggle/input/gemma/transformers/7b-it/1"
+def evaluate_response(problem):
+#     problem=b'what is angle x if angle y is 60 degree and angle z in 60 degree of a traingle'
+    problem=problem+'\nPlease reason step by step, and put your final answer within \\boxed{}.'
+    messages = [
+        {"role": "user", "content": problem}
+    ]
+    input_tensor = tokenizer.apply_chat_template(messages, add_generation_prompt=True, return_tensors="pt")
+    outputs = model.generate(input_tensor.to(model.device), max_new_tokens=100)
+
+    result = tokenizer.decode(outputs[0][input_tensor.shape[1]:], skip_special_tokens=True)
+#     result_output, code_output = process_output(raw_output)
+    return result
     
-# DEEP = True
-import torch
+# def respond(
+#     evaluate_response,
+#     history: list[tuple[str, str]],
+#     system_message,
+#     max_tokens,
+#     temperature,
+#     top_p,
+# ):
+#     messages = [{"role": "system", "content": system_message}]
+
+#     for val in history:
+#         if val[0]:
+#             messages.append({"role": "user", "content": val[0]})
+#         if val[1]:
+#             messages.append({"role": "assistant", "content": val[1]})
+
+#     messages.append({"role": "user", "content": message})
+
+#     response = ""
+
+#     for message in client.chat_completion(
+#         messages,
+#         max_tokens=max_tokens,
+#         stream=True,
+#         temperature=temperature,
+#         top_p=top_p,
+#     ):
+#         token = message.choices[0].delta.content
+
+#         response += token
+#         yield response
 
-from transformers import AutoModelForCausalLM, AutoTokenizer, AutoConfig
-import transformers
+"""
+For information on how to customize the ChatInterface, peruse the gradio docs: https://www.gradio.app/docs/chatinterface
+"""
+# demo = gr.ChatInterface(
+#     evaluate_response,
+#     additional_inputs=[
+#         gr.Textbox(value="You are a friendly Chatbot.", label="System message"),
+#         gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"),
+#         gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
+#         gr.Slider(
+#             minimum=0.1,
+#             maximum=1.0,
+#             value=0.95,
+#             step=0.05,
+#             label="Top-p (nucleus sampling)",
+#         ),
+#     ],
+# )
 
+demo = gr.Interface(
+        fn=evaluate_response,
+        inputs=[gr.Textbox(label="Question")],
+        outputs=gr.Textbox(label="Answer"),
+        title="Question and Answer Interface",
+        description="Enter a question."
+    )
 
+  
+if __name__ == "__main__":
+    demo.launch()
 
-tokenizer = AutoTokenizer.from_pretrained(MODEL_PATH)
 
-model = AutoModelForCausalLM.from_pretrained(
-            MODEL_PATH,
-            device_map="cpu",
-            torch_dtype="auto",
-            trust_remote_code=True, 
+# import gradio as gr
+# # from huggingface_hub import InferenceClient
 
-        )
-pipeline = transformers.pipeline(
-    "text-generation",
-    model=model,
-    tokenizer=tokenizer,
-    torch_dtype='auto',
-    device_map='cpu',
-)
-from transformers import StoppingCriteriaList
+# """
+# For more information on `huggingface_hub` Inference API support, please check the docs: https://huggingface.co/docs/huggingface_hub/v0.22.2/en/guides/inference
+# """
+# # client = InferenceClient("HuggingFaceH4/zephyr-7b-beta")
+# from transformers import AutoModelForCausalLM, AutoTokenizer, AutoConfig, set_seed
+# # from accelerate import infer_auto_device_map as iadm
 
-class StoppingCriteriaSub(StoppingCriteria):
-        def __init__(self, stops = [], encounters=1):
-            super().__init__()
-            # self.stops = [stop.to("cuda") for stop in stops]
-            self.stops = stops
+# import torch
+# from transformers import AutoTokenizer, AutoModelForCausalLM, GenerationConfig
+# from transformers import BitsAndBytesConfig
+# from tqdm import tqdm
+# import os 
 
-        def __call__(self, input_ids: torch.LongTensor, scores: torch.FloatTensor):
-            for stop in self.stops:
-                last_token = input_ids[0][-len(stop):]
-                if torch.all(torch.eq(stop,last_token)):
-                    return True
-            return False
 
+# USE_PAST_KEY = True
+# import gc
+# torch.backends.cuda.enable_mem_efficient_sdp(False)
 
-stop_words = ["```output", "```python", "```\nOutput" , ")\n```" , "``````output"] #,  
-stop_words_ids = [tokenizer(stop_word, return_tensors='pt', add_special_tokens=False)['input_ids'].squeeze() for stop_word in stop_words]
-stopping_criteria = StoppingCriteriaList([StoppingCriteriaSub(stops=stop_words_ids)])
+# from transformers import (
+#     AutoModelForCausalLM, 
+#     AutoTokenizer, 
+#     AutoConfig,
+#     StoppingCriteria,
+#     set_seed
+# )
 
-code = """Below is a math problem you are to solve (positive numerical answer):
-\"{}\"
-To accomplish this, first determine a sympy-based approach for solving the problem by listing each step to take and what functions need to be called in each step. Be clear so even an idiot can follow your instructions, and remember, your final answer should be positive integer, not an algebraic expression!
-Write the entire script covering all the steps (use comments and document it well) and print the result. After solving the problem, output the final numerical answer within \\boxed{}.
+# n_repetitions = 1 
+# TOTAL_TOKENS = 2048 
 
-Approach:"""
+# MODEL_PATH = "Pra-tham/quant_deepseekmath"
+#     #"/kaggle/input/gemma/transformers/7b-it/1"
+    
+# # DEEP = True
+# import torch
 
+# from transformers import AutoModelForCausalLM, AutoTokenizer, AutoConfig
+# import transformers
 
-cot = """Below is a math problem you are to solve (positive numerical answer!):
-\"{}\"
-Analyze this problem and think step by step to come to a solution with programs. After solving the problem, output the final numerical answer within \\boxed{}.\n\n"""
 
-promplt_options = [code,cot]
 
-import re
-from collections import defaultdict
-from collections import Counter
+# tokenizer = AutoTokenizer.from_pretrained(MODEL_PATH)
 
-from numpy.random import choice
-import numpy as np
+# model = AutoModelForCausalLM.from_pretrained(
+#             MODEL_PATH,
+#             device_map="cpu",
+#             torch_dtype="auto",
+#             trust_remote_code=True, 
 
-tool_instruction = '\n\nPlease integrate natural language reasoning with programs to solve the above problem, and put your final numerical answer within \\boxed{}.\nNote that the intermediary calculations may be real numbers, but the final numercal answer would always be an integer.'
+#         )
+# pipeline = transformers.pipeline(
+#     "text-generation",
+#     model=model,
+#     tokenizer=tokenizer,
+#     torch_dtype='auto',
+#     device_map='cpu',
+# )
+# from transformers import StoppingCriteriaList
 
+# class StoppingCriteriaSub(StoppingCriteria):
+#         def __init__(self, stops = [], encounters=1):
+#             super().__init__()
+#             # self.stops = [stop.to("cuda") for stop in stops]
+#             self.stops = stops
 
-#tool_instruction = " The answer should be given as a non-negative modulo 1000."
-#tool_instruction += '\nPlease integrate natural language reasoning with programs to solve the problem above, and put your final answer within \\boxed{}.'
+#         def __call__(self, input_ids: torch.LongTensor, scores: torch.FloatTensor):
+#             for stop in self.stops:
+#                 last_token = input_ids[0][-len(stop):]
+#                 if torch.all(torch.eq(stop,last_token)):
+#                     return True
+#             return False
 
-demo = gr.Interface(
-        fn=predict,
-        inputs=[gr.Textbox(label="Question")],
-        outputs=gr.Textbox(label="Answer"),
-        title="Question and Answer Interface",
-        description="Enter a question."
-    )
 
-import subprocess
+# stop_words = ["```output", "```python", "```\nOutput" , ")\n```" , "``````output"] #,  
+# stop_words_ids = [tokenizer(stop_word, return_tensors='pt', add_special_tokens=False)['input_ids'].squeeze() for stop_word in stop_words]
+# stopping_criteria = StoppingCriteriaList([StoppingCriteriaSub(stops=stop_words_ids)])
+
+# code = """Below is a math problem you are to solve (positive numerical answer):
+# \"{}\"
+# To accomplish this, first determine a sympy-based approach for solving the problem by listing each step to take and what functions need to be called in each step. Be clear so even an idiot can follow your instructions, and remember, your final answer should be positive integer, not an algebraic expression!
+# Write the entire script covering all the steps (use comments and document it well) and print the result. After solving the problem, output the final numerical answer within \\boxed{}.
+
+# Approach:"""
+
+
+# cot = """Below is a math problem you are to solve (positive numerical answer!):
+# \"{}\"
+# Analyze this problem and think step by step to come to a solution with programs. After solving the problem, output the final numerical answer within \\boxed{}.\n\n"""
+
+# promplt_options = [code,cot]
 
-def reboot_system():
-    try:
-        # Execute the reboot command
-        subprocess.run(['sudo', 'reboot'], check=True)
-    except subprocess.CalledProcessError as e:
-        print(f"Error occurred while trying to reboot the system: {e}")
+# import re
+# from collections import defaultdict
+# from collections import Counter
+
+# from numpy.random import choice
+# import numpy as np
+
+# tool_instruction = '\n\nPlease integrate natural language reasoning with programs to solve the above problem, and put your final numerical answer within \\boxed{}.\nNote that the intermediary calculations may be real numbers, but the final numercal answer would always be an integer.'
+
+
+# #tool_instruction = " The answer should be given as a non-negative modulo 1000."
+# #tool_instruction += '\nPlease integrate natural language reasoning with programs to solve the problem above, and put your final answer within \\boxed{}.'
+
+# demo = gr.Interface(
+#         fn=predict,
+#         inputs=[gr.Textbox(label="Question")],
+#         outputs=gr.Textbox(label="Answer"),
+#         title="Question and Answer Interface",
+#         description="Enter a question."
+#     )
+
+# import subprocess
+
+# def reboot_system():
+#     try:
+#         # Execute the reboot command
+#         subprocess.run(['sudo', 'reboot'], check=True)
+#     except subprocess.CalledProcessError as e:
+#         print(f"Error occurred while trying to reboot the system: {e}")
   
-if __name__ == "__main__":
-    if os.path.exists("temp.txt"):
-        os.remove("temp.txt")
-        reboot_system()
-    demo.launch()
+# if __name__ == "__main__":
+#     if os.path.exists("temp.txt"):
+#         os.remove("temp.txt")
+#         reboot_system()
+#     demo.launch()