SFT Scaling Law

import numpy as np
from scipy.optimize import least_squares

def scaling_law_func(D, p):
    # L(D) = L_inf + A / (D^alpha + N0)
    D = np.ravel(D).astype(float)
    L_inf, A, alpha, N0 = np.maximum(p, [0.0, 1e-12, 1e-6, 1e-12])
    return L_inf + A / (D**alpha + N0)

def fit_scaling_law(data_points, loss_values):
    D = np.ravel(data_points).astype(float)
    y = np.ravel(loss_values).astype(float)
    y0, y1 = y.min(), y.max()

    # Initial guesses
    L0 = max(0.0, 0.9 * y0)
    a0 = 0.5
    n0 = max(1e-8, D.min())
    A0 = max(1e-8, (y1 - L0) * (D.min()**a0 + n0))
    p0 = np.array([L0, A0, a0, n0])

    # Bounds
    lb = [0.0, 1e-12, 1e-6, 1e-12]
    ub = [y0,  np.inf, 50.0, D.max() * 10.0]

    # Residuals: combine absolute + relative error
    def residuals(p):
        pred = scaling_law_func(D, p)
        e = pred - y
        return np.concatenate([e, e / (y + 1e-8)])

    res = least_squares(
        residuals,
        p0,
        bounds=(lb, ub),
        loss='soft_l1',
        f_scale=0.1,
        max_nfev=5000
    )

    p_opt = res.x if res.success else p0
    return np.maximum(p_opt, [0.0, 0.0, 0.0, 0.0])

import numpy as np
from scipy.optimize import minimize

def scaling_law_func(data_points, params):
    """
    4-parameter logistic-style scaling law:
      L(D) = L_inf + A / (1 + (D/D0)^alpha)
    params = [logA, logD0, logAlpha, L_inf]
    """
    D = np.atleast_1d(np.squeeze(data_points)).astype(float)
    p = np.ravel(params).astype(float)
    A      = np.exp(p[0])
    D0     = np.exp(p[1])
    alpha  = np.exp(p[2])
    L_inf  = p[3]
    return L_inf + A / (1.0 + (D / D0)**alpha)

def fit_scaling_law(data_points, loss_values):
    """
    Fit the 4-parameter form L_inf + A/(1+(D/D0)^alpha)
    by minimizing squared log-errors via L-BFGS-B.
    Returns optimized [logA, logD0, logAlpha, L_inf].
    """
    D = np.atleast_1d(np.squeeze(data_points)).astype(float)
    L = np.ravel(loss_values).astype(float)
    D = np.maximum(D, 1e-8)
    # Initial guesses
    L_min, L_max = L.min(), L.max()
    L_inf0 = max(0.9 * L_min, 1e-3)
    A0      = max(L_max - L_inf0, 1e-3)
    D0_0    = np.median(D)
    alpha0  = 0.5
    p0 = np.array([np.log(A0), np.log(D0_0), np.log(alpha0), L_inf0], dtype=float)
    # Objective: mean squared log-residual
    def obj(p):
        pred = scaling_law_func(D, p)
        return np.mean((np.log(pred + 1e-8) - np.log(L + 1e-8))**2)
    # Optimize with L-BFGS-B for stability
    res = minimize(obj, p0, method='L-BFGS-B')
    return res.x if res.success else p0

import numpy as np
from scipy.optimize import least_squares

# EVOLVE-BLOCK-START
def scaling_law_func(data_points, params):
    """
    4-parameter logistic scaling on log-data size:
      Let d = log10(D + eps).
      L(D) = L_inf + (L0 - L_inf) / [1 + (d/d_mid)^alpha].
    params = [L_inf, L0, d_mid, alpha]
    """
    D = np.ravel(data_points).astype(float)
    d = np.log10(D + 1e-8)
    L_inf, L0, d_mid, alpha = params
    return L_inf + (L0 - L_inf) / (1.0 + np.power(d / d_mid, alpha))

def fit_scaling_law(data_points, loss_values):
    """
    Fit [L_inf, L0, d_mid, alpha] by robust least_squares
    using a Cauchy loss for stability against outliers.
    """
    D = np.ravel(data_points).astype(float)
    y = np.ravel(loss_values).astype(float)
    d = np.log10(D + 1e-8)
    y_min, y_max = float(y.min()), float(y.max())

    # Initial guesses: asymptote ~min loss, start ~max loss,
    # midpoint ~median(log10 D), slope ~1
    p0 = [y_min, y_max, float(np.median(d)), 1.0]

    # Bounds to keep parameters in sensible ranges
    lb = [
        0.0,                    # L_inf >= 0
        y_max * 0.9,            # L0 >= ~90% of max loss
        max(d.min() * 0.1, 1e-6),  # d_mid > 0
        0.01                    # alpha > 0
    ]
    ub = [
        y_min * 1.2 + 1e-6,     # L_inf not far above min loss
        y_max * 1.5 + 1e-6,     # L0 not far above max loss
        d.max() * 2.0 + 1e-6,   # d_mid up to 2× max(log D)
        20.0                    # alpha upper bound
    ]

    def residuals(p):
        return scaling_law_func(D, p) - y

    try:
        res = least_squares(
            residuals, p0,
            bounds=(lb, ub),
            loss='cauchy', f_scale=0.1,
            xtol=1e-9, ftol=1e-9, max_nfev=1000
        )
        return res.x if res.success else np.array(p0, dtype=float)
    except Exception:
        return np.array(p0, dtype=float)
# EVOLVE-BLOCK-END

# EVOLVE-BLOCK-START
import numpy as np
from scipy.optimize import least_squares

def scaling_law_func(data_points, params):
    """
    4-parameter sigmoid-like scaling law:
      L(D) = a + b / (1 + (D / c)**d)
    where b, c, d are kept positive via absolute+eps.
    params: array([a, b, c, d])
    """
    # Flatten to 1D array of data sizes
    D = np.atleast_1d(np.squeeze(data_points)).astype(float)
    a, b, c, d = params
    # enforce positivity for b, c, d
    b = np.abs(b) + 1e-12
    c = np.abs(c) + 1e-12
    d = np.abs(d) + 1e-12
    return a + b / (1.0 + (D / c)**d)

def fit_scaling_law(data_points, loss_values):
    """
    Fit L(D) = a + b / (1 + (D/c)**d) via non-linear least squares.
    Returns optimized [a, b, c, d].
    """
    # Prepare 1D arrays
    D = np.atleast_1d(np.squeeze(data_points)).astype(float)
    y = np.atleast_1d(np.squeeze(loss_values)).astype(float)
    # Basic statistics for initialization
    y_min, y_max = y.min(), y.max()
    # Initial guess
    a0 = max(y_min * 0.9, 1e-3)
    b0 = max(y_max - a0, 1e-3)
    c0 = np.median(D)
    d0 = 1.0
    p0 = np.array([a0, b0, c0, d0])
    # Bounds: b, c, d strictly positive
    lower = np.array([-np.inf, 1e-8, 1e-8, 1e-8])
    upper = np.array([ np.inf,  np.inf,  np.inf,  np.inf])
    # Residual function
    def residuals(p):
        return scaling_law_func(D, p) - y
    # Solve with trust-region-reflective bounds
    res = least_squares(residuals, p0, bounds=(lower, upper),
                        ftol=1e-8, xtol=1e-8, gtol=1e-8)
    return res.x if res.success else p0
# EVOLVE-BLOCK-END