Update app.py

app.py

@@ -62,9 +62,29 @@ def calc_mem(hf_model_name_or_path, num_gpus, tensor_parallel_size, pipeline_par
 
 # ---- Gradio Interface ---- #
 with gr.Blocks() as demo:
+
     with gr.Tabs():
-        # Memory Calculation Tab
+        gr.Markdown("""
+        This app is a re-creation of [this calculator](https://github.com/EleutherAI/cookbook/tree/main/calc) from EleutherAI.
+        
+        Before training or inference even begins, common practical questions about potential models must be answered such as:
+
+        1. How many parameters are we targeting? How should those parameters be allocated within the model?
+        1. How many FLOPs does the model from step 1 take to train on t tokens? How about inference?
+        1. How much memory does the model from step 1 take to train/infer on d devices? What memory-saving strategies (e.g. parallelism, quantization, etc) are necessary to fit the model on device memory?
+        """)
         with gr.TabItem("Memory Calculation"):
+            gr.Markdown("""
+            ## Memory Calculation
+        
+            Memory Calculation calculates the amount of device memory required to train or infer a model. See [Transformers Math 101](https://blog.eleuther.ai/transformer-math/) for more details on how memory overhead is calculated. 
+            Take this estimation with a grain of salt, because every implementation is different and these calculations were written to match the GPT-NeoX library as close as possible. 
+            Even for other training and inference libraries, however, we expect our script to give approximate memory estimations within acceptable error. 
+            (Please see [LLM finetuning memory requirements](https://blog.scottlogic.com/2023/11/24/llm-mem.html) for a treatment of how specific memory costs may vary framework-to-framework). Other good resources that we consulted are the [ZeRO Paper](https://arxiv.org/abs/1910.02054) and [Reducing Activation Recomputation in Large Transformer Models](https://arxiv.org/pdf/2205.05198.pdf).
+
+            ## To Use
+            Fill in the required details below and click 'Calculate Memory' to get a result.
+            """)
             with gr.Row():
                 with gr.Column("Generatable"):
                     with gr.Group():
@@ -152,6 +172,19 @@ with gr.Blocks() as demo:
 
         # Parameter Calculation Tab
         with gr.TabItem("Parameter Calculation"):
+            gr.Markdown("""
+            ## Parameter Calculation
+            
+            Parameter Calculation calculates the number of parameters present in a given model based on its hyperparams. 
+            Such calculations are important to determine memory overheads, FLOPs, or to determine the size of an unknown transformer model. 
+            We also found the following resources helpful: 
+            [How does GPT-3 spend its 175B parameters?](https://www.lesswrong.com/posts/3duR8CrvcHywrnhLo/how-does-gpt-3-spend-its-175b-parameters) 
+            and [LLM Parameter Counting](https://kipp.ly/transformer-param-count/).
+
+            ## How To Use
+            Simply input the model details, such as the hidden size, number of layers, and attention heads, and press 'Calculate Parameters' to get a result.
+
+            """)
             with gr.Row():
                 with gr.Column("Generatable"):
                     with gr.Group():