from gradio.components import Component import gradio as gr import pandas as pd from abc import ABC, abstractclassmethod import inspect class BaseTCOModel(ABC): # TO DO: Find way to specify which component should be used for computing cost def __setattr__(self, name, value): if isinstance(value, Component): self._components.append(value) self.__dict__[name] = value def __init__(self): super(BaseTCOModel, self).__setattr__("_components", []) self.use_case = None def get_components(self) -> list[Component]: return self._components def get_components_for_cost_computing(self): return self.components_for_cost_computing def get_name(self): return self.name def register_components_for_cost_computing(self): args = inspect.getfullargspec(self.compute_cost_per_token)[0][1:] self.components_for_cost_computing = [self.__getattribute__(arg) for arg in args] @abstractclassmethod def compute_cost_per_token(self): pass @abstractclassmethod def render(self): pass def set_name(self, name): self.name = name def set_formula(self, formula): self.formula = formula def get_formula(self): return self.formula def set_latency(self, latency): self.latency = latency def get_latency(self): return self.latency class OpenAIModel(BaseTCOModel): def __init__(self): self.set_name("(SaaS) OpenAI") self.set_formula(r"""$CR = \frac{CIT\_1K \times IT + COT\_1K \times OT}{1000}$
with:
CR = Cost per Request
CIT_1K = Cost per 1000 Input Tokens
COT_1K = Cost per 1000 Output Tokens
IT = Input Tokens
OT = Output Tokens """) self.latency = "15s" #Default value for GPT4 super().__init__() def render(self): def on_model_change(model): if model == "GPT-4": self.latency = "15s" return gr.Dropdown.update(choices=["8K", "32K"]) else: self.latency = "5s" return gr.Dropdown.update(choices=["4K", "16K"], value="4K") def define_cost_per_token(model, context_length): if model == "GPT-4" and context_length == "8K": cost_per_1k_input_tokens = 0.03 cost_per_1k_output_tokens = 0.06 elif model == "GPT-4" and context_length == "32K": cost_per_1k_input_tokens = 0.06 cost_per_1k_output_tokens = 0.12 elif model == "GPT-3.5" and context_length == "4K": cost_per_1k_input_tokens = 0.0015 cost_per_1k_output_tokens = 0.002 else: cost_per_1k_input_tokens = 0.003 cost_per_1k_output_tokens = 0.004 return cost_per_1k_input_tokens, cost_per_1k_output_tokens self.model = gr.Dropdown(["GPT-4", "GPT-3.5 Turbo"], value="GPT-4", label="OpenAI models", interactive=True, visible=False) self.context_length = gr.Dropdown(["8K", "32K"], value="8K", interactive=True, label="Context size", visible=False, info="Number of tokens the model considers when processing text") self.input_tokens_cost_per_second = gr.Number(0.03, visible=False, label="($) Price/1K input prompt tokens", interactive=False ) self.output_tokens_cost_per_second = gr.Number(0.06, visible=False, label="($) Price/1K output prompt tokens", interactive=False ) self.info = gr.Markdown("The cost per input and output tokens values are from OpenAI's [pricing web page](https://openai.com/pricing)", interactive=False, visible=False) self.model.change(on_model_change, inputs=self.model, outputs=self.context_length).then(define_cost_per_token, inputs=[self.model, self.context_length], outputs=[self.input_tokens_cost_per_second, self.output_tokens_cost_per_second]) self.context_length.change(define_cost_per_token, inputs=[self.model, self.context_length], outputs=[self.input_tokens_cost_per_second, self.output_tokens_cost_per_second]) self.labor = gr.Number(0, visible=False, label="($) Labor cost per month", info="This is how much it will cost you to have an engineer specialized in Machine Learning take care of the deployment of your model service", interactive=True ) def compute_cost_per_token(self, input_tokens_cost_per_second, output_tokens_cost_per_second, labor): cost_per_input_token = (input_tokens_cost_per_second / 1000) cost_per_output_token = (output_tokens_cost_per_second / 1000) return cost_per_input_token, cost_per_output_token, labor class OpenSourceLlama2Model(BaseTCOModel): def __init__(self): self.set_name("(Open source) Llama 2 70B") self.set_formula(r"""$CR = \frac{CIT\_1K \times IT + COT\_1K \times OT}{1000}$
with:
CR = Cost per Request
CIT_1K = Cost per 1000 Input Tokens
COT_1K = Cost per 1000 Output Tokens
IT = Input Tokens
OT = Output Tokens """) self.set_latency("27s") super().__init__() def render(self): self.vm = gr.Textbox(value="2x A100 80GB NVLINK", visible=False, label="Instance of VM with GPU", ) self.vm_cost_per_hour = gr.Number(2.21, label="VM instance cost ($) per hour", info="Note that this is the cost for a single VM instance, it is doubled in our case since two GPUs are needed", interactive=False, visible=False) self.input_tokens_cost_per_second = gr.Number(0.00052, visible=False, label="($) Price/1K input prompt tokens", interactive=False ) self.output_tokens_cost_per_second = gr.Number(0.06656, visible=False, label="($) Price/1K output prompt tokens", interactive=False ) self.info = gr.Markdown("For the Llama2-70B model, we took the cost per input and output tokens values from [these benchmark results](https://www.cursor.so/blog/llama-inference#user-content-fn-llama-paper)", interactive=False, visible=False) self.labor = gr.Number(10000, visible=False, label="($) Labor cost per month", info="This is how much it will cost you to have an engineer specialized in Machine Learning take care of the deployment of your model service", interactive=True ) # self.used = gr.Slider(minimum=0.01, value=30., step=0.01, label="% used", # info="Percentage of time the GPU is used", # interactive=True, # visible=False) def compute_cost_per_token(self, input_tokens_cost_per_second, output_tokens_cost_per_second, labor): cost_per_input_token = (input_tokens_cost_per_second / 1000) cost_per_output_token = (output_tokens_cost_per_second / 1000) return cost_per_input_token, cost_per_output_token, labor class CohereModel(BaseTCOModel): def __init__(self): self.set_name("(SaaS) Cohere") self.set_formula(r"""$CR = \frac{CT\_1M \times (IT + OT)}{1000000}$
with:
CR = Cost per Request
CT_1M = Cost per one million Tokens (from Cohere's pricing web page)
IT = Input Tokens
OT = Output Tokens """) self.set_latency("") super().__init__() def render(self): self.model = gr.Dropdown(["Default", "Custom"], value="Default", label="Model", interactive=True, visible=False) if self.use_case == "Summarize": self.model: gr.Dropdown.update(choices=["Default"]) elif self.use_case == "Question-answering": self.model: gr.Dropdown.update(choices=["Default", "Custom"]) else: self.model: gr.Dropdown.update(choices=["Default", "Custom"]) self.labor = gr.Number(0, visible=False, label="($) Labor cost per month", info="This is how much it will cost you to have an engineer specialized in Machine Learning take care of the deployment of your model service", interactive=True ) def compute_cost_per_token(self, model, labor): """Cost per token = """ use_case = self.use_case if use_case == "Generate": if model == "Default": cost_per_1M_tokens = 15 else: cost_per_1M_tokens = 30 elif use_case == "Summarize": cost_per_1M_tokens = 15 else: cost_per_1M_tokens = 200 cost_per_input_token = cost_per_1M_tokens / 1000000 cost_per_output_token = cost_per_1M_tokens / 1000000 return cost_per_input_token, cost_per_output_token, labor class ModelPage: def __init__(self, Models: BaseTCOModel): self.models: list[BaseTCOModel] = [] for Model in Models: model = Model() self.models.append(model) def render(self): for model in self.models: model.render() model.register_components_for_cost_computing() def get_all_components(self) -> list[Component]: output = [] for model in self.models: output += model.get_components() return output def get_all_components_for_cost_computing(self) -> list[Component]: output = [] for model in self.models: output += model.get_components_for_cost_computing() return output def make_model_visible(self, name:str, use_case: gr.Dropdown): # First decide which indexes output = [] for model in self.models: if model.get_name() == name: output+= [gr.update(visible=True)] * len(model.get_components()) # Set use_case and num_users values in the model model.use_case = use_case else: output+= [gr.update(visible=False)] * len(model.get_components()) return output def compute_cost_per_token(self, *args): begin=0 current_model = args[-3] current_input_tokens = args[-2] current_output_tokens = args[-1] for model in self.models: model_n_args = len(model.get_components_for_cost_computing()) if current_model == model.get_name(): model_args = args[begin:begin+model_n_args] cost_per_input_token, cost_per_output_token, labor_cost = model.compute_cost_per_token(*model_args) model_tco = cost_per_input_token * current_input_tokens + cost_per_output_token * current_output_tokens formula = model.get_formula() latency = model.get_latency() return f"Model {current_model} has a cost/request of: ${model_tco:.5f}", model_tco, formula, f"The average latency of this model is {latency}", labor_cost begin = begin+model_n_args