From b85ee9d64a536937912544c7bbd5b98b635b7e8d Mon Sep 17 00:00:00 2001 From: Christian C Date: Mon, 11 Nov 2024 12:29:32 -0800 Subject: Initial commit --- notebooks/SmoothInterpolation.ipynb | 864 ++++++++++++++++++++++++++++++++++++ 1 file changed, 864 insertions(+) create mode 100644 notebooks/SmoothInterpolation.ipynb (limited to 'notebooks/SmoothInterpolation.ipynb') diff --git a/notebooks/SmoothInterpolation.ipynb b/notebooks/SmoothInterpolation.ipynb new file mode 100644 index 0000000..b7e86cf --- /dev/null +++ b/notebooks/SmoothInterpolation.ipynb @@ -0,0 +1,864 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "ebfce4c6", + "metadata": {}, + "source": [ + "# Imports and Functions" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "ff590465", + "metadata": {}, + "outputs": [], + "source": [ + "from sunlab.environment.base.cpu import *\n", + "from sunlab.environment.base.extras import *\n", + "from sunlab.globals import FILES\n", + "from sunlab.sunflow import *" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "f99a5c63", + "metadata": {}, + "outputs": [], + "source": [ + "from itertools import combinations" + ] + }, + { + "cell_type": "code", + "execution_count": 141, + "id": "04d5ee86", + "metadata": {}, + "outputs": [], + "source": [ + "def DistanceCovariance(model, mfv_dataset, labels=None, shuffle=False, silent=False):\n", + " \"\"\"# Distance Covariance\n", + " Compute the distance in the MFS and MLS\n", + " - mfv_dataset: (N,13)\n", + " - labels: (N,...) ?\"\"\"\n", + " from numpy import vstack, array\n", + " from numpy.linalg import norm\n", + " from tqdm.auto import tqdm\n", + " assert mfv_dataset.shape[1] == 13\n", + " if labels is None:\n", + " neighborhood_labels = None\n", + " else:\n", + " assert labels.shape[0] == mfv_dataset.shape[0]\n", + " neighborhood_labels = []\n", + " neighborhood_distances = []\n", + " progress = tqdm\n", + " if silent:\n", + " progress = lambda x: x\n", + " for cell_index in progress(range(mfv_dataset.shape[0])):\n", + " source_cell = mfv_dataset[[cell_index],:]\n", + " destination_cells = vstack([mfv_dataset[(cell_index+1):,:]])\n", + " mfv_distance = norm((destination_cells - source_cell), axis=-1)\n", + " mlv_distance = norm((model.encoder(destination_cells)-model.encoder(source_cell)), axis=-1)\n", + " v_distances = list(zip(mfv_distance, mlv_distance))\n", + " if labels is not None:\n", + " neighborhood_labels.extend([labels[cell_index,...]] * len(v_distances))\n", + " for distance in v_distances:\n", + " neighborhood_distances.append(distance)\n", + " neighborhood_distances = array(neighborhood_distances)\n", + " if labels is not None:\n", + " neighborhood_labels = array(neighborhood_labels)\n", + " if shuffle:\n", + " from numpy.random import permutation as permute\n", + " permutation = permute(neighborhood_distances.shape[0])\n", + " neighborhood_distances = neighborhood_distances[permutation,...]\n", + " if labels is not None:\n", + " neighborhood_labels = neighborhood_labels[permutation,...]\n", + " return neighborhood_distances, neighborhood_labels" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "id": "645f6355", + "metadata": {}, + "outputs": [], + "source": [ + "def interpolate_shape_data(s_a, s_b, M=10, p=0, progress=True):\n", + " N = M + 1\n", + " assert N > 0\n", + " assert isinstance(N, int)\n", + " source = s_a\n", + " destination = s_b\n", + " assert len(source.shape) == 1\n", + " assert len(destination.shape) == 1\n", + " assert source.shape[0] == destination.shape[0]\n", + " iteration_powers = np.array([2, 1, 1, 0, 2, 1, 0, 0, 1, 1, 1, 1, 1])\n", + " assert source.shape[0] == iteration_powers.shape[0]\n", + " \n", + " ps = [p,p,p]\n", + " if progress:\n", + " ps = [p,p+1,p+2]\n", + "\n", + " s0_data = source[iteration_powers == 0]\n", + " s1_data = source[iteration_powers == 1]\n", + " s2_data = source[iteration_powers == 2]\n", + " d0_data = destination[iteration_powers == 0]\n", + " d1_data = destination[iteration_powers == 1]\n", + " d2_data = destination[iteration_powers == 2]\n", + "\n", + " _sum = lambda p, N: np.sum([i ** p for i in range(1,N+1)])\n", + "# alpha_N = (d0_data - s0_data)/N\n", + "# beta_N = (d1_data - s1_data)/((N*(N+1))/2)\n", + "# gamma_N = (d2_data - s2_data)/((N*(N+1)*(2*N+1))/6)\n", + " alpha_N = (d0_data - s0_data) / _sum(ps[0],N)\n", + " beta_N = (d1_data - s1_data) / _sum(ps[1],N)\n", + " gamma_N = (d2_data - s2_data) / _sum(ps[2],N)\n", + "\n", + " i0_data = np.zeros((N+1, s0_data.shape[0]))\n", + " i0_data[0,...] = s0_data\n", + " i1_data = np.zeros((N+1, s1_data.shape[0]))\n", + " i1_data[0,...] = s1_data\n", + " i2_data = np.zeros((N+1, s2_data.shape[0]))\n", + " i2_data[0,...] = s2_data\n", + " _t = 0\n", + " for i in range(1,1+N):\n", + " j = i\n", + " i0_data[j,...] = i0_data[j-1,...] + alpha_N * (i ** ps[0])\n", + " i1_data[j,...] = i1_data[j-1,...] + beta_N * (i ** (ps[1]))\n", + " i2_data[j,...] = i2_data[j-1,...] + gamma_N * (i ** ps[2])\n", + " _data = np.hstack([i0_data,i1_data,i2_data])[:,np.argsort(np.argsort(iteration_powers))]\n", + " return _data" + ] + }, + { + "cell_type": "markdown", + "id": "001c1fbb", + "metadata": {}, + "source": [ + "# Runtime Parameters" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "5ce1ed49", + "metadata": {}, + "outputs": [], + "source": [ + "SAVE_EXTRAS = False" + ] + }, + { + "cell_type": "code", + "execution_count": 166, + "id": "a85a22d9", + "metadata": {}, + "outputs": [], + "source": [ + "g_Base = lambda *args: DIR_ROOT + \"Figures/\"\n", + "g_Interpolation = 25*8" + ] + }, + { + "cell_type": "markdown", + "id": "cb02bc7e", + "metadata": {}, + "source": [ + "# Setup" + ] + }, + { + "cell_type": "code", + "execution_count": 112, + "id": "3230e8e7", + "metadata": {}, + "outputs": [], + "source": [ + "model, dataset = load_aae_and_dataset(FILES['TRAINING_DATASET'], FILES['PRETRAINED_MODEL_DIR'], MaxAbsScaler)" + ] + }, + { + "cell_type": "code", + "execution_count": 197, + "id": "28e74585", + "metadata": {}, + "outputs": [], + "source": [ + "_T = 500" + ] + }, + { + "cell_type": "code", + "execution_count": 199, + "id": "817ed4cc", + "metadata": {}, + "outputs": [], + "source": [ + "data = []\n", + "for (a,b) in combinations(range(100),2):\n", + " source = dataset.dataset[a,...]\n", + " destination = dataset.dataset[b,...]\n", + " data.append(interpolate_shape_data(source, destination, M=g_Interpolation, p=-1))\n", + "data = np.vstack(data)" + ] + }, + { + "cell_type": "code", + "execution_count": 201, + "id": "bc1cf736", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "62d489fd5ab8491a86d26e23ab65a511", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/500 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter2d(output[0], c=output[1], cmap='jet')\n", + "_ = _" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ef025b86", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 203, + "id": "96c6d5ae", + "metadata": {}, + "outputs": [], + "source": [ + "data = []\n", + "for (a,b) in combinations(range(100),2):\n", + " source = dataset.dataset[a,...]\n", + " destination = dataset.dataset[b,...]\n", + " data.append(interpolate_shape_data(source, destination, M=g_Interpolation, p=0, progress=False))\n", + "data = np.vstack(data)" + ] + }, + { + "cell_type": "code", + "execution_count": 204, + "id": "25f408b8", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "80328c3c9df54f43bdba68f5862fde48", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/500 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter2d(output[0], c=output[1], cmap='jet')\n", + "_ = _" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "438c59e2", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 206, + "id": "66d02bab", + "metadata": {}, + "outputs": [], + "source": [ + "data = []\n", + "for (a,b) in combinations(range(100),2):\n", + " source = dataset.dataset[a,...]\n", + " destination = dataset.dataset[b,...]\n", + " data.append(interpolate_shape_data(source, destination, M=g_Interpolation, p=0))\n", + "data = np.vstack(data)" + ] + }, + { + "cell_type": "code", + "execution_count": 208, + "id": "a2bb4c04", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c76befaafc7b4b50808ba9f21b6f0489", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/500 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter2d(output[0], c=output[1], cmap='jet')\n", + "_ = _" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "de1f5b25", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a6bbd55d", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "dd22e2b4", + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "output = DistanceCovariance(model, data)" + ] + }, + { + "cell_type": "markdown", + "id": "27e84e37", + "metadata": {}, + "source": [ + "# Plots" + ] + }, + { + "cell_type": "code", + "execution_count": 179, + "id": "3f932439", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "for _M in range(1,20):\n", + " _N = 0\n", + " source = dataset.dataset[_N,...]\n", + " destination = dataset.dataset[_M,...]\n", + "\n", + " out = interpolate_shape_data(source, destination, M=g_Interpolation, p=-1)\n", + " out_mlv = model.encoder(out).numpy()\n", + " R = np.linalg.norm(out_mlv[-1,...] - out_mlv[0,...])\n", + " if R < 1.5:\n", + " plt.scatter2d(out_mlv, s=1, c=range(out_mlv.shape[0]), cmap='jet')\n", + "plt.apply_boundary()" + ] + }, + { + "cell_type": "code", + "execution_count": 260, + "id": "b205ef0f", + "metadata": {}, + "outputs": [], + "source": [ + "_P = 0\n", + "_PROGRESS = True" + ] + }, + { + "cell_type": "code", + "execution_count": 261, + "id": "178ebaee", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a3b62f8bb6784673a40fd52647715d58", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/202 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "_N,_M = (2,23)\n", + "\n", + "fig, ax = plt.subplots(1,2, figsize=(15,7))\n", + "source = dataset.dataset[_N,...]\n", + "destination = dataset.dataset[_M,...]\n", + "\n", + "out = interpolate_shape_data(source, destination, M=g_Interpolation, p=_P, progress=_PROGRESS)\n", + "out_mlv = model.encoder(out).numpy()\n", + "ax[0].scatter(out_mlv[...,0], out_mlv[...,1], s=1, c=range(out_mlv.shape[0]), cmap='jet')\n", + "plt.apply_boundary(_plt=ax[0])\n", + "\n", + "interpolated = interpolate_shape_data(source, destination, M=g_Interpolation, p=_P, progress=_PROGRESS)\n", + "distances, _labels = DistanceCovariance(model, interpolated, np.arange(interpolated.shape[0]))\n", + "ax[1].scatter(distances[...,0], distances[...,1], c=_labels, cmap='jet')\n", + "\n", + "_ = _" + ] + }, + { + "cell_type": "code", + "execution_count": 262, + "id": "708b368a", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "4951e01d51a24afd949cfb9c685094f4", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/202 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "_N,_M = (2,24)\n", + "\n", + "fig, ax = plt.subplots(1,2, figsize=(15,7))\n", + "source = dataset.dataset[_N,...]\n", + "destination = dataset.dataset[_M,...]\n", + "\n", + "out = interpolate_shape_data(source, destination, M=g_Interpolation, p=_P, progress=_PROGRESS)\n", + "out_mlv = model.encoder(out).numpy()\n", + "ax[0].scatter(out_mlv[...,0], out_mlv[...,1], s=1, c=range(out_mlv.shape[0]), cmap='jet')\n", + "plt.apply_boundary(_plt=ax[0])\n", + "\n", + "interpolated = interpolate_shape_data(source, destination, M=g_Interpolation, p=_P, progress=_PROGRESS)\n", + "distances, _labels = DistanceCovariance(model, interpolated, np.arange(interpolated.shape[0]))\n", + "ax[1].scatter(distances[...,0], distances[...,1], c=_labels, cmap='jet')\n", + "\n", + "_ = _" + ] + }, + { + "cell_type": "code", + "execution_count": 263, + "id": "d68402d8", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "5407fc16c2e74ca29ef739feba921596", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/202 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "_N,_M = (2,25)\n", + "\n", + "fig, ax = plt.subplots(1,2, figsize=(15,7))\n", + "source = dataset.dataset[_N,...]\n", + "destination = dataset.dataset[_M,...]\n", + "\n", + "out = interpolate_shape_data(source, destination, M=g_Interpolation, p=_P, progress=_PROGRESS)\n", + "out_mlv = model.encoder(out).numpy()\n", + "ax[0].scatter(out_mlv[...,0], out_mlv[...,1], s=1, c=range(out_mlv.shape[0]), cmap='jet')\n", + "plt.apply_boundary(_plt=ax[0])\n", + "\n", + "interpolated = interpolate_shape_data(source, destination, M=g_Interpolation, p=_P, progress=_PROGRESS)\n", + "distances, _labels = DistanceCovariance(model, interpolated, np.arange(interpolated.shape[0]))\n", + "ax[1].scatter(distances[...,0], distances[...,1], c=_labels, cmap='jet')\n", + "\n", + "_ = _" + ] + }, + { + "cell_type": "code", + "execution_count": 264, + "id": "77dec483", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "3e012fbce2de4bf4bcfa88778e578613", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/202 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "_N,_M = (2,26)\n", + "\n", + "fig, ax = plt.subplots(1,2, figsize=(15,7))\n", + "source = dataset.dataset[_N,...]\n", + "destination = dataset.dataset[_M,...]\n", + "\n", + "out = interpolate_shape_data(source, destination, M=g_Interpolation, p=_P, progress=_PROGRESS)\n", + "out_mlv = model.encoder(out).numpy()\n", + "ax[0].scatter(out_mlv[...,0], out_mlv[...,1], s=1, c=range(out_mlv.shape[0]), cmap='jet')\n", + "plt.apply_boundary(_plt=ax[0])\n", + "\n", + "interpolated = interpolate_shape_data(source, destination, M=g_Interpolation, p=_P, progress=_PROGRESS)\n", + "distances, _labels = DistanceCovariance(model, interpolated, np.arange(interpolated.shape[0]))\n", + "ax[1].scatter(distances[...,0], distances[...,1], c=_labels, cmap='jet')\n", + "\n", + "_ = _" + ] + }, + { + "cell_type": "code", + "execution_count": 265, + "id": "0f8d9a7c", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "9f4e4d7ee7d34f46b88e58fd1fcf7cea", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/202 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "_N,_M = (2,27)\n", + "\n", + "fig, ax = plt.subplots(1,2, figsize=(15,7))\n", + "source = dataset.dataset[_N,...]\n", + "destination = dataset.dataset[_M,...]\n", + "\n", + "out = interpolate_shape_data(source, destination, M=g_Interpolation, p=_P, progress=_PROGRESS)\n", + "out_mlv = model.encoder(out).numpy()\n", + "ax[0].scatter(out_mlv[...,0], out_mlv[...,1], s=1, c=range(out_mlv.shape[0]), cmap='jet')\n", + "plt.apply_boundary(_plt=ax[0])\n", + "\n", + "interpolated = interpolate_shape_data(source, destination, M=g_Interpolation, p=_P, progress=_PROGRESS)\n", + "distances, _labels = DistanceCovariance(model, interpolated, np.arange(interpolated.shape[0]))\n", + "ax[1].scatter(distances[...,0], distances[...,1], c=_labels, cmap='jet')\n", + "\n", + "_ = _" + ] + }, + { + "cell_type": "code", + "execution_count": 266, + "id": "49f2357a", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "685af8347057458dbf4566021146ab18", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/202 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "_N,_M = (2,28)\n", + "\n", + "fig, ax = plt.subplots(1,2, figsize=(15,7))\n", + "source = dataset.dataset[_N,...]\n", + "destination = dataset.dataset[_M,...]\n", + "\n", + "out = interpolate_shape_data(source, destination, M=g_Interpolation, p=_P, progress=_PROGRESS)\n", + "out_mlv = model.encoder(out).numpy()\n", + "ax[0].scatter(out_mlv[...,0], out_mlv[...,1], s=1, c=range(out_mlv.shape[0]), cmap='jet')\n", + "plt.apply_boundary(_plt=ax[0])\n", + "\n", + "interpolated = interpolate_shape_data(source, destination, M=g_Interpolation, p=_P, progress=_PROGRESS)\n", + "distances, _labels = DistanceCovariance(model, interpolated, np.arange(interpolated.shape[0]))\n", + "ax[1].scatter(distances[...,0], distances[...,1], c=_labels, cmap='jet')\n", + "\n", + "_ = _" + ] + }, + { + "cell_type": "code", + "execution_count": 267, + "id": "c8c890fd", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "3d2685557cfb4de198c8d06a3ed11a7f", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/202 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "_N,_M = (2,29)\n", + "\n", + "fig, ax = plt.subplots(1,2, figsize=(15,7))\n", + "source = dataset.dataset[_N,...]\n", + "destination = dataset.dataset[_M,...]\n", + "\n", + "out = interpolate_shape_data(source, destination, M=g_Interpolation, p=_P, progress=_PROGRESS)\n", + "out_mlv = model.encoder(out).numpy()\n", + "ax[0].scatter(out_mlv[...,0], out_mlv[...,1], s=1, c=range(out_mlv.shape[0]), cmap='jet')\n", + "plt.apply_boundary(_plt=ax[0])\n", + "\n", + "interpolated = interpolate_shape_data(source, destination, M=g_Interpolation, p=_P, progress=_PROGRESS)\n", + "distances, _labels = DistanceCovariance(model, interpolated, np.arange(interpolated.shape[0]))\n", + "ax[1].scatter(distances[...,0], distances[...,1], c=_labels, cmap='jet')\n", + "\n", + "_ = _" + ] + }, + { + "cell_type": "markdown", + "id": "ae236fe1", + "metadata": { + "heading_collapsed": true + }, + "source": [ + "# END" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1e96e010", + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "tfnb", + "language": "python", + "name": "python3" + }, + "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.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} -- cgit v1.2.1