Update models.py

models.py

@@ -36,11 +36,23 @@ class BaseTCOModel(ABC):
     
     def set_name(self, name):
         self.name = name
+    
+    def set_formula(self, formula):
+        self.formula = formula
+    
+    def get_formula(self):
+        return self.formula
 
 class OpenAIModel(BaseTCOModel):
 
     def __init__(self):
         self.set_name("(SaaS) OpenAI")
+        self.set_formula(r"""$CT = \frac{CT\_1K \times 1000}{L}$  <br>
+                         with: <br>
+                         CT = Cost per output Token <br>
+                         CT_1K = Cost per 1000 Tokens (from OpenAI's pricing web page) <br>
+                         L = Input Length 
+                         """)
         super().__init__()
 
     def render(self):
@@ -54,11 +66,11 @@ class OpenAIModel(BaseTCOModel):
                 return gr.Dropdown.update(choices=["4K", "16K"])
 
         self.model = gr.Dropdown(["GPT-4", "GPT-3.5 Turbo"], value="GPT-4",
-                                 label="OpenAI model",
+                                 label="OpenAI models",
                                  interactive=True, visible=False)
         self.context_length = gr.Dropdown(["8K", "32K"], value="8K", interactive=True,
                                           label="Context size",
-                                          visible=False)
+                                          visible=False, info="Number of tokens the model considers when processing text")
         self.model.change(on_model_change, inputs=self.model, outputs=self.context_length)
         self.input_length = gr.Number(350, label="Average number of input tokens", 
                                       interactive=True, visible=False)
@@ -77,13 +89,22 @@ class OpenAIModel(BaseTCOModel):
         else:
             cost_per_1k_input_tokens = 0.003
 
-        cost_per_output_token = cost_per_1k_input_tokens * input_length / 1000
+        cost_per_output_token = cost_per_1k_input_tokens * 1000 / input_length
 
         return cost_per_output_token
 
 class OpenSourceLlama2Model(BaseTCOModel):
+    
     def __init__(self):
         self.set_name("(Open source) Llama 2")
+        self.set_formula(r"""$CT = \frac{VM\_CH}{TS \times 3600 \times MO \times U}$<br>
+                         with: <br>
+                         CT = Cost per Token <br>
+                         VM_CH = VM Cost per Hour <br>
+                         TS = Tokens per Second (for an input length of 233 tokens) <br>
+                         MO = Maxed Out <br>
+                         U = Used
+                         """)
         super().__init__()
     
     def render(self):
@@ -101,18 +122,20 @@ class OpenSourceLlama2Model(BaseTCOModel):
         def on_vm_change(model, vm):
             # TO DO: load info from CSV
             if model == "Llama 2 7B" and vm == "1x Nvidia A100 (Azure NC24ads A100 v4)":
-                return gr.Number.update(value=900)
+                return [gr.Number.update(value=3.6730), gr.Number.update(value=694.38)]
             elif model == "Llama 2 7B" and vm == "2x Nvidia A100 (Azure NC48ads A100 v4)":
-                return gr.Number.update(value=1800)
+                return [gr.Number.update(value=7.346), gr.Number.update(value=1388.76)]
         
-        self.model = gr.Dropdown(["Llama 2 7B", "Llama 2 70B"], value="Llama 2 7B", visible=False)
-        self.vm = gr.Dropdown(vm_choices, 
+        self.model = gr.Dropdown(["Llama 2 7B", "Llama 2 70B"], value="Llama 2 7B", label="OpenSource models", visible=False)
+        self.vm = gr.Dropdown(vm_choices,
+                              value="1x Nvidia A100 (Azure NC24ads A100 v4)", 
                               visible=False,
-                              label="Instance of VM with GPU"
+                              label="Instance of VM with GPU",
+                              info="Your options for this choice depend on the model you previously chose"
                               )
-        self.vm_cost_per_hour = gr.Number(3.5, label="VM instance cost per hour", 
+        self.vm_cost_per_hour = gr.Number(3.6730, label="VM instance cost per hour", 
                                       interactive=True, visible=False)
-        self.tokens_per_second = gr.Number(900, visible=False,
+        self.tokens_per_second = gr.Number(694.38, visible=False,
                                            label="Number of tokens per second for this specific model and VM instance",
                                            interactive=False
                                            )
@@ -120,17 +143,22 @@ class OpenSourceLlama2Model(BaseTCOModel):
                                       interactive=True, visible=False)
         
         self.model.change(on_model_change, inputs=self.model, outputs=self.vm)
-        self.vm.change(on_vm_change, inputs=[self.model, self.vm], outputs=self.tokens_per_second)
-        self.maxed_out = gr.Slider(minimum=0.01, value=1., step=0.01, label="% maxed out", 
+        self.vm.change(on_vm_change, inputs=[self.model, self.vm], outputs=[self.vm_cost_per_hour, self.tokens_per_second])
+        self.maxed_out = gr.Slider(minimum=0.01, value=50., step=0.01, label="% maxed out", 
                                    info="How much the GPU is fully used.",
                                    interactive=True,
                                    visible=False)
+        self.used = gr.Slider(minimum=0.01, value=50., step=0.01, label="% used", 
+                                   info="Percentage of time the GPU is used.",
+                                   interactive=True,
+                                   visible=False)
 
-    def compute_cost_per_token(self, vm_cost_per_hour, tokens_per_second, maxed_out):
-        cost_per_token = vm_cost_per_hour / (tokens_per_second * 3600 * maxed_out)
+    def compute_cost_per_token(self, vm_cost_per_hour, tokens_per_second, maxed_out, used):
+        cost_per_token = vm_cost_per_hour / (tokens_per_second * 3600 * maxed_out * used)
         return cost_per_token 
     
 class ModelPage:
+    
     def __init__(self, Models: BaseTCOModel):
         self.models: list[BaseTCOModel] = []
         for Model in Models:
@@ -170,8 +198,10 @@ class ModelPage:
         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]
-                print("Model args: ",model_args)
                 model_tco = model.compute_cost_per_token(*model_args)
-                return f"Model {current_model} has TCO {model_tco}"
+                formula = model.get_formula()
+                return f"Model {current_model} has TCO {model_tco}", model_tco, formula
+            
             begin = begin+model_n_args