update

app.py

@@ -0,0 +1,109 @@
+import streamlit as st
+import pandas as pd
+from model_util import get_mode_from_hf, calculate_flops_in_hugging_space
+
+
+def calculate_flops_architecture(num_params, num_tokens):
+    """
+    Calculate FLOPs based on model architecture.
+    """
+    total_flops = 6 * num_params * num_tokens
+    threshold_flops = 10 ** 25
+    meets_criteria = total_flops > threshold_flops
+
+    return {
+        "total_flops": total_flops,
+        "meets_criteria": meets_criteria
+    }
+
+
+def calculate_flops_gpu(gpu_hours, power_consumption_w, flops_per_gpu_s):
+    """
+    Calculate FLOPs based on GPU hours and type.
+    """
+    threshold_flops = 10 ** 25
+    total_energy_wh = gpu_hours * power_consumption_w
+    total_flops = gpu_hours * flops_per_gpu_s * 3600
+    meets_criteria = total_flops > threshold_flops
+
+    return {
+        "total_energy_wh": total_energy_wh,
+        "total_flops": total_flops,
+        "meets_criteria": meets_criteria
+    }
+
+
+def calculate_flops_hf(model_name, input_shape, access_token, bp_factor, output_unit):
+    """
+    Calculate FLOPs using Hugging Face model information.
+    """
+    model = get_mode_from_hf(model_name=model_name, library="auto", access_token=access_token)
+    data, return_print = calculate_flops_in_hugging_space(model_name=model_name, empty_model=model,
+                                                          access_token=access_token, input_shape=input_shape,
+                                                          bp_factor=bp_factor, output_unit=output_unit)
+    df = pd.DataFrame(data)
+    total_flops = df['Forward+Backward FLOPs'][0] * 10 ** 9  # Convert GFLOPs to FLOPs
+    threshold_flops = 10 ** 25
+    meets_criteria = total_flops > threshold_flops
+
+    return {
+        "total_flops": total_flops,
+        "meets_criteria": meets_criteria,
+        "dataframe": df,
+        "return_print": return_print
+    }
+
+
+st.title("FLOPs Calculator for EU AI Act High Impact Capabilities")
+
+# Choose calculation method
+calculation_method = st.selectbox("Choose Calculation Method:",
+                                  ["Model Architecture", "GPU Hours and Type", "Hugging Face Model"])
+
+if calculation_method == "Model Architecture":
+    num_params = st.number_input("Number of Parameters (N):", min_value=0.0, value=float(7.0 * 10 ** 9), step=1.0)
+    num_tokens = st.number_input("Number of Training Tokens (D):", min_value=0.0, value=float(1500 * 10 ** 9), step=1.0)
+
+    if st.button("Calculate FLOPs (Model Architecture)"):
+        result = calculate_flops_architecture(num_params, num_tokens)
+        st.write(f"Total FLOPs: {result['total_flops']:.2e} FLOPs")
+        st.write(f"Meets high impact capabilities criteria: {result['meets_criteria']}")
+
+elif calculation_method == "GPU Hours and Type":
+    # Define GPU types and their corresponding FLOPs per second
+    gpu_types = {
+        "Nvidia A100": {"flops_per_s": 312 * 10 ** 12, "power": 400},
+        "Nvidia V100": {"flops_per_s": 125 * 10 ** 12, "power": 300},
+        "Nvidia H100": {"flops_per_s": 1.25 * 10 ** 15, "power": 700},
+        "Nvidia T4": {"flops_per_s": 65 * 10 ** 12, "power": 70}
+    }
+
+    gpu_type = st.selectbox("Select GPU type:", list(gpu_types.keys()))
+    flops_per_gpu_s = gpu_types[gpu_type]["flops_per_s"]
+    power_consumption_w = gpu_types[gpu_type]["power"]
+
+    gpu_hours = st.number_input("Total GPU hours used for training:", min_value=0.0, value=float(7.7 * 10 ** 6),
+                                step=1.0)
+
+    if st.button("Calculate FLOPs (GPU Hours and Type)"):
+        result = calculate_flops_gpu(gpu_hours, power_consumption_w, flops_per_gpu_s)
+        st.write(f"Total energy consumption: {result['total_energy_wh']:.2e} Wh")
+        st.write(f"Total FLOPs: {result['total_flops']:.2e} FLOPs")
+        st.write(f"Meets high impact capabilities criteria: {result['meets_criteria']}")
+
+elif calculation_method == "Hugging Face Model":
+    model_name = st.text_input("Model Name:", "tiiuae/falcon-40b")
+    batch_size = st.number_input("Batch Size:", min_value=1, value=1)
+    max_seq_length = st.number_input("Max Sequence Length:", min_value=1, value=128)
+    input_shape = (batch_size, max_seq_length)
+    access_token = st.text_input("Hugging Face Access Token:", "")
+    bp_factor = st.number_input("Backward Pass Factor (BP Factor):", min_value=0.0, value=1.0, step=0.1)
+    output_unit = st.selectbox("Output Unit:", ["auto", "MFLOPs", "GFLOPs", "TFLOPs", "PFLOPs"])
+
+    if st.button("Calculate FLOPs (Hugging Face Model)"):
+        result = calculate_flops_hf(model_name, input_shape, access_token, bp_factor, output_unit)
+        st.write(f"Total FLOPs: {result['total_flops']:.2e} FLOPs")
+        st.write(f"Meets high impact capabilities criteria: {result['meets_criteria']}")
+        st.write("Detailed FLOPs Data:")
+        st.dataframe(result["dataframe"])
+        st.text(result["return_print"])

model_util.py

@@ -0,0 +1,127 @@
+import gradio as gr
+import torch
+
+from urllib.parse import urlparse
+from huggingface_hub.utils import GatedRepoError
+from huggingface_hub.utils import RepositoryNotFoundError
+
+from calflops import create_empty_model
+from calflops import calculate_flops_hf
+from calflops import flops_to_string
+from calflops import macs_to_string
+from calflops import params_to_string
+
+
+def calculate_flops_in_hugging_space(model_name: str,
+                                     empty_model: torch.nn.modules,
+                                     access_token: str,
+                                     input_shape: tuple,
+                                     bp_factor: float,
+                                     output_unit: str):
+    "Calculates the FLOPs and Params usage for a model init on `meta` device"
+
+    try:
+        flops, macs, params, return_print = calculate_flops_hf(model_name=model_name,
+                                                               empty_model=empty_model,
+                                                               access_token=access_token,
+                                                               input_shape=input_shape,
+                                                               return_results=True,
+                                                               output_as_string=False)
+    except Exception as e:
+        print("Error info:", e)
+        raise gr.Error(
+            f"Model `{model_name}` does not support inference on the meta device, You can download the complete model parameters to your local and using the python package calflops to calculate FLOPs and Params of model `{model_name}`."
+        )
+
+    fw_bp_flops = flops * (1.0 + bp_factor)
+    fw_bp_macs = macs * (1.0 + bp_factor)
+
+    if output_unit == "":
+        pass
+    elif output_unit == "auto":
+        params = params_to_string(params, units=None, precision=3)
+        flops = flops_to_string(flops, units=None, precision=3)
+        macs = macs_to_string(macs, units=None, precision=3)
+        fw_bp_flops = flops_to_string(fw_bp_flops, units=None, precision=3)
+        fw_bp_macs = macs_to_string(fw_bp_macs, units=None, precision=3)
+    elif output_unit == "T" or output_unit == "G" or output_unit == "M" or output_unit == "K" or output_unit == "m" or output_unit == "u":
+        params = params_to_string(params, units=output_unit, precision=3)
+        flops = flops_to_string(flops, units=output_unit, precision=3)
+        macs = macs_to_string(macs, units=output_unit, precision=3)
+        fw_bp_flops = flops_to_string(fw_bp_flops, units=output_unit, precision=3)
+        fw_bp_macs = macs_to_string(fw_bp_macs, units=output_unit, precision=3)
+
+    return_lines = return_print.split("\n")
+    return_start = False
+    return_print = ""
+    for line in return_lines[:-2]:
+        if return_start:
+            return_print += line + "\n"
+        if "Detailed" in line:
+            return_start = True
+
+    data = []
+    data.append(
+        {"Total Training Params": params,
+         "Forward FLOPs": flops,
+         "Forward MACs": macs,
+         "Forward+Backward FLOPs": fw_bp_flops,
+         "Forward+Backward MACs": fw_bp_macs
+         }
+    )
+    return data, return_print
+
+
+def extract_from_url(name: str):
+    "Checks if `name` is a URL, and if so converts it to a model name"
+    is_url = False
+    try:
+        result = urlparse(name)
+        is_url = all([result.scheme, result.netloc])
+    except Exception:
+        is_url = False
+    # Pass through if not a URL
+    if not is_url:
+        return name
+    else:
+        path = result.path
+        return path[1:]
+
+
+def translate_llama2(text):
+    "Translates llama-2 to its hf counterpart"
+    if not text.endswith("-hf"):
+        return text + "-hf"
+    return text
+
+
+def get_mode_from_hf(model_name: str, library: str, access_token: str):
+    "Finds and grabs model from the Hub, and initializes on `meta`"
+    if "meta-llama" in model_name:
+        model_name = translate_llama2(model_name)
+    if library == "auto":
+        library = None
+    model_name = extract_from_url(model_name)
+    try:
+        model = create_empty_model(model_name, library_name=library, trust_remote_code=True, access_token=access_token)
+    except GatedRepoError:
+        raise gr.Error(
+            f"Model `{model_name}` is a gated model, please ensure to pass in your access token and try again if you have access. You can find your access token here : https://huggingface.co/settings/tokens. "
+        )
+    except RepositoryNotFoundError:
+        raise gr.Error(f"Model `{model_name}` was not found on the Hub, please try another model name.")
+    except ValueError:
+        raise gr.Error(
+            f"Model `{model_name}` does not have any library metadata on the Hub, please manually select a library_name to use (such as `transformers`)"
+        )
+
+    except ImportError:
+        # hacky way to check if it works with `trust_remote_code=False`
+        model = create_empty_model(
+            model_name, library_name=library, trust_remote_code=False, access_token=access_token
+        )
+    except Exception as e:
+        raise gr.Error(
+            f"Model `{model_name}` had an error, please open a discussion on the model's page with the error message and name: `{e}`"
+        )
+    return model

requirements.txt

@@ -0,0 +1,4 @@
+gradio
+torch==2.0.1
+calflops
+pandas