Почему я думаю, что это происходит

Я собираюсь проигнорировать то, что вы выполняете стохастический градиентный спуск, и просто представьте, что вы работаете со всем набором данных для каждого шага. В этом случае ваша проблема в обоих случаях - минимизировать || Y-AX || ^ 2 над A.

После некоторого изучения алгебры вы можете записать это как задачу квадратичной оптимизации вида

\ min_ {z} z ^ T Q z + b ^ T z,

где z \ in R ^ {256 ^ 2} представляет элементы матрицы A, Q - симметричная матрица, полученная только из X, а b - вектор, полученный из X и Y. Вы просите Tensorflow решить эта проблема с использованием градиентного спуска.

Скорость сходимости градиентного спуска в задачах этого типа определяется числом обусловленности Q, которое представляет собой наибольшее собственное значение, деленное на наименьшее. Число условий, которое намного больше единицы, приводит к медленному градиентному спуску, поскольку некоторые переменные обновляются намного быстрее, чем другие. Число условий, близкое к единице, лучше всего для получения быстрой сходимости. В «Основах оптимизации» Гулера (раздел 14.2) вы можете узнать больше о влиянии числа условий на сходимость (варианта) градиентного спуска, хотя, вероятно, есть лучшие ресурсы по этому поводу.

В вашем случае собственные значения Q - это просто собственные значения XX ^ T, которые представляют собой квадрат сингулярных значений X. Для первого набора данных X равномерно распределен, а во втором X = A_0 ^ {- 1} Y, где Y равномерно распределен.

Разница в сходимости, которую вы наблюдаете, происходит от того факта, что умножение на A_0 ^ {- 1} сильно увеличивает число обусловленности вашей матрицы. В следующем коде Python я провел несколько случайных испытаний и обнаружил, что число обусловленности второй матрицы намного больше. В тысячи раз больше.

import numpy as np

cond1 = []
cond2 = []


for i in range(10):
    A = np.random.normal(0,0.4,(256,256))
    Ainv = np.linalg.inv(A)

    X1 = np.random.rand(256,950)
    X1sv = np.linalg.svd(X1, compute_uv = False)

    Y = np.random.rand(256,950)
    X2 = np.dot(Ainv,Y)
    X2sv = np.linalg.svd(X2, compute_uv = False)

    cond1.append((X1sv.max()/X1sv.min())**2)
    cond2.append((X2sv.max()/X2sv.min())**2)
cond1 = np.array(cond1)
cond2 = np.array(cond2)

print('X1\'s condition number has mean {:.2f} and std {:.2f} '.format(cond1.mean(), cond1.std()))
print('X2\'s condition number has mean {:.2f} and std {:.2f} '.format(cond2.mean(), cond2.std()))
print('X2\'s mean condition number is {:.1f} times as big as X1\'s'.format(cond2.mean()/cond1.mean()))

Вот и я предполагаю, почему вы видите худшую сходимость во втором случае, чем в первом. Я могу ошибаться, но, возможно, это укажет вам правильное направление.

Предлагаемые решения

Для этого есть несколько решений:

1. Используйте алгоритм оптимизации, такой как Adam или RMSprop, который приложит некоторые усилия для улучшения числа обусловленности вашей матрицы. Вы можете узнать больше о них в главе 8 https://www.deeplearningbook.org/.
2. Вам нужно, чтобы A была гауссовой матрицей? Матрица с собственными значениями, близкими к 1, уменьшит эту проблему.
3. Существуют методы оптимизации (не имеющие отношения к машинному обучению), облегчающие трудности, связанные с большим числом условий. Для получения дополнительной информации вы можете найти предварительный градиентный спуск.

Я не думаю, что в процессе оптимизации что-то не так, я думаю, проблема в ваших вводящих в заблуждение показателях rabs(y_t, y_p)

Поскольку выходы rabs(y_t, y_p) одинаковы после деления MAE на (backend.max(y_t) - backend.min(y_t)), Y поколения 1 и Y поколения 2 должны иметь одинаковое распределение вероятностей, что здесь не так, поскольку в поколении 1 ваши Y = np.dot(Ainv,np.random.rand(N,1)) и в поколении 2 Y = np.random.rand(N,1)

Простым примером здесь является рассмотрение y_true_1 = (0.1, 0.2, 0.3), y_true_2 = (0.1, 0.2, 0.5) и y_predict_1 = (0.0, 0.1, 0.2), y_predict_2 = (0.0, 0.1, 0.4), затем MAE_1 = MAE_2 = 0.1, но после деления MAE_1 на (max(y_true_1) - min(y_true_1 )) RMAE_1 = 0.5 и деления MAE_2 на (max(y_true_2) - min(y_true_2 )) RMAE_2 = 0.25, теперь вы можете видеть, почему, если распределение y_true_1 отличается от распределения y_true_2, тогда нельзя ожидать, что два выхода rabs(y_t, y_p) будут одинаковыми

Меняю rabs(y_t, y_p) на МАС:

def rabs(y_t, y_p):
    return backend.mean(backend.abs(y_p - y_t))

И оптимизатор для:

learning_rate_fn = tf.keras.optimizers.schedules.InverseTimeDecay(1.0, 950 * 100, 9)
opt = tf.keras.optimizers.Adam(learning_rate=learning_rate_fn)

И я много раз запускал его с epochs = 100, выходы для gen1() и gen2() примерно такие:

gen1:
Epoch 1/100
950/950 [==============================] - 1s 625us/step - loss: 1631.5898 - rabs: 31.9912 - val_loss: 1568.4200 - val_rabs: 31.6044
Epoch 100/100
950/950 [==============================] - 1s 541us/step - loss: 16.1436 - rabs: 3.1877 - val_loss: 19.1974 - val_rabs: 3.5311

gen2:
Epoch 1/100
950/950 [==============================] - 1s 614us/step - loss: 51.9863 - rabs: 5.7896 - val_loss: 20.9347 - val_rabs: 3.5948
Epoch 100/100
950/950 [==============================] - 1s 540us/step - loss: 0.7340 - rabs: 0.6716 - val_loss: 0.5478 - val_rabs: 0.5920

Как видите, оптимизатор в основном выполняет ту же работу, он уменьшает потери (MSE) в 100 раз и rabs (MAE) в 10 раз.