Understanding dimensional analysis

[arasugurlu]

Hello, this is my code, i was trying to search for expressions such as exp(x4/x0) or exp(x5/x0). I was unable to, thanks to Miles Cranmer, I changed the dimensional_constants_only = False, than i realized i can search such expressions above. However, this time, even if I apply for a high magnitude of dimensional penalty variable, (dimensional_constraint_penalty = 10000), PySR never creates analytical forms which are dimensionally consistent. I want my analytical equations to be dimensionally consistent, so I need help about this subject.

Thank you in advance

import numpy as np
import matplotlib.pyplot as plt
from pysr import PySRRegressor

--- Example data ---
file_path = r"/arasugurlu/PySR-2/train_set.txt"

with open(file_path, "r", encoding="utf-8") as file:
for line in file:
parts = line.strip().split()
if len(parts) != 7:
continue
try:
        x0 = float(parts[0])  # m
        x1 = float(parts[1])  # N/m^2
        x2 = float(parts[2])  # N/m^2
        x3 = float(parts[3])  # N/m^2
        x4 = float(parts[4])  # m
        x5 = float(parts[5])  # m
        x6 = x4 / x0          # dimensionless
        x7 = x5 / x0          # dimensionless
        x8 = x4 / x5          # dimensionless
        g = 3*x3*(x1-x2)/(x1-x2+4*x3) # N/m^2
    y_val = float(parts[6]) # N/m^2

    X.append([x0, g, x6, x7])
    y.append(y_val)
X = np.array(X)
y = np.array(y)

X_units = ["m","N/m^2","",""]
y_units = "N/m^2"

--- Example elementwise loss (it is randomly chosen)---
elementwise_loss = """
function loss_fnc(predictions, targets)
total_loss = 0.0
for (p, t) in zip(predictions, targets)
# simple relative error
total_loss += abs(p - t) / (abs(t) + 1e-6)
end
return total_loss
end
"""

--- PySR model ---
model = PySRRegressor(
procs=64,
populations=192,
population_size=192,
ncycles_per_iteration=500,
niterations=1000,
maxsize=25,
maxdepth=25,
parsimony=0.001,
binary_operators=["*", "+", "-", "/"],
unary_operators=["exp"],
dimensionless_constants_only=False,
dimensional_constraint_penalty = 10000,
weight_randomize=0.2,
weight_optimize=0.001,
warm_start=True,
elementwise_loss=elementwise_loss
)

Fit model
model.fit(X, y)
y_pred = model.predict(X)
’’’

[MilesCranmer]

What is x4 and x5? Your X_units only has four units in it.

[MilesCranmer]

Btw,

function loss_fnc(predictions, targets)
    total_loss = 0.0
    for (p, t) in zip(predictions, targets)
        # simple relative error
        total_loss += abs(p - t) / (abs(t) + 1e-6)
    end
    return total_loss
end

is mixing up the definitions. An elementwise_loss is defined elementwise. So no need to sum over anything. i.e., you could just do

function loss_fnc(prediction, target)
    T = typeof(prediction)
    return abs(prediction - target) / (abs(target) + T(1e-6))
end

[MilesCranmer]

Note that dimensionless_constants_only=False means that the constants have dimensions now. So it's not that the expressions are invalid, it's that you now have enabled dimensionsless constants being found.

[arasugurlu]

Hey Miles, thanks for the clarification.

I’ve tried setting dimensionless_constants_only=False, but I’m still running into dimensional inconsistencies — for example, PySR sometimes produces expressions like exp(x0 [m] + K) where K is a constant or ends up summing dimensionally inconsistent terms.

I understand that dimensionless_constants_only allows dimensional constants, but it doesn’t actually enforce dimensional consistency across operators.

What I’m trying to achieve is full dimensional consistency throughout the generated expression — for instance:
• the argument of exp() (and similar functions like log) should be strictly dimensionless,
• and the entire analytical formula should remain dimensionally consistent, so that all sums, multiplications, etc. respect physical dimensions.

Is there currently any mechanism, or planned feature, to propagate or validate dimensions automatically in PySR, ensuring that operators like exp only receive dimensionless arguments and that the final expression is physically consistent?

If not, do you recommend any workaround (e.g. manually normalizing inputs or defining custom operator constraints) for enforcing that kind of dimensional logic?

[MilesCranmer]

PySR sometimes produces expressions like exp(x0 [m] + K) where K is a constant

Do you have an example of this? This should receive a large penalty and not show up in the final expression.

Note that you need to set the dimensional analysis penalty as a hyperparameter.

But yes, PySR does flag such examples as dimensionally inconsistent. This is the entire point of the X_units API, without dimensional consistency checks there would be no reason for it to exist

[arasugurlu]

Sorry, I will provide the example of exp(x0[m] + K) later today.

my dimensional penalty was 1e6, in this example, what should I do right now?

[arasugurlu]

PySR sometimes produces expressions like exp(x0 [m] + K) where K is a constant

Do you have an example of this? This should receive a large penalty and not show up in the final expression.

Note that you need to set the dimensional analysis penalty as a hyperparameter.

But yes, PySR does flag such examples as dimensionally inconsistent. This is the entire point of the X_units API, without dimensional consistency checks there would be no reason for it to exist

One of the example I got from PySR is the following:

y[m⁻² N] = ((((x₁[m⁻² N] / x₃[m]) / x₃[m]) * exp(-10.673[?] / x₀[m])) * (x₀[m] * 85.058[?])) / x₃[m]

As you can see, there is exp(-10.673[?] / x₀[m]), which makes the expression dimensionally unconsistent.

Thank you in advance

[MilesCranmer]

Actually no that is dimensionally consistent. The [?] just means that constant should have dimensions. But sometimes it is ambiguous what that dimensions should be. In this case, that constant should have dimensions [m]. Which is valid.