diff --git a/.DS_Store b/.DS_Store index 942c245..c622fd7 100644 Binary files a/.DS_Store and b/.DS_Store differ diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 0000000..f303061 --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,3 @@ +{ + "python.pythonPath": "/opt/homebrew/bin/python3" +} \ No newline at end of file diff --git a/change_ver1.gif b/change_ver1.gif new file mode 100644 index 0000000..69a43ae Binary files /dev/null and b/change_ver1.gif differ diff --git a/test .gif b/test .gif new file mode 100644 index 0000000..fcedd86 Binary files /dev/null and b/test .gif differ diff --git a/ukr/.DS_Store b/ukr/.DS_Store new file mode 100644 index 0000000..18d6390 Binary files /dev/null and b/ukr/.DS_Store differ diff --git a/ukr/ando/TUKRsample.py b/ukr/ando/TUKRsample.py new file mode 100644 index 0000000..a51f683 --- /dev/null +++ b/ukr/ando/TUKRsample.py @@ -0,0 +1,88 @@ +import numpy as np +import tensorflow as tf +tf.keras.backend.set_floatx("float64") + + +def E(Z: tf.Variable, X: np.ndarray) -> tf.Variable: + Dzz = Z[:, None, :] - Z[None, :, :] + D = tf.reduce_sum(tf.square(Dzz), axis=2) + H = tf.exp(-0.5 * D) + G = tf.reduce_sum(H, axis=1, keepdims=True) + R = H / G + Y = R @ X + result = 0.5 * tf.reduce_sum((Y - X)**2) + return result + + +def fit(Z1: np.ndarray, Z2: np.ndarray, X: np.ndarray, index1: np.ndarray, index2: np.ndarray, n_epoch: int, eta: float): + N1, L1 = Z1.shape + N2, L2 = Z2.shape + tZ = tf.Variable(np.concatenate((Z1[index1, :], Z2[index2, :]), axis=1)) + count1 = np.bincount(index1, minlength=N1) + count2 = np.bincount(index2, minlength=N2) + + optimizer = tf.keras.optimizers.SGD(learning_rate=eta) + for epoch in range(n_epoch): + with tf.GradientTape() as tape: + result = E(tZ, X) + grad = tape.gradient(result, tZ) + grad1 = tf.concat([tf.math.bincount(index1, grad[:, i], minlength=N1)[:, None] for i in range(L1)], axis=1) / count1[:, None] + grad2 = tf.concat([tf.math.bincount(index2, grad[:, i+L1], minlength=N2)[:, None] for i in range(L2)], axis=1) / count2[:, None] + grad = tf.concat([tf.gather(grad1, index1), tf.gather(grad2, index2)], axis=1) + optimizer.apply_gradients([(grad, tZ)]) + + _, index1_inverse = np.unique(index1, return_index=True) + _, index2_inverse = np.unique(index2, return_index=True) + Z1 = tZ.numpy()[index1_inverse, :L1] + Z2 = tZ.numpy()[index2_inverse, L1:] + return Z1, Z2 + + +if __name__ == '__main__': + import itertools + import matplotlib.pyplot as plt + from mpl_toolkits.mplot3d import Axes3D + + N1 = 20 + N2 = 30 + D = 3 + L = 1 # This will work in more than two dimensions + seed = 100 + observation_rate = 0.5 + n_epoch = 100 + eta = 0.1 + np.random.seed(seed) + + # create true latent variable + oZ1 = np.random.uniform(-1, 1, (N1, L)) + oZ2 = np.random.uniform(-1, 1, (N2, L)) + oZ = np.array(list(itertools.product(oZ1, oZ2))).reshape((N1, N2, -1)) + + # create full data + X_full = np.zeros((N1, N2, D)) + X_full[:, :, 0] = oZ[:, :, 0] + X_full[:, :, 1] = oZ[:, :, L] + X_full[:, :, 2] = oZ[:, :, 0] ** 2 - oZ[:, :, L] ** 2 + + # create observed data + Gamma = np.random.binomial(1, observation_rate, (N1, N2)) + index1, index2 = Gamma.nonzero() + X = X_full[index1, index2, :] + + # init latent variable + eZ1 = np.random.normal(0.0, 0.1, (N1, L)) + eZ2 = np.random.normal(0.0, 0.1, (N2, L)) + + # learn + eZ1, eZ2 = fit(eZ1, eZ2, X, index1, index2, n_epoch=n_epoch, eta=eta) + eZ = np.array(list(itertools.product(eZ1, eZ2))) + + # plot + fig = plt.figure() + ax1 = fig.add_subplot(121, projection='3d') + # ax1.scatter(X_full[:, :, 0], X_full[:, :, 1], X_full[:, :, 2]) + ax1.scatter(X[:, 0], X[:, 1], X[:, 2]) + ax2 = fig.add_subplot(122, aspect='equal') + ax2.scatter(eZ[:, 0], eZ[:, L]) + plt.show() + \ No newline at end of file diff --git a/ukr/ando/ando_TUKR.py b/ukr/ando/ando_TUKR.py new file mode 100644 index 0000000..9286b18 --- /dev/null +++ b/ukr/ando/ando_TUKR.py @@ -0,0 +1,97 @@ +import numpy as np +import matplotlib.animation as animation +import matplotlib.pyplot as plt +import tensorflow as tf +from utils import make_grid +tf.keras.backend.set_floatx("float64") + +#目的関数の値の用意 +def E(Z1: tf.Variable, Z2: tf.Variable, X: np.ndarray, sigma: float) -> tf.Variable: + #ドメイン1のデータの距離の計算 + distance_N1 = Z1[:, None, :] - Z1[None, :, :] + dist_N1 = tf.reduce_sum(tf.square(distance_N1), axis=2) + #ドメイン2のデータの距離 + distance_N2 = Z2[:, None, :] - Z2[None, :, :] + dist_N2 = tf.reduce_sum(tf.square(distance_N2), axis=2) + # + k_N1 = tf.exp(-1/(2*(sigma**2))*dist_N1) + k_N2 = tf.exp(-1/(2*(sigma**2))*dist_N2) + h1 = k_N1[:, :, None, None]*k_N2[None, None, :, :] + K = tf.reduce_sum(h1,axis=(1,3),keepdims=True) + h2 = k_N1[:, :, None, None, None]*k_N2[None, None, :, :, None]*X[None, :, None, :, :] + k= tf.reduce_sum(h2,axis=(1,3),keepdims=True) + Y = k/K[:, :, None] + result = 0.5 * tf.reduce_sum((Y - X)**2) + return result + +#目的関数の微分 +def fit(Z1: np.ndarray, Z2: np.ndarray, X: np.ndarray, T: int, eta: float) -> np.ndarray: + tZ1 = tf.Variable(Z1) + tZ2 = tf.Variable(Z2) + + optimizer = tf.keras.optimizers.SGD(learning_rate=eta) + for t in range(T): + with tf.GradientTape() as tape: + result = E(tZ1, tZ2, X) + grad1 = tape.gradient(result, tZ1)#ここで微分 + grad2 = tape.gradient(result, tZ2) + optimizer.apply_gradients([(grad1, tZ1),(grad2, tZ2)]) + Z1 = tZ1.numpy() + Z2 = tZ2.numpy() + + return Z1,Z2 +#学習用の関数 +#def fit(Z1: np.nadarry, Z2: np.ndarray, X: np.ndarray,): + #写像の推定の部分の準備 + #誤差関数の計算 + #自動微分 + #潜在変数の更新 + + + + +if __name__ == '__main__': + import dataTUKR + + N1 = 30 #ドメイン1のデータ数 + N2 = 20 #ドメイン2のデータ数 + D = 3 #データ一つあたりの次元数 + L = 2 #潜在空間の次元数 + seed = 0 + T = 100 #学習回数 + eta = 0.1 #勾配法で用いるステップ幅 + sigma = 0.1 #カーネル関数で使う. + np.random.seed(seed) + + #人口データ + X = dataTUKR.load_kura_tsom(N1, N2, retz=False) + + #描画の関数 + def update(i, history, x): + #plt.cla() + ax_latent.cla() + ax_observable.cla() + + fig.suptitle(f"epoch: {i}") + Z = history['Z'][i] + f = history['f'][i] + + ax_latent.scatter(Z[:, 0], Z[:, 1], s=50, edgecolors="k", c=x[:, 0]) + + ax_latent.set_xlim(-1.1, 1.1) + ax_latent.set_ylim(-1.1, 1.1) + + ax_observable.scatter(x[:, 0], x[:, 1],x[:, 2], c=x[:, 0], s=50, marker='x') + ax_observable.plot_wireframe(f[:, :, 0], f[:, :, 1],f[:, :, 2], color='black') + + + ax_observable.set_xlim(x[:, 0].min(), x[:, 0].max()) + ax_observable.set_ylim(x[:, 1].min(), x[:, 1].max()) + + ani = animation.FuncAnimation(fig, update, fargs=(history, X), interval=50, frames=T) + ani.save("change_ver1.gif", writer = "pillow") + plt.show() + #HTML(ani.to_jshtml()) + + + diff --git a/ukr/ando/ando_ukr.ipynb b/ukr/ando/ando_ukr.ipynb new file mode 100644 index 0000000..1880040 --- /dev/null +++ b/ukr/ando/ando_ukr.ipynb @@ -0,0 +1,151258 @@ +{ + "metadata": { + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.2" + }, + "orig_nbformat": 4, + "kernelspec": { + "name": "python3", + "display_name": "Python 3.8.2 64-bit" + }, + "interpreter": { + "hash": "31f2aee4e71d21fbe5cf8b01ff0e069b9275f58929596ceb00d14d90e3e16cd6" + } + }, + "nbformat": 4, + "nbformat_minor": 2, + "cells": [ + { + "cell_type": "code", + "execution_count": 8, + "source": [ + "#拡張機能のインポート\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.animation as animation\n", + "from IPython.display import HTML\n", + "\n", + "#各変数の初期設定\n", + "N = 100 #データ数\n", + "D = 3 #データの次元数\n", + "L = 2 #潜在空間の次元数\n", + "T = 100 #総学習回数(epoch数のこと)\n", + "#観測データの生成の際に用いる変数\n", + "seed = 0\n", + "noise_scale = 1e-3\n", + "np.random.seed(seed)\n", + "sigma = 0.1\n", + "eta = 2.0" + ], + "outputs": [ + { + "output_type": "error", + "ename": "ModuleNotFoundError", + "evalue": "No module named 'numpy'", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mModuleNotFoundError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;31m#拡張機能のインポート\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0;32mimport\u001b[0m \u001b[0mnumpy\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 3\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mmatplotlib\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpyplot\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mmatplotlib\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0manimation\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0manimation\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mIPython\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdisplay\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mHTML\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mModuleNotFoundError\u001b[0m: No module named 'numpy'" + ] + } + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": null, + "source": [ + "#使用する観測データ\n", + "def gen_saddle_shape(num, seed, noise_scale):\n", + " np.random.seed(seed)\n", + " z1 = np.random.uniform(low=-1, high=+1, size=(num,))\n", + " z2 = np.random.uniform(low=-1, high=+1, size=(num,))\n", + "\n", + " X = np.empty((num, 3))\n", + " X[:, 0] = z1\n", + " X[:, 1] = z2\n", + " X[:, 2] = 0.5 * (z1**2 - z2**2)\n", + " X += np.random.normal(loc=0, scale=noise_scale, size=X.shape)\n", + "\n", + " return X" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": null, + "source": [ + "#観測データの描画(データの確認)\n", + "X = gen_saddle_shape(N, seed, noise_scale)\n", + "print(\"Xのシェイプ\",X.shape)\n", + "\n", + "fig = plt.figure()\n", + "ax = fig.add_subplot(111, projection='3d') #三次元マップの描画\n", + "ax.scatter(X[:, 0], X[:, 1], X[:, 2])\n", + "plt.show()" + ], + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Xのシェイプ (100, 3)\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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", + "image/svg+xml": "\n\n\n \n \n \n \n 2021-07-08T12:12:14.497711\n image/svg+xml\n \n \n Matplotlib v3.4.1, https://matplotlib.org/\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n" + }, + "metadata": { + "needs_background": "light" + } + } + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": null, + "source": [ + "#初期化、潜在変数zを乱数によって初期化\n", + "Z = np.random.rand(N, L)*0.01\n", + "print(Z.shape)" + ], + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(100, 2)\n" + ] + } + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": null, + "source": [ + "#Xの値\n", + "plt.close()\n", + "fig = plt.figure()\n", + "plt.scatter(X[:, 0], X[:, 1],marker='x', linewidth=2)\n", + "plt.show()" + ], + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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", + "image/svg+xml": "\n\n\n \n \n \n \n 2021-07-08T12:12:14.609420\n image/svg+xml\n \n \n Matplotlib v3.4.1, https://matplotlib.org/\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n" + }, + "metadata": { + "needs_background": "light" + } + } + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": null, + "source": [ + "#Zの値\n", + "plt.close()\n", + "plt.scatter(Z[:, 0], Z[:, 1],c=X[:, 0], marker='x', linewidth=2)" + ], + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ] + }, + "metadata": {}, + "execution_count": 6 + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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", + "image/svg+xml": "\n\n\n \n \n \n \n 2021-07-08T12:12:14.693556\n image/svg+xml\n \n \n Matplotlib v3.4.1, https://matplotlib.org/\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n" + }, + "metadata": { + "needs_background": "light" + } + } + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": null, + "source": [ + "#データの距離\n", + "def distance_function(Z1,Z2):\n", + " distance= np.sum((Z1[:, None, :]-Z2[None, :, :])**2, axis=2)\n", + " return distance\n", + "Distance = distance_function(Z,Z)\n", + "Distance.shape" + ], + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(100, 100)" + ] + }, + "metadata": {}, + "execution_count": 7 + } + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": null, + "source": [ + "#写像の推定\n", + "def estimate_Y (sigma,X,Z1,Z2):\n", + " k = np.exp((-1/(2*sigma**2))*distance_function(Z1,Z2))\n", + " K = np.sum(k,axis=1,keepdims=True)\n", + " Y = (k@X)/K\n", + " return Y" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": null, + "source": [ + "#潜在変数の推定\n", + "def estimate_Z(sigma,Z1,Z2,X,Y,eta):\n", + " k = np.exp((-1/(2*sigma**2))*distance_function(Z1,Z2))\n", + " K = np.sum(k,axis=1,keepdims=True)\n", + " r = k/K #N*N\n", + " d_ij = Y[:,None]-X[None,:] #N*N*D\n", + " d_nn = Y-X #N*D\n", + " delta = Z1[:,None]-Z2[None,:] #N*N*L\n", + " #誤差関数の微分 (8)式 : (2/(N*sigma**2))*C (B = A+A_T) (C = Σ[B○δ])\n", + " A = np.einsum(\"ni,nd,nid->ni\",r,d_nn,d_ij) #N*I\n", + " B = A+A.T #N*I\n", + " C = np.einsum(\"ni,nil->nl\",B,delta)\n", + " dE = (2/(N*sigma**2))*C\n", + " #勾配法による潜在変数の更新\n", + " Z_new = Z1-eta*dE\n", + " return Z_new\n" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": null, + "source": [ + "#以下図をanimationで見るためのコードを書く\n", + "f_reso=10\n", + "#シェイプのTの部分でanimationを行う\n", + "history_Z = np.zeros((T, N, L))\n", + "history_y = np.zeros((T, N, D))\n", + "history_f = np.zeros((T,f_reso,f_reso,D))\n", + "\n", + "for t in range(T):\n", + " Y = estimate_Y(sigma,X,Z,Z)\n", + " Z = estimate_Z(sigma,Z,Z,X,Y,eta)\n", + " history_y[t] = Y\n", + " history_Z[t] = Z\n", + " A = np.linspace(-1,1,f_reso)\n", + " B = np.linspace(-1,1,f_reso)\n", + " XX, YY = np.meshgrid(A,B)\n", + " xx = XX.reshape(-1)\n", + " yy = YY.reshape(-1)\n", + " M = np.concatenate([xx[:, None], yy[:, None]], axis=1) #変数表でいうζkに該当する\n", + " f = estimate_Y(sigma,X,M,Z)\n", + " history_f[t] = f.reshape(f_reso,f_reso,D)\n", + "\n", + "#f = history_y.reshape(T,10,10,D)" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": null, + "source": [ + "fig = plt.figure(figsize=(10, 5))\n", + "ax_observable = fig.add_subplot(122, projection='3d')\n", + "ax_latent = fig.add_subplot(121)\n", + "#%matplotlib nbagg\n", + "\n", + "def update(i, z, f, x):\n", + " #plt.cla()\n", + " ax_latent.cla()\n", + " ax_observable.cla()\n", + "\n", + " fig.suptitle(f\"epoch: {i}\")\n", + "\n", + " ax_latent.scatter(z[i, :, 0], z[i, :, 1], s=50, edgecolors=\"k\", c=x[:, 0])\n", + " \n", + " ax_latent.set_xlim(z[:, :, 0].min(), z[:, :, 0].max())\n", + " ax_latent.set_ylim(z[:, :, 1].min(), z[:, :, 1].max())\n", + "\n", + " ax_observable.scatter(x[:, 0], x[:, 1],x[:, 2], c=x[:, 0], s=50, marker='x')\n", + " ax_observable.plot_wireframe(f[i, :, :, 0], f[i, :, :, 1],f[i, :, :, 2], color='black')\n", + " \n", + "\n", + " ax_observable.set_xlim(x[:, 0].min(), x[:, 0].max())\n", + " ax_observable.set_ylim(x[:, 1].min(), x[:, 1].max())\n", + "\n", + "ani = animation.FuncAnimation(fig, update, fargs=(history_Z, history_f , X), interval=50, frames=T)\n", + "ani.save(\"change_ver1.gif\", writer = \"pillow\")\n", + "HTML(ani.to_jshtml())" + ], + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ], + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
\n", + " \n", + "
\n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + "
\n", + "
\n", + "\n", + "\n", + "\n" + ] + }, + "metadata": {}, + "execution_count": 11 + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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", + "image/svg+xml": "\n\n\n \n \n \n \n 2021-07-08T12:12:30.831109\n image/svg+xml\n \n \n Matplotlib v3.4.1, https://matplotlib.org/\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n" + }, + "metadata": { + "needs_background": "light" + } + } + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": null, + "source": [], + "outputs": [], + "metadata": {} + } + ] +} \ No newline at end of file diff --git a/ukr/ando/ando_ukr_training.py b/ukr/ando/ando_ukr_training.py new file mode 100644 index 0000000..656d798 --- /dev/null +++ b/ukr/ando/ando_ukr_training.py @@ -0,0 +1,132 @@ +import numpy as np +import matplotlib.animation as animation +import matplotlib.pyplot as plt +from utils import make_grid + +#seed = 0 +#import scipy.spatial.distance as dist + +class UKR(object): + #各変数の準備 インスタンス変数? + def __init__(self, N, D, L, eta, sigma, rambda, scale,clipping=(-1, +1)): + self.N = N + self.D = D + self.L = L + self.eta = eta + self.sigma = sigma + self.scale = scale + self.clipping = clipping + self.λ = rambda + + #データの距離 + def distance_function(self,Z1,Z2): + distance= np.sum((Z1[:, None, :]-Z2[None, :, :])**2, axis=2) + return distance + + #写像の推定 + def estimate_Y (self,X,Z1,Z2): + k = np.exp((-1/(2*(self.sigma**2)))*self.distance_function(Z1,Z2)) + K = np.sum(k,axis=1,keepdims=True) + Y = (k@X)/K + return Y + + #潜在変数の推定 + def estimate_Z(self,Z1,Z2,X,Y): + k = np.exp((-1/(2*self.sigma**2))*self.distance_function(Z1,Z2)) + K = np.sum(k,axis=1,keepdims=True) + r = k/K #N*N + d_ij = Y[:,None]-X[None,:] #N*N*D + d_nn = Y-X #N*D + delta = Z1[:,None]-Z2[None,:] #N*N*L + #誤差関数の微分 (8)式 : (2/(N*sigma**2))*C (B = A+A_T) (C = Σ[B○δ]) + A = np.einsum("ni,nd,nid->ni",r,d_nn,d_ij) #N*I + B = A+A.T #N*I + C = np.einsum("ni,nil->nl",B,delta) + dE = (2/(self.N*self.sigma**2))*C + dE += 2 * self.λ * Z2 + #勾配法による潜在変数の更新 + Z_new = Z1-self.eta*dE + return Z_new + + + #学習用の関数 + def fit(self, X, T, f_reso, seed): + np.random.seed(seed) + Z = np.random.normal(scale=self.scale, size=(self.N, self.L)) + + history = dict( + E=np.zeros((T,)), + Z = np.zeros((T, self.N, self.L)), + Y = np.zeros((T, self.N, self.D)), + f = np.zeros((T,f_reso,f_reso,self.D)) + ) + + for t in range(T): + Y = self.estimate_Y(X,Z,Z) + Z = self.estimate_Z(Z,Z,X,Y) + + history['Y'][t] = Y + history['Z'][t] = Z + history['E'][t] = np.sum((Y - X)**2) / N + self.λ * np.sum(Z**2) + + A = np.linspace(Z.min(),Z.max(),f_reso) + B = np.linspace(Z.min(),Z.max(),f_reso) + XX, YY = np.meshgrid(A,B) + xx = XX.reshape(-1) + yy = YY.reshape(-1) + M = np.concatenate([xx[:, None], yy[:, None]], axis=1) #変数表でいうζkに該当する + Z_new = make_grid(f_reso, + bounds=(np.min(Z), np.max(Z)), + dim=self.L) + f = self.estimate_Y(X,M,Z) + history['f'][t] = f.reshape(f_reso,f_reso,self.D) + + return history + +if __name__ == '__main__': + import data + seed = 0 + #from visualizer import visualize_history + N = 100 + D = 3 + L = 2 + T = 200 + eta = 2.0 + sigma = 0.5 + f_reso = 10 + + X = data.gen_saddle_shape(num_samples=N, random_seed=1, noise_scale=0.05) + ukr = UKR(N, D, L, eta, sigma, rambda=3e-3, scale=1e-2,clipping=(-1, 1)) + history = ukr.fit(X, T, f_reso = f_reso, seed=seed) + fig = plt.figure(figsize=(10, 5)) + ax_observable = fig.add_subplot(122, projection='3d') + ax_latent = fig.add_subplot(121) + #%matplotlib nbagg + + #描画の関数 + def update(i, history, x): + #plt.cla() + ax_latent.cla() + ax_observable.cla() + + fig.suptitle(f"epoch: {i}") + Z = history['Z'][i] + f = history['f'][i] + + ax_latent.scatter(Z[:, 0], Z[:, 1], s=50, edgecolors="k", c=x[:, 0]) + + ax_latent.set_xlim(-1.1, 1.1) + ax_latent.set_ylim(-1.1, 1.1) + + ax_observable.scatter(x[:, 0], x[:, 1],x[:, 2], c=x[:, 0], s=50, marker='x') + ax_observable.plot_wireframe(f[:, :, 0], f[:, :, 1],f[:, :, 2], color='black') + + + ax_observable.set_xlim(x[:, 0].min(), x[:, 0].max()) + ax_observable.set_ylim(x[:, 1].min(), x[:, 1].max()) + + ani = animation.FuncAnimation(fig, update, fargs=(history, X), interval=50, frames=T) + ani.save("change_ver1.gif", writer = "pillow") + plt.show() + #HTML(ani.to_jshtml()) + \ No newline at end of file diff --git a/ukr/ando/change_ver1.gif b/ukr/ando/change_ver1.gif new file mode 100644 index 0000000..3f1ecf1 Binary files /dev/null and b/ukr/ando/change_ver1.gif differ diff --git a/ukr/ando/change_ver2.gif b/ukr/ando/change_ver2.gif new file mode 100644 index 0000000..c0fe280 Binary files /dev/null and b/ukr/ando/change_ver2.gif differ diff --git a/ukr/ando/data.py b/ukr/ando/data.py index 18fc39e..e86cfe6 100644 --- a/ukr/ando/data.py +++ b/ukr/ando/data.py @@ -32,7 +32,7 @@ def gen_2d_sin_curve(num_samples, random_seed=None, noise_scale=0.01): from matplotlib import pyplot as plt - X = gen_saddle_shape(200, random_seed=0, noise_scale=0.05) + X = gen_saddle_shape(1000, random_seed=0, noise_scale=0.05) # X = gen_2d_sin_curve(100, random_seed=0, noise_scale=0.01) _, D = X.shape diff --git a/ukr/ando/dataTUKR.py b/ukr/ando/dataTUKR.py new file mode 100644 index 0000000..b30bff6 --- /dev/null +++ b/ukr/ando/dataTUKR.py @@ -0,0 +1,46 @@ +import numpy as np +import random +import itertools + +def load_kura_tsom(xsamples, ysamples, missing_rate=None,retz=False): + z1 = np.linspace(-1, 1, xsamples) + z2 = np.linspace(-1, 1, ysamples) + + z1_repeated, z2_repeated = np.meshgrid(z1, z2, indexing='ij') + x1 = z1_repeated + x2 = z2_repeated + x3 = (z1_repeated ** 2.0 - z2_repeated ** 2.0)+np.random.normal(loc = 0.0, scale = 0.1, size=(xsamples,ysamples)) + #ノイズを加えたい時はここをいじる,locがガウス分布の平均、scaleが分散,size何個ノイズを作るか + #このノイズを加えることによって三次元空間のデータ点は上下に動く + + x = np.concatenate((x1[:, :, np.newaxis], x2[:, :, np.newaxis], x3[:, :, np.newaxis]), axis=2) + truez = np.concatenate((z1_repeated[:, :, np.newaxis], z2_repeated[:, :, np.newaxis]), axis=2) + + #欠損値を入れない場合(missing_rateが0か特に指定していない場合はそのまま返す) + if missing_rate == 0 or missing_rate == None: + if retz: + return x, truez + else: + return x + +if __name__ == '__main__': + import matplotlib.pyplot as plt + from mpl_toolkits.mplot3d import Axes3D + + xsamples = 20 #ドメイン1のデータ数 + ysamples = 30 #ドメイン2のデータ数 + + #欠損なしver + x, truez = load_kura_tsom(xsamples, ysamples, retz=True) #retzは真の潜在変数を返す,Xは観測データ,truezは真の潜在変数 + #Xは左側の図の作成に必要、truez右側の図の作成に必要(実行結果の図より) + # 欠損ありver + #x, truez, Gamma = load_kura_tsom(xsamples, ysamples, retz=True,missing_rate=0.7) + + fig = plt.figure(figsize=[10, 5]) + ax_x = fig.add_subplot(1, 2, 1, projection='3d') + ax_truez = fig.add_subplot(1, 2, 2) + ax_x.scatter(x[:, :, 0].flatten(), x[:, :, 1].flatten(), x[:, :, 2].flatten(), c=x[:, :, 0].flatten()) + ax_truez.scatter(truez[:, :, 0].flatten(), truez[:, :, 1].flatten(), c=x[:, :, 0].flatten()) + ax_x.set_title('Generated three-dimensional data') + ax_truez.set_title('True two-dimensional latent variable') + plt.show() diff --git a/ukr/ando/tensorflowtest.py b/ukr/ando/tensorflowtest.py new file mode 100644 index 0000000..4f13459 --- /dev/null +++ b/ukr/ando/tensorflowtest.py @@ -0,0 +1,27 @@ +import numpy as np +import tensorflow as tf +tf.keras.backend.set_floatx("float64") + +#目的関数の値の推定 +def E(Z: tf.Variable, X: np.ndarray) -> tf.Variable: + Dzz = Z[:, None, :] - Z[None, :, :] + D = tf.reduce_sum(tf.square(Dzz), axis=2) + H = tf.exp(-0.5 * D) + G = tf.reduce_sum(H, axis=1, keepdims=True) + R = H / G + Y = R @ X + result = 0.5 * tf.reduce_sum((Y - X)**2) + return result + + +def fit(Z: np.ndarray, X: np.ndarray, n_epoch: int, alpha: float) -> np.ndarray: + tZ = tf.Variable(Z) + + optimizer = tf.keras.optimizers.SGD(learning_rate=alpha) + for epoch in range(n_epoch): + with tf.GradientTape() as tape: + result = E(tZ, X) + grad = tape.gradient(result, tZ) + optimizer.apply_gradients([(grad, tZ)]) + + return tZ.numpy() \ No newline at end of file diff --git a/ukr/ando/tensorflowtest2.py b/ukr/ando/tensorflowtest2.py new file mode 100644 index 0000000..e7886d8 --- /dev/null +++ b/ukr/ando/tensorflowtest2.py @@ -0,0 +1,207 @@ +# ver3 +import numpy as np +import tensorflow as tf +tf.keras.backend.set_floatx("float64") +from sklearn.base import BaseEstimator +from mmnet.lib.models.miyazaki.base.history_dataclass import History + + +class UKR(BaseEstimator): + def __init__(self, data, learn_info, dev=False): + self.dev = dev + if data.data_type == 'multi_variate': + self.X = data.values + if self.X.ndim == 1: + self.N = self.X.shape[0] + self.D = 1 + else: + self.N, self.D = self.X.shape + else: + raise ValueError("this is for multivariate data") + + self.nb_epoch = learn_info.nb_epoch + self.eta = learn_info.step_width + self.sigma = learn_info.kernel_width + if learn_info.regularization_approach == 'penalty_term': + self.is_clip = False + self.alpha = learn_info.regularization_term + elif learn_info.regularization_approach is None: + self.is_clip = False + self.alpha = 0 + elif learn_info.regularization_approach == 'restrict_z': + self.is_clip = True + self.bounded_shape = learn_info.shape + self.bounded_range = learn_info.range + else: + raise ValueError('we dont know such approach') + + self.L = learn_info.latent_dim + init = learn_info.init_method + if isinstance(init, str) and init in 'random': + try: + seed = learn_info.initz_seed + except KeyError: + seed = 1 + print("This Initial_Z is made by default seed: {}").format(seed) + random_state = np.random.RandomState(seed) + + if learn_info.latent_distribution == 'gaussian': + self.Z = random_state.normal(0, 0.1, (self.N, self.L)) + elif learn_info.latent_distribution == 'uniform': + self.Z = random_state.uniform(-1e-5, 1e-5, (self.N, self.L)) + else: + raise ValueError('we dont know such init') + elif isinstance(init, np.ndarray) and init.shape == (self.N, self.L): + self.Z = init.copy() + print("This Initial_Z is used External varibales") + else: + raise ValueError("invalid init: {}".format(init)) + + self.history = History(self.X.shape, self.Z.shape, self.nb_epoch) + self.history.z[0, :, :] = self.Z + + def nadaraya_watson_estimator(self, z1: tf.Variable, z2: tf.Variable, x, sigma=1): + # This is Nadaraya-Watson Esitmator + Dist = tf.reduce_sum(tf.square(z1[:, None, :] - z2[None, :, :]), axis=2) + H = tf.exp(-0.5 * Dist / (sigma**2)) + G = tf.reduce_sum(H, axis=1, keepdims=True) + R = H / G + return R @ x + + def estimate_x(self, z1, z2, x, ret_numpy=False): + x_hat = self.nadaraya_watson_estimator(z1, z2, x) + if ret_numpy: + x_hat = x_hat.numpy() + return x_hat + + def E(self, Z: tf.Variable, X: np.ndarray) -> tf.Variable: + self.x_hat = self.estimate_x(Z, Z, X) + E = 0.5 * tf.reduce_sum((self.x_hat - X)**2) / self.N + return E + + def fit(self) -> np.ndarray: + tZ = tf.Variable(self.Z) + optimizer = tf.keras.optimizers.SGD(learning_rate=self.eta) + for t in range(self.nb_epoch): + with tf.GradientTape() as tape: + result = self.E(tZ, self.X) + grad = tape.gradient(result, tZ) + optimizer.apply_gradients([(grad, tZ)]) + self.history.E[t + 1] = result.numpy() + self.history.z[t + 1, :, :] = tZ.numpy() + self.history.x_hat[t + 1, :, :] = self.x_hat + + def extrapolation_create_f(self, all_z, x, resolution): + import itertools + T, N, L = all_z.shape + N , D = x.shape + + all_mesh1 = np.zeros((T, resolution, 1)) + all_mesh2 = np.zeros((T, resolution, resolution, L)) + all_zeta = np.zeros((T, resolution, resolution, L)) + all_f_2d = np.zeros((T, resolution, resolution, D)) + np.random.seed(1) + a = np.sort(np.random.beta(0.5, 0.5, int(resolution/2))) + for t in range(T): + zmin = np.min(all_z[t, :, :]) + zmax = np.max(all_z[t, :, :]) + r = np.max([zmax, np.abs(zmin)]) + r = r + 0.6 * r + b = np.concatenate([a,np.abs(1-a)]) + c = (b/(np.max(b)- np.min(b))) * 2 * r - r + mesh1 = np.sort(c) + # mesh1 = np.linspace(zmin, zmax, resolution, endpoint=True) + mesh2 = np.array(list(itertools.product(mesh1, repeat=2))) + f = self.estimate_x(mesh2, all_z[t, :, :], x) + all_mesh1[t, :, :] = mesh1[:, None] + all_zeta[t, :, :, :] = mesh2.reshape(resolution, resolution, L) + all_mesh2[t, :, :, :] = mesh2.reshape(resolution, resolution, L) + all_f_2d[t, :, :, :] = f.reshape(resolution, resolution, D) + + return all_mesh1, all_mesh2, all_f_2d + + def create_f(self, all_z, x, resolution): + import itertools + T, N, L = all_z.shape + N , D = x.shape + + all_mesh1 = np.zeros((T, resolution, 1)) + all_mesh2 = np.zeros((T, resolution, resolution, L)) + all_zeta = np.zeros((T, resolution, resolution, L)) + all_f_2d = np.zeros((T, resolution, resolution, D)) + for t in range(T): + zmin = np.min(all_z[t, :, :]) + zmax = np.max(all_z[t, :, :]) + mesh1 = np.linspace(zmin, zmax, resolution, endpoint=True) + mesh2 = np.array(list(itertools.product(mesh1, repeat=2))) + # f = self.nadaraya_watson_estimator(mesh2, all_z[t, :, :], x) + f = self.estimate_x(mesh2, all_z[t, :, :], x, ret_numpy=True) + all_mesh1[t, :, :] = mesh1[:, None] + all_zeta[t, :, :, :] = mesh2.reshape(resolution, resolution, L) + all_mesh2[t, :, :, :] = mesh2.reshape(resolution, resolution, L) + all_f_2d[t, :, :, :] = f.reshape(resolution, resolution, D) + + return all_mesh1, all_mesh2, all_f_2d + + +if __name__ == "__main__": + +# self-made files + from mmnet.lib.models.miyazaki.base.dataclass import ToyMultiVariate + from mmnet.lib.models.miyazaki.base.learning_dataclass import LearningInfo + from mmnet.lib.models.miyazaki.base.history_dataclass import History + + import dataclasses as dc + from mmnet.lib.datasets.artificial.saddle_dc import load_saddle + from mmnet.lib.graphics.plot_animation_2view import View + + seed = 1 + sample_num = 200 + data_latent_distribution = 'uniform' + + nb_epoch = 50 + step_width = 2.7 * sample_num + regularization_approach = None + + # for view + resolution = 10 + + init_method = 'random' + init_latent_distribution = 'uniform' + latent_dim = 2 + + saddle_data = ToyMultiVariate( + data_name="saddle_shape", + latent_distribution=data_latent_distribution, + random_seed=seed + ) + + saddle_data.sample_num = sample_num + saddle_data.values, saddle_data.latent_values = load_saddle(dc.asdict(saddle_data)) + saddle_data.sample_num, saddle_data.feature_num = saddle_data.values.shape + print("Data_shape", saddle_data.values.shape) + + learn_info = LearningInfo( + init_method, init_latent_distribution, latent_dim, + step_width, + regularization_approach, + nb_epoch + ) + model = UKR(saddle_data, learn_info) + model.fit() + model.history.mesh1, model.history.mesh2, model.history.f = model.create_f(model.history.z, model.X, resolution) + # model.history.mesh1, model.history.mesh2, model.history.f = model.extrapolation_create_f(model.history.z, model.X, model.history.resolution) + model.history.zeta = model.history.mesh2 + + view = View(model) + view.plot(show_mesh=False, rotation=True, check_reshape=False, show_f=True,show_legend=True) + view.show() + # view.save() + + # import matplotlib.pyplot as plt + # fig = plt.figure(figsize=[6, 8]) + # plt.plot(range(nb_epoch + 1), model.history.E) + # plt.show() + + + # print(model.get_params()) \ No newline at end of file diff --git a/ukr/ando/tensorflowver.py b/ukr/ando/tensorflowver.py new file mode 100644 index 0000000..6156072 --- /dev/null +++ b/ukr/ando/tensorflowver.py @@ -0,0 +1,2 @@ +import tensorflow as tf +print(tf.__version__) \ No newline at end of file diff --git a/ukr/ando/test.py b/ukr/ando/test.py new file mode 100644 index 0000000..43961a0 --- /dev/null +++ b/ukr/ando/test.py @@ -0,0 +1,57 @@ +import numpy as np +from numpy.random import seed +import data +from ando_ukr_training import UKR as andoUKR +from ukr_uniform import UKR as UniformUKR +from ukr_gaussian import UKR as GaussianUKR +from matplotlib import pyplot as plt + + +SEED = 0 +if __name__ == '__main__': + + N = 100 + num_epoch = 100 + eta = 1 + X = data.gen_saddle_shape(num_samples=N, random_seed=0, noise_scale=0.05) + + params_for_gukr = dict( + latent_dim=2, + eta=eta, + sigma=0.1, + scale=1e-3, + rambda=0, + ) + + #init = init_uniform_Z(params_for_myukr) + params_for_andoukr = dict( + N=N, + D=3, + L=2, + eta=eta, + sigma=0.1, + scale=1e-3 + ) + + ukr_1 = GaussianUKR(**params_for_gukr) + history_1 = ukr_1.fit(X, num_epoch=num_epoch, seed=SEED) + ukr_2 = andoUKR(**params_for_andoukr) + history_2 = ukr_2.fit(X, T=num_epoch, f_reso=10, seed=SEED) + + # is_E_close = np.allclose(history_1['obj_func'][0], history_2['E'][0]) + is_Y_close = np.allclose(history_1['Y'], history_2['Y']) + is_Z_close = np.allclose(history_1['Z'], history_2['Z']) + # print("E: ", is_E_close) + print("Y: ", is_Y_close) + print("Z: ", is_Z_close) + + fig = plt.figure(figsize=(10, 5)) + ax1 = fig.add_subplot(121) + # ax1.plot(np.arange(num_epoch), history_1['obj_func'], label="somf") + # ax1.plot(np.arange(num_epoch), history_2['E'], label="myukr") + + ax2 = fig.add_subplot(122) + epo =-1 + ax2.scatter(history_1['Z'][epo, :, 0], history_1['Z'][epo, :, 1], label="somf") + ax2.scatter(history_2['Z'][epo, :, 0], history_2['Z'][epo, :, 1], label="myukr") + plt.show() \ No newline at end of file diff --git a/ukr/ando/ukr_gaussian.py b/ukr/ando/ukr_gaussian.py new file mode 100644 index 0000000..19d85c2 --- /dev/null +++ b/ukr/ando/ukr_gaussian.py @@ -0,0 +1,117 @@ +# Copyright 2021 tanacchi +# +# Permission is hereby granted, free of charge, +# to any person obtaining a copy of this software +# and associated documentation files (the "Software"), +# to deal in the Software without restriction, +# including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, +# and/or sell copies of the Software, +# and to permit persons to whom the Software is furnished to do so, +# subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included +# in all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +# DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + + +import numpy as np +#from scipy.spatial import distance as dist +try: + from scipy.spatial import distance + cdist = distance.cdist +except ModuleNotFoundError: + print("scipy is not installed, so the custom cdist defined.") + cdist = lambda XA, XB, metric: np.sum((XA[:, None] - XB[None, :])**2, axis=2) + +from tqdm import tqdm + +from utils import make_grid + + +class UKR(object): + def __init__(self, latent_dim, eta, rambda, sigma, scale): + self.L = latent_dim + self.η = eta + self.σ = sigma + self.λ = rambda + self.scale = scale + self.kernel = lambda Z1, Z2: np.exp(-cdist(Z1, Z2, "sqeuclidean") / (2 * self.σ**2)) + + def fit(self, X, num_epoch=50, seed=0, f_resolution=10, init='random'): + N, D = X.shape + + if init != 'random': + Z = init.copy() + else: + np.random.seed(seed) + Z = np.random.normal(scale=self.scale, size=(N, self.L)) + history = dict( + E=np.zeros((num_epoch,)), + Y=np.zeros((num_epoch, N, D)), + f=np.zeros((num_epoch, f_resolution**self.L, D)), + Z=np.zeros((num_epoch, N, self.L))) + + for epoch in tqdm(range(num_epoch)): + Y, R = self.estimate_f(X, Z) + Z = self.estimate_e(X, Y, Z, R) + + Z_new = make_grid(f_resolution, + bounds=(np.min(Z), np.max(Z)), + dim=self.L) + f, _ = self.estimate_f(X, Z_new, Z) + + history['Y'][epoch] = Y + history['f'][epoch] = f + history['Z'][epoch] = Z + history['E'][epoch] = np.sum((Y - X)**2) / N + self.λ * np.sum(Z**2) + + return history + + def estimate_f(self, X, Z1, Z2=None): + Z2 = np.copy(Z1) if Z2 is None else Z2 + kernels = self.kernel(Z1, Z2) + R = kernels / np.sum(kernels, axis=1, keepdims=True) + return R @ X, R + + def estimate_e(self, X, Y, Z, R): + d_ii = Y - X + d_in = Y[:, np.newaxis, :] - X[np.newaxis, :, :] + d_ni = - d_in + δ_in = Z[:, np.newaxis, :] - Z[np.newaxis, :, :] + δ_ni = - δ_in + + diff_left = np.einsum("ni,nd,nid,nil->nl", + R, + d_ii, + d_ni, + δ_ni, + optimize=True) + diff_right = np.einsum("in,id,ind,inl->nl", + R, + d_ii, + d_in, + δ_in, + optimize=True) + diff = 2 * (diff_left - diff_right) / (self.σ**2 * X.shape[0]) + diff += 2 * self.λ * Z + Z -= self.η * diff + return Z + + +if __name__ == '__main__': + from data import gen_saddle_shape + from visualizer import visualize_history + + + X = gen_saddle_shape(num_samples=200, random_seed=1, noise_scale=0.001) + ukr = UKR(latent_dim=2, eta=5, rambda=5e-4, sigma=0.2, scale=1e-2) + history = ukr.fit(X, num_epoch=200) + visualize_history(X, history['f'], history['Z'], save_gif=False) diff --git a/ukr/ando/ukr_uniform.py b/ukr/ando/ukr_uniform.py new file mode 100644 index 0000000..44e2b86 --- /dev/null +++ b/ukr/ando/ukr_uniform.py @@ -0,0 +1,124 @@ +# Copyright 2021 tanacchi +# +# Permission is hereby granted, free of charge, +# to any person obtaining a copy of this software +# and associated documentation files (the "Software"), +# to deal in the Software without restriction, +# including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, +# and/or sell copies of the Software, +# and to permit persons to whom the Software is furnished to do so, +# subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included +# in all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +# DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + + +import numpy as np + +try: + from scipy.spatial import distance + cdist = distance.cdist +except ModuleNotFoundError: + print("scipy is not installed, so the custom cdist defined.") + cdist = lambda XA, XB: np.sum((XA[:, None] - XB[None, :])**2, axis=2) + +try: + from tqdm import tqdm +except ModuleNotFoundError: + print("tqdm is not installed, so progress bar won't be shown.") + tqdm = iter + +from utils import make_grid + + +class UKR(object): + def __init__(self, latent_dim, eta, sigma, scale, clipping=(-1, +1)): + self.L = latent_dim + self.eta = eta + self.sigma = sigma + self.scale = scale + self.clipping = clipping + self.kernel = lambda Z1, Z2: np.exp(-cdist(Z1, Z2)**2 / (2 * self.sigma**2)) + + def fit(self, X, num_epoch=50, seed=0, f_resolution=10, init='random'): + N, D = X.shape + + if init != 'random': + Z = init.copy() + else: + width = (max(self.clipping) - min(self.clipping)) + mid = sum(self.clipping) / 2 + low, high = mid - self.scale*width, mid + self.scale* width + np.random.seed(seed) + Z = np.random.uniform(low=low, high=high, size=(N, self.L)) + history = dict( + E=np.zeros((num_epoch,)), + Y=np.zeros((num_epoch, N, D)), + f=np.zeros((num_epoch, f_resolution**self.L, D)), + Z=np.zeros((num_epoch, N, self.L))) + + for epoch in tqdm(range(num_epoch)): + Y, R = self.estimate_f(X, Z) + Z = self.estimate_e(X, Y, Z, R) + + Z_new = make_grid(f_resolution, + bounds=(np.min(Z), np.max(Z)), + dim=self.L) + f, _ = self.estimate_f(X, Z_new, Z) + + history['Y'][epoch] = Y + history['f'][epoch] = f + history['Z'][epoch] = Z + history['E'][epoch] = np.sum((Y - X)**2) / N + return history + + def estimate_f(self, X, Z1, Z2=None): + Z2 = np.copy(Z1) if Z2 is None else Z2 + kernels = self.kernel(Z1, Z2) + R = kernels / np.sum(kernels, axis=1, keepdims=True) + return R @ X, R + + def estimate_e(self, X, Y, Z, R): + d_ii = Y - X + d_in = Y[:, np.newaxis, :] - X[np.newaxis, :, :] + d_ni = - d_in + δ_in = Z[:, np.newaxis, :] - Z[np.newaxis, :, :] + δ_ni = - δ_in + + diff_left = np.einsum("ni,nd,nid,nil->nl", + R, + d_ii, + d_ni, + δ_ni, + optimize=True) + diff_right = np.einsum("in,id,ind,inl->nl", + R, + d_ii, + d_in, + δ_in, + optimize=True) + diff = 2 * (diff_left - diff_right) / (self.sigma**2 * X.shape[0]) + Z -= self.eta * diff + Z = np.clip(Z, self.clipping[0], self.clipping[1]) + return Z + + +if __name__ == '__main__': + import data + from visualizer import visualize_history + + + X = data.gen_saddle_shape(num_samples=200, random_seed=0, noise_scale=0.05) + # X = data.gen_2d_sin_curve(100, random_seed=0, noise_scale=0.01) + ukr = UKR(latent_dim=2, eta=8, sigma=0.2, scale=0.1, clipping=(-1, 1)) + history = ukr.fit(X, num_epoch=300) + visualize_history(X, history['f'], history['Z'], save_gif=False) diff --git a/ukr/ando/utils.py b/ukr/ando/utils.py new file mode 100644 index 0000000..24d52f5 --- /dev/null +++ b/ukr/ando/utils.py @@ -0,0 +1,21 @@ +import numpy as np + + +def make_grid(resolution, bounds=(-1, +1), dim=2): + mesh, step = np.linspace(bounds[0], + bounds[1], + resolution, + endpoint=False, + retstep=True) + mesh += step / 2.0 + grid = np.meshgrid(*[np.copy(mesh)]*dim) + return np.dstack(grid).reshape(-1, dim) + + +if __name__ == '__main__': + grid = make_grid(5, dim=3) + print(f"3D:\n{grid}\n") + grid = make_grid(5, dim=2) + print(f"2D:\n{grid}\n") + grid = make_grid(5, dim=1) + print(f"1D:\n{grid}\n") diff --git a/ukr/sample/somf.py b/ukr/sample/somf.py index df2dccb..610dcf3 100644 --- a/ukr/sample/somf.py +++ b/ukr/sample/somf.py @@ -1,5 +1,11 @@ import numpy as np -import scipy.spatial.distance as dist +#import scipy.spatial.distance as dist +try: + from scipy.spatial import distance + cdist = distance.cdist +except ModuleNotFoundError: + print("scipy is not installed, so the custom cdist defined.") + cdist = lambda XA, XB, metric: np.sum((XA[:, None] - XB[None, :])**2, axis=2) from tqdm import tqdm diff --git a/ukr/sample/test.py b/ukr/sample/test.py new file mode 100644 index 0000000..2d7536d --- /dev/null +++ b/ukr/sample/test.py @@ -0,0 +1,200 @@ +import numpy as np +from numpy.random import seed +import data +from somf import UnsupervisedKernelRegression as SomfUKR +from ukr_uniform import UKR as UniformUKR +from ukr_gaussian import UKR as GaussianUKR +from ukr_autograd import UKR as AutogradUKR +from matplotlib import pyplot as plt + + +SEED = 0 +N = 100 + +# 潜在変数を一様分布で初期化するための関数 +# UKR クラスの外で潜在変数初期化の処理を書いたのは +# somf の UKR が,引数で潜在変数を受け取れるような仕様になっていたため +def init_uniform_Z(params): + scale = params['scale'] + clipping = params['clipping'] + L = params['latent_dim'] + + width = (max(clipping) - min(clipping)) + mid = sum(clipping) / 2 + low, high = mid - scale*width, mid + scale* width + np.random.seed(SEED) + Z = np.random.uniform(low=low, high=high, size=(N, L)) + return Z + +# 潜在変数をガウス分布で初期化するための関数 +def init_gaussian_Z(params): + scale = params['scale'] + L = params['latent_dim'] + + np.random.seed(SEED) + Z = np.random.normal(scale=scale, size=(N, L)) + return Z + + + +# 一様潜在変数の UKR (ukr_uniform と somf)のクロステスト +def test_mode1(X, show_result): + # それぞれの UKR について同じパラメータを設定する. + # 実装の違いがあるのでそこはうまいこと合わせる(少々面倒) + eta = 2 + num_epoch = 100 + params_for_myukr = dict( + latent_dim=2, + eta=eta, + sigma=0.1, + scale=1e-3, + clipping=(-1, +1), + ) + init = init_uniform_Z(params_for_myukr) + params_for_somf = dict( + X=X, + n_components=params_for_myukr['latent_dim'], + bandwidth_gaussian_kernel=params_for_myukr['sigma'], + is_compact=True, + lambda_=0.0, + init=init, + is_save_history=True, + ) + + # UKR をそれぞれ実行し,学習結果を history_* に格納 + ukr_1 = SomfUKR(**params_for_somf) + history_1 = ukr_1.fit(nb_epoch=num_epoch, eta=eta) + ukr_2 = UniformUKR(**params_for_myukr) + history_2 = ukr_2.fit(X, num_epoch=num_epoch, seed=SEED, init=init) + + # numpy の allclose 関数を用いて + # 目的関数の値,写像,潜在変数について比較 + # (正味 潜在変数が一致していれば OK) + # 一致していれば True が返る + is_E_close = np.allclose(history_1['obj_func'], history_2['E']) + is_Y_close = np.allclose(history_1['y'], history_2['Y']) + is_Z_close = np.allclose(history_1['z'], history_2['Z']) + print("E: ", is_E_close) + print("Y: ", is_Y_close) + print("Z: ", is_Z_close) + + if show_result: + fig = plt.figure(figsize=(10, 5)) + ax1 = fig.add_subplot(121) + ax1.plot(np.arange(num_epoch), history_1['obj_func'], label="somf") + ax1.plot(np.arange(num_epoch), history_2['E'], label="myukr") + + ax2 = fig.add_subplot(122) + epo =-1 + ax2.scatter(history_1['z'][epo, :, 0], history_1['z'][epo, :, 1], label="somf") + ax2.scatter(history_2['Z'][epo, :, 0], history_2['Z'][epo, :, 1], label="myukr") + plt.show() + + +# ガウス潜在変数の UKR (ukr_gaussian と somf)のクロステスト +def test_mode2(X, show_result): + eta = 2 + num_epoch = 100 + params_for_myukr = dict( + latent_dim=2, + eta=eta, + sigma=0.1, + scale=1e-3, + rambda=1e-04, + ) + init = init_gaussian_Z(params_for_myukr) + params_for_somf = dict( + X=X, + n_components=params_for_myukr['latent_dim'], + bandwidth_gaussian_kernel=params_for_myukr['sigma'], + lambda_=params_for_myukr['rambda'], + init=init, + is_save_history=True, + ) + + ukr_1 = SomfUKR(**params_for_somf) + history_1 = ukr_1.fit(nb_epoch=num_epoch, eta=eta) + ukr_2 = GaussianUKR(**params_for_myukr) + history_2 = ukr_2.fit(X, num_epoch=num_epoch, seed=SEED, init=init) + + # 目的関数の値を計算するタイミングが違うため結果は合わない + # is_E_close = np.allclose(history_1['obj_func'], history_2['E']) + is_Y_close = np.allclose(history_1['y'], history_2['Y']) + is_Z_close = np.allclose(history_1['z'], history_2['Z']) + print("Y: ", is_Y_close) + print("Z: ", is_Z_close) + + if show_result: + fig = plt.figure(figsize=(10, 5)) + ax1 = fig.add_subplot(121) + ax1.plot(np.arange(num_epoch), history_1['obj_func'], label="somf") + ax1.plot(np.arange(num_epoch), history_2['E'], label="myukr") + + ax2 = fig.add_subplot(122) + epo =-1 + ax2.scatter(history_1['z'][epo, :, 0], history_1['z'][epo, :, 1], label="somf") + ax2.scatter(history_2['Z'][epo, :, 0], history_2['Z'][epo, :, 1], label="myukr") + plt.show() + + +# 手動微分版の UKR (ukr_uniform)と自動微分版の UKR(ukr_autograd)のクロステスト +def test_mode3(X, show_result): + num_epoch = 100 + params_for_init = dict( + latent_dim=2, + eta=0.1, + sigma=0.1, + scale=1e-3, + clipping=(-1, +1), + ) + params_for_fit = dict( + X=X.copy(), + num_epoch=num_epoch, + seed=SEED, + f_resolution=10, + init='random', + ) + + ukr_1 = UniformUKR(**params_for_init) + history_1 = ukr_1.fit(**params_for_fit) + ukr_2 = AutogradUKR(**params_for_init) + history_2 = ukr_2.fit(**params_for_fit) + + is_E_close = np.allclose(history_1['E'], history_2['E']) + is_Y_close = np.allclose(history_1['Y'], history_2['Y']) + is_Z_close = np.allclose(history_1['Z'], history_2['Z']) + print("E: ", is_E_close) + print("Y: ", is_Y_close) + print("Z: ", is_Z_close) + + if show_result: + fig = plt.figure(figsize=(10, 5)) + ax1 = fig.add_subplot(121) + ax1.plot(np.arange(num_epoch), history_1['E'], label="hand") + ax1.plot(np.arange(num_epoch), history_2['E'], label="auto") + + ax2 = fig.add_subplot(122) + epo =-1 + ax2.scatter(history_1['Z'][epo, :, 0], history_1['Z'][epo, :, 1], label="hand") + ax2.scatter(history_2['Z'][epo, :, 0], history_2['Z'][epo, :, 1], label="auto") + plt.show() + + +if __name__ == '__main__': + + mode = 'all' + show_result = False + + X = data.gen_saddle_shape(num_samples=N, random_seed=0, noise_scale=0.05) + + # mode に 1, 2, 3 以外を指定すると test_mode* 関数全てを実行する + # この書き方を真似する必要はないです + if mode == 1: # somf uniform vs my uniform ukr + test_mode1(X, show_result) + elif mode == 2: # somf gaussian vs my gaussian ukr + test_mode2(X, show_result) + elif mode == 3: + test_mode3(X, show_result) + else: + for i in range(1, 4): + eval(f"test_mode{i}")(X, show_result) \ No newline at end of file diff --git a/ukr/sample/ukr_gaussian.py b/ukr/sample/ukr_gaussian.py index a6cc993..febca7e 100644 --- a/ukr/sample/ukr_gaussian.py +++ b/ukr/sample/ukr_gaussian.py @@ -23,7 +23,7 @@ import numpy as np -from scipy.spatial import distance as dist +#from scipy.spatial import distance as dist try: from scipy.spatial import distance cdist = distance.cdist diff --git a/ukr/sample/ukr_uniform.py b/ukr/sample/ukr_uniform.py index 9d81778..44e2b86 100644 --- a/ukr/sample/ukr_uniform.py +++ b/ukr/sample/ukr_uniform.py @@ -119,6 +119,6 @@ def estimate_e(self, X, Y, Z, R): X = data.gen_saddle_shape(num_samples=200, random_seed=0, noise_scale=0.05) # X = data.gen_2d_sin_curve(100, random_seed=0, noise_scale=0.01) - ukr = UKR(latent_dim=2, eta=8, sigma=0.2, scale=1e-3, clipping=(-1, 1)) + ukr = UKR(latent_dim=2, eta=8, sigma=0.2, scale=0.1, clipping=(-1, 1)) history = ukr.fit(X, num_epoch=300) visualize_history(X, history['f'], history['Z'], save_gif=False)