[modify] simplify table

app/models.py

@@ -1,5 +1,3 @@
-from typing import Optional
-
 from pydantic import BaseModel, Field
 
 

app/tables.py

@@ -0,0 +1,38 @@
+import pandas as pd
+
+from app.models import Architecture, Estimate, Metadata, Tokenizer
+from app.utils import abbreviate_number, human_readable_size
+
+
+def get_model_info_df(
+    metadata: Metadata, architecture: Architecture, tokenizer: Tokenizer
+):
+    return pd.DataFrame(
+        [
+            {
+                "Type": metadata.type_,
+                "Name": metadata.name,
+                "Architecture": metadata.architecture,
+                "File Size": human_readable_size(metadata.file_size),
+                "Parameters": abbreviate_number(metadata.parameters),
+                "Bits Per Weight": round(metadata.bits_per_weight, 2),
+                "Maximum Context Length": architecture.maximum_context_length,
+                "Vocabulary Length": architecture.vocabulary_length,
+                "Tokenizer Model": tokenizer.model,
+                "Tokens Size": human_readable_size(tokenizer.tokens_size),
+            }
+        ]
+    )
+
+
+def get_estimate_df(estimate: Estimate):
+    return pd.DataFrame(
+        [
+            {
+                "Context Size": estimate.context_size,
+                "Flash Attention": estimate.flash_attention,
+                "Logical Batch Size": estimate.logical_batch_size,
+                "Physical Batch Size": estimate.physical_batch_size,
+            }
+        ]
+    )

app/utils.py

@@ -1,15 +1,15 @@
 def human_readable_size(size_in_bytes: int) -> str:
-    # 將檔案大小轉換為人類可讀的格式
+    # Convert file size to a human-readable format
     for unit in ["B", "KB", "MB", "GB", "TB", "PB"]:
         if size_in_bytes < 1024:
-            return f"{size_in_bytes:.2f}{unit}"
+            return f"{size_in_bytes:.2f} {unit}"
         size_in_bytes /= 1024
-    return f"{size_in_bytes:.2f}EB"
+    return f"{size_in_bytes:.2f} EB"
 
 
 def abbreviate_number(number: int) -> str:
-    # 將大數字轉換為縮寫格式
+    # Convert large numbers to abbreviated format
     for unit, threshold in [("B", 1e9), ("M", 1e6), ("K", 1e3)]:
         if number >= threshold:
-            return f"{number/threshold:.2f}{unit}"
+            return f"{number/threshold:.2f} {unit}"
     return str(number)

main.py

@@ -6,6 +6,7 @@ import gradio as gr
 import pandas as pd
 
 from app.models import GgufParser
+from app.tables import get_estimate_df, get_model_info_df
 
 GGUF_PARSER_VERSION = os.getenv("GGUF_PARSER_VERSION", "v0.12.0")
 gguf_parser = Path("gguf-parser-linux-amd64")
@@ -19,19 +20,14 @@ def process_url(url, context_length):
             f"./{gguf_parser} --ctx-size={context_length} -url {url} --json"
         ).read()
         parser_result = GgufParser.model_validate_json(res)
-        # data = json.loads(res)
 
-        metadata_df = pd.DataFrame([parser_result.metadata.model_dump()])
-
-        architecture_df = pd.DataFrame([parser_result.architecture.model_dump()])
-
-        tokenizer_df = pd.DataFrame([parser_result.tokenizer.model_dump()])
-
-        estimate_df = pd.DataFrame(
-            [parser_result.estimate.model_dump(exclude_none=True)]
+        model_info = get_model_info_df(
+            parser_result.metadata, parser_result.architecture, parser_result.tokenizer
         )
 
-        return metadata_df, architecture_df, tokenizer_df, estimate_df
+        estimate_df = get_estimate_df(parser_result.estimate)
+
+        return model_info, estimate_df
     except Exception as e:
         return e
 
@@ -52,9 +48,7 @@ if __name__ == "__main__":
             fn=process_url,
             inputs=[url_input, context_length],
             outputs=[
-                gr.DataFrame(label="METADATA"),
-                gr.DataFrame(label="ARCHITECTURE"),
-                gr.DataFrame(label="TOKENIZER"),
+                gr.DataFrame(label="Model Info"),
                 gr.DataFrame(label="ESTIMATE"),
             ],
         )