Datasets:

ZHENGRAN

/

cross_code_eval_python

like 2

import asyncio import websockets import json from sentencepiece import SentencePieceProcessor from model import ExLlama, ExLlamaCache, ExLlamaConfig from lora import ExLlamaLora from tokenizer import ExLlamaTokenizer from generator import ExLlamaGenerator import argparse import torch import sys import os import glob import model_init # Initialized from command line args by init() model: ExLlama cache: ExLlamaCache config: ExLlamaConfig generator: ExLlamaGenerator tokenizer: ExLlamaTokenizer max_cached_strings = 100 tokenizer_cache = {} prompt_ids: torch.tensor stop_strings: list stop_tokens: list held_text: str max_stop_string: int remaining_tokens: int full_prompt: str utilized_prompt: str built_response: str def cached_tokenize(text: str): global model, cache, config, generator, tokenizer global max_cached_strings, tokenizer_cache if text in tokenizer_cache: return tokenizer_cache[text] while len(tokenizer_cache) >= max_cached_strings: del tokenizer_cache[next(iter(tokenizer_cache))] # Always removes oldest entry as of Python 3.7 new_enc = tokenizer.encode(text) tokenizer_cache[text] = new_enc return new_enc def begin_stream(prompt: str, stop_conditions: list, max_new_tokens: int, gen_settings: ExLlamaGenerator.Settings): global model, cache, config, generator, tokenizer global stop_strings, stop_tokens, prompt_ids, held_text, max_stop_string, remaining_tokens global full_prompt, utilized_prompt, built_response # Tokenize prompt and limit length to allow prompt and (max) new tokens within max sequence length max_input_tokens = model.config.max_seq_len - max_new_tokens input_ids = cached_tokenize(prompt) input_ids = input_ids[:, -max_input_tokens:] prompt_ids = input_ids full_prompt = prompt utilized_prompt = tokenizer.decode(prompt_ids)[0] built_response = "" remaining_tokens = max_new_tokens # Settings stop_strings = [] stop_tokens = [] for t in stop_conditions: if isinstance(t, int): stop_tokens += [t] if isinstance(t, str): stop_strings += [t] held_text = "" max_stop_string = 2 for ss in stop_strings: max_stop_string = max(max_stop_string, get_num_tokens(ss) + 2) generator.settings = gen_settings # Start generation generator.gen_begin_reuse(input_ids) def stream(): global model, cache, config, generator, tokenizer global stop_strings, stop_tokens, prompt_ids, held_text, max_stop_string, remaining_tokens global full_prompt, utilized_prompt, built_response # Check total response length if remaining_tokens == 0: return held_text, True, full_prompt + built_response, utilized_prompt + built_response, built_response remaining_tokens -= 1 # Generate old_tail = tokenizer.decode(generator.

next_token = generator.gen_single_token() # End on stop token if next_token in stop_tokens: return held_text, True, full_prompt + built_response, utilized_prompt + built_response, built_response # Get new text new_tail = tokenizer.decode(generator.sequence_actual[:, -(max_stop_string + 1):])[0] added_text = new_tail[len(old_tail):] held_text += added_text # Hold text if it's part of a stop condition, end if it's a full stop condition partial_ss = False for ss in stop_strings: # Check if held_text fully contains stop string position = held_text.find(ss) if position != -1: built_response += held_text[:position] return held_text[:position], True, full_prompt + built_response, utilized_prompt + built_response, built_response # Check if end of held_text overlaps with start of stop string overlap = 0 for j in range(1, min(len(held_text), len(ss)) + 1): if held_text[-j:] == ss[:j]: overlap = j if overlap > 0: partial_ss = True # Return partial result if partial_ss: return "", False, full_prompt + built_response, utilized_prompt + built_response, built_response stream_text = held_text held_text = "" built_response += stream_text return stream_text, False, full_prompt, utilized_prompt, built_response def leftTrimTokens(text: str, desiredLen: int): encodedText = tokenizer.encode(text) if encodedText.shape[-1] <= desiredLen: return text else: return tokenizer.decode(encodedText[:, -desiredLen:])[0] def oneshot_generation(prompt: str, stop_conditions: list, max_new_tokens: int, gen_settings: ExLlamaGenerator.Settings): begin_stream(prompt, stop_conditions, max_new_tokens, gen_settings) response = "" while True: _, eos, _, _, _ = stream() if eos: break return full_prompt + built_response, utilized_prompt + built_response, built_response def get_num_tokens(text: str): return cached_tokenize(text).shape[-1] # Websocket server async def estimateToken(request, ws): text = request["text"] numTokens=get_num_tokens(text) return numTokens# return number of tokens in int async def oneShotInfer(request, ws): stopToken = request["stopToken"] fullContext = request["text"] maxNew = int(request["maxNew"]) top_p = float(request["top_p"]) top_k = int(request["top_k"]) temp = float(request["temp"]) rep_pen = float(request["rep_pen"]) sc = [tokenizer.eos_token_id] sc.append(stopToken) gs = ExLlamaGenerator.Settings() gs.top_k = top_k gs.top_p = top_p gs.temperature = temp gs.token_repetition_penalty_max = rep_pen full_ctx, util_ctx, response = oneshot_generation(prompt=fullContext, stop_conditions=sc, max_new_tokens=maxNew, gen_settings=gs) return full_ctx, util_ctx, response# return requested prompt/context, pruned prompt/context(eg. prunedctx+maxNew=4096), model generated response, not including prompt async def streamInfer(request, ws): stopToken = [tokenizer.eos_token_id] stopToken.append(request["stopToken"]) prompt = request["text"] maxNew = int(request["maxNew"]) top_p = float(request["top_p"]) top_k = int(request["top_k"]) temp = float(request["temp"]) rep_pen = float(request["rep_pen"]) gs = ExLlamaGenerator.Settings() gs.top_k = top_k gs.top_p = top_p gs.temperature = temp gs.token_repetition_penalty_max = rep_pen begin_stream(prompt, stopToken, maxNew, gs) while True: chunk, eos, x, y, builtResp = stream() await ws.send(json.dumps({'action':request["action"], 'request_id':request['request_id'], 'utilContext':utilized_prompt + builtResp, 'response':builtResp})) if eos: break return utilized_prompt + built_response,builtResp async def main(websocket, path): async for message in websocket: #try: request = json.loads(message) reqID = request["request_id"] action = request["action"] if action == "estimateToken": response = await estimateToken(request, websocket) await websocket.send(json.dumps({'action':action, 'request_id':reqID, 'response':response})) elif action == "echo": await websocket.send(json.dumps({'action':action, 'request_id':reqID})) elif action == "oneShotInfer": fctx, utlctx, res = await oneShotInfer(request, websocket) await websocket.send(json.dumps({'action':action, 'request_id':reqID,'utilContext':utlctx, 'response':res})) elif action == "leftTrim": prompt = request["text"] desiredLen = int(request["desiredLen"]) processedPrompt = leftTrimTokens(prompt, desiredLen) await websocket.send(json.dumps({'action':action, 'request_id':reqID, 'response':processedPrompt})) else: utlctx, builtResp= await streamInfer(request, websocket) await websocket.send(json.dumps({'action':action, 'request_id':reqID,'utilContext':utlctx, 'response':builtResp+'</s>'})) #except Exception as e: #print({"error": str(e)}) model_directory = "./models/Llama-2-70B-chat-GPTQ/" tokenizer_path = os.path.join(model_directory, "tokenizer.model") model_config_path = os.path.join(model_directory, "config.json") st_pattern = os.path.join(model_directory, "*.safetensors") model_path = glob.glob(st_pattern)[0] esTokenizer = SentencePieceProcessor(model_file = tokenizer_path) config = ExLlamaConfig(model_config_path) # create config from config.json config.set_auto_map('17.615,18.8897') config.model_path = model_path # supply path to model weights file model = ExLlama(config) # create ExLlama instance and load the weights print(f"Model loaded: {model_path}") tokenizer = ExLlamaTokenizer(tokenizer_path) # create tokenizer from tokenizer model file cache = ExLlamaCache(model) # create cache for inference generator = ExLlamaGenerator(model, tokenizer, cache) # create generator start_server = websockets.serve(main, "0.0.0.0", 8080) asyncio.get_event_loop().run_until_complete(start_server) asyncio.get_event_loop().run_forever()

sequence_actual[:, -max_stop_string:])[0]

from model import ExLlama, ExLlamaCache, ExLlamaConfig from tokenizer import ExLlamaTokenizer from generator import ExLlamaGenerator import torch import torch.nn.functional as F import os, glob import cuda_ext # Directory containing model, tokenizer, generator model_directory = "/mnt/str/models/_test_models/TheBloke_Llama-2-13B-chat-GPTQ/" # Locate files we need within that directory tokenizer_path = os.path.join(model_directory, "tokenizer.model") model_config_path = os.path.join(model_directory, "config.json") st_pattern = os.path.join(model_directory, "*.safetensors") model_path = glob.glob(st_pattern)[0] # Create config, model, tokenizer and generator config = ExLlamaConfig(model_config_path) # create config from config.json config.model_path = model_path # supply path to model weights file model = ExLlama(config) # create ExLlama instance and load the weights tokenizer = ExLlamaTokenizer(tokenizer_path) # create tokenizer from tokenizer model file cache = ExLlamaCache(model, batch_size = 2) # create cache for inference generator = ExLlamaGenerator(model, tokenizer, cache) # create generator # Configure generator generator.settings.token_repetition_penalty_max = 1.15 generator.settings.temperature = 0.95 generator.settings.top_k = 40 generator.settings.top_p = 0.75 # generator.settings.typical = 0.95 # Prompts to mix f1 = \ """[INST] <<SYS>> You are a helpful, respectful and honest assistant. Always answer as helpfully as possible, while being safe. Your answers should not include any harmful, unethical, racist, sexist, toxic, dangerous, or illegal content. Please ensure that your responses are socially unbiased and positive in nature. If a question does not make any sense, or is not factually coherent, explain why instead of answering something not correct. If you don't know the answer to a question, please don't share false information. <</SYS>> {prompt}[/INST]""" f2 = \ """[INST] <<SYS>> <</SYS>> You are a rude and obnoxious assistant. You hate everything and everyone. {prompt}[/INST]""" prompts = \ [ f1.replace("{prompt}", "Tell me about Homer Simpson"), f2.replace("{prompt}", "Tell me about Homer Simpson"), ] def generate_cfg(prompts, alpha, max_new_tokens): ids, mask = tokenizer.encode(prompts, return_mask = True) generator.gen_begin(ids, mask = mask) # Sampling loop for _ in range(max_new_tokens): logits = model.forward(generator.sequence[:, -1:], cache, input_mask = mask) generator.apply_rep_penalty(logits) logits = F.log_softmax(logits, dim = -1) logits_mixed = (1 - alpha) * logits[0] + alpha * logits[1] sampled_token, _ = generator.sample_current(logits_mixed) if sampled_token.item() == tokenizer.eos_token_id: break batch_token = sampled_token.repeat(2, 1) generator.

output = tokenizer.decode(generator.sequence[0]) return output for i in range(10): alpha = i / 5.0 - 0.4 print() print(f"--------------------------------------") print(f"alpha = {alpha:.1f}") print(f"--------------------------------------") output = generate_cfg(prompts, alpha, 200) print(output[len(prompts[0]):].strip())

gen_accept_token(batch_token)

from model import ExLlama, ExLlamaCache, ExLlamaConfig from flask import Flask, request from tokenizer import ExLlamaTokenizer from generator import ExLlamaGenerator import os, glob # Directory containing config.json, tokenizer.model and safetensors file for the model model_directory = "/mnt/str/models/llama-7b-4bit/" tokenizer_path = os.path.join(model_directory, "tokenizer.model") model_config_path = os.path.join(model_directory, "config.json") st_pattern = os.path.join(model_directory, "*.safetensors") model_path = glob.glob(st_pattern)[0] config = ExLlamaConfig(model_config_path) # create config from config.json config.model_path = model_path # supply path to model weights file model = ExLlama(config) # create ExLlama instance and load the weights print(f"Model loaded: {model_path}") tokenizer = ExLlamaTokenizer(tokenizer_path) # create tokenizer from tokenizer model file cache = ExLlamaCache(model) # create cache for inference generator = ExLlamaGenerator(model, tokenizer, cache) # create generator # Flask app app = Flask(__name__) # Inference with settings equivalent to the "precise" preset from the /r/LocalLLaMA wiki @app.route('/infer_precise', methods=['POST']) def inferContextP(): print(request.form) prompt = request.form.get('prompt') generator.

generator.settings.token_repetition_penalty_sustain = config.max_seq_len generator.settings.temperature = 0.7 generator.settings.top_p = 0.1 generator.settings.top_k = 40 generator.settings.typical = 0.0 # Disabled outputs = generator.generate_simple(prompt, max_new_tokens = 200) return outputs # Inference with settings equivalent to the "creative" preset from the /r/LocalLLaMA wiki @app.route('/infer_creative', methods=['POST']) def inferContextC(): print(request.form) prompt = request.form.get('prompt') generator.settings.token_repetition_penalty_max = 1.1 generator.settings.token_repetition_penalty_sustain = config.max_seq_len generator.settings.temperature = 0.72 generator.settings.top_p = 0.73 generator.settings.top_k = 0 # Disabled generator.settings.typical = 0.0 # Disabled outputs = generator.generate_simple(prompt, max_new_tokens = 200) return outputs # Inference with settings equivalent to the "sphinx" preset from the /r/LocalLLaMA wiki @app.route('/infer_sphinx', methods=['POST']) def inferContextS(): print(request.form) prompt = request.form.get('prompt') generator.settings.token_repetition_penalty_max = 1.15 generator.settings.token_repetition_penalty_sustain = config.max_seq_len generator.settings.temperature = 1.99 generator.settings.top_p = 0.18 generator.settings.top_k = 30 generator.settings.typical = 0.0 # Disabled outputs = generator.generate_simple(prompt, max_new_tokens = 200) return outputs # Start Flask app host = "0.0.0.0" port = 8004 print(f"Starting server on address {host}:{port}") if __name__ == '__main__': from waitress import serve serve(app, host = host, port = port)

settings.token_repetition_penalty_max = 1.176

import asyncio import websockets import json from sentencepiece import SentencePieceProcessor from model import ExLlama, ExLlamaCache, ExLlamaConfig from lora import ExLlamaLora from tokenizer import ExLlamaTokenizer from generator import ExLlamaGenerator import argparse import torch import sys import os import glob import model_init # Initialized from command line args by init() model: ExLlama cache: ExLlamaCache config: ExLlamaConfig generator: ExLlamaGenerator tokenizer: ExLlamaTokenizer max_cached_strings = 100 tokenizer_cache = {} prompt_ids: torch.tensor stop_strings: list stop_tokens: list held_text: str max_stop_string: int remaining_tokens: int full_prompt: str utilized_prompt: str built_response: str def cached_tokenize(text: str): global model, cache, config, generator, tokenizer global max_cached_strings, tokenizer_cache if text in tokenizer_cache: return tokenizer_cache[text] while len(tokenizer_cache) >= max_cached_strings: del tokenizer_cache[next(iter(tokenizer_cache))] # Always removes oldest entry as of Python 3.7 new_enc = tokenizer.encode(text) tokenizer_cache[text] = new_enc return new_enc def begin_stream(prompt: str, stop_conditions: list, max_new_tokens: int, gen_settings: ExLlamaGenerator.Settings): global model, cache, config, generator, tokenizer global stop_strings, stop_tokens, prompt_ids, held_text, max_stop_string, remaining_tokens global full_prompt, utilized_prompt, built_response # Tokenize prompt and limit length to allow prompt and (max) new tokens within max sequence length max_input_tokens = model.config.max_seq_len - max_new_tokens input_ids = cached_tokenize(prompt) input_ids = input_ids[:, -max_input_tokens:] prompt_ids = input_ids full_prompt = prompt utilized_prompt = tokenizer.

built_response = "" remaining_tokens = max_new_tokens # Settings stop_strings = [] stop_tokens = [] for t in stop_conditions: if isinstance(t, int): stop_tokens += [t] if isinstance(t, str): stop_strings += [t] held_text = "" max_stop_string = 2 for ss in stop_strings: max_stop_string = max(max_stop_string, get_num_tokens(ss) + 2) generator.settings = gen_settings # Start generation generator.gen_begin_reuse(input_ids) def stream(): global model, cache, config, generator, tokenizer global stop_strings, stop_tokens, prompt_ids, held_text, max_stop_string, remaining_tokens global full_prompt, utilized_prompt, built_response # Check total response length if remaining_tokens == 0: return held_text, True, full_prompt + built_response, utilized_prompt + built_response, built_response remaining_tokens -= 1 # Generate old_tail = tokenizer.decode(generator.sequence_actual[:, -max_stop_string:])[0] next_token = generator.gen_single_token() # End on stop token if next_token in stop_tokens: return held_text, True, full_prompt + built_response, utilized_prompt + built_response, built_response # Get new text new_tail = tokenizer.decode(generator.sequence_actual[:, -(max_stop_string + 1):])[0] added_text = new_tail[len(old_tail):] held_text += added_text # Hold text if it's part of a stop condition, end if it's a full stop condition partial_ss = False for ss in stop_strings: # Check if held_text fully contains stop string position = held_text.find(ss) if position != -1: built_response += held_text[:position] return held_text[:position], True, full_prompt + built_response, utilized_prompt + built_response, built_response # Check if end of held_text overlaps with start of stop string overlap = 0 for j in range(1, min(len(held_text), len(ss)) + 1): if held_text[-j:] == ss[:j]: overlap = j if overlap > 0: partial_ss = True # Return partial result if partial_ss: return "", False, full_prompt + built_response, utilized_prompt + built_response, built_response stream_text = held_text held_text = "" built_response += stream_text return stream_text, False, full_prompt, utilized_prompt, built_response def leftTrimTokens(text: str, desiredLen: int): encodedText = tokenizer.encode(text) if encodedText.shape[-1] <= desiredLen: return text else: return tokenizer.decode(encodedText[:, -desiredLen:])[0] def oneshot_generation(prompt: str, stop_conditions: list, max_new_tokens: int, gen_settings: ExLlamaGenerator.Settings): begin_stream(prompt, stop_conditions, max_new_tokens, gen_settings) response = "" while True: _, eos, _, _, _ = stream() if eos: break return full_prompt + built_response, utilized_prompt + built_response, built_response def get_num_tokens(text: str): return cached_tokenize(text).shape[-1] # Websocket server async def estimateToken(request, ws): text = request["text"] numTokens=get_num_tokens(text) return numTokens# return number of tokens in int async def oneShotInfer(request, ws): stopToken = request["stopToken"] fullContext = request["text"] maxNew = int(request["maxNew"]) top_p = float(request["top_p"]) top_k = int(request["top_k"]) temp = float(request["temp"]) rep_pen = float(request["rep_pen"]) sc = [tokenizer.eos_token_id] sc.append(stopToken) gs = ExLlamaGenerator.Settings() gs.top_k = top_k gs.top_p = top_p gs.temperature = temp gs.token_repetition_penalty_max = rep_pen full_ctx, util_ctx, response = oneshot_generation(prompt=fullContext, stop_conditions=sc, max_new_tokens=maxNew, gen_settings=gs) return full_ctx, util_ctx, response# return requested prompt/context, pruned prompt/context(eg. prunedctx+maxNew=4096), model generated response, not including prompt async def streamInfer(request, ws): stopToken = [tokenizer.eos_token_id] stopToken.append(request["stopToken"]) prompt = request["text"] maxNew = int(request["maxNew"]) top_p = float(request["top_p"]) top_k = int(request["top_k"]) temp = float(request["temp"]) rep_pen = float(request["rep_pen"]) gs = ExLlamaGenerator.Settings() gs.top_k = top_k gs.top_p = top_p gs.temperature = temp gs.token_repetition_penalty_max = rep_pen begin_stream(prompt, stopToken, maxNew, gs) while True: chunk, eos, x, y, builtResp = stream() await ws.send(json.dumps({'action':request["action"], 'request_id':request['request_id'], 'utilContext':utilized_prompt + builtResp, 'response':builtResp})) if eos: break return utilized_prompt + built_response,builtResp async def main(websocket, path): async for message in websocket: #try: request = json.loads(message) reqID = request["request_id"] action = request["action"] if action == "estimateToken": response = await estimateToken(request, websocket) await websocket.send(json.dumps({'action':action, 'request_id':reqID, 'response':response})) elif action == "echo": await websocket.send(json.dumps({'action':action, 'request_id':reqID})) elif action == "oneShotInfer": fctx, utlctx, res = await oneShotInfer(request, websocket) await websocket.send(json.dumps({'action':action, 'request_id':reqID,'utilContext':utlctx, 'response':res})) elif action == "leftTrim": prompt = request["text"] desiredLen = int(request["desiredLen"]) processedPrompt = leftTrimTokens(prompt, desiredLen) await websocket.send(json.dumps({'action':action, 'request_id':reqID, 'response':processedPrompt})) else: utlctx, builtResp= await streamInfer(request, websocket) await websocket.send(json.dumps({'action':action, 'request_id':reqID,'utilContext':utlctx, 'response':builtResp+'</s>'})) #except Exception as e: #print({"error": str(e)}) model_directory = "./models/Llama-2-70B-chat-GPTQ/" tokenizer_path = os.path.join(model_directory, "tokenizer.model") model_config_path = os.path.join(model_directory, "config.json") st_pattern = os.path.join(model_directory, "*.safetensors") model_path = glob.glob(st_pattern)[0] esTokenizer = SentencePieceProcessor(model_file = tokenizer_path) config = ExLlamaConfig(model_config_path) # create config from config.json config.set_auto_map('17.615,18.8897') config.model_path = model_path # supply path to model weights file model = ExLlama(config) # create ExLlama instance and load the weights print(f"Model loaded: {model_path}") tokenizer = ExLlamaTokenizer(tokenizer_path) # create tokenizer from tokenizer model file cache = ExLlamaCache(model) # create cache for inference generator = ExLlamaGenerator(model, tokenizer, cache) # create generator start_server = websockets.serve(main, "0.0.0.0", 8080) asyncio.get_event_loop().run_until_complete(start_server) asyncio.get_event_loop().run_forever()

decode(prompt_ids)[0]

import asyncio import websockets import json from sentencepiece import SentencePieceProcessor from model import ExLlama, ExLlamaCache, ExLlamaConfig from lora import ExLlamaLora from tokenizer import ExLlamaTokenizer from generator import ExLlamaGenerator import argparse import torch import sys import os import glob import model_init # Initialized from command line args by init() model: ExLlama cache: ExLlamaCache config: ExLlamaConfig generator: ExLlamaGenerator tokenizer: ExLlamaTokenizer max_cached_strings = 100 tokenizer_cache = {} prompt_ids: torch.tensor stop_strings: list stop_tokens: list held_text: str max_stop_string: int remaining_tokens: int full_prompt: str utilized_prompt: str built_response: str def cached_tokenize(text: str): global model, cache, config, generator, tokenizer global max_cached_strings, tokenizer_cache if text in tokenizer_cache: return tokenizer_cache[text] while len(tokenizer_cache) >= max_cached_strings: del tokenizer_cache[next(iter(tokenizer_cache))] # Always removes oldest entry as of Python 3.7 new_enc = tokenizer.encode(text) tokenizer_cache[text] = new_enc return new_enc def begin_stream(prompt: str, stop_conditions: list, max_new_tokens: int, gen_settings: ExLlamaGenerator.Settings): global model, cache, config, generator, tokenizer global stop_strings, stop_tokens, prompt_ids, held_text, max_stop_string, remaining_tokens global full_prompt, utilized_prompt, built_response # Tokenize prompt and limit length to allow prompt and (max) new tokens within max sequence length max_input_tokens = model.config.max_seq_len - max_new_tokens input_ids = cached_tokenize(prompt) input_ids = input_ids[:, -max_input_tokens:] prompt_ids = input_ids full_prompt = prompt utilized_prompt = tokenizer.decode(prompt_ids)[0] built_response = "" remaining_tokens = max_new_tokens # Settings stop_strings = [] stop_tokens = [] for t in stop_conditions: if isinstance(t, int): stop_tokens += [t] if isinstance(t, str): stop_strings += [t] held_text = "" max_stop_string = 2 for ss in stop_strings: max_stop_string = max(max_stop_string, get_num_tokens(ss) + 2) generator.settings = gen_settings # Start generation generator.

def stream(): global model, cache, config, generator, tokenizer global stop_strings, stop_tokens, prompt_ids, held_text, max_stop_string, remaining_tokens global full_prompt, utilized_prompt, built_response # Check total response length if remaining_tokens == 0: return held_text, True, full_prompt + built_response, utilized_prompt + built_response, built_response remaining_tokens -= 1 # Generate old_tail = tokenizer.decode(generator.sequence_actual[:, -max_stop_string:])[0] next_token = generator.gen_single_token() # End on stop token if next_token in stop_tokens: return held_text, True, full_prompt + built_response, utilized_prompt + built_response, built_response # Get new text new_tail = tokenizer.decode(generator.sequence_actual[:, -(max_stop_string + 1):])[0] added_text = new_tail[len(old_tail):] held_text += added_text # Hold text if it's part of a stop condition, end if it's a full stop condition partial_ss = False for ss in stop_strings: # Check if held_text fully contains stop string position = held_text.find(ss) if position != -1: built_response += held_text[:position] return held_text[:position], True, full_prompt + built_response, utilized_prompt + built_response, built_response # Check if end of held_text overlaps with start of stop string overlap = 0 for j in range(1, min(len(held_text), len(ss)) + 1): if held_text[-j:] == ss[:j]: overlap = j if overlap > 0: partial_ss = True # Return partial result if partial_ss: return "", False, full_prompt + built_response, utilized_prompt + built_response, built_response stream_text = held_text held_text = "" built_response += stream_text return stream_text, False, full_prompt, utilized_prompt, built_response def leftTrimTokens(text: str, desiredLen: int): encodedText = tokenizer.encode(text) if encodedText.shape[-1] <= desiredLen: return text else: return tokenizer.decode(encodedText[:, -desiredLen:])[0] def oneshot_generation(prompt: str, stop_conditions: list, max_new_tokens: int, gen_settings: ExLlamaGenerator.Settings): begin_stream(prompt, stop_conditions, max_new_tokens, gen_settings) response = "" while True: _, eos, _, _, _ = stream() if eos: break return full_prompt + built_response, utilized_prompt + built_response, built_response def get_num_tokens(text: str): return cached_tokenize(text).shape[-1] # Websocket server async def estimateToken(request, ws): text = request["text"] numTokens=get_num_tokens(text) return numTokens# return number of tokens in int async def oneShotInfer(request, ws): stopToken = request["stopToken"] fullContext = request["text"] maxNew = int(request["maxNew"]) top_p = float(request["top_p"]) top_k = int(request["top_k"]) temp = float(request["temp"]) rep_pen = float(request["rep_pen"]) sc = [tokenizer.eos_token_id] sc.append(stopToken) gs = ExLlamaGenerator.Settings() gs.top_k = top_k gs.top_p = top_p gs.temperature = temp gs.token_repetition_penalty_max = rep_pen full_ctx, util_ctx, response = oneshot_generation(prompt=fullContext, stop_conditions=sc, max_new_tokens=maxNew, gen_settings=gs) return full_ctx, util_ctx, response# return requested prompt/context, pruned prompt/context(eg. prunedctx+maxNew=4096), model generated response, not including prompt async def streamInfer(request, ws): stopToken = [tokenizer.eos_token_id] stopToken.append(request["stopToken"]) prompt = request["text"] maxNew = int(request["maxNew"]) top_p = float(request["top_p"]) top_k = int(request["top_k"]) temp = float(request["temp"]) rep_pen = float(request["rep_pen"]) gs = ExLlamaGenerator.Settings() gs.top_k = top_k gs.top_p = top_p gs.temperature = temp gs.token_repetition_penalty_max = rep_pen begin_stream(prompt, stopToken, maxNew, gs) while True: chunk, eos, x, y, builtResp = stream() await ws.send(json.dumps({'action':request["action"], 'request_id':request['request_id'], 'utilContext':utilized_prompt + builtResp, 'response':builtResp})) if eos: break return utilized_prompt + built_response,builtResp async def main(websocket, path): async for message in websocket: #try: request = json.loads(message) reqID = request["request_id"] action = request["action"] if action == "estimateToken": response = await estimateToken(request, websocket) await websocket.send(json.dumps({'action':action, 'request_id':reqID, 'response':response})) elif action == "echo": await websocket.send(json.dumps({'action':action, 'request_id':reqID})) elif action == "oneShotInfer": fctx, utlctx, res = await oneShotInfer(request, websocket) await websocket.send(json.dumps({'action':action, 'request_id':reqID,'utilContext':utlctx, 'response':res})) elif action == "leftTrim": prompt = request["text"] desiredLen = int(request["desiredLen"]) processedPrompt = leftTrimTokens(prompt, desiredLen) await websocket.send(json.dumps({'action':action, 'request_id':reqID, 'response':processedPrompt})) else: utlctx, builtResp= await streamInfer(request, websocket) await websocket.send(json.dumps({'action':action, 'request_id':reqID,'utilContext':utlctx, 'response':builtResp+'</s>'})) #except Exception as e: #print({"error": str(e)}) model_directory = "./models/Llama-2-70B-chat-GPTQ/" tokenizer_path = os.path.join(model_directory, "tokenizer.model") model_config_path = os.path.join(model_directory, "config.json") st_pattern = os.path.join(model_directory, "*.safetensors") model_path = glob.glob(st_pattern)[0] esTokenizer = SentencePieceProcessor(model_file = tokenizer_path) config = ExLlamaConfig(model_config_path) # create config from config.json config.set_auto_map('17.615,18.8897') config.model_path = model_path # supply path to model weights file model = ExLlama(config) # create ExLlama instance and load the weights print(f"Model loaded: {model_path}") tokenizer = ExLlamaTokenizer(tokenizer_path) # create tokenizer from tokenizer model file cache = ExLlamaCache(model) # create cache for inference generator = ExLlamaGenerator(model, tokenizer, cache) # create generator start_server = websockets.serve(main, "0.0.0.0", 8080) asyncio.get_event_loop().run_until_complete(start_server) asyncio.get_event_loop().run_forever()

gen_begin_reuse(input_ids)

from model import ExLlama, ExLlamaCache, ExLlamaConfig from tokenizer import ExLlamaTokenizer from generator import ExLlamaGenerator import torch import torch.nn.functional as F import os, glob import cuda_ext # Directory containing model, tokenizer, generator model_directory = "/mnt/str/models/_test_models/TheBloke_Llama-2-13B-chat-GPTQ/" # Locate files we need within that directory tokenizer_path = os.path.join(model_directory, "tokenizer.model") model_config_path = os.path.join(model_directory, "config.json") st_pattern = os.path.join(model_directory, "*.safetensors") model_path = glob.glob(st_pattern)[0] # Create config, model, tokenizer and generator config = ExLlamaConfig(model_config_path) # create config from config.json config.model_path = model_path # supply path to model weights file model = ExLlama(config) # create ExLlama instance and load the weights tokenizer = ExLlamaTokenizer(tokenizer_path) # create tokenizer from tokenizer model file cache = ExLlamaCache(model, batch_size = 2) # create cache for inference generator = ExLlamaGenerator(model, tokenizer, cache) # create generator # Configure generator generator.settings.token_repetition_penalty_max = 1.15 generator.settings.temperature = 0.95 generator.settings.top_k = 40 generator.settings.top_p = 0.75 # generator.settings.typical = 0.95 # Prompts to mix f1 = \ """[INST] <<SYS>> You are a helpful, respectful and honest assistant. Always answer as helpfully as possible, while being safe. Your answers should not include any harmful, unethical, racist, sexist, toxic, dangerous, or illegal content. Please ensure that your responses are socially unbiased and positive in nature. If a question does not make any sense, or is not factually coherent, explain why instead of answering something not correct. If you don't know the answer to a question, please don't share false information. <</SYS>> {prompt}[/INST]""" f2 = \ """[INST] <<SYS>> <</SYS>> You are a rude and obnoxious assistant. You hate everything and everyone. {prompt}[/INST]""" prompts = \ [ f1.replace("{prompt}", "Tell me about Homer Simpson"), f2.replace("{prompt}", "Tell me about Homer Simpson"), ] def generate_cfg(prompts, alpha, max_new_tokens): ids, mask = tokenizer.

generator.gen_begin(ids, mask = mask) # Sampling loop for _ in range(max_new_tokens): logits = model.forward(generator.sequence[:, -1:], cache, input_mask = mask) generator.apply_rep_penalty(logits) logits = F.log_softmax(logits, dim = -1) logits_mixed = (1 - alpha) * logits[0] + alpha * logits[1] sampled_token, _ = generator.sample_current(logits_mixed) if sampled_token.item() == tokenizer.eos_token_id: break batch_token = sampled_token.repeat(2, 1) generator.gen_accept_token(batch_token) output = tokenizer.decode(generator.sequence[0]) return output for i in range(10): alpha = i / 5.0 - 0.4 print() print(f"--------------------------------------") print(f"alpha = {alpha:.1f}") print(f"--------------------------------------") output = generate_cfg(prompts, alpha, 200) print(output[len(prompts[0]):].strip())

encode(prompts, return_mask = True)

from model import ExLlama, ExLlamaCache, ExLlamaConfig from tokenizer import ExLlamaTokenizer from generator import ExLlamaGenerator import torch import torch.nn.functional as F import os, glob import cuda_ext # Directory containing model, tokenizer, generator model_directory = "/mnt/str/models/_test_models/TheBloke_Llama-2-13B-chat-GPTQ/" # Locate files we need within that directory tokenizer_path = os.path.join(model_directory, "tokenizer.model") model_config_path = os.path.join(model_directory, "config.json") st_pattern = os.path.join(model_directory, "*.safetensors") model_path = glob.glob(st_pattern)[0] # Create config, model, tokenizer and generator config = ExLlamaConfig(model_config_path) # create config from config.json config.model_path = model_path # supply path to model weights file model = ExLlama(config) # create ExLlama instance and load the weights tokenizer = ExLlamaTokenizer(tokenizer_path) # create tokenizer from tokenizer model file cache = ExLlamaCache(model, batch_size = 2) # create cache for inference generator = ExLlamaGenerator(model, tokenizer, cache) # create generator # Configure generator generator.settings.token_repetition_penalty_max = 1.15 generator.settings.temperature = 0.95 generator.settings.top_k = 40 generator.settings.top_p = 0.75 # generator.settings.typical = 0.95 # Prompts to mix f1 = \ """[INST] <<SYS>> You are a helpful, respectful and honest assistant. Always answer as helpfully as possible, while being safe. Your answers should not include any harmful, unethical, racist, sexist, toxic, dangerous, or illegal content. Please ensure that your responses are socially unbiased and positive in nature. If a question does not make any sense, or is not factually coherent, explain why instead of answering something not correct. If you don't know the answer to a question, please don't share false information. <</SYS>> {prompt}[/INST]""" f2 = \ """[INST] <<SYS>> <</SYS>> You are a rude and obnoxious assistant. You hate everything and everyone. {prompt}[/INST]""" prompts = \ [ f1.replace("{prompt}", "Tell me about Homer Simpson"), f2.replace("{prompt}", "Tell me about Homer Simpson"), ] def generate_cfg(prompts, alpha, max_new_tokens): ids, mask = tokenizer.encode(prompts, return_mask = True) generator.gen_begin(ids, mask = mask) # Sampling loop for _ in range(max_new_tokens): logits = model.forward(generator.sequence[:, -1:], cache, input_mask = mask) generator.apply_rep_penalty(logits) logits = F.log_softmax(logits, dim = -1) logits_mixed = (1 - alpha) * logits[0] + alpha * logits[1] sampled_token, _ = generator.sample_current(logits_mixed) if sampled_token.item() == tokenizer.eos_token_id: break batch_token = sampled_token.repeat(2, 1) generator.gen_accept_token(batch_token) output = tokenizer.

return output for i in range(10): alpha = i / 5.0 - 0.4 print() print(f"--------------------------------------") print(f"alpha = {alpha:.1f}") print(f"--------------------------------------") output = generate_cfg(prompts, alpha, 200) print(output[len(prompts[0]):].strip())

decode(generator.sequence[0])

from model import ExLlama, ExLlamaCache, ExLlamaConfig from tokenizer import ExLlamaTokenizer import argparse, sys, os, glob from torch import version as torch_version from globals import set_affinity_str def add_args(parser): parser.add_argument("-t", "--tokenizer", type = str, help = "Tokenizer model path") parser.add_argument("-c", "--config", type = str, help = "Model config path (config.json)") parser.add_argument("-m", "--model", type = str, help = "Model weights path (.pt or .safetensors file)") parser.add_argument("-d", "--directory", type = str, help = "Path to directory containing config.json, model.tokenizer and * .safetensors") parser.add_argument("-gs", "--gpu_split", type = str, help = "Comma-separated list of VRAM (in GB) to use per GPU device for model layers, e.g. -gs 20,7,7") parser.add_argument("-l", "--length", type = int, help = "Maximum sequence length", default = 2048) parser.add_argument("-cpe", "--compress_pos_emb", type = float, help = "Compression factor for positional embeddings", default = 1.0) parser.add_argument("-a", "--alpha", type = float, help = "alpha for context size extension via embedding extension", default = 1.0) parser.add_argument("-theta", "--theta", type = float, help = "theta (base) for RoPE embeddings") parser.add_argument("-gpfix", "--gpu_peer_fix", action = "store_true", help = "Prevent direct copies of data between GPUs") parser.add_argument("-flash", "--flash_attn", nargs = '?', const = 'default', metavar = "METHOD", help = "Use Flash Attention with specified input length (must have Flash Attention 2.0 installed)") parser.add_argument("-mmrt", "--matmul_recons_thd", type = int, help = "No. rows at which to use reconstruction and cuBLAS for quant matmul. 0 = never, 1 = always", default = 8) parser.add_argument("-fmt", "--fused_mlp_thd", type = int, help = "Maximum no. of rows for which to use fused MLP. 0 = never", default = 2) parser.add_argument("-sdpt", "--sdp_thd", type = int, help = "No. rows at which to switch to scaled_dot_product_attention. 0 = never, 1 = always", default = 8) parser.add_argument("-mmfr", "--matmul_fused_remap", action = "store_true", help = "Fuse column remapping in Q4 matmul kernel") parser.add_argument("-nfa", "--no_fused_attn", action = "store_true", help = "Disable fused attention") parser.add_argument("-rnnh2", "--rmsnorm_no_half2", action = "store_true", help = "Don't use half2 in RMS norm kernel") parser.add_argument("-rpnh2", "--rope_no_half2", action = "store_true", help = "Don't use half2 in RoPE kernel") parser.add_argument("-mmnh2", "--matmul_no_half2", action = "store_true", help = "Don't use half2 in Q4 matmul kernel") parser.add_argument("-snh2", "--silu_no_half2", action = "store_true", help = "Don't use half2 in SiLU kernel") parser.add_argument("-nh2", "--no_half2", action = "store_true", help = "(All of the above) disable half2 in all kernela") parser.add_argument("-fh2", "--force_half2", action = "store_true", help = "Force enable half2 even if unsupported") parser.add_argument("-cs", "--concurrent_streams", action = "store_true", help = "Use concurrent CUDA streams") parser.add_argument("-aff", "--affinity", type = str, help = "Comma-separated list, sets processor core affinity. E.g.: -aff 0,1,2,3") def post_parse(args): if args.no_half2 or torch_version.hip and not args.force_half2: args.rmsnorm_no_half2 = True args.rope_no_half2 = True args.matmul_no_half2 = True args.silu_no_half2 = True # Get model files from --directory def get_model_files(args): if args.directory is not None: args.tokenizer = os.path.join(args.directory, "tokenizer.model") args.config = os.path.join(args.directory, "config.json") st_pattern = os.path.join(args.directory, "*.safetensors") st = glob.glob(st_pattern) if len(st) == 0: print(f" !! No files matching {st_pattern}") sys.exit() if len(st) > 1: print(f" !! Multiple files matching {st_pattern}") sys.exit() args.model = st[0] else: if args.tokenizer is None or args.config is None or args.model is None: print(" !! Please specify either -d or all of -t, -c and -m") sys.exit() # Feedback def print_options(args, extra_options = None): print_opts = [] if args.gpu_split is not None: print_opts.append(f"gpu_split: {args.gpu_split}") if args.gpu_peer_fix: print_opts.append("gpu_peer_fix") if args.affinity: print_opts.append(f" --affinity: {args.affinity}") if extra_options is not None: print_opts += extra_options print(f" -- Tokenizer: {args.tokenizer}") print(f" -- Model config: {args.config}") print(f" -- Model: {args.model}") print(f" -- Sequence length: {args.length}") if args.compress_pos_emb != 1.0: print(f" -- RoPE compression factor: {args.compress_pos_emb}") if args.alpha != 1.0: print(f" -- RoPE alpha factor: {args.alpha}") print(f" -- Tuning:") if args.flash_attn: print(f" -- --flash_attn") else: print(f" -- --sdp_thd: {args.sdp_thd}" + (" (disabled)" if args.sdp_thd == 0 else "")) print(f" -- --matmul_recons_thd: {args.matmul_recons_thd}" + (" (disabled)" if args.matmul_recons_thd == 0 else "")) print(f" -- --fused_mlp_thd: {args.fused_mlp_thd}" + (" (disabled)" if args.fused_mlp_thd == 0 else "")) if args.matmul_fused_remap: print(f" -- --matmul_fused_remap") if args.no_fused_attn: print(f" -- --no_fused_attn") if args.rmsnorm_no_half2: print(f" -- --rmsnorm_no_half2") if args.rope_no_half2: print(f" -- --rope_no_half2") if args.matmul_no_half2: print(f" -- --matmul_no_half2") if args.silu_no_half2: print(f" -- --silu_no_half2") if args.concurrent_streams: print(f" -- --concurrent_streams") print(f" -- Options: {print_opts}") # Build ExLlamaConfig from args def make_config(args): config = ExLlamaConfig(args.config) config.model_path = args.model config.max_seq_len = args.length config.compress_pos_emb = args.compress_pos_emb config.set_auto_map(args.gpu_split) config.gpu_peer_fix = args.gpu_peer_fix config.alpha_value = args.alpha config.

if args.flash_attn: config.use_flash_attn_2 = True try: config.max_input_len = int(args.flash_attn) except ValueError: pass config.matmul_recons_thd = args.matmul_recons_thd config.fused_mlp_thd = args.fused_mlp_thd config.sdp_thd = args.sdp_thd config.matmul_fused_remap = args.matmul_fused_remap config.fused_attn = not args.no_fused_attn config.rmsnorm_no_half2 = args.rmsnorm_no_half2 config.rope_no_half2 = args.rope_no_half2 config.matmul_no_half2 = args.matmul_no_half2 config.silu_no_half2 = args.silu_no_half2 config.concurrent_streams = args.concurrent_streams if args.theta: config.rotary_embedding_base = args.theta return config # Global state def set_globals(args): if args.affinity: set_affinity_str(args.affinity) # Print stats after loading model def print_stats(model): print(f" -- Groupsize (inferred): {model.config.groupsize if model.config.groupsize is not None else 'None'}") print(f" -- Act-order (inferred): {'yes' if model.config.act_order else 'no'}") if model.config.empty_g_idx: print(f" !! Model has empty group index (discarded)")

calculate_rotary_embedding_base()

from model import ExLlama, ExLlamaCache, ExLlamaConfig from tokenizer import ExLlamaTokenizer from generator import ExLlamaGenerator import os, glob # Directory containing model, tokenizer, generator model_directory = "/mnt/str/models/llama-13b-4bit-128g/" # Locate files we need within that directory tokenizer_path = os.path.join(model_directory, "tokenizer.model") model_config_path = os.path.join(model_directory, "config.json") st_pattern = os.path.join(model_directory, "*.safetensors") model_path = glob.glob(st_pattern)[0] # Batched prompts prompts = [ "Once upon a time,", "I don't like to", "A turbo encabulator is a", "In the words of Mark Twain," ] # Create config, model, tokenizer and generator config = ExLlamaConfig(model_config_path) # create config from config.json config.model_path = model_path # supply path to model weights file model = ExLlama(config) # create ExLlama instance and load the weights tokenizer = ExLlamaTokenizer(tokenizer_path) # create tokenizer from tokenizer model file cache = ExLlamaCache(model, batch_size = len(prompts)) # create cache for inference generator = ExLlamaGenerator(model, tokenizer, cache) # create generator # Configure generator generator.disallow_tokens([tokenizer.eos_token_id]) generator.settings.token_repetition_penalty_max = 1.2 generator.settings.temperature = 0.95 generator.settings.top_p = 0.65 generator.settings.top_k = 100 generator.settings.typical = 0.5 # Generate, batched for line in prompts: print(line) output = generator.

for line in output: print("---") print(line)

generate_simple(prompts, max_new_tokens = 200)

from model import ExLlama, ExLlamaCache, ExLlamaConfig from tokenizer import ExLlamaTokenizer import argparse, sys, os, glob from torch import version as torch_version from globals import set_affinity_str def add_args(parser): parser.add_argument("-t", "--tokenizer", type = str, help = "Tokenizer model path") parser.add_argument("-c", "--config", type = str, help = "Model config path (config.json)") parser.add_argument("-m", "--model", type = str, help = "Model weights path (.pt or .safetensors file)") parser.add_argument("-d", "--directory", type = str, help = "Path to directory containing config.json, model.tokenizer and * .safetensors") parser.add_argument("-gs", "--gpu_split", type = str, help = "Comma-separated list of VRAM (in GB) to use per GPU device for model layers, e.g. -gs 20,7,7") parser.add_argument("-l", "--length", type = int, help = "Maximum sequence length", default = 2048) parser.add_argument("-cpe", "--compress_pos_emb", type = float, help = "Compression factor for positional embeddings", default = 1.0) parser.add_argument("-a", "--alpha", type = float, help = "alpha for context size extension via embedding extension", default = 1.0) parser.add_argument("-theta", "--theta", type = float, help = "theta (base) for RoPE embeddings") parser.add_argument("-gpfix", "--gpu_peer_fix", action = "store_true", help = "Prevent direct copies of data between GPUs") parser.add_argument("-flash", "--flash_attn", nargs = '?', const = 'default', metavar = "METHOD", help = "Use Flash Attention with specified input length (must have Flash Attention 2.0 installed)") parser.add_argument("-mmrt", "--matmul_recons_thd", type = int, help = "No. rows at which to use reconstruction and cuBLAS for quant matmul. 0 = never, 1 = always", default = 8) parser.add_argument("-fmt", "--fused_mlp_thd", type = int, help = "Maximum no. of rows for which to use fused MLP. 0 = never", default = 2) parser.add_argument("-sdpt", "--sdp_thd", type = int, help = "No. rows at which to switch to scaled_dot_product_attention. 0 = never, 1 = always", default = 8) parser.add_argument("-mmfr", "--matmul_fused_remap", action = "store_true", help = "Fuse column remapping in Q4 matmul kernel") parser.add_argument("-nfa", "--no_fused_attn", action = "store_true", help = "Disable fused attention") parser.add_argument("-rnnh2", "--rmsnorm_no_half2", action = "store_true", help = "Don't use half2 in RMS norm kernel") parser.add_argument("-rpnh2", "--rope_no_half2", action = "store_true", help = "Don't use half2 in RoPE kernel") parser.add_argument("-mmnh2", "--matmul_no_half2", action = "store_true", help = "Don't use half2 in Q4 matmul kernel") parser.add_argument("-snh2", "--silu_no_half2", action = "store_true", help = "Don't use half2 in SiLU kernel") parser.add_argument("-nh2", "--no_half2", action = "store_true", help = "(All of the above) disable half2 in all kernela") parser.add_argument("-fh2", "--force_half2", action = "store_true", help = "Force enable half2 even if unsupported") parser.add_argument("-cs", "--concurrent_streams", action = "store_true", help = "Use concurrent CUDA streams") parser.add_argument("-aff", "--affinity", type = str, help = "Comma-separated list, sets processor core affinity. E.g.: -aff 0,1,2,3") def post_parse(args): if args.no_half2 or torch_version.hip and not args.force_half2: args.rmsnorm_no_half2 = True args.rope_no_half2 = True args.matmul_no_half2 = True args.silu_no_half2 = True # Get model files from --directory def get_model_files(args): if args.directory is not None: args.tokenizer = os.path.join(args.directory, "tokenizer.model") args.config = os.path.join(args.directory, "config.json") st_pattern = os.path.join(args.directory, "*.safetensors") st = glob.glob(st_pattern) if len(st) == 0: print(f" !! No files matching {st_pattern}") sys.exit() if len(st) > 1: print(f" !! Multiple files matching {st_pattern}") sys.exit() args.model = st[0] else: if args.tokenizer is None or args.config is None or args.model is None: print(" !! Please specify either -d or all of -t, -c and -m") sys.exit() # Feedback def print_options(args, extra_options = None): print_opts = [] if args.gpu_split is not None: print_opts.append(f"gpu_split: {args.gpu_split}") if args.gpu_peer_fix: print_opts.append("gpu_peer_fix") if args.affinity: print_opts.append(f" --affinity: {args.affinity}") if extra_options is not None: print_opts += extra_options print(f" -- Tokenizer: {args.tokenizer}") print(f" -- Model config: {args.config}") print(f" -- Model: {args.model}") print(f" -- Sequence length: {args.length}") if args.compress_pos_emb != 1.0: print(f" -- RoPE compression factor: {args.compress_pos_emb}") if args.alpha != 1.0: print(f" -- RoPE alpha factor: {args.alpha}") print(f" -- Tuning:") if args.flash_attn: print(f" -- --flash_attn") else: print(f" -- --sdp_thd: {args.sdp_thd}" + (" (disabled)" if args.sdp_thd == 0 else "")) print(f" -- --matmul_recons_thd: {args.matmul_recons_thd}" + (" (disabled)" if args.matmul_recons_thd == 0 else "")) print(f" -- --fused_mlp_thd: {args.fused_mlp_thd}" + (" (disabled)" if args.fused_mlp_thd == 0 else "")) if args.matmul_fused_remap: print(f" -- --matmul_fused_remap") if args.no_fused_attn: print(f" -- --no_fused_attn") if args.rmsnorm_no_half2: print(f" -- --rmsnorm_no_half2") if args.rope_no_half2: print(f" -- --rope_no_half2") if args.matmul_no_half2: print(f" -- --matmul_no_half2") if args.silu_no_half2: print(f" -- --silu_no_half2") if args.concurrent_streams: print(f" -- --concurrent_streams") print(f" -- Options: {print_opts}") # Build ExLlamaConfig from args def make_config(args): config = ExLlamaConfig(args.config) config.model_path = args.model config.max_seq_len = args.length config.compress_pos_emb = args.compress_pos_emb config.

config.gpu_peer_fix = args.gpu_peer_fix config.alpha_value = args.alpha config.calculate_rotary_embedding_base() if args.flash_attn: config.use_flash_attn_2 = True try: config.max_input_len = int(args.flash_attn) except ValueError: pass config.matmul_recons_thd = args.matmul_recons_thd config.fused_mlp_thd = args.fused_mlp_thd config.sdp_thd = args.sdp_thd config.matmul_fused_remap = args.matmul_fused_remap config.fused_attn = not args.no_fused_attn config.rmsnorm_no_half2 = args.rmsnorm_no_half2 config.rope_no_half2 = args.rope_no_half2 config.matmul_no_half2 = args.matmul_no_half2 config.silu_no_half2 = args.silu_no_half2 config.concurrent_streams = args.concurrent_streams if args.theta: config.rotary_embedding_base = args.theta return config # Global state def set_globals(args): if args.affinity: set_affinity_str(args.affinity) # Print stats after loading model def print_stats(model): print(f" -- Groupsize (inferred): {model.config.groupsize if model.config.groupsize is not None else 'None'}") print(f" -- Act-order (inferred): {'yes' if model.config.act_order else 'no'}") if model.config.empty_g_idx: print(f" !! Model has empty group index (discarded)")

set_auto_map(args.gpu_split)

from model import ExLlama, ExLlamaCache, ExLlamaConfig from tokenizer import ExLlamaTokenizer from generator import ExLlamaGenerator import torch import torch.nn.functional as F import os, glob import cuda_ext # Directory containing model, tokenizer, generator model_directory = "/mnt/str/models/_test_models/TheBloke_Llama-2-13B-chat-GPTQ/" # Locate files we need within that directory tokenizer_path = os.path.join(model_directory, "tokenizer.model") model_config_path = os.path.join(model_directory, "config.json") st_pattern = os.path.join(model_directory, "*.safetensors") model_path = glob.glob(st_pattern)[0] # Create config, model, tokenizer and generator config = ExLlamaConfig(model_config_path) # create config from config.json config.model_path = model_path # supply path to model weights file model = ExLlama(config) # create ExLlama instance and load the weights tokenizer = ExLlamaTokenizer(tokenizer_path) # create tokenizer from tokenizer model file cache = ExLlamaCache(model, batch_size = 2) # create cache for inference generator = ExLlamaGenerator(model, tokenizer, cache) # create generator # Configure generator generator.settings.token_repetition_penalty_max = 1.15 generator.settings.temperature = 0.95 generator.settings.top_k = 40 generator.settings.top_p = 0.75 # generator.settings.typical = 0.95 # Prompts to mix f1 = \ """[INST] <<SYS>> You are a helpful, respectful and honest assistant. Always answer as helpfully as possible, while being safe. Your answers should not include any harmful, unethical, racist, sexist, toxic, dangerous, or illegal content. Please ensure that your responses are socially unbiased and positive in nature. If a question does not make any sense, or is not factually coherent, explain why instead of answering something not correct. If you don't know the answer to a question, please don't share false information. <</SYS>> {prompt}[/INST]""" f2 = \ """[INST] <<SYS>> <</SYS>> You are a rude and obnoxious assistant. You hate everything and everyone. {prompt}[/INST]""" prompts = \ [ f1.replace("{prompt}", "Tell me about Homer Simpson"), f2.replace("{prompt}", "Tell me about Homer Simpson"), ] def generate_cfg(prompts, alpha, max_new_tokens): ids, mask = tokenizer.encode(prompts, return_mask = True) generator.gen_begin(ids, mask = mask) # Sampling loop for _ in range(max_new_tokens): logits = model.

generator.apply_rep_penalty(logits) logits = F.log_softmax(logits, dim = -1) logits_mixed = (1 - alpha) * logits[0] + alpha * logits[1] sampled_token, _ = generator.sample_current(logits_mixed) if sampled_token.item() == tokenizer.eos_token_id: break batch_token = sampled_token.repeat(2, 1) generator.gen_accept_token(batch_token) output = tokenizer.decode(generator.sequence[0]) return output for i in range(10): alpha = i / 5.0 - 0.4 print() print(f"--------------------------------------") print(f"alpha = {alpha:.1f}") print(f"--------------------------------------") output = generate_cfg(prompts, alpha, 200) print(output[len(prompts[0]):].strip())

forward(generator.sequence[:, -1:], cache, input_mask = mask)