Create How_to_contribute.md (#2)

- Create How_to_contribute.md (3e333fc1283b92774e02764adf0a7897876cde07)

How_to_contribute.md

@@ -0,0 +1,100 @@
+# Contribute to our TCO Calculator
+
+## What can you contribute with
+
+The TCO Calculator’s purpose is to assist users in comparing the deployment [Total Cost of Ownership](https://www.techtarget.com/searchdatacenter/definition/TCO?Offer=abt_pubpro_AI-Insider) (TCO) of various AI model services. To do so, it computes the cost/request of said service and adds a labor cost to get a comprehensive estimate of how much the set-up of these services would cost.
+
+Here is the formula used to compute the cost/request of an AI model service:
+
+
+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
+
+To contribute, you’ll have to provide the value of the input and output cost/token.
+
+If you want to add your own service to this [Gradio](https://www.gradio.app/) application, you’ll have to follow two main steps:
+1. Create a class for your model in our `models.py` file.
+2. Add the name of your model class in our `app.py` file.
+
+## Create a class for your model
+
+Step by step, we’ll see how you can create a model class for your own service that can later be an option of our TCO Calculator.
+
+First, you need to create a class for your model and set basic information such as the name of your service and the latency of your model.
+
+```python
+# The name of your new model service's class
+class NewModel(BaseTCOModel):
+
+    def __init__(self):
+        # Name of the AI model service and the category it belongs to (SaaS, Open source)
+        self.set_name("(Category) Service name")
+        self.set_latency("The average latency of your model")
+        super().__init__()
+```
+Then, you’ll have to create the core function of your model page, the `render` function. Its first elements will be the [Gradio components](https://www.gradio.app/docs/components) that you want to put in your model page.
+It can be a Dropdown with multiple choices for the user to make or a Textbox with information about the computation parameters the user has to know (for instance, the cost of the hardware set-up used). There can be multiple of them.
+**All components’ visibility must be set to `False`**.
+
+```python
+def render(self):
+#Create as many Gradio components as you want to provide information or customization to the user
+#Put all their visibility to False
+#Don't forget to put the interactive parameter of the component to False if the value is fixed
+self.model_parameter = gr.Dropdown(["Option 1", "Option 2"], value="Option 1", visible=False, interactive=True, label="Title for this parameter", info="Add some information to clarify specific aspects of your parameter")
+```
+Then, still in the `render` function, you must instantiate your input and output cost/token. They are the key values needed to compute the cost/request of your AI model service. 
+Note that the user can’t interact with these since they are the values you’ll have to provide from benchmark tests on your model.
+```python
+#Put the values of the input and output cost per token
+#These values can be updated using a function above that is triggered by a change in the parameters
+#Put default values accordingly to the default parameters
+
+self.input_cost_per_token = gr.Number(0.1, visible=False, label="($) Price/1K input prompt tokens", interactive=False)
+
+self.output_cost_per_token = gr.Number(0.2, visible=False, label="($) Price/1K output prompt tokens", interactive=False)
+```
+Then, if the user can modify some parameters using the Gradio components mentioned above, you’ll have to update the values influenced by this. 
+This is why you need to create an update function that has the changing parameter(s) for input(s) and outputs the correct value. 
+In the test example, the parameter only influences the cost/token but it could be another parameter whose choices depend on the value of the former one. 
+```python
+
+def on_model_parameter_change(model_parameter):
+if model_parameter == "Option 1":
+input_tokens_cost_per_token = 0.1
+output_tokens_cost_per_token = 0.2
+else:
+input_tokens_cost_per_token = 0.2
+output_tokens_cost_per_token = 0.4
+return input_tokens_cost_per_token, output_tokens_cost_per_token
+```
+
+Don’t forget to add the triggering event that calls the update function when a Gradio parameter is changed. 
+Note that the inputs and outputs can vary depending on the update function. 
+```python
+self.model_parameter.change(on_model_parameter_change, inputs=self.model_parameter, outputs=[self.input_cost_per_token, self.output_cost_per_token])
+```
+The last element of the render function you have to implement is the labor cost parameter. It provides an estimation of how much it would cost to have engineers deploy the model. Note that for a SaaS solution, this cost is 0 when considering the set-up of the service. 
+```python
+self.labor = gr.Number(0, visible=False, label="($) Labor cost per month", info="This is an estimate of the labor cost of the AI engineer in charge of deploying the model", interactive=True)
+```
+Eventually, you need to create another function that will be necessary to compute the cost/request of your AI model service. You must have the same inputs and outputs as below and this function can be used to convert values.
+```python
+def compute_cost_per_token(self, input_cost_per_token, output_cost_per_token, labor):
+#Additional computation on your cost_per_token values
+#You often need to convert some values here
+return input_cost_per_token, output_cost_per_token, labor
+```
+
+Once your model class is ready, you’ll have to **add it to the `models.py` file** in our TCO Calculator’s [Hugging Face repository](https://huggingface.co/spaces/mithril-security/TCO_calculator/tree/main). 
+## Update the app.py file
+For the user to be able to select your AI model service option in the Calculator, you still have one step to go. 
+
+In the following code line of the `app.py` file (line 93), you’ll have to **add the name of your model class** as follows:
+```python
+Models: list[models.BaseTCOModel] = [models.OpenAIModelGPT4,...,  models.NewModel]
+```