Thank You @fkiraly , I will check it once.

@fkiraly I have added the changes that I missed earlier.
Really sorry, I didn't check my code the first time and made the PR.
Will definitely work on this.

@fkiraly Thank you, I will give it a check and will let you know.

@fkiraly I checked your conjecture and yepp you are right in that.
With the given values of a vector of length 100, with value 1000.

and implementing the given functions to check it, I found this as my result.

# Function to compute GMAE using direct product approach
def gmae_direct(y_true, y_pred):
errors = np.abs(y_true - y_pred)
product_of_errors = np.prod(errors)
gmae = np.power(product_of_errors, 1 / len(errors))
return gmae

And :-

def gmae_log_exp(y_true, y_pred, epsilon=1e-10):
errors = np.abs(y_true - y_pred)
errors = np.maximum(errors, epsilon) # Ensure errors are strictly positive
log_errors = np.log(errors)
log_mean = np.mean(log_errors)
gmae = np.exp(log_mean)
return gmae

And so this was the result I got :-

GMAE using direct product approach: 0.0
GMAE using log/exp representation approach: 9.999999999999996e-11

hm, something is not right here - the result should be 1000

Okay I will check it once.
Is there any problem with the given function definition.

I see - I meant when the errors are a vector of 1000. To create that situation, you could make y_true a vector of 1s, and y_pred a vector of 1001-s.

@fkiraly I gave the input as :-

test_length = 100
y_true = np.ones(test_length)
y_pred = np.ones(test_length) * 1001

and I got this as the result :-

GMAE using direct product approach: 1000.0000000000001

GMAE using log/exp representation approach: 999.9999999999989

hm, is direct more accurate? Surprising.

How about you make the errors larger, e.g., 1e-10 and see what happens?

@fkiraly So I used the input values given and here is the output for the same :-

GMAE using direct product approach: 0.0
GMAE using log/exp representation approach: 1.0000000827403598e-10

yes, seems more stable for extreme values. Shall we go with the log/exp approach then?

Yes I have written the code for that as well. I will just add it.

for discussion later in our mentoring meeting.

I made some corrections and simplifications to the code, but I think it's not done yet.

• replaced what I thought was an overly verbose (and perhaps incorrect?) implementation in _evaluate with the scipy gmean method
• removed inheritance for BaseForecastingErrorMetricFunc
• replaced what looked like an incorrect implementation of the pseudovalues with a few lines in _evaluate_by_index

The implementation in _evaluate_by_index should be correct if I made no mistake, but it may not be numerically stable when dealing with values close to zero. One may have to put some additional thinking in how to tackle that corner of the parameter space.

there are some failures due to wrong type - would be great if you could handle these, @KaustubhUp025. The formula should be correct, but a double check would also be appreciated, might be errors of sign or numerical issues.

@fkiraly I misunderstood the working flow and created two different PR's for the same GMAE issue and the one I needed to review was on #6461.
Should I close this PR or what else could be done with this PR since I left it without adding the proper improvements that I implemented in #6461