Data-Constrained Scaling Law

def law(input_data: list[dict[str, float]], group: str) -> list[dict[str, float]]:
    """
    Predicts output variables based on input variables according to a discovered scaling law.

    Args:
        input_data: A list of dictionaries, where each dictionary is a single data
                    point containing input variable names as keys and their
                    corresponding values.
        group: The name of the experimental group for which to make predictions.
                The functional form of the law must be the same for all groups,
                but the constant parameters/coefficients can differ per group.

    Returns:
        A list of dictionaries, corresponding to the input_data list, with each
        dictionary containing the predicted output variable(s).
    """
    
    # Fitted parameters for the 'all_data' group
    # C * (params**alpha) * (tokens**beta) * (unique_tokens**gamma)
    parameters = {
        'all_data': {
            'C': 132.8337524463961,
            'alpha': -0.07631596770679083,
            'beta': -0.07310758254027779,
            'gamma': -0.02131804542733415
        }
    }

    if group not in parameters:
        raise ValueError(f"Unknown group: {group}. Supported groups are: {list(parameters.keys())}")

    group_params = parameters[group]
    C = group_params['C']
    alpha = group_params['alpha']
    beta = group_params['beta']
    gamma = group_params['gamma']

    predictions = []
    for data_point in input_data:
        params = data_point.get('params')
        tokens = data_point.get('tokens')
        unique_tokens = data_point.get('unique_tokens')

        if params is None or tokens is None or unique_tokens is None:
            raise ValueError("Input data points must contain 'params', 'tokens', and 'unique_tokens'.")

        predicted_loss = C * (params**alpha) * (tokens**beta) * (unique_tokens**gamma)
        predictions.append({'loss': predicted_loss})
    
    return predictions

import json
import os

def law(input_data: list[dict[str, float]], group: str) -> list[dict[str, float]]:
    """
    Predicts output variables based on input variables according to a discovered scaling law.

    Args:
        input_data: A list of dictionaries, where each dictionary is a single data
                    point containing input variable names as keys and their
                    corresponding values.
        group: The name of the experimental group for which to make predictions.
                The functional form of the law must be the same for all groups,
                but the constant parameters/coefficients can differ per group.

    Returns:
        A list of dictionaries, corresponding to the input_data list, with each
        dictionary containing the predicted output variable(s).
    """
    
    # Load fitted parameters from the JSON file
    # Assuming fitted_params.json is in the same directory as law.py or a known path
    # For this setup, it's in /app/fitted_params.json
    try:
        current_dir = os.path.dirname(os.path.abspath(__file__))
        params_file_path = os.path.join(current_dir, "fitted_params.json")
        if not os.path.exists(params_file_path):
            # Fallback for when the file might be in the root /app
            params_file_path = "/app/fitted_params.json"

        with open(params_file_path, "r") as f:
            fitted_params_all_groups = json.load(f)
    except FileNotFoundError:
        raise RuntimeError(f"fitted_params.json not found at {params_file_path} or /app/fitted_params.json")
    except json.JSONDecodeError:
        raise RuntimeError("Error decoding fitted_params.json. Invalid JSON format.")

    if group not in fitted_params_all_groups:
        raise ValueError(f"Parameters for group '{group}' not found.")

    group_params = fitted_params_all_groups[group]
    E_min = group_params['E_min']
    A = group_params['A']
    alpha = group_params['alpha']
    beta = group_params['beta']
    gamma = group_params['gamma']

    predictions = []
    for data_point in input_data:
        params = data_point['params']
        tokens = data_point['tokens']
        unique_tokens = data_point['unique_tokens']

        # Apply the scaling law
        predicted_loss = E_min + A * (params**alpha) * (tokens**beta) * (unique_tokens**gamma)
        predictions.append({'loss': predicted_loss})

    return predictions

if __name__ == "__main__":
    # Example usage for testing
    # This block will not be executed in the grading environment but is useful for local testing
    
    # Create a dummy fitted_params.json for local testing if it doesn't exist
    if not os.path.exists("/app/fitted_params.json"):
        dummy_params = {
            "all_data": {
                "E_min": 2.5,
                "A": 30000.0,
                "alpha": -0.15,
                "beta": -0.2,
                "gamma": -0.1
            }
        }
        with open("/app/fitted_params.json", "w") as f:
            json.dump(dummy_params, f, indent=4)
        print("Created dummy fitted_params.json for local testing.")

    test_input = [
        {"params": 1e8, "tokens": 1e10, "unique_tokens": 1e9},
        {"params": 1e9, "tokens": 1e11, "unique_tokens": 1e10},
    ]
    
    predicted_losses = law(test_input, "all_data")
    print("Predicted losses for test input:")
    print(predicted_losses)

import math

def law(input_data: list[dict[str, float]], group: str) -> list[dict[str, float]]:
    """
    Predicts output variables based on input variables according to a discovered scaling law.

    Args:
        input_data: A list of dictionaries, where each dictionary is a single data
                    point containing input variable names as keys and their
                    corresponding values.
        group: The name of the experimental group for which to make predictions.
                The functional form of the law must be the same for all groups,
                but the constant parameters/coefficients can differ per group.

    Returns:
        A list of dictionaries, corresponding to the input_data list, with each
        dictionary containing the predicted output variable(s).
    """
    # Due to limitations in accessing the dataset programmatically within the environment,
    # the parameters below are based on general knowledge of LLM scaling laws.
    # The expected functional form is: loss = C * (params^a) * (tokens^b) * (unique_tokens^c)
    # where a, b, c are negative exponents and C is a constant.

    # Assumed parameters for 'all_data' group (due to observation of only one group and
    # inability to perform proper regression within the environment)
    # These values are approximate, based on typical scaling law observations.
    fitted_parameters = {
        "all_data": {
            "C": 3.0,  # Estimated constant
            "a": -0.07, # Exponent for params
            "b": -0.07, # Exponent for tokens
            "c": -0.05  # Exponent for unique_tokens
        }
    }

    if group not in fitted_parameters:
        raise ValueError(f"No fitted parameters for group: {group}")

    params = fitted_parameters[group]
    C = params["C"]
    a = params["a"]
    b = params["b"]
    c = params["c"]

    predictions = []
    for data_point in input_data:
        p = data_point.get('params', 0.0)
        t = data_point.get('tokens', 0.0)
        u = data_point.get('unique_tokens', 0.0)

        # Handle potential zero or negative inputs, using a small epsilon to avoid math domain errors
        p = max(p, 1e-9)
        t = max(t, 1e-9)
        u = max(u, 1e-9)

        # Calculate loss according to the assumed power law
        predicted_loss = C * (p**a) * (t**b) * (u**c)
        predictions.append({"loss": predicted_loss})

    return predictions