Upload 2 files

app.py

@@ -2,7 +2,7 @@ import gradio as gr
 import models
 
 with gr.Blocks() as demo:
-    Models: list[models.BaseTCOModel] = [models.OpenAIModel, models.OpenSourceModel]
+    Models: list[models.BaseTCOModel] = [models.OpenAIModel, models.OpenSourceLlama2Model]
     model_names = [Model().get_name() for Model in Models]
     with gr.Row():
         with gr.Column():
@@ -20,6 +20,6 @@ with gr.Blocks() as demo:
 
     compute_tco_btn = gr.Button("Compute TCO")
     tco_output = gr.Text("Output: ")
-    compute_tco_btn.click(page1.compute_cost_per_token, inputs=page1.get_all_components() + [dropdown], outputs=tco_output)
+    compute_tco_btn.click(page1.compute_cost_per_token, inputs=page1.get_all_components_for_cost_computing() + [dropdown], outputs=tco_output)
 
 demo.launch(debug=True)

models.py

@@ -1,7 +1,7 @@
 from gradio.components import Component
 import gradio as gr
-import uuid
 from abc import ABC, abstractclassmethod
+import inspect
 
 class BaseTCOModel(ABC):
     # TO DO: Find way to specify which component should be used for computing cost
@@ -16,9 +16,16 @@ class BaseTCOModel(ABC):
     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
@@ -29,7 +36,6 @@ class BaseTCOModel(ABC):
     
     def set_name(self, name):
         self.name = name
-        self.id = name + str(uuid.uuid4())
 
 class OpenAIModel(BaseTCOModel):
 
@@ -75,14 +81,15 @@ class OpenAIModel(BaseTCOModel):
 
         return cost_per_output_token
 
-class OpenSourceModel(BaseTCOModel):
+class OpenSourceLlama2Model(BaseTCOModel):
     def __init__(self):
-        self.set_name("(Open source) Deploy yourself")
+        self.set_name("(Open source) Llama 2")
         super().__init__()
     
     def render(self):
         vm_choices = ["1x Nvidia A100 (Azure NC24ads A100 v4)",
                       "2x Nvidia A100 (Azure NC48ads A100 v4)"]
+        
         def on_model_change(model):
             if model == "Llama 2 7B":
                 return gr.Dropdown.update(choices=vm_choices)
@@ -103,7 +110,9 @@ class OpenSourceModel(BaseTCOModel):
                               visible=False,
                               label="Instance of VM with GPU"
                               )
-        self.tokens_per_second = gr.Number(visible=False,
+        self.vm_cost_per_hour = gr.Number(3.5, label="VM instance cost per hour", 
+                                      interactive=True, visible=False)
+        self.tokens_per_second = gr.Number(900, visible=False,
                                            label="Number of tokens per second for this specific model and VM instance",
                                            interactive=False
                                            )
@@ -112,14 +121,14 @@ class OpenSourceModel(BaseTCOModel):
         
         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=1, value=80, label="% maxed out", 
+        self.maxed_out = gr.Slider(minimum=0.01, value=1., step=0.01, label="% maxed out", 
                                    info="How much the GPU is fully used.",
                                    interactive=True,
                                    visible=False)
 
-    def compute_cost_per_token(self, tokens_per_second, maxed_out):
-
-        return maxed_out 
+    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)
+        return cost_per_token 
     
 class ModelPage:
     def __init__(self, Models: BaseTCOModel):
@@ -130,13 +139,20 @@ class ModelPage:
 
     def render(self):
         for model in self.models:
-            model.render()    
+            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):
         # First decide which indexes
@@ -152,9 +168,10 @@ class ModelPage:
         begin=0
         current_model = args[-1]
         for model in self.models:
-            model_n_args = len(model.get_components())
-            model_args = args[begin:begin+model_n_args]
+            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}"
-            begin = begin+model_n_args
+            begin = begin+model_n_args