diff --git a/antipasti/model/model.py b/antipasti/model/model.py index ab808ad..62d05d7 100644 --- a/antipasti/model/model.py +++ b/antipasti/model/model.py @@ -7,7 +7,7 @@ """ import numpy as np import torch -from torch.nn import Linear, ReLU, Conv2d, MaxPool2d, Module, Dropout, Parameter +from torch.nn import Linear, ReLU, Conv2d, MaxPool2d, Module class ANTIPASTI(Module): r"""Predicting the binding affinity of an antibody from its normal mode correlation map. @@ -25,7 +25,7 @@ class ANTIPASTI(Module): l1_lambda: float Weight of L1 regularisation. mode: str - To use the full model, provide ``full``. Otherwise, ANTIPASTI corresponds to a linear classifier. + To use the full model, provide ``full``. Otherwise, ANTIPASTI corresponds to a linear map. """ def __init__( @@ -47,12 +47,10 @@ def __init__( self.fully_connected_input = n_filters * ((input_shape-filter_size+1)//pooling_size) ** 2 self.conv1 = Conv2d(1, n_filters, filter_size) self.pool = MaxPool2d(pooling_size, pooling_size) - #self.dropit = Dropout(p=0.05) self.relu = ReLU() else: self.fully_connected_input = self.input_shape ** 2 self.fc1 = Linear(self.fully_connected_input, 1, bias=False) - #self.fc2 = Linear(4, 1, bias=False) self.l1_lambda = l1_lambda def forward(self, x): @@ -72,10 +70,7 @@ def forward(self, x): x = self.relu(x) inter = x = self.pool(x) x = x.view(x.size(0), -1) - #if self.mode == 'full': - # x = self.dropit(x) x = self.fc1(x) - #x = self.fc2(x) return x.float(), inter diff --git a/antipasti/preprocessing/preprocessing.py b/antipasti/preprocessing/preprocessing.py index fd45d12..0b7dc7c 100644 --- a/antipasti/preprocessing/preprocessing.py +++ b/antipasti/preprocessing/preprocessing.py @@ -46,6 +46,14 @@ class Preprocessing(object): Compute all the normal mode correlation maps. renew_residues: bool Retrieve the lists of residues for each entry. + cmaps: bool + If ``True``, ANTIPASTI computes the contact maps of the complexes instead of the Normal Modes. + cmaps_thr: float + Thresholding distance for alpha (α) carbons to build the contact maps. + ag_agnostic: bool + If ``True``, Normal Mode correlation maps are computed in complete absence of the antigen. + affinity_entries_only: bool + This is ``False`` in general, but the ANTIPASTI pipeline could be used to other types of projects and thus consider data without affinity values. stage: str Choose between ``training`` and ``predicting``. test_data_path: str @@ -64,7 +72,7 @@ class Preprocessing(object): Amount of absent residues between positions 1 and 25 in the heavy chain. l_offset: int Amount of absent residues between positions 1 and 23 in the light chain. - + """ def __init__( diff --git a/antipasti/utils/biology_utils.py b/antipasti/utils/biology_utils.py index 7ddc553..3d16223 100644 --- a/antipasti/utils/biology_utils.py +++ b/antipasti/utils/biology_utils.py @@ -90,6 +90,8 @@ def remove_nanobodies(pdb_codes, representations, embedding=None, labels=[], num Low-dimensional version of ``representations``. labels: list Data point labels. + numerical_values: list + If data is numerical (e.g., affinity values), it is necessary to include a list here. In this way, values associated to nanobodies can be removed. """ input_shape = representations.shape[-1] diff --git a/antipasti/utils/explaining_utils.py b/antipasti/utils/explaining_utils.py index edf5c02..cabde38 100644 --- a/antipasti/utils/explaining_utils.py +++ b/antipasti/utils/explaining_utils.py @@ -58,6 +58,16 @@ def get_maps_of_interest(preprocessed_data, learnt_filter, affinity_thr=-8): return mean_learnt, mean_image, mean_diff_image def get_output_representations(preprocessed_data, model): + r"""Returns maps that reveal the important residue interactions for the binding affinity. We call them 'output layer representations'. + + Parameters + ---------- + preprocessed_data: antipasti.preprocessing.preprocessing.Preprocessing + The ``Preprocessing`` class. + model: antipasti.model.model.ANTIPASTI + The model class, i.e., ``ANTIPASTI``. + + """ input_shape = preprocessed_data.test_x.shape[-1] each_img_enl = np.zeros((preprocessed_data.train_x.shape[0], input_shape**2)) size_le = int(np.sqrt(model.fc1.weight.data.numpy().shape[-1] / model.n_filters)) @@ -110,7 +120,7 @@ def plot_map_with_regions(preprocessed_data, map, title='Normal mode correlation title: str The image title. interactive: bool - Set to ``True`` when running a script or Pytest. + Set to ``True`` when running a script or ``pytest``. """ # Font sizes @@ -212,8 +222,8 @@ def compute_umap(preprocessed_data, model, scheme='heavy_species', categorical=T external_cdict: dictionary Option to provide an external dictionary of the UMAP labels. interactive: bool - Set to ``True`` when running a script or Pytest. - remove_nanobodies: bool + Set to ``True`` when running a script or ``pytest``. + exclude_nanobodies: bool Set to ``True`` to exclude nanobodies from the UMAP plot. """ @@ -337,8 +347,10 @@ def plot_umap(embedding, colours, scheme, pdb_codes, categorical=True, include_e ``True`` if ``scheme`` is categorical. include_ellipses: bool ``True`` to include ellipses comprising 85% of the points of a given class. + cdict: dictionary + External dictionary of the UMAP labels. interactive: bool - Set to ``True`` when running a script or Pytest. + Set to ``True`` when running a script or ``pytest``. """ fig = plt.figure(figsize=(20,20)) @@ -411,6 +423,22 @@ def plot_umap(embedding, colours, scheme, pdb_codes, categorical=True, include_e plt.close('all') def plot_region_importance(importance_factor, importance_factor_ob, antigen_type, mode='region', interactive=False): + r"""Plots ranking of important regions. + + Parameters + ---------- + importance_factor: list + Measure of importance (0-100) for each antibody region. + importance_factor_ob: list + Measure of importance (0-100) for each antibody region attributable to off-block correlations. This can be inter-region or inter-chain depending on the selected ``mode``. + antigen_type: int + Plot corresponding to antigens of a given type. These can be proteins (0), haptens (1), peptides (2) or carbohydrates (3). + mode: str + ``region`` to explicitely show which correlations are inter/intra-region (likewise for ``chain``). + interactive: bool + Set to ``True`` when running a script or ``pytest``. + + """ labels = ['FR-H1', 'CDR-H1', 'FR-H2', 'CDR-H2', 'FR-H3', 'CDR-H3', 'FR-H4', 'FR-L1', 'CDR-L1', 'FR-L2', 'CDR-L2', 'FR-L3', 'CDR-L3', 'FR-L4'] mapping_dict = {0: 0, 1: 2, 2: 1, 3: 5} @@ -446,7 +474,7 @@ def plot_region_importance(importance_factor, importance_factor_ob, antigen_type plt.close('all') def add_region_based_on_range(list_residues): - + r"""Given a list of residues in Chothia numbering, this function adds the corresponding regions in brackets for each of them.""" output_list_residues = [] new_coord = np.array([range(0, 26), range(26, 38), range(38, 57), range(57, 67), range(67, 116), range(116, 142), @@ -463,6 +491,20 @@ def add_region_based_on_range(list_residues): return output_list_residues def plot_residue_importance(preprocessed_data, importance_factor, antigen_type, interactive=False): + r"""Plots ranking of important residues. + + Parameters + ---------- + preprocessed_data: antipasti.preprocessing.preprocessing.Preprocessing + The ``Preprocessing`` class. + importance_factor: list + Measure of importance (0-100) for each antibody residue. + antigen_type: int + Plot corresponding to antigens of a given type. These can be proteins (0), haptens (1), peptides (2) or carbohydrates (3). + interactive: bool + Set to ``True`` when running a script or ``pytest``. + + """ res_labels = add_region_based_on_range(preprocessed_data.max_res_list_h+preprocessed_data.max_res_list_l) mapping_dict = {0: 0, 1: 2, 2: 1, 3: 5} @@ -495,6 +537,14 @@ def plot_residue_importance(preprocessed_data, importance_factor, antigen_type, def get_colours_ag_type(preprocessed_data): + r"""Returns a different colour according to the antigen type. + + Parameters + ---------- + preprocessed_data: antipasti.preprocessing.preprocessing.Preprocessing + The ``Preprocessing`` class. + + """ cluster_according_to = 'antigen_type' db = pd.read_csv(preprocessed_data.data_path+'sabdab_summary_all.tsv', sep='\t') @@ -522,7 +572,25 @@ def get_colours_ag_type(preprocessed_data): return colours def compute_region_importance(preprocessed_data, model, type_of_antigen, nanobodies, mode='region', interactive=False): - + r"""Computes the importance factors (0-100) of all the Fv antibody regions. + + Parameters + ---------- + preprocessed_data: antipasti.preprocessing.preprocessing.Preprocessing + The ``Preprocessing`` class. + model: antipasti.model.model.ANTIPASTI + The model class, i.e., ``ANTIPASTI``. + type_of_antigen: int + Choose between: proteins (0), haptens (1), peptides (2) or carbohydrates (3). + nanobodies: list + PDB codes of nanobodies in the dataset. + mode: str + ``region`` to explicitely calculate which correlations are inter/intra-region (likewise for ``chain``). + interactive: bool + Set to ``True`` when running a script or ``pytest``. + + """ + colours = get_colours_ag_type(preprocessed_data) each_img_enl = get_output_representations(preprocessed_data, model) @@ -581,6 +649,22 @@ def compute_region_importance(preprocessed_data, model, type_of_antigen, nanobod plot_region_importance(tot, ob, type_of_antigen, mode, interactive=interactive) def compute_residue_importance(preprocessed_data, model, type_of_antigen, nanobodies, interactive=False): + r"""Computes the importance factors (0-100) of all the amino acids of the antibody variable region. + + Parameters + ---------- + preprocessed_data: antipasti.preprocessing.preprocessing.Preprocessing + The ``Preprocessing`` class. + model: antipasti.model.model.ANTIPASTI + The model class, i.e., ``ANTIPASTI``. + type_of_antigen: int + Choose between: proteins (0), haptens (1), peptides (2) or carbohydrates (3). + nanobodies: list + PDB codes of nanobodies in the dataset. + interactive: bool + Set to ``True`` when running a script or ``pytest``. + + """ colours = get_colours_ag_type(preprocessed_data) each_img_enl = get_output_representations(preprocessed_data, model) diff --git a/antipasti/utils/torch_utils.py b/antipasti/utils/torch_utils.py index 68ad166..a1e648e 100644 --- a/antipasti/utils/torch_utils.py +++ b/antipasti/utils/torch_utils.py @@ -18,6 +18,8 @@ def create_test_set(train_x, train_y, test_size=None, random_state=0): Labels. test_size: float Fraction of original samples to be included in the test set. + random_state: int + Set lot number. Returns ------- @@ -105,18 +107,7 @@ def training_step(model, criterion, optimiser, train_x, test_x, train_y, test_y, inter_filter = np.zeros((x_train.size()[0], model.n_filters, size_inter, size_inter)) if model.mode != 'full': inter_filter = np.zeros((x_train.size()[0], 1, model.input_shape, model.input_shape)) - #perm_paired = [] - #perm_nano = [] permutation = torch.randperm(x_train.size()[0]) - #for i in range(x_train.size()[0]): - # if torch.numel(torch.nonzero(x_train[i,0,-80:,-80:])) == 0: - # perm_nano.append(i) - # else: - # perm_paired.append(i) - #np.random.shuffle(perm_nano) - #np.random.shuffle(perm_paired) - #print(len(perm_nano)) - #permutation = perm_nano + perm_paired for i in range(0, x_train.size()[0], batch_size): indices = permutation[i:i+batch_size] @@ -130,17 +121,6 @@ def training_step(model, criterion, optimiser, train_x, test_x, train_y, test_y, inter_filter[i:i+batch_size] = inter_filters_detached.numpy() # Training loss, clearing gradients and updating weights - #def closure(): - # optimiser.zero_grad() - # output_train, inter_filters = model(batch_x) - # loss_train = criterion(output_train[:, 0], batch_y[:, 0]) - # loss_train.backward() - # return loss_train - - #optimiser.step(closure) - - #with torch.no_grad(): - # loss_train = criterion(output_train[:, 0], batch_y[:, 0]).detach() optimiser.zero_grad() l1_loss = model.l1_regularization_loss() mse_loss = criterion(output_train[:, 0], batch_y[:, 0]) @@ -246,10 +226,10 @@ def load_checkpoint(path, input_shape, n_filters=None, pooling_size=None, filter Shape of the normal mode correlation maps. n_filters: int Number of filters in the convolutional layer. - filter_size: int - Size of filters in the convolutional layer. pooling_size: int Size of the max pooling operation. + filter_size: int + Size of filters in the convolutional layer. Returns ------- diff --git a/notebooks/[Tutorial] Training ANTIPASTI.ipynb b/notebooks/[Tutorial] Training ANTIPASTI.ipynb index 9a2afef..6007c8c 100644 --- a/notebooks/[Tutorial] Training ANTIPASTI.ipynb +++ b/notebooks/[Tutorial] Training ANTIPASTI.ipynb @@ -1,7 +1,6 @@ { "cells": [ { - "attachments": {}, "cell_type": "markdown", "id": "942f7e6b", "metadata": {}, @@ -27,6 +26,7 @@ "import optuna\n", "\n", "from matplotlib.colors import CenteredNorm\n", + "from random import randint\n", "from sklearn.model_selection import KFold\n", "\n", "# PyTorch-related libraries\n", @@ -42,7 +42,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "c274f4c5", "metadata": {}, @@ -57,48 +56,15 @@ "metadata": { "scrolled": false }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Map 1 out of 634 processed.\n", - "Map 26 out of 634 processed.\n", - "Map 51 out of 634 processed.\n", - "Map 76 out of 634 processed.\n", - "Map 101 out of 634 processed.\n", - "Map 126 out of 634 processed.\n", - "Map 151 out of 634 processed.\n", - "Map 176 out of 634 processed.\n", - "Map 201 out of 634 processed.\n", - "Map 226 out of 634 processed.\n", - "Map 251 out of 634 processed.\n", - "Map 276 out of 634 processed.\n", - "Map 301 out of 634 processed.\n", - "Map 326 out of 634 processed.\n", - "Map 351 out of 634 processed.\n", - "Map 376 out of 634 processed.\n", - "Map 401 out of 634 processed.\n", - "Map 426 out of 634 processed.\n", - "Map 451 out of 634 processed.\n", - "Map 476 out of 634 processed.\n", - "Map 501 out of 634 processed.\n", - "Map 526 out of 634 processed.\n", - "Map 551 out of 634 processed.\n", - "Map 576 out of 634 processed.\n", - "Map 601 out of 634 processed.\n", - "Map 626 out of 634 processed.\n" - ] - } - ], + "outputs": [], "source": [ "modes = 'all' # Number of normal modes to consider. Relevant if renew_maps is True\n", - "renew_maps = True # True to compute again all the normal mode correlation maps\n", - "renew_residues = True # True to retrieve again all the chain lengths \n", + "renew_maps = False # True to compute again all the normal mode correlation maps\n", + "renew_residues = False # True to retrieve again all the chain lengths \n", "dccm_map_path = 'dccm_maps_full_ags_all/' # NM correlation maps or contact maps are saved here\n", "ag_agnostic = False # If True, only the antibody is considered\n", "contact_maps = False # True to compute contact maps and False to compute NM correlation maps\n", - "cmaps_thr = 8.0 # If contact_maps is True, then this is the thresholding parameter, otherwise irrelevant\n", + "cmaps_thr = 8.0 # If contact_maps is True, then this is the thresholding parameter, otherwise irrelevant. If 'all', distance matrices are generated\n", "\n", "pathological = ['5omm', '5i5k', '1uwx', '1mj7', '1qfw', '1qyg', '4ffz', '3ifl', '3lrh', '3pp4', '3ru8', '3t0w', '3t0x', '4fqr', '4gxu', '4jfx', '4k3h', '4jfz', '4jg0', '4jg1', '4jn2', '4o4y', '4qxt', '4r3s', '4w6y', '4w6y', '5ies', '5ivn', '5j57', '5kvd', '5kzp', '5mes', '5nmv', '5sy8', '5t29', '5t5b', '5vag', '3etb', '3gkz', '3uze', '3uzq', '4f9l', '4gqp', '4r2g', '5c6t', '3fku', '1oau', '1oay']\n", "scfv = ['4gqp', '3etb', '3gkz', '3uze', '3uzq', '3gm0', '4f9l', '6ejg', '6ejm', '1h8s', '5dfw', '6cbp', '4f9p', '5kov', '1dzb', '5j74', '5aaw', '3uzv', '5aam', '3ux9', '5a2j', '5a2k', '5a2i', '3fku', '5yy4', '3uyp', '5jyl', '1y0l', '1p4b', '3kdm', '4lar', '4ffy', '2ybr', '1mfa', '5xj3', '5xj4', '4kv5', '5vyf'] \n", @@ -116,7 +82,7 @@ { "data": { "text/plain": [ - "(634, 288, 288)" + "(634, 292, 292)" ] }, "execution_count": 3, @@ -129,7 +95,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "2c25da90", "metadata": {}, @@ -145,7 +110,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -204,7 +169,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "0deb6ac3", "metadata": {}, @@ -222,7 +186,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -257,99 +221,18 @@ { "cell_type": "code", "execution_count": 7, - "id": "4521a5c1", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "\n", - "input_shape = preprocessed_data.train_x.shape[-1]\n", - "\n", - "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(13, 5.25))\n", - "im1 = ax1.imshow(preprocessed_data.raw_imgs[22], origin='lower', cmap='seismic', norm=CenteredNorm())\n", - "im2 = ax2.imshow(preprocessed_data.train_x[22].reshape(input_shape, input_shape), origin='lower', cmap='seismic', norm=CenteredNorm())\n", - "\n", - "ax1.set_title('DCCM map', size=title_size)\n", - "ax2.set_title('DCCM map after adding gaps', size=title_size)\n", - "\n", - "cb1 = plt.colorbar(im1, ax=ax1, fraction=0.045)\n", - "cb2 = plt.colorbar(im2, ax=ax2, fraction=0.045)\n", - "\n", - "ax1.tick_params(axis='both', which='major', labelsize=10)\n", - "ax2.tick_params(axis='both', which='major', labelsize=10)\n", - "cb1.ax.tick_params(labelsize=14) \n", - "cb2.ax.tick_params(labelsize=14) \n", - "\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 8, "id": "fd09ab8d", "metadata": {}, "outputs": [], "source": [ "# The test set is generated\n", - "train_x, test_x, train_y, test_y, idx_tr, idx_te = create_test_set(preprocessed_data.train_x, preprocessed_data.train_y, test_size=0.032, random_state=398)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "89e9f5e6", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "['1flr',\n", - " '4ps4',\n", - " '3ubx',\n", - " '2r1y',\n", - " '5o2u',\n", - " '6msy',\n", - " '5myx',\n", - " '6bkc',\n", - " '2jix',\n", - " '5kn5',\n", - " '4x7d',\n", - " '2yk1',\n", - " '5hvf',\n", - " '3fn0',\n", - " '3ma9',\n", - " '1ct8',\n", - " '5cjq',\n", - " '5otj',\n", - " '2h9g',\n", - " '3ghe',\n", - " '1yei']" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "[preprocessed_data.labels[i] for i in idx_te]" + "random_seed = randint(0, 1000)\n", + "train_x, test_x, train_y, test_y, idx_tr, idx_te = create_test_set(preprocessed_data.train_x, preprocessed_data.train_y, test_size=0.05, random_state=random_seed)" ] }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 8, "id": "836251dd", "metadata": { "scrolled": true @@ -362,21 +245,24 @@ "Weight decoupling enabled in AdaBelief\n", "Rectification enabled in AdaBelief\n", "ANTIPASTI(\n", + " (conv1): Conv2d(1, 4, kernel_size=(4, 4), stride=(1, 1))\n", + " (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n", + " (relu): ReLU()\n", " (fc1): Linear(in_features=82944, out_features=1, bias=False)\n", ")\n" ] } ], "source": [ - "# Hyperparameters\n", + "# Optimal hyperparameters\n", "n_filters = 4\n", "filter_size = 4\n", "pooling_size = 2\n", - "learning_rate = 0.00027253018778843 * 0.4 * 2\n", + "learning_rate = 1e-4\n", "\n", "\n", "# Defining the model, optimiser and loss function\n", - "model = ANTIPASTI(n_filters=n_filters, filter_size=filter_size, pooling_size=pooling_size, input_shape=input_shape, l1_lambda=0.002, mode='linear')\n", + "model = ANTIPASTI(n_filters=n_filters, filter_size=filter_size, pooling_size=pooling_size, input_shape=input_shape, l1_lambda=0.002)\n", "criterion = MSELoss() \n", "optimiser = AdaBelief(model.parameters(), lr=learning_rate, weight_decay=False, eps=1e-8, print_change_log=False) \n", "print(model)" @@ -384,39 +270,30 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 9, "id": "02b73b3c", "metadata": {}, - "outputs": [], - "source": [ - "def count_parameters(model):\n", - " return sum(p.numel() for p in model.parameters() if p.requires_grad)" - ] - }, - { - "cell_type": "code", - "execution_count": 39, - "id": "db9b3a6b", - "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "82944" + "83012" ] }, - "execution_count": 39, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "count_parameters(model.fc1)" + "def count_parameters(model):\n", + " return sum(p.numel() for p in model.parameters() if p.requires_grad)\n", + "count_parameters(model)" ] }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 10, "id": "48c7f224", "metadata": {}, "outputs": [], @@ -427,7 +304,7 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 11, "id": "60177db4", "metadata": { "scrolled": false @@ -437,5980 +314,4485 @@ "name": "stdout", "output_type": "stream", "text": [ - "tensor(0.2883, grad_fn=)\n", - "tensor(0.2964, grad_fn=)\n", - "tensor(0.3045, grad_fn=)\n", - "tensor(0.3069, grad_fn=)\n", - "tensor(0.3061, grad_fn=)\n", - "tensor(0.3036, grad_fn=)\n", - "tensor(0.3030, grad_fn=)\n", - "tensor(0.3024, grad_fn=)\n", - "tensor(0.3016, grad_fn=)\n", - "tensor(0.3007, grad_fn=)\n", - "tensor(0.2997, grad_fn=)\n", - "tensor(0.2986, grad_fn=)\n", - "tensor(0.2974, grad_fn=)\n", - "tensor(0.2962, grad_fn=)\n", - "tensor(0.2948, grad_fn=)\n", - "tensor(0.2934, grad_fn=)\n", - "tensor(0.2919, grad_fn=)\n", - "tensor(0.2904, grad_fn=)\n", - "tensor(0.2887, grad_fn=)\n", - "tensor(0.2870, grad_fn=)\n", - "tensor([[-10.9909]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-11.0472]])\n", - "tensor([[-11.2441]])\n", - "------------------------\n", - "tensor([[-11.1560]])\n", - "tensor([[-7.5986]])\n", - "------------------------\n", - "tensor([[-11.2896]])\n", - "tensor([[-4.5086]])\n", + "tensor(0.3049, grad_fn=)\n", + "tensor(0.3099, grad_fn=)\n", + "tensor(0.3132, grad_fn=)\n", + "tensor(0.3122, grad_fn=)\n", + "tensor(0.3103, grad_fn=)\n", + "tensor(0.3088, grad_fn=)\n", + "tensor(0.3088, grad_fn=)\n", + "tensor(0.3087, grad_fn=)\n", + "tensor(0.3086, grad_fn=)\n", + "tensor(0.3085, grad_fn=)\n", + "tensor(0.3083, grad_fn=)\n", + "tensor(0.3082, grad_fn=)\n", + "tensor(0.3081, grad_fn=)\n", + "tensor(0.3079, grad_fn=)\n", + "tensor(0.3078, grad_fn=)\n", + "tensor(0.3076, grad_fn=)\n", + "tensor(0.3075, grad_fn=)\n", + "tensor(0.3073, grad_fn=)\n", + "tensor(0.3071, grad_fn=)\n", + "tensor(0.3070, grad_fn=)\n", + "tensor([[-6.7731]])\n", + "tensor([[-6.4202]])\n", + "------------------------\n", + "tensor([[-6.4101]])\n", + "tensor([[-7.1427]])\n", + "------------------------\n", + "tensor([[-5.7510]])\n", + "tensor([[-8.0506]])\n", "------------------------\n", - "tensor([[-6.1290]])\n", - "tensor([[-9.1612]])\n", + "tensor([[-7.3637]])\n", + "tensor([[-7.0362]])\n", "------------------------\n", - "tensor([[-11.1980]])\n", - "tensor([[-7.]])\n", + "tensor([[-6.9765]])\n", + "tensor([[-9.2733]])\n", "------------------------\n", - "tensor([[-11.1436]])\n", + "tensor([[-6.8399]])\n", "tensor([[-8.1643]])\n", "------------------------\n", - "tensor([[-10.9180]])\n", - "tensor([[-9.0969]])\n", - "------------------------\n", - "tensor([[-11.0275]])\n", - "tensor([[-7.5229]])\n", + "tensor([[-6.8077]])\n", + "tensor([[-7.9208]])\n", "------------------------\n", - "tensor([[-11.1823]])\n", - "tensor([[-9.9914]])\n", + "tensor([[-6.8881]])\n", + "tensor([[-6.8386]])\n", "------------------------\n", - "tensor([[-5.1315]])\n", - "tensor([[-8.4559]])\n", - "------------------------\n", - "tensor([[-10.6940]])\n", - "tensor([[-8.1308]])\n", + "tensor([[-7.4597]])\n", + "tensor([[-11.2441]])\n", "------------------------\n", - "tensor([[-6.2449]])\n", - "tensor([[-10.5229]])\n", + "tensor([[-6.7599]])\n", + "tensor([[-7.8539]])\n", "------------------------\n", - "tensor([[-10.9900]])\n", - "tensor([[-4.3979]])\n", + "tensor([[-6.8721]])\n", + "tensor([[-5.3098]])\n", "------------------------\n", - "tensor([[-11.0496]])\n", - "tensor([[-8.]])\n", + "tensor([[-6.8404]])\n", + "tensor([[-5.8327]])\n", "------------------------\n", - "tensor([[-11.2112]])\n", - "tensor([[-6.5229]])\n", + "tensor([[-7.0664]])\n", + "tensor([[-9.7905]])\n", "------------------------\n", - "tensor([[-11.1968]])\n", - "tensor([[-9.3010]])\n", + "tensor([[-6.8460]])\n", + "tensor([[-7.6021]])\n", "------------------------\n", - "tensor([[-11.1813]])\n", - "tensor([[-9.7696]])\n", + "tensor([[-6.8980]])\n", + "tensor([[-6.6198]])\n", "------------------------\n", - "tensor([[-11.3065]])\n", - "tensor([[-8.3010]])\n", + "tensor([[-7.3900]])\n", + "tensor([[-11.3010]])\n", "------------------------\n", - "tensor([[-11.0748]])\n", - "tensor([[-5.8861]])\n", + "tensor([[-7.0102]])\n", + "tensor([[-8.0044]])\n", "------------------------\n", - "tensor([[-11.1899]])\n", - "tensor([[-7.4559]])\n", + "tensor([[-6.4490]])\n", + "tensor([[-8.8539]])\n", "------------------------\n", - "Epoch : 1 \t train loss: 17.44642158744774 train MSE: tensor(17.1357, grad_fn=) test MSE: 13.35170718725948\n", - "Corr: -0.2884379147743122\n", - "tensor(0.2853, grad_fn=)\n", - "tensor(0.2835, grad_fn=)\n", - "tensor(0.2816, grad_fn=)\n", - "tensor(0.2797, grad_fn=)\n", - "tensor(0.2777, grad_fn=)\n", - "tensor(0.2757, grad_fn=)\n", - "tensor(0.2737, grad_fn=)\n", - "tensor(0.2716, grad_fn=)\n", - "tensor(0.2694, grad_fn=)\n", - "tensor(0.2672, grad_fn=)\n", - "tensor(0.2650, grad_fn=)\n", - "tensor(0.2628, grad_fn=)\n", - "tensor(0.2605, grad_fn=)\n", - "tensor(0.2582, grad_fn=)\n", - "tensor(0.2558, grad_fn=)\n", - "tensor(0.2534, grad_fn=)\n", - "tensor(0.2510, grad_fn=)\n", - "tensor(0.2486, grad_fn=)\n", - "tensor(0.2461, grad_fn=)\n", - "tensor(0.2437, grad_fn=)\n", - "tensor([[-9.6328]])\n", - "tensor([[-9.3010]])\n", + "tensor([[-6.8401]])\n", + "tensor([[-6.9586]])\n", "------------------------\n", - "tensor([[-9.6852]])\n", - "tensor([[-11.2441]])\n", + "tensor([[-7.5667]])\n", + "tensor([[-8.5376]])\n", "------------------------\n", - "tensor([[-9.7780]])\n", - "tensor([[-7.5986]])\n", + "tensor([[-7.7981]])\n", + "tensor([[-11.3979]])\n", "------------------------\n", - "tensor([[-9.8731]])\n", - "tensor([[-4.5086]])\n", + "tensor([[-6.9329]])\n", + "tensor([[-11.2218]])\n", "------------------------\n", - "tensor([[-5.5339]])\n", - "tensor([[-9.1612]])\n", + "Epoch : 1 \t train loss: 10.760894750457963 train MSE: tensor(10.4382, grad_fn=) test MSE: 4.35229439987928\n", + "Corr: 0.4435492656548739\n", + "tensor(0.3068, grad_fn=)\n", + "tensor(0.3066, grad_fn=)\n", + "tensor(0.3064, grad_fn=)\n", + "tensor(0.3062, grad_fn=)\n", + "tensor(0.3060, grad_fn=)\n", + "tensor(0.3058, grad_fn=)\n", + "tensor(0.3056, grad_fn=)\n", + "tensor(0.3054, grad_fn=)\n", + "tensor(0.3052, grad_fn=)\n", + "tensor(0.3050, grad_fn=)\n", + "tensor(0.3047, grad_fn=)\n", + "tensor(0.3045, grad_fn=)\n", + "tensor(0.3043, grad_fn=)\n", + "tensor(0.3040, grad_fn=)\n", + "tensor(0.3038, grad_fn=)\n", + "tensor(0.3036, grad_fn=)\n", + "tensor(0.3033, grad_fn=)\n", + "tensor(0.3031, grad_fn=)\n", + "tensor(0.3028, grad_fn=)\n", + "tensor(0.3025, grad_fn=)\n", + "tensor([[-7.5004]])\n", + "tensor([[-6.4202]])\n", "------------------------\n", - "tensor([[-9.8156]])\n", - "tensor([[-7.]])\n", + "tensor([[-7.1041]])\n", + "tensor([[-7.1427]])\n", "------------------------\n", - "tensor([[-9.7637]])\n", - "tensor([[-8.1643]])\n", + "tensor([[-6.3509]])\n", + "tensor([[-8.0506]])\n", "------------------------\n", - "tensor([[-9.5300]])\n", - "tensor([[-9.0969]])\n", + "tensor([[-8.0935]])\n", + "tensor([[-7.0362]])\n", "------------------------\n", - "tensor([[-9.6644]])\n", - "tensor([[-7.5229]])\n", + "tensor([[-7.6791]])\n", + "tensor([[-9.2733]])\n", "------------------------\n", - "tensor([[-9.7904]])\n", - "tensor([[-9.9914]])\n", + "tensor([[-7.5714]])\n", + "tensor([[-8.1643]])\n", "------------------------\n", - "tensor([[-4.6259]])\n", - "tensor([[-8.4559]])\n", + "tensor([[-7.5360]])\n", + "tensor([[-7.9208]])\n", "------------------------\n", - "tensor([[-9.3616]])\n", - "tensor([[-8.1308]])\n", + "tensor([[-7.6014]])\n", + "tensor([[-6.8386]])\n", "------------------------\n", - "tensor([[-5.6350]])\n", - "tensor([[-10.5229]])\n", + "tensor([[-8.2055]])\n", + "tensor([[-11.2441]])\n", "------------------------\n", - "tensor([[-9.5974]])\n", - "tensor([[-4.3979]])\n", + "tensor([[-7.4799]])\n", + "tensor([[-7.8539]])\n", "------------------------\n", - "tensor([[-9.6821]])\n", - "tensor([[-8.]])\n", + "tensor([[-7.6108]])\n", + "tensor([[-5.3098]])\n", "------------------------\n", - "tensor([[-9.8341]])\n", - "tensor([[-6.5229]])\n", + "tensor([[-7.5745]])\n", + "tensor([[-5.8327]])\n", "------------------------\n", - "tensor([[-9.7883]])\n", - "tensor([[-9.3010]])\n", + "tensor([[-7.7772]])\n", + "tensor([[-9.7905]])\n", "------------------------\n", - "tensor([[-9.7929]])\n", - "tensor([[-9.7696]])\n", + "tensor([[-7.5798]])\n", + "tensor([[-7.6021]])\n", "------------------------\n", - "tensor([[-9.9101]])\n", - "tensor([[-8.3010]])\n", + "tensor([[-7.6409]])\n", + "tensor([[-6.6198]])\n", "------------------------\n", - "tensor([[-9.6830]])\n", - "tensor([[-5.8861]])\n", + "tensor([[-8.1040]])\n", + "tensor([[-11.3010]])\n", "------------------------\n", - "tensor([[-9.7833]])\n", - "tensor([[-7.4559]])\n", + "tensor([[-7.6982]])\n", + "tensor([[-8.0044]])\n", "------------------------\n", - "Epoch : 2 \t train loss: 8.802019427301056 train MSE: tensor(8.5248, grad_fn=) test MSE: 8.00419305339511\n", - "Corr: -0.28503702594340785\n", - "tensor(0.2412, grad_fn=)\n", - "tensor(0.2386, grad_fn=)\n", - "tensor(0.2361, grad_fn=)\n", - "tensor(0.2335, grad_fn=)\n", - "tensor(0.2310, grad_fn=)\n", - "tensor(0.2284, grad_fn=)\n", - "tensor(0.2258, grad_fn=)\n", - "tensor(0.2232, grad_fn=)\n", - "tensor(0.2206, grad_fn=)\n", - "tensor(0.2180, grad_fn=)\n", - "tensor(0.2153, grad_fn=)\n", - "tensor(0.2127, grad_fn=)\n", - "tensor(0.2100, grad_fn=)\n", - "tensor(0.2074, grad_fn=)\n", - "tensor(0.2047, grad_fn=)\n", - "tensor(0.2021, grad_fn=)\n", - "tensor(0.1994, grad_fn=)\n", - "tensor(0.1967, grad_fn=)\n", - "tensor(0.1941, grad_fn=)\n", - "tensor(0.1914, grad_fn=)\n", - "tensor([[-8.4220]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.4793]])\n", - "tensor([[-11.2441]])\n", + "tensor([[-7.1463]])\n", + "tensor([[-8.8539]])\n", "------------------------\n", - "tensor([[-8.5552]])\n", - "tensor([[-7.5986]])\n", + "tensor([[-7.5780]])\n", + "tensor([[-6.9586]])\n", "------------------------\n", - "tensor([[-8.6061]])\n", - "tensor([[-4.5086]])\n", + "tensor([[-8.3144]])\n", + "tensor([[-8.5376]])\n", "------------------------\n", - "tensor([[-5.0505]])\n", - "tensor([[-9.1612]])\n", + "tensor([[-8.5584]])\n", + "tensor([[-11.3979]])\n", "------------------------\n", - "tensor([[-8.5860]])\n", - "tensor([[-7.]])\n", + "tensor([[-7.6433]])\n", + "tensor([[-11.2218]])\n", "------------------------\n", - "tensor([[-8.5355]])\n", + "Epoch : 2 \t train loss: 4.063900492549722 train MSE: tensor(3.7452, grad_fn=) test MSE: 3.005913566700077\n", + "Corr: 0.4192200832400716\n", + "tensor(0.3023, grad_fn=)\n", + "tensor(0.3020, grad_fn=)\n", + "tensor(0.3017, grad_fn=)\n", + "tensor(0.3015, grad_fn=)\n", + "tensor(0.3012, grad_fn=)\n", + "tensor(0.3009, grad_fn=)\n", + "tensor(0.3006, grad_fn=)\n", + "tensor(0.3003, grad_fn=)\n", + "tensor(0.3000, grad_fn=)\n", + "tensor(0.2997, grad_fn=)\n", + "tensor(0.2993, grad_fn=)\n", + "tensor(0.2990, grad_fn=)\n", + "tensor(0.2987, grad_fn=)\n", + "tensor(0.2983, grad_fn=)\n", + "tensor(0.2980, grad_fn=)\n", + "tensor(0.2976, grad_fn=)\n", + "tensor(0.2973, grad_fn=)\n", + "tensor(0.2969, grad_fn=)\n", + "tensor(0.2965, grad_fn=)\n", + "tensor(0.2961, grad_fn=)\n", + "tensor([[-7.8673]])\n", + "tensor([[-6.4202]])\n", + "------------------------\n", + "tensor([[-7.4883]])\n", + "tensor([[-7.1427]])\n", + "------------------------\n", + "tensor([[-6.6621]])\n", + "tensor([[-8.0506]])\n", + "------------------------\n", + "tensor([[-8.4254]])\n", + "tensor([[-7.0362]])\n", + "------------------------\n", + "tensor([[-8.0198]])\n", + "tensor([[-9.2733]])\n", + "------------------------\n", + "tensor([[-7.9410]])\n", "tensor([[-8.1643]])\n", "------------------------\n", - "tensor([[-8.3120]])\n", - "tensor([[-9.0969]])\n", - "------------------------\n", - "tensor([[-8.4558]])\n", - "tensor([[-7.5229]])\n", + "tensor([[-7.9030]])\n", + "tensor([[-7.9208]])\n", "------------------------\n", - "tensor([[-8.5531]])\n", - "tensor([[-9.9914]])\n", + "tensor([[-7.9439]])\n", + "tensor([[-6.8386]])\n", "------------------------\n", - "tensor([[-4.2228]])\n", - "tensor([[-8.4559]])\n", - "------------------------\n", - "tensor([[-8.1837]])\n", - "tensor([[-8.1308]])\n", + "tensor([[-8.5555]])\n", + "tensor([[-11.2441]])\n", "------------------------\n", - "tensor([[-5.1482]])\n", - "tensor([[-10.5229]])\n", + "tensor([[-7.8450]])\n", + "tensor([[-7.8539]])\n", "------------------------\n", - "tensor([[-8.3752]])\n", - "tensor([[-4.3979]])\n", + "tensor([[-7.9835]])\n", + "tensor([[-5.3098]])\n", "------------------------\n", - "tensor([[-8.4742]])\n", - "tensor([[-8.]])\n", + "tensor([[-7.9463]])\n", + "tensor([[-5.8327]])\n", "------------------------\n", - "tensor([[-8.6111]])\n", - "tensor([[-6.5229]])\n", + "tensor([[-8.1146]])\n", + "tensor([[-9.7905]])\n", "------------------------\n", - "tensor([[-8.5466]])\n", - "tensor([[-9.3010]])\n", + "tensor([[-7.9488]])\n", + "tensor([[-7.6021]])\n", "------------------------\n", - "tensor([[-8.5643]])\n", - "tensor([[-9.7696]])\n", + "tensor([[-8.0144]])\n", + "tensor([[-6.6198]])\n", "------------------------\n", - "tensor([[-8.6712]])\n", - "tensor([[-8.3010]])\n", + "tensor([[-8.3997]])\n", + "tensor([[-11.3010]])\n", + "------------------------\n", + "tensor([[-8.0162]])\n", + "tensor([[-8.0044]])\n", + "------------------------\n", + "tensor([[-7.5342]])\n", + "tensor([[-8.8539]])\n", + "------------------------\n", + "tensor([[-7.9508]])\n", + "tensor([[-6.9586]])\n", + "------------------------\n", + "tensor([[-8.6319]])\n", + "tensor([[-8.5376]])\n", + "------------------------\n", + "tensor([[-8.8842]])\n", + "tensor([[-11.3979]])\n", + "------------------------\n", + "tensor([[-8.0007]])\n", + "tensor([[-11.2218]])\n", + "------------------------\n", + "Epoch : 3 \t train loss: 3.5162931330063767 train MSE: tensor(3.2032, grad_fn=) test MSE: 2.7490999912062595\n", + "Corr: 0.3989430432831204\n", + "tensor(0.2957, grad_fn=)\n", + "tensor(0.2953, grad_fn=)\n", + "tensor(0.2949, grad_fn=)\n", + "tensor(0.2945, grad_fn=)\n", + "tensor(0.2941, grad_fn=)\n", + "tensor(0.2936, grad_fn=)\n", + "tensor(0.2932, grad_fn=)\n", + "tensor(0.2928, grad_fn=)\n", + "tensor(0.2924, grad_fn=)\n", + "tensor(0.2920, grad_fn=)\n", + "tensor(0.2915, grad_fn=)\n", + "tensor(0.2911, grad_fn=)\n", + "tensor(0.2907, grad_fn=)\n", + "tensor(0.2903, grad_fn=)\n", + "tensor(0.2898, grad_fn=)\n", + "tensor(0.2894, grad_fn=)\n", + "tensor(0.2890, grad_fn=)\n", + "tensor(0.2886, grad_fn=)\n", + "tensor(0.2882, grad_fn=)\n", + "tensor(0.2878, grad_fn=)\n", + "tensor([[-7.6853]])\n", + "tensor([[-6.4202]])\n", + "------------------------\n", + "tensor([[-7.3802]])\n", + "tensor([[-7.1427]])\n", + "------------------------\n", + "tensor([[-6.5442]])\n", + "tensor([[-8.0506]])\n", + "------------------------\n", + "tensor([[-8.1895]])\n", + "tensor([[-7.0362]])\n", + "------------------------\n", + "tensor([[-7.8303]])\n", + "tensor([[-9.2733]])\n", + "------------------------\n", + "tensor([[-7.7593]])\n", + "tensor([[-8.1643]])\n", "------------------------\n", - "tensor([[-8.4657]])\n", - "tensor([[-5.8861]])\n", + "tensor([[-7.7206]])\n", + "tensor([[-7.9208]])\n", "------------------------\n", - "tensor([[-8.5313]])\n", - "tensor([[-7.4559]])\n", + "tensor([[-7.7400]])\n", + "tensor([[-6.8386]])\n", "------------------------\n", - "Epoch : 3 \t train loss: 4.6634391299274185 train MSE: tensor(4.4374, grad_fn=) test MSE: 6.019533056776881\n", - "Corr: -0.2805877847685438\n", - "tensor(0.1888, grad_fn=)\n", - "tensor(0.1861, grad_fn=)\n", - "tensor(0.1834, grad_fn=)\n", - "tensor(0.1808, grad_fn=)\n", - "tensor(0.1781, grad_fn=)\n", - "tensor(0.1755, grad_fn=)\n", - "tensor(0.1729, grad_fn=)\n", - "tensor(0.1702, grad_fn=)\n", - "tensor(0.1676, grad_fn=)\n", - "tensor(0.1650, grad_fn=)\n", - "tensor(0.1624, grad_fn=)\n", - "tensor(0.1598, grad_fn=)\n", - "tensor(0.1573, grad_fn=)\n", - "tensor(0.1547, grad_fn=)\n", - "tensor(0.1522, grad_fn=)\n", - "tensor(0.1496, grad_fn=)\n", - "tensor(0.1471, grad_fn=)\n", - "tensor(0.1445, grad_fn=)\n", - "tensor(0.1420, grad_fn=)\n", - "tensor(0.1395, grad_fn=)\n", - "tensor([[-8.0321]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.1097]])\n", + "tensor([[-8.3380]])\n", "tensor([[-11.2441]])\n", "------------------------\n", - "tensor([[-8.1802]])\n", - "tensor([[-7.5986]])\n", - "------------------------\n", - "tensor([[-8.1900]])\n", - "tensor([[-4.5086]])\n", - "------------------------\n", - "tensor([[-4.9914]])\n", - "tensor([[-9.1612]])\n", - "------------------------\n", - "tensor([[-8.2111]])\n", - "tensor([[-7.]])\n", - "------------------------\n", - "tensor([[-8.1442]])\n", - "tensor([[-8.1643]])\n", - "------------------------\n", - "tensor([[-7.9484]])\n", - "tensor([[-9.0969]])\n", - "------------------------\n", - "tensor([[-8.0828]])\n", - "tensor([[-7.5229]])\n", + "tensor([[-7.6703]])\n", + "tensor([[-7.8539]])\n", "------------------------\n", - "tensor([[-8.1615]])\n", - "tensor([[-9.9914]])\n", + "tensor([[-7.7985]])\n", + "tensor([[-5.3098]])\n", "------------------------\n", - "tensor([[-4.1888]])\n", - "tensor([[-8.4559]])\n", + "tensor([[-7.7649]])\n", + "tensor([[-5.8327]])\n", "------------------------\n", - "tensor([[-7.8255]])\n", - "tensor([[-8.1308]])\n", + "tensor([[-7.9095]])\n", + "tensor([[-9.7905]])\n", "------------------------\n", - "tensor([[-5.1056]])\n", - "tensor([[-10.5229]])\n", + "tensor([[-7.7636]])\n", + "tensor([[-7.6021]])\n", "------------------------\n", - "tensor([[-8.0064]])\n", - "tensor([[-4.3979]])\n", + "tensor([[-7.8252]])\n", + "tensor([[-6.6198]])\n", "------------------------\n", - "tensor([[-8.1101]])\n", - "tensor([[-8.]])\n", + "tensor([[-8.1109]])\n", + "tensor([[-11.3010]])\n", "------------------------\n", - "tensor([[-8.2358]])\n", - "tensor([[-6.5229]])\n", + "tensor([[-7.8027]])\n", + "tensor([[-8.0044]])\n", "------------------------\n", - "tensor([[-8.1804]])\n", - "tensor([[-9.3010]])\n", + "tensor([[-7.4291]])\n", + "tensor([[-8.8539]])\n", "------------------------\n", - "tensor([[-8.1921]])\n", - "tensor([[-9.7696]])\n", + "tensor([[-7.7673]])\n", + "tensor([[-6.9586]])\n", "------------------------\n", - "tensor([[-8.2931]])\n", - "tensor([[-8.3010]])\n", + "tensor([[-8.3521]])\n", + "tensor([[-8.5376]])\n", "------------------------\n", - "tensor([[-8.1178]])\n", - "tensor([[-5.8861]])\n", + "tensor([[-8.6037]])\n", + "tensor([[-11.3979]])\n", "------------------------\n", - "tensor([[-8.1334]])\n", - "tensor([[-7.4559]])\n", + "tensor([[-7.8287]])\n", + "tensor([[-11.2218]])\n", "------------------------\n", - "Epoch : 4 \t train loss: 3.8272774651233368 train MSE: tensor(3.6562, grad_fn=) test MSE: 5.807627022980126\n", - "Corr: -0.27736647097150124\n", - "tensor(0.1371, grad_fn=)\n", - "tensor(0.1346, grad_fn=)\n", - "tensor(0.1321, grad_fn=)\n", - "tensor(0.1297, grad_fn=)\n", - "tensor(0.1273, grad_fn=)\n", - "tensor(0.1249, grad_fn=)\n", - "tensor(0.1225, grad_fn=)\n", - "tensor(0.1202, grad_fn=)\n", - "tensor(0.1178, grad_fn=)\n" + "Epoch : 4 \t train loss: 3.267506549560946 train MSE: tensor(2.9624, grad_fn=) test MSE: 2.910722479732199\n", + "Corr: 0.39367960791626916\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "tensor(0.1155, grad_fn=)\n", - "tensor(0.1133, grad_fn=)\n", - "tensor(0.1110, grad_fn=)\n", - "tensor(0.1088, grad_fn=)\n", - "tensor(0.1065, grad_fn=)\n", - "tensor(0.1043, grad_fn=)\n", - "tensor(0.1022, grad_fn=)\n", - "tensor(0.1000, grad_fn=)\n", - "tensor(0.0979, grad_fn=)\n", - "tensor(0.0958, grad_fn=)\n", - "tensor(0.0937, grad_fn=)\n", - "tensor([[-8.0988]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.2007]])\n", - "tensor([[-11.2441]])\n", + "tensor(0.2874, grad_fn=)\n", + "tensor(0.2869, grad_fn=)\n", + "tensor(0.2865, grad_fn=)\n", + "tensor(0.2861, grad_fn=)\n", + "tensor(0.2857, grad_fn=)\n", + "tensor(0.2853, grad_fn=)\n", + "tensor(0.2849, grad_fn=)\n", + "tensor(0.2845, grad_fn=)\n", + "tensor(0.2840, grad_fn=)\n", + "tensor(0.2836, grad_fn=)\n", + "tensor(0.2832, grad_fn=)\n", + "tensor(0.2828, grad_fn=)\n", + "tensor(0.2824, grad_fn=)\n", + "tensor(0.2820, grad_fn=)\n", + "tensor(0.2816, grad_fn=)\n", + "tensor(0.2812, grad_fn=)\n", + "tensor(0.2808, grad_fn=)\n", + "tensor(0.2804, grad_fn=)\n", + "tensor(0.2799, grad_fn=)\n", + "tensor(0.2795, grad_fn=)\n", + "tensor([[-7.8288]])\n", + "tensor([[-6.4202]])\n", "------------------------\n", - "tensor([[-8.2676]])\n", - "tensor([[-7.5986]])\n", + "tensor([[-7.5942]])\n", + "tensor([[-7.1427]])\n", "------------------------\n", - "tensor([[-8.2392]])\n", - "tensor([[-4.5086]])\n", + "tensor([[-6.7088]])\n", + "tensor([[-8.0506]])\n", "------------------------\n", - "tensor([[-5.1921]])\n", - "tensor([[-9.1612]])\n", + "tensor([[-8.2854]])\n", + "tensor([[-7.0362]])\n", "------------------------\n", - "tensor([[-8.3059]])\n", - "tensor([[-7.]])\n", + "tensor([[-7.9588]])\n", + "tensor([[-9.2733]])\n", "------------------------\n", - "tensor([[-8.2151]])\n", + "tensor([[-7.9050]])\n", "tensor([[-8.1643]])\n", "------------------------\n", - "tensor([[-8.0584]])\n", - "tensor([[-9.0969]])\n", + "tensor([[-7.8641]])\n", + "tensor([[-7.9208]])\n", "------------------------\n", - "tensor([[-8.1728]])\n", - "tensor([[-7.5229]])\n", + "tensor([[-7.8561]])\n", + "tensor([[-6.8386]])\n", "------------------------\n", - "tensor([[-8.2415]])\n", - "tensor([[-9.9914]])\n", + "tensor([[-8.4577]])\n", + "tensor([[-11.2441]])\n", "------------------------\n", - "tensor([[-4.3760]])\n", - "tensor([[-8.4559]])\n", + "tensor([[-7.8193]])\n", + "tensor([[-7.8539]])\n", "------------------------\n", - "tensor([[-7.9164]])\n", - "tensor([[-8.1308]])\n", + "tensor([[-7.9435]])\n", + "tensor([[-5.3098]])\n", "------------------------\n", - "tensor([[-5.3326]])\n", - "tensor([[-10.5229]])\n", + "tensor([[-7.9118]])\n", + "tensor([[-5.8327]])\n", "------------------------\n", - "tensor([[-8.1128]])\n", - "tensor([[-4.3979]])\n", + "tensor([[-8.0271]])\n", + "tensor([[-9.7905]])\n", + "------------------------\n", + "tensor([[-7.9061]])\n", + "tensor([[-7.6021]])\n", + "------------------------\n", + "tensor([[-7.9672]])\n", + "tensor([[-6.6198]])\n", + "------------------------\n", + "tensor([[-8.1483]])\n", + "tensor([[-11.3010]])\n", + "------------------------\n", + "tensor([[-7.9034]])\n", + "tensor([[-8.0044]])\n", + "------------------------\n", + "tensor([[-7.6494]])\n", + "tensor([[-8.8539]])\n", + "------------------------\n", + "tensor([[-7.9141]])\n", + "tensor([[-6.9586]])\n", + "------------------------\n", + "tensor([[-8.4111]])\n", + "tensor([[-8.5376]])\n", + "------------------------\n", + "tensor([[-8.6671]])\n", + "tensor([[-11.3979]])\n", + "------------------------\n", + "tensor([[-7.9778]])\n", + "tensor([[-11.2218]])\n", + "------------------------\n", + "Epoch : 5 \t train loss: 3.383640763027216 train MSE: tensor(3.0872, grad_fn=) test MSE: 2.8515680568631403\n", + "Corr: 0.37838124333012857\n", + "tensor(0.2791, grad_fn=)\n", + "tensor(0.2787, grad_fn=)\n", + "tensor(0.2783, grad_fn=)\n", + "tensor(0.2779, grad_fn=)\n", + "tensor(0.2775, grad_fn=)\n", + "tensor(0.2771, grad_fn=)\n", + "tensor(0.2767, grad_fn=)\n", + "tensor(0.2763, grad_fn=)\n", + "tensor(0.2759, grad_fn=)\n", + "tensor(0.2754, grad_fn=)\n", + "tensor(0.2750, grad_fn=)\n", + "tensor(0.2746, grad_fn=)\n", + "tensor(0.2742, grad_fn=)\n", + "tensor(0.2737, grad_fn=)\n", + "tensor(0.2733, grad_fn=)\n", + "tensor(0.2728, grad_fn=)\n", + "tensor(0.2724, grad_fn=)\n", + "tensor(0.2720, grad_fn=)\n", + "tensor(0.2715, grad_fn=)\n", + "tensor(0.2711, grad_fn=)\n", + "tensor([[-7.7810]])\n", + "tensor([[-6.4202]])\n", "------------------------\n", - "tensor([[-8.2065]])\n", - "tensor([[-8.]])\n", + "tensor([[-7.6367]])\n", + "tensor([[-7.1427]])\n", "------------------------\n", - "tensor([[-8.3255]])\n", - "tensor([[-6.5229]])\n", + "tensor([[-6.8190]])\n", + "tensor([[-8.0506]])\n", "------------------------\n", - "tensor([[-8.2912]])\n", - "tensor([[-9.3010]])\n", + "tensor([[-8.2377]])\n", + "tensor([[-7.0362]])\n", "------------------------\n", - "tensor([[-8.2879]])\n", - "tensor([[-9.7696]])\n", + "tensor([[-7.9399]])\n", + "tensor([[-9.2733]])\n", "------------------------\n", - "tensor([[-8.3852]])\n", - "tensor([[-8.3010]])\n", + "tensor([[-7.8584]])\n", + "tensor([[-8.1643]])\n", "------------------------\n", - "tensor([[-8.2513]])\n", - "tensor([[-5.8861]])\n", + "tensor([[-7.8161]])\n", + "tensor([[-7.9208]])\n", "------------------------\n", - "tensor([[-8.2082]])\n", - "tensor([[-7.4559]])\n", + "tensor([[-7.8125]])\n", + "tensor([[-6.8386]])\n", "------------------------\n", - "Epoch : 5 \t train loss: 3.755276715774909 train MSE: tensor(3.6355, grad_fn=) test MSE: 5.581089227881638\n", - "Corr: -0.2752061206562508\n", - "tensor(0.0916, grad_fn=)\n", - "tensor(0.0896, grad_fn=)\n", - "tensor(0.0876, grad_fn=)\n", - "tensor(0.0856, grad_fn=)\n", - "tensor(0.0836, grad_fn=)\n", - "tensor(0.0817, grad_fn=)\n", - "tensor(0.0798, grad_fn=)\n", - "tensor(0.0780, grad_fn=)\n", - "tensor(0.0762, grad_fn=)\n", - "tensor(0.0744, grad_fn=)\n", - "tensor(0.0726, grad_fn=)\n", - "tensor(0.0709, grad_fn=)\n", - "tensor(0.0692, grad_fn=)\n", - "tensor(0.0676, grad_fn=)\n", - "tensor(0.0660, grad_fn=)\n", - "tensor(0.0644, grad_fn=)\n", - "tensor(0.0629, grad_fn=)\n", - "tensor(0.0614, grad_fn=)\n", - "tensor(0.0600, grad_fn=)\n", - "tensor(0.0586, grad_fn=)\n", - "tensor([[-8.1029]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.2502]])\n", + "tensor([[-8.4272]])\n", "tensor([[-11.2441]])\n", "------------------------\n", - "tensor([[-8.3122]])\n", - "tensor([[-7.5986]])\n", + "tensor([[-7.7839]])\n", + "tensor([[-7.8539]])\n", "------------------------\n", - "tensor([[-8.2293]])\n", - "tensor([[-4.5086]])\n", + "tensor([[-7.8922]])\n", + "tensor([[-5.3098]])\n", "------------------------\n", - "tensor([[-5.4067]])\n", - "tensor([[-9.1612]])\n", + "tensor([[-7.8645]])\n", + "tensor([[-5.8327]])\n", "------------------------\n", - "tensor([[-8.3589]])\n", - "tensor([[-7.]])\n", + "tensor([[-8.0012]])\n", + "tensor([[-9.7905]])\n", "------------------------\n", - "tensor([[-8.2301]])\n", - "tensor([[-8.1643]])\n", + "tensor([[-7.8540]])\n", + "tensor([[-7.6021]])\n", "------------------------\n", - "tensor([[-8.1175]])\n", - "tensor([[-9.0969]])\n", + "tensor([[-7.9099]])\n", + "tensor([[-6.6198]])\n", "------------------------\n", - "tensor([[-8.2081]])\n", - "tensor([[-7.5229]])\n", + "tensor([[-8.0746]])\n", + "tensor([[-11.3010]])\n", "------------------------\n", - "tensor([[-8.2632]])\n", - "tensor([[-9.9914]])\n", + "tensor([[-7.8790]])\n", + "tensor([[-8.0044]])\n", "------------------------\n", - "tensor([[-4.5821]])\n", - "tensor([[-8.4559]])\n", + "tensor([[-7.7003]])\n", + "tensor([[-8.8539]])\n", "------------------------\n", - "tensor([[-7.9613]])\n", - "tensor([[-8.1308]])\n", + "tensor([[-7.8662]])\n", + "tensor([[-6.9586]])\n", "------------------------\n", - "tensor([[-5.5796]])\n", - "tensor([[-10.5229]])\n", + "tensor([[-8.3398]])\n", + "tensor([[-8.5376]])\n", "------------------------\n", - "tensor([[-8.1685]])\n", - "tensor([[-4.3979]])\n", + "tensor([[-8.5929]])\n", + "tensor([[-11.3979]])\n", "------------------------\n", - "tensor([[-8.2638]])\n", - "tensor([[-8.]])\n", + "tensor([[-7.9630]])\n", + "tensor([[-11.2218]])\n", "------------------------\n", - "tensor([[-8.3673]])\n", - "tensor([[-6.5229]])\n", + "Epoch : 6 \t train loss: 3.0858860763848996 train MSE: tensor(2.7981, grad_fn=) test MSE: 2.8481888964306563\n", + "Corr: 0.415702465489691\n", + "tensor(0.2706, grad_fn=)\n", + "tensor(0.2701, grad_fn=)\n", + "tensor(0.2697, grad_fn=)\n", + "tensor(0.2693, grad_fn=)\n", + "tensor(0.2689, grad_fn=)\n", + "tensor(0.2685, grad_fn=)\n", + "tensor(0.2680, grad_fn=)\n", + "tensor(0.2676, grad_fn=)\n", + "tensor(0.2672, grad_fn=)\n", + "tensor(0.2668, grad_fn=)\n", + "tensor(0.2664, grad_fn=)\n", + "tensor(0.2659, grad_fn=)\n", + "tensor(0.2655, grad_fn=)\n", + "tensor(0.2651, grad_fn=)\n", + "tensor(0.2647, grad_fn=)\n", + "tensor(0.2643, grad_fn=)\n", + "tensor(0.2640, grad_fn=)\n", + "tensor(0.2636, grad_fn=)\n", + "tensor(0.2632, grad_fn=)\n", + "tensor(0.2629, grad_fn=)\n", + "tensor([[-7.7430]])\n", + "tensor([[-6.4202]])\n", + "------------------------\n", + "tensor([[-7.6999]])\n", + "tensor([[-7.1427]])\n", + "------------------------\n", + "tensor([[-6.8985]])\n", + "tensor([[-8.0506]])\n", + "------------------------\n", + "tensor([[-8.1940]])\n", + "tensor([[-7.0362]])\n", + "------------------------\n", + "tensor([[-7.9293]])\n", + "tensor([[-9.2733]])\n", + "------------------------\n", + "tensor([[-7.8233]])\n", + "tensor([[-8.1643]])\n", "------------------------\n", - "tensor([[-8.3621]])\n", - "tensor([[-9.3010]])\n", + "tensor([[-7.7792]])\n", + "tensor([[-7.9208]])\n", "------------------------\n", - "tensor([[-8.3414]])\n", - "tensor([[-9.7696]])\n", + "tensor([[-7.7684]])\n", + "tensor([[-6.8386]])\n", "------------------------\n", - "tensor([[-8.4365]])\n", - "tensor([[-8.3010]])\n", + "tensor([[-8.4048]])\n", + "tensor([[-11.2441]])\n", "------------------------\n", - "tensor([[-8.3422]])\n", - "tensor([[-5.8861]])\n", + "tensor([[-7.7602]])\n", + "tensor([[-7.8539]])\n", "------------------------\n", - "tensor([[-8.2303]])\n", - "tensor([[-7.4559]])\n", + "tensor([[-7.8520]])\n", + "tensor([[-5.3098]])\n", "------------------------\n", - "Epoch : 6 \t train loss: 3.4899348808151665 train MSE: tensor(3.4126, grad_fn=) test MSE: 5.3259367716188235\n", - "Corr: -0.27117635033887316\n", - "tensor(0.0572, grad_fn=)\n", - "tensor(0.0559, grad_fn=)\n", - "tensor(0.0546, grad_fn=)\n", - "tensor(0.0533, grad_fn=)\n", - "tensor(0.0521, grad_fn=)\n", - "tensor(0.0509, grad_fn=)\n", - "tensor(0.0497, grad_fn=)\n", - "tensor(0.0486, grad_fn=)\n", - "tensor(0.0476, grad_fn=)\n", - "tensor(0.0466, grad_fn=)\n", - "tensor(0.0457, grad_fn=)\n", - "tensor(0.0449, grad_fn=)\n", - "tensor(0.0440, grad_fn=)\n", - "tensor(0.0432, grad_fn=)\n", - "tensor(0.0425, grad_fn=)\n", - "tensor(0.0418, grad_fn=)\n", - "tensor(0.0411, grad_fn=)\n", - "tensor(0.0405, grad_fn=)\n", - "tensor(0.0400, grad_fn=)\n", - "tensor(0.0395, grad_fn=)\n", - "tensor([[-8.1033]])\n", - "tensor([[-9.3010]])\n", + "tensor([[-7.8285]])\n", + "tensor([[-5.8327]])\n", "------------------------\n", - "tensor([[-8.2834]])\n", - "tensor([[-11.2441]])\n", + "tensor([[-7.9804]])\n", + "tensor([[-9.7905]])\n", "------------------------\n", - "tensor([[-8.3469]])\n", - "tensor([[-7.5986]])\n", + "tensor([[-7.8127]])\n", + "tensor([[-7.6021]])\n", "------------------------\n", - "tensor([[-8.2055]])\n", - "tensor([[-4.5086]])\n", + "tensor([[-7.8638]])\n", + "tensor([[-6.6198]])\n", + "------------------------\n", + "tensor([[-7.9826]])\n", + "tensor([[-11.3010]])\n", + "------------------------\n", + "tensor([[-7.8534]])\n", + "tensor([[-8.0044]])\n", + "------------------------\n", + "tensor([[-7.7726]])\n", + "tensor([[-8.8539]])\n", + "------------------------\n", + "tensor([[-7.8297]])\n", + "tensor([[-6.9586]])\n", + "------------------------\n", + "tensor([[-8.2614]])\n", + "tensor([[-8.5376]])\n", + "------------------------\n", + "tensor([[-8.5175]])\n", + "tensor([[-11.3979]])\n", + "------------------------\n", + "tensor([[-7.9631]])\n", + "tensor([[-11.2218]])\n", + "------------------------\n", + "Epoch : 7 \t train loss: 2.9339484607472137 train MSE: tensor(2.6551, grad_fn=) test MSE: 2.85795119273561\n", + "Corr: 0.44446065558878745\n", + "tensor(0.2625, grad_fn=)\n", + "tensor(0.2621, grad_fn=)\n", + "tensor(0.2618, grad_fn=)\n", + "tensor(0.2614, grad_fn=)\n", + "tensor(0.2611, grad_fn=)\n", + "tensor(0.2607, grad_fn=)\n", + "tensor(0.2604, grad_fn=)\n", + "tensor(0.2600, grad_fn=)\n", + "tensor(0.2596, grad_fn=)\n", + "tensor(0.2592, grad_fn=)\n", + "tensor(0.2589, grad_fn=)\n", + "tensor(0.2585, grad_fn=)\n", + "tensor(0.2582, grad_fn=)\n", + "tensor(0.2578, grad_fn=)\n", + "tensor(0.2575, grad_fn=)\n", + "tensor(0.2571, grad_fn=)\n", + "tensor(0.2567, grad_fn=)\n", + "tensor(0.2564, grad_fn=)\n", + "tensor(0.2560, grad_fn=)\n", + "tensor(0.2557, grad_fn=)\n", + "tensor([[-7.8047]])\n", + "tensor([[-6.4202]])\n", "------------------------\n", - "tensor([[-5.6117]])\n", - "tensor([[-9.1612]])\n", + "tensor([[-7.8655]])\n", + "tensor([[-7.1427]])\n", "------------------------\n", - "tensor([[-8.3784]])\n", - "tensor([[-7.]])\n", + "tensor([[-7.1500]])\n", + "tensor([[-8.0506]])\n", "------------------------\n", - "tensor([[-8.2446]])\n", - "tensor([[-8.1643]])\n", + "tensor([[-8.3081]])\n", + "tensor([[-7.0362]])\n", "------------------------\n", + "tensor([[-8.0539]])\n", + "tensor([[-9.2733]])\n", + "------------------------\n", + "tensor([[-7.8895]])\n", "tensor([[-8.1643]])\n", - "tensor([[-9.0969]])\n", "------------------------\n", - "tensor([[-8.2381]])\n", - "tensor([[-7.5229]])\n", + "tensor([[-7.8439]])\n", + "tensor([[-7.9208]])\n", "------------------------\n", - "tensor([[-8.2822]])\n", - "tensor([[-9.9914]])\n", + "tensor([[-7.8552]])\n", + "tensor([[-6.8386]])\n", "------------------------\n", - "tensor([[-4.7727]])\n", - "tensor([[-8.4559]])\n", + "tensor([[-8.5333]])\n", + "tensor([[-11.2441]])\n", "------------------------\n", - "tensor([[-7.9897]])\n", - "tensor([[-8.1308]])\n", + "tensor([[-7.8406]])\n", + "tensor([[-7.8539]])\n", "------------------------\n", - "tensor([[-5.8052]])\n", - "tensor([[-10.5229]])\n", + "tensor([[-7.9112]])\n", + "tensor([[-5.3098]])\n", "------------------------\n", - "tensor([[-8.2088]])\n", - "tensor([[-4.3979]])\n", + "tensor([[-7.8912]])\n", + "tensor([[-5.8327]])\n", "------------------------\n", - "tensor([[-8.3097]])\n", - "tensor([[-8.]])\n", + "tensor([[-8.1045]])\n", + "tensor([[-9.7905]])\n", "------------------------\n", - "tensor([[-8.4022]])\n", - "tensor([[-6.5229]])\n", + "tensor([[-7.8714]])\n", + "tensor([[-7.6021]])\n", "------------------------\n", - "tensor([[-8.4221]])\n", - "tensor([[-9.3010]])\n", + "tensor([[-7.9182]])\n", + "tensor([[-6.6198]])\n", "------------------------\n", - "tensor([[-8.3842]])\n", - "tensor([[-9.7696]])\n", + "tensor([[-8.0871]])\n", + "tensor([[-11.3010]])\n", "------------------------\n", - "tensor([[-8.4704]])\n", - "tensor([[-8.3010]])\n", + "tensor([[-7.9860]])\n", + "tensor([[-8.0044]])\n", "------------------------\n", - "tensor([[-8.4124]])\n", - "tensor([[-5.8861]])\n", + "tensor([[-7.9511]])\n", + "tensor([[-8.8539]])\n", "------------------------\n", - "tensor([[-8.2376]])\n", - "tensor([[-7.4559]])\n", + "tensor([[-7.8945]])\n", + "tensor([[-6.9586]])\n", "------------------------\n", - "Epoch : 7 \t train loss: 3.1936464978664585 train MSE: tensor(3.1446, grad_fn=) test MSE: 5.0924787855086215\n", - "Corr: -0.2650622509105653\n", - "tensor(0.0390, grad_fn=)\n", - "tensor(0.0385, grad_fn=)\n", - "tensor(0.0381, grad_fn=)\n", - "tensor(0.0378, grad_fn=)\n", - "tensor(0.0376, grad_fn=)\n", - "tensor(0.0374, grad_fn=)\n", - "tensor(0.0372, grad_fn=)\n", - "tensor(0.0372, grad_fn=)\n", - "tensor(0.0372, grad_fn=)\n", - "tensor(0.0372, grad_fn=)\n", - "tensor(0.0372, grad_fn=)\n", - "tensor(0.0372, grad_fn=)\n", - "tensor(0.0372, grad_fn=)\n", - "tensor(0.0371, grad_fn=)\n", - "tensor(0.0370, grad_fn=)\n", - "tensor(0.0369, grad_fn=)\n", - "tensor(0.0368, grad_fn=)\n", - "tensor(0.0367, grad_fn=)\n", - "tensor(0.0366, grad_fn=)\n", - "tensor(0.0365, grad_fn=)\n", - "tensor([[-8.0049]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.2151]])\n", - "tensor([[-11.2441]])\n", + "tensor([[-8.3640]])\n", + "tensor([[-8.5376]])\n", "------------------------\n", - "tensor([[-8.2759]])\n", - "tensor([[-7.5986]])\n", + "tensor([[-8.6222]])\n", + "tensor([[-11.3979]])\n", "------------------------\n", - "tensor([[-8.0787]])\n", - "tensor([[-4.5086]])\n", + "tensor([[-8.0830]])\n", + "tensor([[-11.2218]])\n", "------------------------\n", - "tensor([[-5.7718]])\n", - "tensor([[-9.1612]])\n", + "Epoch : 8 \t train loss: 2.8922950520234942 train MSE: tensor(2.6214, grad_fn=) test MSE: 2.7287377295579063\n", + "Corr: 0.5220280210954513\n", + "tensor(0.2553, grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor(0.2550, grad_fn=)\n", + "tensor(0.2547, grad_fn=)\n", + "tensor(0.2543, grad_fn=)\n", + "tensor(0.2540, grad_fn=)\n", + "tensor(0.2537, grad_fn=)\n", + "tensor(0.2534, grad_fn=)\n", + "tensor(0.2530, grad_fn=)\n", + "tensor(0.2527, grad_fn=)\n", + "tensor(0.2523, grad_fn=)\n", + "tensor(0.2520, grad_fn=)\n", + "tensor(0.2516, grad_fn=)\n", + "tensor(0.2513, grad_fn=)\n", + "tensor(0.2510, grad_fn=)\n", + "tensor(0.2507, grad_fn=)\n", + "tensor(0.2504, grad_fn=)\n", + "tensor(0.2501, grad_fn=)\n", + "tensor(0.2498, grad_fn=)\n", + "tensor(0.2495, grad_fn=)\n", + "tensor(0.2493, grad_fn=)\n", + "tensor([[-7.6888]])\n", + "tensor([[-6.4202]])\n", "------------------------\n", - "tensor([[-8.3049]])\n", - "tensor([[-7.]])\n", + "tensor([[-7.8704]])\n", + "tensor([[-7.1427]])\n", "------------------------\n", - "tensor([[-8.1522]])\n", - "tensor([[-8.1643]])\n", + "tensor([[-7.2928]])\n", + "tensor([[-8.0506]])\n", "------------------------\n", - "tensor([[-8.1023]])\n", - "tensor([[-9.0969]])\n", + "tensor([[-8.2588]])\n", + "tensor([[-7.0362]])\n", "------------------------\n", - "tensor([[-8.1685]])\n", - "tensor([[-7.5229]])\n", + "tensor([[-8.0191]])\n", + "tensor([[-9.2733]])\n", "------------------------\n", - "tensor([[-8.1965]])\n", - "tensor([[-9.9914]])\n", + "tensor([[-7.7755]])\n", + "tensor([[-8.1643]])\n", "------------------------\n", - "tensor([[-4.9218]])\n", - "tensor([[-8.4559]])\n", + "tensor([[-7.7300]])\n", + "tensor([[-7.9208]])\n", "------------------------\n", - "tensor([[-7.9109]])\n", - "tensor([[-8.1308]])\n", + "tensor([[-7.7779]])\n", + "tensor([[-6.8386]])\n", "------------------------\n", - "tensor([[-5.9838]])\n", - "tensor([[-10.5229]])\n", + "tensor([[-8.4963]])\n", + "tensor([[-11.2441]])\n", "------------------------\n", - "tensor([[-8.1386]])\n", - "tensor([[-4.3979]])\n", + "tensor([[-7.7468]])\n", + "tensor([[-7.8539]])\n", "------------------------\n", - "tensor([[-8.2410]])\n", - "tensor([[-8.]])\n", + "tensor([[-7.7888]])\n", + "tensor([[-5.3098]])\n", "------------------------\n", - "tensor([[-8.3342]])\n", - "tensor([[-6.5229]])\n", + "tensor([[-7.7737]])\n", + "tensor([[-5.8327]])\n", "------------------------\n", - "tensor([[-8.3597]])\n", - "tensor([[-9.3010]])\n", + "tensor([[-8.0681]])\n", + "tensor([[-9.7905]])\n", "------------------------\n", - "tensor([[-8.3094]])\n", - "tensor([[-9.7696]])\n", + "tensor([[-7.7502]])\n", + "tensor([[-7.6021]])\n", "------------------------\n", - "tensor([[-8.4002]])\n", - "tensor([[-8.3010]])\n", + "tensor([[-7.7886]])\n", + "tensor([[-6.6198]])\n", "------------------------\n", - "tensor([[-8.3789]])\n", - "tensor([[-5.8861]])\n", + "tensor([[-8.0414]])\n", + "tensor([[-11.3010]])\n", "------------------------\n", - "tensor([[-8.1386]])\n", - "tensor([[-7.4559]])\n", + "tensor([[-7.9720]])\n", + "tensor([[-8.0044]])\n", "------------------------\n", - "Epoch : 8 \t train loss: 2.988298518817149 train MSE: tensor(2.9493, grad_fn=) test MSE: 4.859950399649929\n", - "Corr: -0.2582560999784615\n", - "tensor(0.0364, grad_fn=)\n", - "tensor(0.0364, grad_fn=)\n", - "tensor(0.0363, grad_fn=)\n", - "tensor(0.0364, grad_fn=)\n", - "tensor(0.0364, grad_fn=)\n", - "tensor(0.0364, grad_fn=)\n", - "tensor(0.0364, grad_fn=)\n", - "tensor(0.0364, grad_fn=)\n", - "tensor(0.0364, grad_fn=)\n", - "tensor(0.0364, grad_fn=)\n", - "tensor(0.0364, grad_fn=)\n", - "tensor(0.0364, grad_fn=)\n", - "tensor(0.0364, grad_fn=)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "tensor(0.0364, grad_fn=)\n", - "tensor(0.0364, grad_fn=)\n", - "tensor(0.0365, grad_fn=)\n", - "tensor(0.0365, grad_fn=)\n", - "tensor(0.0366, grad_fn=)\n", - "tensor(0.0366, grad_fn=)\n", - "tensor(0.0366, grad_fn=)\n", - "tensor([[-7.9635]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.2145]])\n", - "tensor([[-11.2441]])\n", + "tensor([[-7.9699]])\n", + "tensor([[-8.8539]])\n", "------------------------\n", - "tensor([[-8.2710]])\n", - "tensor([[-7.5986]])\n", + "tensor([[-7.7778]])\n", + "tensor([[-6.9586]])\n", "------------------------\n", - "tensor([[-8.0088]])\n", - "tensor([[-4.5086]])\n", + "tensor([[-8.2955]])\n", + "tensor([[-8.5376]])\n", "------------------------\n", - "tensor([[-5.9807]])\n", - "tensor([[-9.1612]])\n", + "tensor([[-8.5590]])\n", + "tensor([[-11.3979]])\n", "------------------------\n", - "tensor([[-8.2909]])\n", - "tensor([[-7.]])\n", + "tensor([[-8.0393]])\n", + "tensor([[-11.2218]])\n", "------------------------\n", - "tensor([[-8.1200]])\n", + "Epoch : 9 \t train loss: 2.8712944703943584 train MSE: tensor(2.6076, grad_fn=) test MSE: 2.682112666397271\n", + "Corr: 0.6170681933698573\n", + "tensor(0.2489, grad_fn=)\n", + "tensor(0.2486, grad_fn=)\n", + "tensor(0.2483, grad_fn=)\n", + "tensor(0.2480, grad_fn=)\n", + "tensor(0.2477, grad_fn=)\n", + "tensor(0.2475, grad_fn=)\n", + "tensor(0.2472, grad_fn=)\n", + "tensor(0.2469, grad_fn=)\n", + "tensor(0.2467, grad_fn=)\n", + "tensor(0.2465, grad_fn=)\n", + "tensor(0.2462, grad_fn=)\n", + "tensor(0.2460, grad_fn=)\n", + "tensor(0.2458, grad_fn=)\n", + "tensor(0.2456, grad_fn=)\n", + "tensor(0.2455, grad_fn=)\n", + "tensor(0.2453, grad_fn=)\n", + "tensor(0.2451, grad_fn=)\n", + "tensor(0.2449, grad_fn=)\n", + "tensor(0.2446, grad_fn=)\n", + "tensor(0.2444, grad_fn=)\n", + "tensor([[-7.7860]])\n", + "tensor([[-6.4202]])\n", + "------------------------\n", + "tensor([[-8.0773]])\n", + "tensor([[-7.1427]])\n", + "------------------------\n", + "tensor([[-7.5458]])\n", + "tensor([[-8.0506]])\n", + "------------------------\n", + "tensor([[-8.3955]])\n", + "tensor([[-7.0362]])\n", + "------------------------\n", + "tensor([[-8.1697]])\n", + "tensor([[-9.2733]])\n", + "------------------------\n", + "tensor([[-7.8781]])\n", "tensor([[-8.1643]])\n", "------------------------\n", - "tensor([[-8.1047]])\n", - "tensor([[-9.0969]])\n", + "tensor([[-7.8293]])\n", + "tensor([[-7.9208]])\n", + "------------------------\n", + "tensor([[-7.8940]])\n", + "tensor([[-6.8386]])\n", "------------------------\n", - "tensor([[-8.1612]])\n", - "tensor([[-7.5229]])\n", + "tensor([[-8.6527]])\n", + "tensor([[-11.2441]])\n", "------------------------\n", - "tensor([[-8.1741]])\n", - "tensor([[-9.9914]])\n", + "tensor([[-7.8602]])\n", + "tensor([[-7.8539]])\n", + "------------------------\n", + "tensor([[-7.8851]])\n", + "tensor([[-5.3098]])\n", + "------------------------\n", + "tensor([[-7.8735]])\n", + "tensor([[-5.8327]])\n", + "------------------------\n", + "tensor([[-8.2169]])\n", + "tensor([[-9.7905]])\n", + "------------------------\n", + "tensor([[-7.8442]])\n", + "tensor([[-7.6021]])\n", + "------------------------\n", + "tensor([[-7.8803]])\n", + "tensor([[-6.6198]])\n", + "------------------------\n", + "tensor([[-8.1623]])\n", + "tensor([[-11.3010]])\n", + "------------------------\n", + "tensor([[-8.1210]])\n", + "tensor([[-8.0044]])\n", + "------------------------\n", + "tensor([[-8.1895]])\n", + "tensor([[-8.8539]])\n", + "------------------------\n", + "tensor([[-7.8784]])\n", + "tensor([[-6.9586]])\n", + "------------------------\n", + "tensor([[-8.4058]])\n", + "tensor([[-8.5376]])\n", + "------------------------\n", + "tensor([[-8.6863]])\n", + "tensor([[-11.3979]])\n", + "------------------------\n", + "tensor([[-8.1948]])\n", + "tensor([[-11.2218]])\n", + "------------------------\n", + "Epoch : 10 \t train loss: 2.7539809108559608 train MSE: tensor(2.4962, grad_fn=) test MSE: 2.572061672404247\n", + "Corr: 0.6601006991660396\n", + "tensor(0.2442, grad_fn=)\n", + "tensor(0.2440, grad_fn=)\n", + "tensor(0.2438, grad_fn=)\n", + "tensor(0.2435, grad_fn=)\n", + "tensor(0.2433, grad_fn=)\n", + "tensor(0.2431, grad_fn=)\n", + "tensor(0.2429, grad_fn=)\n", + "tensor(0.2427, grad_fn=)\n", + "tensor(0.2425, grad_fn=)\n", + "tensor(0.2423, grad_fn=)\n", + "tensor(0.2422, grad_fn=)\n", + "tensor(0.2420, grad_fn=)\n", + "tensor(0.2419, grad_fn=)\n", + "tensor(0.2417, grad_fn=)\n", + "tensor(0.2415, grad_fn=)\n", + "tensor(0.2413, grad_fn=)\n", + "tensor(0.2411, grad_fn=)\n", + "tensor(0.2410, grad_fn=)\n", + "tensor(0.2408, grad_fn=)\n", + "tensor(0.2407, grad_fn=)\n", + "tensor([[-7.6144]])\n", + "tensor([[-6.4202]])\n", "------------------------\n", - "tensor([[-5.1148]])\n", - "tensor([[-8.4559]])\n", + "tensor([[-8.0125]])\n", + "tensor([[-7.1427]])\n", "------------------------\n", - "tensor([[-7.9136]])\n", - "tensor([[-8.1308]])\n", + "tensor([[-7.5479]])\n", + "tensor([[-8.0506]])\n", "------------------------\n", - "tensor([[-6.2135]])\n", - "tensor([[-10.5229]])\n", + "tensor([[-8.2591]])\n", + "tensor([[-7.0362]])\n", "------------------------\n", - "tensor([[-8.1388]])\n", - "tensor([[-4.3979]])\n", + "tensor([[-8.0609]])\n", + "tensor([[-9.2733]])\n", "------------------------\n", - "tensor([[-8.2538]])\n", - "tensor([[-8.]])\n", + "tensor([[-7.7099]])\n", + "tensor([[-8.1643]])\n", "------------------------\n", - "tensor([[-8.3317]])\n", - "tensor([[-6.5229]])\n", + "tensor([[-7.6587]])\n", + "tensor([[-7.9208]])\n", "------------------------\n", - "tensor([[-8.3891]])\n", - "tensor([[-9.3010]])\n", + "tensor([[-7.7347]])\n", + "tensor([[-6.8386]])\n", "------------------------\n", - "tensor([[-8.3214]])\n", - "tensor([[-9.7696]])\n", + "tensor([[-8.5348]])\n", + "tensor([[-11.2441]])\n", "------------------------\n", - "tensor([[-8.3972]])\n", - "tensor([[-8.3010]])\n", + "tensor([[-7.7090]])\n", + "tensor([[-7.8539]])\n", "------------------------\n", - "tensor([[-8.4226]])\n", - "tensor([[-5.8861]])\n", + "tensor([[-7.7094]])\n", + "tensor([[-5.3098]])\n", "------------------------\n", - "tensor([[-8.0973]])\n", - "tensor([[-7.4559]])\n", + "tensor([[-7.7032]])\n", + "tensor([[-5.8327]])\n", "------------------------\n", - "Epoch : 9 \t train loss: 2.8448090296585056 train MSE: tensor(2.8068, grad_fn=) test MSE: 4.621123068400526\n", - "Corr: -0.24776318790251012\n", - "tensor(0.0367, grad_fn=)\n", - "tensor(0.0367, grad_fn=)\n", - "tensor(0.0368, grad_fn=)\n", - "tensor(0.0368, grad_fn=)\n", - "tensor(0.0369, grad_fn=)\n", - "tensor(0.0370, grad_fn=)\n", - "tensor(0.0370, grad_fn=)\n", - "tensor(0.0370, grad_fn=)\n", - "tensor(0.0371, grad_fn=)\n", - "tensor(0.0371, grad_fn=)\n", - "tensor(0.0372, grad_fn=)\n", - "tensor(0.0372, grad_fn=)\n", - "tensor(0.0373, grad_fn=)\n", - "tensor(0.0373, grad_fn=)\n", - "tensor(0.0374, grad_fn=)\n", - "tensor(0.0374, grad_fn=)\n", - "tensor(0.0375, grad_fn=)\n", - "tensor(0.0375, grad_fn=)\n", - "tensor(0.0376, grad_fn=)\n", - "tensor(0.0376, grad_fn=)\n", - "tensor([[-7.9188]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.2105]])\n", - "tensor([[-11.2441]])\n", + "tensor([[-8.0968]])\n", + "tensor([[-9.7905]])\n", "------------------------\n", - "tensor([[-8.2662]])\n", - "tensor([[-7.5986]])\n", + "tensor([[-7.6674]])\n", + "tensor([[-7.6021]])\n", "------------------------\n", - "tensor([[-7.9230]])\n", - "tensor([[-4.5086]])\n", + "tensor([[-7.6962]])\n", + "tensor([[-6.6198]])\n", "------------------------\n", - "tensor([[-6.1827]])\n", - "tensor([[-9.1612]])\n", + "tensor([[-7.9893]])\n", + "tensor([[-11.3010]])\n", "------------------------\n", - "tensor([[-8.2799]])\n", - "tensor([[-7.]])\n", + "tensor([[-8.0085]])\n", + "tensor([[-8.0044]])\n", "------------------------\n", - "tensor([[-8.0908]])\n", - "tensor([[-8.1643]])\n", + "tensor([[-8.1371]])\n", + "tensor([[-8.8539]])\n", "------------------------\n", - "tensor([[-8.1021]])\n", - "tensor([[-9.0969]])\n", + "tensor([[-7.7061]])\n", + "tensor([[-6.9586]])\n", "------------------------\n", - "tensor([[-8.1584]])\n", - "tensor([[-7.5229]])\n", + "tensor([[-8.2334]])\n", + "tensor([[-8.5376]])\n", + "------------------------\n", + "tensor([[-8.5215]])\n", + "tensor([[-11.3979]])\n", + "------------------------\n", + "tensor([[-8.0921]])\n", + "tensor([[-11.2218]])\n", + "------------------------\n", + "Epoch : 11 \t train loss: 2.660095993989434 train MSE: tensor(2.4067, grad_fn=) test MSE: 2.6058887827047412\n", + "Corr: 0.6882954465157534\n", + "tensor(0.2405, grad_fn=)\n", + "tensor(0.2404, grad_fn=)\n", + "tensor(0.2403, grad_fn=)\n", + "tensor(0.2402, grad_fn=)\n", + "tensor(0.2401, grad_fn=)\n", + "tensor(0.2400, grad_fn=)\n", + "tensor(0.2399, grad_fn=)\n", + "tensor(0.2399, grad_fn=)\n", + "tensor(0.2398, grad_fn=)\n", + "tensor(0.2398, grad_fn=)\n", + "tensor(0.2398, grad_fn=)\n", + "tensor(0.2397, grad_fn=)\n", + "tensor(0.2397, grad_fn=)\n", + "tensor(0.2396, grad_fn=)\n", + "tensor(0.2395, grad_fn=)\n", + "tensor(0.2395, grad_fn=)\n", + "tensor(0.2393, grad_fn=)\n", + "tensor(0.2392, grad_fn=)\n", + "tensor(0.2391, grad_fn=)\n", + "tensor(0.2390, grad_fn=)\n", + "tensor([[-7.5575]])\n", + "tensor([[-6.4202]])\n", + "------------------------\n", + "tensor([[-8.0620]])\n", + "tensor([[-7.1427]])\n", "------------------------\n", - "tensor([[-8.1564]])\n", - "tensor([[-9.9914]])\n", + "tensor([[-7.7418]])\n", + "tensor([[-8.0506]])\n", "------------------------\n", - "tensor([[-5.3024]])\n", - "tensor([[-8.4559]])\n", + "tensor([[-8.3001]])\n", + "tensor([[-7.0362]])\n", "------------------------\n", - "tensor([[-7.8926]])\n", - "tensor([[-8.1308]])\n", + "tensor([[-8.1028]])\n", + "tensor([[-9.2733]])\n", "------------------------\n", - "tensor([[-6.4356]])\n", - "tensor([[-10.5229]])\n", + "tensor([[-7.6590]])\n", + "tensor([[-8.1643]])\n", "------------------------\n", - "tensor([[-8.1378]])\n", - "tensor([[-4.3979]])\n", + "tensor([[-7.6058]])\n", + "tensor([[-7.9208]])\n", "------------------------\n", - "tensor([[-8.2504]])\n", - "tensor([[-8.]])\n", + "tensor([[-7.7272]])\n", + "tensor([[-6.8386]])\n", "------------------------\n", - "tensor([[-8.3316]])\n", - "tensor([[-6.5229]])\n", + "tensor([[-8.5873]])\n", + "tensor([[-11.2441]])\n", "------------------------\n", - "tensor([[-8.3979]])\n", - "tensor([[-9.3010]])\n", + "tensor([[-7.6743]])\n", + "tensor([[-7.8539]])\n", "------------------------\n", - "tensor([[-8.3166]])\n", - "tensor([[-9.7696]])\n", + "tensor([[-7.6480]])\n", + "tensor([[-5.3098]])\n", "------------------------\n", - "tensor([[-8.3910]])\n", - "tensor([[-8.3010]])\n", + "tensor([[-7.6456]])\n", + "tensor([[-5.8327]])\n", "------------------------\n", - "tensor([[-8.4442]])\n", - "tensor([[-5.8861]])\n", + "tensor([[-8.1407]])\n", + "tensor([[-9.7905]])\n", "------------------------\n", - "tensor([[-8.0615]])\n", - "tensor([[-7.4559]])\n", + "tensor([[-7.6068]])\n", + "tensor([[-7.6021]])\n", "------------------------\n", - "Epoch : 10 \t train loss: 2.7651161019603734 train MSE: tensor(2.7263, grad_fn=) test MSE: 4.398369469569021\n", - "Corr: -0.23467239052280744\n", - "tensor(0.0376, grad_fn=)\n", - "tensor(0.0377, grad_fn=)\n", - "tensor(0.0377, grad_fn=)\n", - "tensor(0.0378, grad_fn=)\n", - "tensor(0.0378, grad_fn=)\n", - "tensor(0.0379, grad_fn=)\n", - "tensor(0.0380, grad_fn=)\n", - "tensor(0.0380, grad_fn=)\n", - "tensor(0.0381, grad_fn=)\n", - "tensor(0.0382, grad_fn=)\n", - "tensor(0.0382, grad_fn=)\n", - "tensor(0.0383, grad_fn=)\n", - "tensor(0.0384, grad_fn=)\n", - "tensor(0.0385, grad_fn=)\n", - "tensor(0.0385, grad_fn=)\n", - "tensor(0.0386, grad_fn=)\n", - "tensor(0.0387, grad_fn=)\n", - "tensor(0.0387, grad_fn=)\n", - "tensor(0.0388, grad_fn=)\n", - "tensor(0.0388, grad_fn=)\n", - "tensor([[-7.9129]])\n", - "tensor([[-9.3010]])\n", + "tensor([[-7.6296]])\n", + "tensor([[-6.6198]])\n", "------------------------\n", - "tensor([[-8.2459]])\n", - "tensor([[-11.2441]])\n", + "tensor([[-8.0424]])\n", + "tensor([[-11.3010]])\n", "------------------------\n", - "tensor([[-8.3001]])\n", - "tensor([[-7.5986]])\n", + "tensor([[-8.0755]])\n", + "tensor([[-8.0044]])\n", "------------------------\n", - "tensor([[-7.8995]])\n", - "tensor([[-4.5086]])\n", + "tensor([[-8.2025]])\n", + "tensor([[-8.8539]])\n", "------------------------\n", - "tensor([[-6.3780]])\n", - "tensor([[-9.1612]])\n", + "tensor([[-7.6484]])\n", + "tensor([[-6.9586]])\n", "------------------------\n", - "tensor([[-8.2684]])\n", - "tensor([[-7.]])\n", + "tensor([[-8.2701]])\n", + "tensor([[-8.5376]])\n", "------------------------\n", - "tensor([[-8.1056]])\n", + "tensor([[-8.5608]])\n", + "tensor([[-11.3979]])\n", + "------------------------\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor([[-8.1184]])\n", + "tensor([[-11.2218]])\n", + "------------------------\n", + "Epoch : 12 \t train loss: 2.5662013658511094 train MSE: tensor(2.3155, grad_fn=) test MSE: 2.509422795647548\n", + "Corr: 0.7155050047172941\n", + "tensor(0.2389, grad_fn=)\n", + "tensor(0.2388, grad_fn=)\n", + "tensor(0.2387, grad_fn=)\n", + "tensor(0.2386, grad_fn=)\n", + "tensor(0.2386, grad_fn=)\n", + "tensor(0.2386, grad_fn=)\n", + "tensor(0.2387, grad_fn=)\n", + "tensor(0.2387, grad_fn=)\n", + "tensor(0.2387, grad_fn=)\n", + "tensor(0.2387, grad_fn=)\n", + "tensor(0.2387, grad_fn=)\n", + "tensor(0.2387, grad_fn=)\n", + "tensor(0.2387, grad_fn=)\n", + "tensor(0.2387, grad_fn=)\n", + "tensor(0.2387, grad_fn=)\n", + "tensor(0.2387, grad_fn=)\n", + "tensor(0.2387, grad_fn=)\n", + "tensor(0.2387, grad_fn=)\n", + "tensor(0.2387, grad_fn=)\n", + "tensor(0.2387, grad_fn=)\n", + "tensor([[-7.6755]])\n", + "tensor([[-6.4202]])\n", + "------------------------\n", + "tensor([[-8.2487]])\n", + "tensor([[-7.1427]])\n", + "------------------------\n", + "tensor([[-8.0207]])\n", + "tensor([[-8.0506]])\n", + "------------------------\n", + "tensor([[-8.4760]])\n", + "tensor([[-7.0362]])\n", + "------------------------\n", + "tensor([[-8.2872]])\n", + "tensor([[-9.2733]])\n", + "------------------------\n", + "tensor([[-7.7840]])\n", "tensor([[-8.1643]])\n", "------------------------\n", - "tensor([[-8.1214]])\n", - "tensor([[-9.0969]])\n", + "tensor([[-7.7265]])\n", + "tensor([[-7.9208]])\n", "------------------------\n", - "tensor([[-8.1845]])\n", - "tensor([[-7.5229]])\n", + "tensor([[-7.8652]])\n", + "tensor([[-6.8386]])\n", "------------------------\n", - "tensor([[-8.1783]])\n", - "tensor([[-9.9914]])\n", + "tensor([[-8.7811]])\n", + "tensor([[-11.2441]])\n", "------------------------\n", - "tensor([[-5.4787]])\n", - "tensor([[-8.4559]])\n", + "tensor([[-7.8105]])\n", + "tensor([[-7.8539]])\n", "------------------------\n", - "tensor([[-7.8958]])\n", - "tensor([[-8.1308]])\n", + "tensor([[-7.7661]])\n", + "tensor([[-5.3098]])\n", "------------------------\n", - "tensor([[-6.6427]])\n", - "tensor([[-10.5229]])\n", + "tensor([[-7.7666]])\n", + "tensor([[-5.8327]])\n", "------------------------\n", - "tensor([[-8.1557]])\n", - "tensor([[-4.3979]])\n", + "tensor([[-8.3218]])\n", + "tensor([[-9.7905]])\n", "------------------------\n", - "tensor([[-8.2823]])\n", - "tensor([[-8.]])\n", + "tensor([[-7.7231]])\n", + "tensor([[-7.6021]])\n", "------------------------\n", - "tensor([[-8.3660]])\n", - "tensor([[-6.5229]])\n", + "tensor([[-7.7421]])\n", + "tensor([[-6.6198]])\n", "------------------------\n", - "tensor([[-8.4401]])\n", - "tensor([[-9.3010]])\n", + "tensor([[-8.2002]])\n", + "tensor([[-11.3010]])\n", "------------------------\n", - "tensor([[-8.3453]])\n", - "tensor([[-9.7696]])\n", + "tensor([[-8.2614]])\n", + "tensor([[-8.0044]])\n", "------------------------\n", - "tensor([[-8.4221]])\n", - "tensor([[-8.3010]])\n", + "tensor([[-8.4033]])\n", + "tensor([[-8.8539]])\n", "------------------------\n", - "tensor([[-8.4850]])\n", - "tensor([[-5.8861]])\n", + "tensor([[-7.7686]])\n", + "tensor([[-6.9586]])\n", "------------------------\n", - "tensor([[-8.0577]])\n", - "tensor([[-7.4559]])\n", + "tensor([[-8.4423]])\n", + "tensor([[-8.5376]])\n", "------------------------\n", - "Epoch : 11 \t train loss: 2.665899422973832 train MSE: tensor(2.6260, grad_fn=) test MSE: 4.210219995273898\n", - "Corr: -0.2193568501973509\n", - "tensor(0.0388, grad_fn=)\n", - "tensor(0.0388, grad_fn=)\n", - "tensor(0.0388, grad_fn=)\n", - "tensor(0.0388, grad_fn=)\n", - "tensor(0.0388, grad_fn=)\n", - "tensor(0.0388, grad_fn=)\n", - "tensor(0.0388, grad_fn=)\n", - "tensor(0.0389, grad_fn=)\n", - "tensor(0.0389, grad_fn=)\n", - "tensor(0.0390, grad_fn=)\n", - "tensor(0.0390, grad_fn=)\n", - "tensor(0.0391, grad_fn=)\n", - "tensor(0.0391, grad_fn=)\n", - "tensor(0.0392, grad_fn=)\n", - "tensor(0.0393, grad_fn=)\n", - "tensor(0.0394, grad_fn=)\n", - "tensor(0.0394, grad_fn=)\n", - "tensor(0.0396, grad_fn=)\n", - "tensor(0.0397, grad_fn=)\n", - "tensor(0.0398, grad_fn=)\n", - "tensor([[-7.7716]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.1526]])\n", - "tensor([[-11.2441]])\n", + "tensor([[-8.7334]])\n", + "tensor([[-11.3979]])\n", "------------------------\n", - "tensor([[-8.2018]])\n", - "tensor([[-7.5986]])\n", + "tensor([[-8.2956]])\n", + "tensor([[-11.2218]])\n", "------------------------\n", - "tensor([[-7.7219]])\n", - "tensor([[-4.5086]])\n", + "Epoch : 13 \t train loss: 2.659548379237356 train MSE: tensor(2.4099, grad_fn=) test MSE: 2.3893898802396674\n", + "Corr: 0.7172346386197117\n", + "tensor(0.2389, grad_fn=)\n", + "tensor(0.2390, grad_fn=)\n", + "tensor(0.2391, grad_fn=)\n", + "tensor(0.2391, grad_fn=)\n", + "tensor(0.2391, grad_fn=)\n", + "tensor(0.2390, grad_fn=)\n", + "tensor(0.2390, grad_fn=)\n", + "tensor(0.2390, grad_fn=)\n", + "tensor(0.2389, grad_fn=)\n", + "tensor(0.2388, grad_fn=)\n", + "tensor(0.2388, grad_fn=)\n", + "tensor(0.2387, grad_fn=)\n", + "tensor(0.2386, grad_fn=)\n", + "tensor(0.2385, grad_fn=)\n", + "tensor(0.2384, grad_fn=)\n", + "tensor(0.2383, grad_fn=)\n", + "tensor(0.2383, grad_fn=)\n", + "tensor(0.2382, grad_fn=)\n", + "tensor(0.2382, grad_fn=)\n", + "tensor(0.2382, grad_fn=)\n", + "tensor([[-7.4563]])\n", + "tensor([[-6.4202]])\n", "------------------------\n", - "tensor([[-6.5198]])\n", - "tensor([[-9.1612]])\n", + "tensor([[-8.1033]])\n", + "tensor([[-7.1427]])\n", "------------------------\n", - "tensor([[-8.1496]])\n", - "tensor([[-7.]])\n", + "tensor([[-7.9690]])\n", + "tensor([[-8.0506]])\n", "------------------------\n", - "tensor([[-7.9808]])\n", - "tensor([[-8.1643]])\n", + "tensor([[-8.2897]])\n", + "tensor([[-7.0362]])\n", "------------------------\n", - "tensor([[-8.0112]])\n", - "tensor([[-9.0969]])\n", + "tensor([[-8.1291]])\n", + "tensor([[-9.2733]])\n", "------------------------\n", - "tensor([[-8.0843]])\n", - "tensor([[-7.5229]])\n", + "tensor([[-7.5689]])\n", + "tensor([[-8.1643]])\n", "------------------------\n", - "tensor([[-8.0559]])\n", - "tensor([[-9.9914]])\n", + "tensor([[-7.5093]])\n", + "tensor([[-7.9208]])\n", "------------------------\n", - "tensor([[-5.6107]])\n", - "tensor([[-8.4559]])\n", + "tensor([[-7.6635]])\n", + "tensor([[-6.8386]])\n", "------------------------\n", - "tensor([[-7.7937]])\n", - "tensor([[-8.1308]])\n", + "tensor([[-8.6109]])\n", + "tensor([[-11.2441]])\n", "------------------------\n", - "tensor([[-6.7981]])\n", - "tensor([[-10.5229]])\n", + "tensor([[-7.6098]])\n", + "tensor([[-7.8539]])\n", "------------------------\n", - "tensor([[-8.0355]])\n", - "tensor([[-4.3979]])\n", + "tensor([[-7.5419]])\n", + "tensor([[-5.3098]])\n", "------------------------\n", - "tensor([[-8.1981]])\n", - "tensor([[-8.]])\n", + "tensor([[-7.5467]])\n", + "tensor([[-5.8327]])\n", "------------------------\n", - "tensor([[-8.2678]])\n", - "tensor([[-6.5229]])\n", + "tensor([[-8.1512]])\n", + "tensor([[-9.7905]])\n", "------------------------\n", - "tensor([[-8.3605]])\n", - "tensor([[-9.3010]])\n", + "tensor([[-7.4984]])\n", + "tensor([[-7.6021]])\n", "------------------------\n", - "tensor([[-8.2555]])\n", - "tensor([[-9.7696]])\n", + "tensor([[-7.5116]])\n", + "tensor([[-6.6198]])\n", "------------------------\n", - "tensor([[-8.3219]])\n", - "tensor([[-8.3010]])\n", + "tensor([[-7.9900]])\n", + "tensor([[-11.3010]])\n", "------------------------\n", - "tensor([[-8.4070]])\n", - "tensor([[-5.8861]])\n", + "tensor([[-8.1012]])\n", + "tensor([[-8.0044]])\n", "------------------------\n", - "tensor([[-7.9204]])\n", - "tensor([[-7.4559]])\n", + "tensor([[-8.2693]])\n", + "tensor([[-8.8539]])\n", "------------------------\n", - "Epoch : 12 \t train loss: 2.559155468839611 train MSE: tensor(2.5183, grad_fn=) test MSE: 4.014542788906033\n", - "Corr: -0.1937131368706203\n", - "tensor(0.0400, grad_fn=)\n", - "tensor(0.0401, grad_fn=)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "tensor(0.0402, grad_fn=)\n", - "tensor(0.0403, grad_fn=)\n", - "tensor(0.0404, grad_fn=)\n", - "tensor(0.0405, grad_fn=)\n", - "tensor(0.0406, grad_fn=)\n", - "tensor(0.0407, grad_fn=)\n", - "tensor(0.0407, grad_fn=)\n", - "tensor(0.0408, grad_fn=)\n", - "tensor(0.0409, grad_fn=)\n", - "tensor(0.0410, grad_fn=)\n", - "tensor(0.0410, grad_fn=)\n", - "tensor(0.0411, grad_fn=)\n", - "tensor(0.0412, grad_fn=)\n", - "tensor(0.0412, grad_fn=)\n", - "tensor(0.0413, grad_fn=)\n", - "tensor(0.0413, grad_fn=)\n", - "tensor(0.0414, grad_fn=)\n", - "tensor(0.0415, grad_fn=)\n", - "tensor([[-7.9104]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.3280]])\n", - "tensor([[-11.2441]])\n", + "tensor([[-7.5462]])\n", + "tensor([[-6.9586]])\n", "------------------------\n", - "tensor([[-8.3790]])\n", - "tensor([[-7.5986]])\n", + "tensor([[-8.2248]])\n", + "tensor([[-8.5376]])\n", "------------------------\n", - "tensor([[-7.8196]])\n", - "tensor([[-4.5086]])\n", + "tensor([[-8.5224]])\n", + "tensor([[-11.3979]])\n", "------------------------\n", - "tensor([[-6.7607]])\n", - "tensor([[-9.1612]])\n", + "tensor([[-8.1355]])\n", + "tensor([[-11.2218]])\n", "------------------------\n", - "tensor([[-8.2995]])\n", - "tensor([[-7.]])\n", + "Epoch : 14 \t train loss: 2.6511351828481637 train MSE: tensor(2.4015, grad_fn=) test MSE: 2.456622330302542\n", + "Corr: 0.7105723474808853\n", + "tensor(0.2383, grad_fn=)\n", + "tensor(0.2385, grad_fn=)\n", + "tensor(0.2386, grad_fn=)\n", + "tensor(0.2387, grad_fn=)\n", + "tensor(0.2388, grad_fn=)\n", + "tensor(0.2389, grad_fn=)\n", + "tensor(0.2389, grad_fn=)\n", + "tensor(0.2389, grad_fn=)\n", + "tensor(0.2389, grad_fn=)\n", + "tensor(0.2389, grad_fn=)\n", + "tensor(0.2388, grad_fn=)\n", + "tensor(0.2387, grad_fn=)\n", + "tensor(0.2386, grad_fn=)\n", + "tensor(0.2385, grad_fn=)\n", + "tensor(0.2384, grad_fn=)\n", + "tensor(0.2384, grad_fn=)\n", + "tensor(0.2383, grad_fn=)\n", + "tensor(0.2383, grad_fn=)\n", + "tensor(0.2383, grad_fn=)\n", + "tensor(0.2383, grad_fn=)\n", + "tensor([[-7.4092]])\n", + "tensor([[-6.4202]])\n", "------------------------\n", - "tensor([[-8.1416]])\n", - "tensor([[-8.1643]])\n", + "tensor([[-8.1393]])\n", + "tensor([[-7.1427]])\n", "------------------------\n", - "tensor([[-8.1789]])\n", - "tensor([[-9.0969]])\n", + "tensor([[-8.0205]])\n", + "tensor([[-8.0506]])\n", "------------------------\n", - "tensor([[-8.2680]])\n", - "tensor([[-7.5229]])\n", + "tensor([[-8.2597]])\n", + "tensor([[-7.0362]])\n", "------------------------\n", - "tensor([[-8.2291]])\n", - "tensor([[-9.9914]])\n", + "tensor([[-8.1248]])\n", + "tensor([[-9.2733]])\n", "------------------------\n", - "tensor([[-5.8229]])\n", - "tensor([[-8.4559]])\n", + "tensor([[-7.5269]])\n", + "tensor([[-8.1643]])\n", "------------------------\n", - "tensor([[-7.9372]])\n", - "tensor([[-8.1308]])\n", + "tensor([[-7.4620]])\n", + "tensor([[-7.9208]])\n", "------------------------\n", - "tensor([[-7.0480]])\n", - "tensor([[-10.5229]])\n", + "tensor([[-7.6194]])\n", + "tensor([[-6.8386]])\n", "------------------------\n", - "tensor([[-8.1971]])\n", - "tensor([[-4.3979]])\n", + "tensor([[-8.6026]])\n", + "tensor([[-11.2441]])\n", "------------------------\n", - "tensor([[-8.3652]])\n", - "tensor([[-8.]])\n", + "tensor([[-7.5740]])\n", + "tensor([[-7.8539]])\n", "------------------------\n", - "tensor([[-8.4518]])\n", - "tensor([[-6.5229]])\n", + "tensor([[-7.4953]])\n", + "tensor([[-5.3098]])\n", "------------------------\n", - "tensor([[-8.5405]])\n", - "tensor([[-9.3010]])\n", + "tensor([[-7.5031]])\n", + "tensor([[-5.8327]])\n", "------------------------\n", - "tensor([[-8.4227]])\n", - "tensor([[-9.7696]])\n", + "tensor([[-8.1401]])\n", + "tensor([[-9.7905]])\n", "------------------------\n", - "tensor([[-8.4938]])\n", - "tensor([[-8.3010]])\n", + "tensor([[-7.4478]])\n", + "tensor([[-7.6021]])\n", "------------------------\n", - "tensor([[-8.6012]])\n", - "tensor([[-5.8861]])\n", + "tensor([[-7.4593]])\n", + "tensor([[-6.6198]])\n", "------------------------\n", - "tensor([[-8.0668]])\n", - "tensor([[-7.4559]])\n", + "tensor([[-7.9193]])\n", + "tensor([[-11.3010]])\n", "------------------------\n", - "Epoch : 13 \t train loss: 2.5416091931391307 train MSE: tensor(2.4990, grad_fn=) test MSE: 3.879628496427488\n", - "Corr: -0.17717836881225027\n", - "tensor(0.0415, grad_fn=)\n", - "tensor(0.0416, grad_fn=)\n", - "tensor(0.0417, grad_fn=)\n", - "tensor(0.0418, grad_fn=)\n", - "tensor(0.0419, grad_fn=)\n", - "tensor(0.0419, grad_fn=)\n", - "tensor(0.0420, grad_fn=)\n", - "tensor(0.0420, grad_fn=)\n", - "tensor(0.0420, grad_fn=)\n", - "tensor(0.0421, grad_fn=)\n", - "tensor(0.0421, grad_fn=)\n", - "tensor(0.0422, grad_fn=)\n", - "tensor(0.0422, grad_fn=)\n", - "tensor(0.0423, grad_fn=)\n", - "tensor(0.0424, grad_fn=)\n", - "tensor(0.0425, grad_fn=)\n", - "tensor(0.0426, grad_fn=)\n", - "tensor(0.0427, grad_fn=)\n", - "tensor(0.0427, grad_fn=)\n", - "tensor(0.0428, grad_fn=)\n", - "tensor([[-7.7606]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.2033]])\n", - "tensor([[-11.2441]])\n", + "tensor([[-8.0767]])\n", + "tensor([[-8.0044]])\n", "------------------------\n", - "tensor([[-8.2627]])\n", - "tensor([[-7.5986]])\n", + "tensor([[-8.3145]])\n", + "tensor([[-8.8539]])\n", "------------------------\n", - "tensor([[-7.6348]])\n", - "tensor([[-4.5086]])\n", + "tensor([[-7.4985]])\n", + "tensor([[-6.9586]])\n", "------------------------\n", - "tensor([[-6.8778]])\n", - "tensor([[-9.1612]])\n", + "tensor([[-8.1681]])\n", + "tensor([[-8.5376]])\n", "------------------------\n", - "tensor([[-8.1586]])\n", - "tensor([[-7.]])\n", + "tensor([[-8.4762]])\n", + "tensor([[-11.3979]])\n", "------------------------\n", - "tensor([[-8.0100]])\n", - "tensor([[-8.1643]])\n", + "tensor([[-8.1383]])\n", + "tensor([[-11.2218]])\n", "------------------------\n", - "tensor([[-8.0221]])\n", - "tensor([[-9.0969]])\n", + "Epoch : 15 \t train loss: 2.5312436172385624 train MSE: tensor(2.2817, grad_fn=) test MSE: 2.4679593706096057\n", + "Corr: 0.6945912889430875\n", + "tensor(0.2383, grad_fn=)\n", + "tensor(0.2383, grad_fn=)\n", + "tensor(0.2383, grad_fn=)\n", + "tensor(0.2383, grad_fn=)\n", + "tensor(0.2383, grad_fn=)\n", + "tensor(0.2383, grad_fn=)\n", + "tensor(0.2383, grad_fn=)\n", + "tensor(0.2384, grad_fn=)\n", + "tensor(0.2384, grad_fn=)\n", + "tensor(0.2384, grad_fn=)\n", + "tensor(0.2384, grad_fn=)\n", + "tensor(0.2384, grad_fn=)\n", + "tensor(0.2384, grad_fn=)\n", + "tensor(0.2383, grad_fn=)\n", + "tensor(0.2383, grad_fn=)\n", + "tensor(0.2382, grad_fn=)\n", + "tensor(0.2382, grad_fn=)\n", + "tensor(0.2382, grad_fn=)\n", + "tensor(0.2382, grad_fn=)\n", + "tensor(0.2381, grad_fn=)\n", + "tensor([[-7.5191]])\n", + "tensor([[-6.4202]])\n", "------------------------\n", - "tensor([[-8.1555]])\n", - "tensor([[-7.5229]])\n", + "tensor([[-8.2565]])\n", + "tensor([[-7.1427]])\n", "------------------------\n", - "tensor([[-8.1025]])\n", - "tensor([[-9.9914]])\n", + "tensor([[-8.2465]])\n", + "tensor([[-8.0506]])\n", "------------------------\n", - "tensor([[-5.9249]])\n", - "tensor([[-8.4559]])\n", + "tensor([[-8.4180]])\n", + "tensor([[-7.0362]])\n", "------------------------\n", - "tensor([[-7.7810]])\n", - "tensor([[-8.1308]])\n", - "------------------------\n", - "tensor([[-7.1673]])\n", - "tensor([[-10.5229]])\n", - "------------------------\n", - "tensor([[-8.0478]])\n", - "tensor([[-4.3979]])\n", - "------------------------\n", - "tensor([[-8.2341]])\n", - "tensor([[-8.]])\n", - "------------------------\n", - "tensor([[-8.3420]])\n", - "tensor([[-6.5229]])\n", - "------------------------\n", - "tensor([[-8.4148]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.2925]])\n", - "tensor([[-9.7696]])\n", - "------------------------\n", - "tensor([[-8.3747]])\n", - "tensor([[-8.3010]])\n", - "------------------------\n", - "tensor([[-8.4726]])\n", - "tensor([[-5.8861]])\n", - "------------------------\n", - "tensor([[-7.9093]])\n", - "tensor([[-7.4559]])\n", - "------------------------\n", - "Epoch : 14 \t train loss: 2.367646256239924 train MSE: tensor(2.3236, grad_fn=) test MSE: 3.708499605989172\n", - "Corr: -0.14459236477065635\n", - "tensor(0.0428, grad_fn=)\n", - "tensor(0.0429, grad_fn=)\n", - "tensor(0.0430, grad_fn=)\n", - "tensor(0.0430, grad_fn=)\n", - "tensor(0.0431, grad_fn=)\n", - "tensor(0.0432, grad_fn=)\n", - "tensor(0.0433, grad_fn=)\n", - "tensor(0.0433, grad_fn=)\n", - "tensor(0.0434, grad_fn=)\n", - "tensor(0.0435, grad_fn=)\n", - "tensor(0.0436, grad_fn=)\n", - "tensor(0.0436, grad_fn=)\n", - "tensor(0.0437, grad_fn=)\n", - "tensor(0.0438, grad_fn=)\n", - "tensor(0.0438, grad_fn=)\n", - "tensor(0.0439, grad_fn=)\n", - "tensor(0.0439, grad_fn=)\n", - "tensor(0.0440, grad_fn=)\n", - "tensor(0.0441, grad_fn=)\n", - "tensor(0.0441, grad_fn=)\n", - "tensor([[-7.7198]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.2085]])\n", - "tensor([[-11.2441]])\n", - "------------------------\n", - "tensor([[-8.2643]])\n", - "tensor([[-7.5986]])\n", - "------------------------\n", - "tensor([[-7.5457]])\n", - "tensor([[-4.5086]])\n", + "tensor([[-8.2856]])\n", + "tensor([[-9.2733]])\n", "------------------------\n", - "tensor([[-7.0197]])\n", - "tensor([[-9.1612]])\n", - "------------------------\n", - "tensor([[-8.1242]])\n", - "tensor([[-7.]])\n", - "------------------------\n", - "tensor([[-8.0014]])\n", + "tensor([[-7.6427]])\n", "tensor([[-8.1643]])\n", "------------------------\n", - "tensor([[-8.0074]])\n", - "tensor([[-9.0969]])\n", - "------------------------\n", - "tensor([[-8.1609]])\n", - "tensor([[-7.5229]])\n", - "------------------------\n", - "tensor([[-8.1033]])\n", - "tensor([[-9.9914]])\n", - "------------------------\n", - "tensor([[-6.0434]])\n", - "tensor([[-8.4559]])\n", - "------------------------\n", - "tensor([[-7.7643]])\n", - "tensor([[-8.1308]])\n", - "------------------------\n", - "tensor([[-7.3041]])\n", - "tensor([[-10.5229]])\n", - "------------------------\n", - "tensor([[-8.0290]])\n", - "tensor([[-4.3979]])\n", - "------------------------\n", - "tensor([[-8.2284]])\n", - "tensor([[-8.]])\n", - "------------------------\n", - "tensor([[-8.3544]])\n", - "tensor([[-6.5229]])\n", - "------------------------\n", - "tensor([[-8.4177]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.2877]])\n", - "tensor([[-9.7696]])\n", - "------------------------\n", - "tensor([[-8.3637]])\n", - "tensor([[-8.3010]])\n", - "------------------------\n", - "tensor([[-8.4773]])\n", - "tensor([[-5.8861]])\n", + "tensor([[-7.5720]])\n", + "tensor([[-7.9208]])\n", "------------------------\n", - "tensor([[-7.8777]])\n", - "tensor([[-7.4559]])\n", + "tensor([[-7.7372]])\n", + "tensor([[-6.8386]])\n", "------------------------\n", - "Epoch : 15 \t train loss: 2.453727871519901 train MSE: tensor(2.4083, grad_fn=) test MSE: 3.5807694463458444\n", - "Corr: -0.11023881596296022\n", - "tensor(0.0442, grad_fn=)\n", - "tensor(0.0443, grad_fn=)\n", - "tensor(0.0444, grad_fn=)\n", - "tensor(0.0445, grad_fn=)\n", - "tensor(0.0445, grad_fn=)\n", - "tensor(0.0446, grad_fn=)\n", - "tensor(0.0447, grad_fn=)\n", - "tensor(0.0448, grad_fn=)\n", - "tensor(0.0449, grad_fn=)\n", - "tensor(0.0450, grad_fn=)\n", - "tensor(0.0451, grad_fn=)\n", - "tensor(0.0452, grad_fn=)\n", - "tensor(0.0453, grad_fn=)\n", - "tensor(0.0453, grad_fn=)\n", - "tensor(0.0454, grad_fn=)\n", - "tensor(0.0455, grad_fn=)\n", - "tensor(0.0455, grad_fn=)\n", - "tensor(0.0456, grad_fn=)\n", - "tensor(0.0456, grad_fn=)\n", - "tensor(0.0457, grad_fn=)\n", - "tensor([[-7.7560]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.2791]])\n", + "tensor([[-8.7707]])\n", "tensor([[-11.2441]])\n", "------------------------\n", - "tensor([[-8.3415]])\n", - "tensor([[-7.5986]])\n", - "------------------------\n", - "tensor([[-7.5513]])\n", - "tensor([[-4.5086]])\n", - "------------------------\n", - "tensor([[-7.1642]])\n", - "tensor([[-9.1612]])\n", - "------------------------\n", - "tensor([[-8.1607]])\n", - "tensor([[-7.]])\n", - "------------------------\n", - "tensor([[-8.0722]])\n", - "tensor([[-8.1643]])\n", - "------------------------\n", - "tensor([[-8.0637]])\n", - "tensor([[-9.0969]])\n", - "------------------------\n", - "tensor([[-8.2248]])\n", - "tensor([[-7.5229]])\n", + "tensor([[-7.6933]])\n", + "tensor([[-7.8539]])\n", "------------------------\n", - "tensor([[-8.1776]])\n", - "tensor([[-9.9914]])\n", + "tensor([[-7.6067]])\n", + "tensor([[-5.3098]])\n", "------------------------\n", - "tensor([[-6.1688]])\n", - "tensor([[-8.4559]])\n", + "tensor([[-7.6148]])\n", + "tensor([[-5.8327]])\n", "------------------------\n", - "tensor([[-7.8253]])\n", - "tensor([[-8.1308]])\n", + "tensor([[-8.2960]])\n", + "tensor([[-9.7905]])\n", "------------------------\n", - "tensor([[-7.4452]])\n", - "tensor([[-10.5229]])\n", + "tensor([[-7.5546]])\n", + "tensor([[-7.6021]])\n", "------------------------\n", - "tensor([[-8.0697]])\n", - "tensor([[-4.3979]])\n", + "tensor([[-7.5671]])\n", + "tensor([[-6.6198]])\n", "------------------------\n", - "tensor([[-8.3160]])\n", - "tensor([[-8.]])\n", + "tensor([[-8.0807]])\n", + "tensor([[-11.3010]])\n", "------------------------\n", - "tensor([[-8.4384]])\n", - "tensor([[-6.5229]])\n", + "tensor([[-8.2421]])\n", + "tensor([[-8.0044]])\n", "------------------------\n", - "tensor([[-8.5179]])\n", - "tensor([[-9.3010]])\n", + "tensor([[-8.4423]])\n", + "tensor([[-8.8539]])\n", "------------------------\n", - "tensor([[-8.3807]])\n", - "tensor([[-9.7696]])\n", + "tensor([[-7.6054]])\n", + "tensor([[-6.9586]])\n", "------------------------\n", - "tensor([[-8.4295]])\n", - "tensor([[-8.3010]])\n", + "tensor([[-8.3390]])\n", + "tensor([[-8.5376]])\n", "------------------------\n", - "tensor([[-8.5656]])\n", - "tensor([[-5.8861]])\n", + "tensor([[-8.6372]])\n", + "tensor([[-11.3979]])\n", "------------------------\n", - "tensor([[-7.9225]])\n", - "tensor([[-7.4559]])\n", + "tensor([[-8.2856]])\n", + "tensor([[-11.2218]])\n", "------------------------\n", - "Epoch : 16 \t train loss: 2.339683545160838 train MSE: tensor(2.2927, grad_fn=) test MSE: 3.4850145356197437\n", - "Corr: -0.08094043123066498\n", - "tensor(0.0458, grad_fn=)\n", - "tensor(0.0458, grad_fn=)\n", - "tensor(0.0459, grad_fn=)\n", - "tensor(0.0459, grad_fn=)\n", - "tensor(0.0460, grad_fn=)\n", - "tensor(0.0460, grad_fn=)\n", - "tensor(0.0461, grad_fn=)\n", - "tensor(0.0462, grad_fn=)\n", - "tensor(0.0463, grad_fn=)\n" + "Epoch : 16 \t train loss: 2.391419354607077 train MSE: tensor(2.1422, grad_fn=) test MSE: 2.345382092541761\n", + "Corr: 0.697710613049351\n", + "tensor(0.2381, grad_fn=)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "tensor(0.0464, grad_fn=)\n", - "tensor(0.0464, grad_fn=)\n", - "tensor(0.0465, grad_fn=)\n", - "tensor(0.0465, grad_fn=)\n", - "tensor(0.0466, grad_fn=)\n", - "tensor(0.0467, grad_fn=)\n", - "tensor(0.0467, grad_fn=)\n", - "tensor(0.0468, grad_fn=)\n", - "tensor(0.0468, grad_fn=)\n", - "tensor(0.0469, grad_fn=)\n", - "tensor(0.0469, grad_fn=)\n", - "tensor([[-7.6937]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.2560]])\n", - "tensor([[-11.2441]])\n", - "------------------------\n", - "tensor([[-8.3205]])\n", - "tensor([[-7.5986]])\n", - "------------------------\n", - "tensor([[-7.4531]])\n", - "tensor([[-4.5086]])\n", - "------------------------\n", - "tensor([[-7.2364]])\n", - "tensor([[-9.1612]])\n", - "------------------------\n", - "tensor([[-8.0970]])\n", - "tensor([[-7.]])\n", - "------------------------\n", - "tensor([[-8.0452]])\n", + "tensor(0.2381, grad_fn=)\n", + "tensor(0.2381, grad_fn=)\n", + "tensor(0.2382, grad_fn=)\n", + "tensor(0.2382, grad_fn=)\n", + "tensor(0.2383, grad_fn=)\n", + "tensor(0.2383, grad_fn=)\n", + "tensor(0.2383, grad_fn=)\n", + "tensor(0.2383, grad_fn=)\n", + "tensor(0.2382, grad_fn=)\n", + "tensor(0.2381, grad_fn=)\n", + "tensor(0.2380, grad_fn=)\n", + "tensor(0.2379, grad_fn=)\n", + "tensor(0.2378, grad_fn=)\n", + "tensor(0.2377, grad_fn=)\n", + "tensor(0.2376, grad_fn=)\n", + "tensor(0.2375, grad_fn=)\n", + "tensor(0.2375, grad_fn=)\n", + "tensor(0.2374, grad_fn=)\n", + "tensor(0.2375, grad_fn=)\n", + "tensor([[-7.1541]])\n", + "tensor([[-6.4202]])\n", + "------------------------\n", + "tensor([[-7.9651]])\n", + "tensor([[-7.1427]])\n", + "------------------------\n", + "tensor([[-8.1350]])\n", + "tensor([[-8.0506]])\n", + "------------------------\n", + "tensor([[-8.1431]])\n", + "tensor([[-7.0362]])\n", + "------------------------\n", + "tensor([[-8.0217]])\n", + "tensor([[-9.2733]])\n", + "------------------------\n", + "tensor([[-7.2817]])\n", "tensor([[-8.1643]])\n", "------------------------\n", - "tensor([[-8.0256]])\n", - "tensor([[-9.0969]])\n", - "------------------------\n", - "tensor([[-8.1972]])\n", - "tensor([[-7.5229]])\n", - "------------------------\n", - "tensor([[-8.1534]])\n", - "tensor([[-9.9914]])\n", - "------------------------\n", - "tensor([[-6.2328]])\n", - "tensor([[-8.4559]])\n", - "------------------------\n", - "tensor([[-7.7790]])\n", - "tensor([[-8.1308]])\n", - "------------------------\n", - "tensor([[-7.5072]])\n", - "tensor([[-10.5229]])\n", - "------------------------\n", - "tensor([[-8.0165]])\n", - "tensor([[-4.3979]])\n", - "------------------------\n", - "tensor([[-8.2922]])\n", - "tensor([[-8.]])\n", - "------------------------\n", - "tensor([[-8.4258]])\n", - "tensor([[-6.5229]])\n", - "------------------------\n", - "tensor([[-8.4941]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.3557]])\n", - "tensor([[-9.7696]])\n", - "------------------------\n", - "tensor([[-8.3952]])\n", - "tensor([[-8.3010]])\n", - "------------------------\n", - "tensor([[-8.5333]])\n", - "tensor([[-5.8861]])\n", - "------------------------\n", - "tensor([[-7.8726]])\n", - "tensor([[-7.4559]])\n", + "tensor([[-7.2085]])\n", + "tensor([[-7.9208]])\n", "------------------------\n", - "Epoch : 17 \t train loss: 2.30278063053797 train MSE: tensor(2.2544, grad_fn=) test MSE: 3.400405673310161\n", - "Corr: -0.04667805604240054\n", - "tensor(0.0470, grad_fn=)\n", - "tensor(0.0471, grad_fn=)\n", - "tensor(0.0471, grad_fn=)\n", - "tensor(0.0472, grad_fn=)\n", - "tensor(0.0473, grad_fn=)\n", - "tensor(0.0473, grad_fn=)\n", - "tensor(0.0474, grad_fn=)\n", - "tensor(0.0474, grad_fn=)\n", - "tensor(0.0475, grad_fn=)\n", - "tensor(0.0476, grad_fn=)\n", - "tensor(0.0477, grad_fn=)\n", - "tensor(0.0478, grad_fn=)\n", - "tensor(0.0479, grad_fn=)\n", - "tensor(0.0480, grad_fn=)\n", - "tensor(0.0480, grad_fn=)\n", - "tensor(0.0481, grad_fn=)\n", - "tensor(0.0481, grad_fn=)\n", - "tensor(0.0482, grad_fn=)\n", - "tensor(0.0482, grad_fn=)\n", - "tensor(0.0483, grad_fn=)\n", - "tensor([[-7.6427]])\n", - "tensor([[-9.3010]])\n", + "tensor([[-7.4196]])\n", + "tensor([[-6.8386]])\n", "------------------------\n", - "tensor([[-8.2300]])\n", + "tensor([[-8.4974]])\n", "tensor([[-11.2441]])\n", "------------------------\n", - "tensor([[-8.3097]])\n", - "tensor([[-7.5986]])\n", - "------------------------\n", - "tensor([[-7.3452]])\n", - "tensor([[-4.5086]])\n", - "------------------------\n", - "tensor([[-7.2936]])\n", - "tensor([[-9.1612]])\n", - "------------------------\n", - "tensor([[-8.0477]])\n", - "tensor([[-7.]])\n", - "------------------------\n", - "tensor([[-8.0225]])\n", - "tensor([[-8.1643]])\n", - "------------------------\n", - "tensor([[-7.9868]])\n", - "tensor([[-9.0969]])\n", - "------------------------\n", - "tensor([[-8.1931]])\n", - "tensor([[-7.5229]])\n", - "------------------------\n", - "tensor([[-8.1479]])\n", - "tensor([[-9.9914]])\n", - "------------------------\n", - "tensor([[-6.2775]])\n", - "tensor([[-8.4559]])\n", - "------------------------\n", - "tensor([[-7.7397]])\n", - "tensor([[-8.1308]])\n", - "------------------------\n", - "tensor([[-7.5543]])\n", - "tensor([[-10.5229]])\n", - "------------------------\n", - "tensor([[-7.9710]])\n", - "tensor([[-4.3979]])\n", + "tensor([[-7.3512]])\n", + "tensor([[-7.8539]])\n", + "------------------------\n", + "tensor([[-7.2344]])\n", + "tensor([[-5.3098]])\n", + "------------------------\n", + "tensor([[-7.2473]])\n", + "tensor([[-5.8327]])\n", + "------------------------\n", + "tensor([[-8.0272]])\n", + "tensor([[-9.7905]])\n", + "------------------------\n", + "tensor([[-7.1822]])\n", + "tensor([[-7.6021]])\n", + "------------------------\n", + "tensor([[-7.1869]])\n", + "tensor([[-6.6198]])\n", + "------------------------\n", + "tensor([[-7.8240]])\n", + "tensor([[-11.3010]])\n", + "------------------------\n", + "tensor([[-8.0040]])\n", + "tensor([[-8.0044]])\n", + "------------------------\n", + "tensor([[-8.1614]])\n", + "tensor([[-8.8539]])\n", + "------------------------\n", + "tensor([[-7.2340]])\n", + "tensor([[-6.9586]])\n", + "------------------------\n", + "tensor([[-8.0582]])\n", + "tensor([[-8.5376]])\n", + "------------------------\n", + "tensor([[-8.3516]])\n", + "tensor([[-11.3979]])\n", + "------------------------\n", + "tensor([[-7.9995]])\n", + "tensor([[-11.2218]])\n", + "------------------------\n", + "Epoch : 17 \t train loss: 2.461012840270996 train MSE: tensor(2.2122, grad_fn=) test MSE: 2.5130006201646378\n", + "Corr: 0.6893821204394136\n", + "tensor(0.2375, grad_fn=)\n", + "tensor(0.2375, grad_fn=)\n", + "tensor(0.2376, grad_fn=)\n", + "tensor(0.2376, grad_fn=)\n", + "tensor(0.2376, grad_fn=)\n", + "tensor(0.2377, grad_fn=)\n", + "tensor(0.2377, grad_fn=)\n", + "tensor(0.2378, grad_fn=)\n", + "tensor(0.2379, grad_fn=)\n", + "tensor(0.2380, grad_fn=)\n", + "tensor(0.2380, grad_fn=)\n", + "tensor(0.2380, grad_fn=)\n", + "tensor(0.2381, grad_fn=)\n", + "tensor(0.2381, grad_fn=)\n", + "tensor(0.2382, grad_fn=)\n", + "tensor(0.2382, grad_fn=)\n", + "tensor(0.2381, grad_fn=)\n", + "tensor(0.2381, grad_fn=)\n", + "tensor(0.2380, grad_fn=)\n", + "tensor(0.2379, grad_fn=)\n", + "tensor([[-7.5435]])\n", + "tensor([[-6.4202]])\n", "------------------------\n", - "tensor([[-8.2629]])\n", - "tensor([[-8.]])\n", + "tensor([[-8.3490]])\n", + "tensor([[-7.1427]])\n", "------------------------\n", - "tensor([[-8.4342]])\n", - "tensor([[-6.5229]])\n", + "tensor([[-8.5265]])\n", + "tensor([[-8.0506]])\n", "------------------------\n", - "tensor([[-8.4765]])\n", - "tensor([[-9.3010]])\n", + "tensor([[-8.5479]])\n", + "tensor([[-7.0362]])\n", "------------------------\n", - "tensor([[-8.3402]])\n", - "tensor([[-9.7696]])\n", + "tensor([[-8.4310]])\n", + "tensor([[-9.2733]])\n", "------------------------\n", - "tensor([[-8.3661]])\n", - "tensor([[-8.3010]])\n", + "tensor([[-7.6778]])\n", + "tensor([[-8.1643]])\n", "------------------------\n", - "tensor([[-8.5132]])\n", - "tensor([[-5.8861]])\n", + "tensor([[-7.5975]])\n", + "tensor([[-7.9208]])\n", "------------------------\n", - "tensor([[-7.8197]])\n", - "tensor([[-7.4559]])\n", + "tensor([[-7.7921]])\n", + "tensor([[-6.8386]])\n", "------------------------\n", - "Epoch : 18 \t train loss: 2.2566493098148515 train MSE: tensor(2.2069, grad_fn=) test MSE: 3.3349221855002855\n", - "Corr: -0.013640141307520129\n", - "tensor(0.0484, grad_fn=)\n", - "tensor(0.0484, grad_fn=)\n", - "tensor(0.0485, grad_fn=)\n", - "tensor(0.0485, grad_fn=)\n", - "tensor(0.0486, grad_fn=)\n", - "tensor(0.0487, grad_fn=)\n", - "tensor(0.0487, grad_fn=)\n", - "tensor(0.0488, grad_fn=)\n", - "tensor(0.0489, grad_fn=)\n", - "tensor(0.0490, grad_fn=)\n", - "tensor(0.0490, grad_fn=)\n", - "tensor(0.0491, grad_fn=)\n", - "tensor(0.0491, grad_fn=)\n", - "tensor(0.0492, grad_fn=)\n", - "tensor(0.0493, grad_fn=)\n", - "tensor(0.0493, grad_fn=)\n", - "tensor(0.0494, grad_fn=)\n", - "tensor(0.0495, grad_fn=)\n", - "tensor(0.0496, grad_fn=)\n", - "tensor(0.0497, grad_fn=)\n", - "tensor([[-7.5737]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.2183]])\n", + "tensor([[-8.9293]])\n", "tensor([[-11.2441]])\n", "------------------------\n", - "tensor([[-8.2901]])\n", - "tensor([[-7.5986]])\n", + "tensor([[-7.7443]])\n", + "tensor([[-7.8539]])\n", "------------------------\n", - "tensor([[-7.2418]])\n", - "tensor([[-4.5086]])\n", + "tensor([[-7.6303]])\n", + "tensor([[-5.3098]])\n", "------------------------\n", - "tensor([[-7.3772]])\n", - "tensor([[-9.1612]])\n", - "------------------------\n", - "tensor([[-7.9828]])\n", - "tensor([[-7.]])\n", - "------------------------\n", - "tensor([[-7.9841]])\n", + "tensor([[-7.6427]])\n", + "tensor([[-5.8327]])\n", + "------------------------\n", + "tensor([[-8.4308]])\n", + "tensor([[-9.7905]])\n", + "------------------------\n", + "tensor([[-7.5703]])\n", + "tensor([[-7.6021]])\n", + "------------------------\n", + "tensor([[-7.5796]])\n", + "tensor([[-6.6198]])\n", + "------------------------\n", + "tensor([[-8.2020]])\n", + "tensor([[-11.3010]])\n", + "------------------------\n", + "tensor([[-8.3898]])\n", + "tensor([[-8.0044]])\n", + "------------------------\n", + "tensor([[-8.5567]])\n", + "tensor([[-8.8539]])\n", + "------------------------\n", + "tensor([[-7.6261]])\n", + "tensor([[-6.9586]])\n", + "------------------------\n", + "tensor([[-8.4621]])\n", + "tensor([[-8.5376]])\n", + "------------------------\n", + "tensor([[-8.7652]])\n", + "tensor([[-11.3979]])\n", + "------------------------\n", + "tensor([[-8.4143]])\n", + "tensor([[-11.2218]])\n", + "------------------------\n", + "Epoch : 18 \t train loss: 2.3946281757230072 train MSE: tensor(2.1459, grad_fn=) test MSE: 2.2316326380664995\n", + "Corr: 0.6931591922959954\n", + "tensor(0.2378, grad_fn=)\n", + "tensor(0.2377, grad_fn=)\n", + "tensor(0.2376, grad_fn=)\n", + "tensor(0.2375, grad_fn=)\n", + "tensor(0.2374, grad_fn=)\n", + "tensor(0.2374, grad_fn=)\n", + "tensor(0.2374, grad_fn=)\n", + "tensor(0.2374, grad_fn=)\n", + "tensor(0.2374, grad_fn=)\n", + "tensor(0.2374, grad_fn=)\n", + "tensor(0.2373, grad_fn=)\n", + "tensor(0.2374, grad_fn=)\n", + "tensor(0.2374, grad_fn=)\n", + "tensor(0.2375, grad_fn=)\n", + "tensor(0.2375, grad_fn=)\n", + "tensor(0.2375, grad_fn=)\n", + "tensor(0.2376, grad_fn=)\n", + "tensor(0.2376, grad_fn=)\n", + "tensor(0.2375, grad_fn=)\n", + "tensor(0.2375, grad_fn=)\n", + "tensor([[-7.6188]])\n", + "tensor([[-6.4202]])\n", + "------------------------\n", + "tensor([[-8.4243]])\n", + "tensor([[-7.1427]])\n", + "------------------------\n", + "tensor([[-8.6436]])\n", + "tensor([[-8.0506]])\n", + "------------------------\n", + "tensor([[-8.6168]])\n", + "tensor([[-7.0362]])\n", + "------------------------\n", + "tensor([[-8.5220]])\n", + "tensor([[-9.2733]])\n", + "------------------------\n", + "tensor([[-7.7593]])\n", "tensor([[-8.1643]])\n", "------------------------\n", - "tensor([[-7.9280]])\n", - "tensor([[-9.0969]])\n", - "------------------------\n", - "tensor([[-8.1739]])\n", - "tensor([[-7.5229]])\n", + "tensor([[-7.6712]])\n", + "tensor([[-7.9208]])\n", "------------------------\n", - "tensor([[-8.1166]])\n", - "tensor([[-9.9914]])\n", + "tensor([[-7.8510]])\n", + "tensor([[-6.8386]])\n", "------------------------\n", - "tensor([[-6.3514]])\n", - "tensor([[-8.4559]])\n", - "------------------------\n", - "tensor([[-7.6798]])\n", - "tensor([[-8.1308]])\n", + "tensor([[-9.0163]])\n", + "tensor([[-11.2441]])\n", "------------------------\n", - "tensor([[-7.6350]])\n", - "tensor([[-10.5229]])\n", + "tensor([[-7.8243]])\n", + "tensor([[-7.8539]])\n", "------------------------\n", - "tensor([[-7.9168]])\n", - "tensor([[-4.3979]])\n", + "tensor([[-7.7083]])\n", + "tensor([[-5.3098]])\n", "------------------------\n", - "tensor([[-8.2300]])\n", - "tensor([[-8.]])\n", + "tensor([[-7.7223]])\n", + "tensor([[-5.8327]])\n", "------------------------\n", - "tensor([[-8.4178]])\n", - "tensor([[-6.5229]])\n", + "tensor([[-8.5115]])\n", + "tensor([[-9.7905]])\n", "------------------------\n", - "tensor([[-8.4497]])\n", - "tensor([[-9.3010]])\n", + "tensor([[-7.6410]])\n", + "tensor([[-7.6021]])\n", "------------------------\n", - "tensor([[-8.3086]])\n", - "tensor([[-9.7696]])\n", + "tensor([[-7.6529]])\n", + "tensor([[-6.6198]])\n", "------------------------\n", - "tensor([[-8.3362]])\n", - "tensor([[-8.3010]])\n", + "tensor([[-8.2459]])\n", + "tensor([[-11.3010]])\n", + "------------------------\n", + "tensor([[-8.4608]])\n", + "tensor([[-8.0044]])\n", + "------------------------\n", + "tensor([[-8.6414]])\n", + "tensor([[-8.8539]])\n", + "------------------------\n", + "tensor([[-7.6982]])\n", + "tensor([[-6.9586]])\n", + "------------------------\n", + "tensor([[-8.5209]])\n", + "tensor([[-8.5376]])\n", + "------------------------\n", + "tensor([[-8.8215]])\n", + "tensor([[-11.3979]])\n", + "------------------------\n", + "tensor([[-8.5054]])\n", + "tensor([[-11.2218]])\n", + "------------------------\n", + "Epoch : 19 \t train loss: 2.6471949994953627 train MSE: tensor(2.3988, grad_fn=) test MSE: 2.222215747966071\n", + "Corr: 0.6876167524643889\n", + "tensor(0.2375, grad_fn=)\n", + "tensor(0.2375, grad_fn=)\n", + "tensor(0.2376, grad_fn=)\n", + "tensor(0.2376, grad_fn=)\n", + "tensor(0.2376, grad_fn=)\n", + "tensor(0.2376, grad_fn=)\n", + "tensor(0.2376, grad_fn=)\n", + "tensor(0.2376, grad_fn=)\n", + "tensor(0.2375, grad_fn=)\n", + "tensor(0.2374, grad_fn=)\n", + "tensor(0.2373, grad_fn=)\n", + "tensor(0.2372, grad_fn=)\n", + "tensor(0.2372, grad_fn=)\n", + "tensor(0.2371, grad_fn=)\n", + "tensor(0.2370, grad_fn=)\n", + "tensor(0.2370, grad_fn=)\n", + "tensor(0.2369, grad_fn=)\n", + "tensor(0.2369, grad_fn=)\n", + "tensor(0.2368, grad_fn=)\n", + "tensor(0.2368, grad_fn=)\n", + "tensor([[-7.0222]])\n", + "tensor([[-6.4202]])\n", + "------------------------\n", + "tensor([[-7.9095]])\n", + "tensor([[-7.1427]])\n", + "------------------------\n", + "tensor([[-8.3599]])\n", + "tensor([[-8.0506]])\n", + "------------------------\n", + "tensor([[-8.1592]])\n", + "tensor([[-7.0362]])\n", + "------------------------\n", + "tensor([[-8.0614]])\n", + "tensor([[-9.2733]])\n", + "------------------------\n", + "tensor([[-7.1688]])\n", + "tensor([[-8.1643]])\n", "------------------------\n", - "tensor([[-8.4532]])\n", - "tensor([[-5.8861]])\n", + "tensor([[-7.0742]])\n", + "tensor([[-7.9208]])\n", "------------------------\n", - "tensor([[-7.7581]])\n", - "tensor([[-7.4559]])\n", + "tensor([[-7.3297]])\n", + "tensor([[-6.8386]])\n", "------------------------\n", - "Epoch : 19 \t train loss: 2.1527417137805633 train MSE: tensor(2.1016, grad_fn=) test MSE: 3.2434937590455992\n", - "Corr: 0.03318177088004287\n", - "tensor(0.0498, grad_fn=)\n", - "tensor(0.0499, grad_fn=)\n", - "tensor(0.0500, grad_fn=)\n", - "tensor(0.0501, grad_fn=)\n", - "tensor(0.0503, grad_fn=)\n", - "tensor(0.0504, grad_fn=)\n", - "tensor(0.0505, grad_fn=)\n", - "tensor(0.0507, grad_fn=)\n", - "tensor(0.0508, grad_fn=)\n", - "tensor(0.0509, grad_fn=)\n", - "tensor(0.0509, grad_fn=)\n", - "tensor(0.0510, grad_fn=)\n", - "tensor(0.0510, grad_fn=)\n", - "tensor(0.0511, grad_fn=)\n", - "tensor(0.0511, grad_fn=)\n", - "tensor(0.0511, grad_fn=)\n", - "tensor(0.0511, grad_fn=)\n", - "tensor(0.0511, grad_fn=)\n", - "tensor(0.0512, grad_fn=)\n", - "tensor(0.0512, grad_fn=)\n", - "tensor([[-7.4294]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.1064]])\n", + "tensor([[-8.5307]])\n", "tensor([[-11.2441]])\n", "------------------------\n", - "tensor([[-8.1878]])\n", - "tensor([[-7.5986]])\n", - "------------------------\n", - "tensor([[-7.0550]])\n", - "tensor([[-4.5086]])\n", - "------------------------\n", - "tensor([[-7.3711]])\n", - "tensor([[-9.1612]])\n", + "tensor([[-7.2466]])\n", + "tensor([[-7.8539]])\n", "------------------------\n", - "tensor([[-7.8278]])\n", - "tensor([[-7.]])\n", + "tensor([[-7.1018]])\n", + "tensor([[-5.3098]])\n", "------------------------\n", - "tensor([[-7.8704]])\n", - "tensor([[-8.1643]])\n", - "------------------------\n", - "tensor([[-7.7881]])\n", - "tensor([[-9.0969]])\n", - "------------------------\n", - "tensor([[-8.0745]])\n", - "tensor([[-7.5229]])\n", + "tensor([[-7.1216]])\n", + "tensor([[-5.8327]])\n", "------------------------\n", - "tensor([[-8.0067]])\n", - "tensor([[-9.9914]])\n", + "tensor([[-8.0552]])\n", + "tensor([[-9.7905]])\n", "------------------------\n", - "tensor([[-6.3394]])\n", - "tensor([[-8.4559]])\n", + "tensor([[-7.0288]])\n", + "tensor([[-7.6021]])\n", "------------------------\n", - "tensor([[-7.5223]])\n", - "tensor([[-8.1308]])\n", + "tensor([[-7.0397]])\n", + "tensor([[-6.6198]])\n", "------------------------\n", - "tensor([[-7.6137]])\n", - "tensor([[-10.5229]])\n", - "------------------------\n", - "tensor([[-7.7722]])\n", - "tensor([[-4.3979]])\n", + "tensor([[-7.8505]])\n", + "tensor([[-11.3010]])\n", "------------------------\n", - "tensor([[-8.1019]])\n", - "tensor([[-8.]])\n", + "tensor([[-8.0489]])\n", + "tensor([[-8.0044]])\n", "------------------------\n", - "tensor([[-8.3211]])\n", - "tensor([[-6.5229]])\n", + "tensor([[-8.1417]])\n", + "tensor([[-8.8539]])\n", "------------------------\n", - "tensor([[-8.3099]])\n", - "tensor([[-9.3010]])\n", + "tensor([[-7.0845]])\n", + "tensor([[-6.9586]])\n", "------------------------\n", - "tensor([[-8.1720]])\n", - "tensor([[-9.7696]])\n", + "tensor([[-8.0655]])\n", + "tensor([[-8.5376]])\n", "------------------------\n", - "tensor([[-8.2153]])\n", - "tensor([[-8.3010]])\n", + "tensor([[-8.3581]])\n", + "tensor([[-11.3979]])\n", "------------------------\n", - "tensor([[-8.3191]])\n", - "tensor([[-5.8861]])\n", + "tensor([[-8.0114]])\n", + "tensor([[-11.2218]])\n", "------------------------\n", - "tensor([[-7.6083]])\n" + "Epoch : 20 \t train loss: 2.5119255040985307 train MSE: tensor(2.2638, grad_fn=) test MSE: 2.456649085972458\n", + "Corr: 0.6813196472315655\n", + "tensor(0.2367, grad_fn=)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "tensor([[-7.4559]])\n", + "tensor(0.2366, grad_fn=)\n", + "tensor(0.2365, grad_fn=)\n", + "tensor(0.2364, grad_fn=)\n", + "tensor(0.2364, grad_fn=)\n", + "tensor(0.2365, grad_fn=)\n", + "tensor(0.2365, grad_fn=)\n", + "tensor(0.2366, grad_fn=)\n", + "tensor(0.2367, grad_fn=)\n", + "tensor(0.2368, grad_fn=)\n", + "tensor(0.2370, grad_fn=)\n", + "tensor(0.2371, grad_fn=)\n", + "tensor(0.2371, grad_fn=)\n", + "tensor(0.2371, grad_fn=)\n", + "tensor(0.2371, grad_fn=)\n", + "tensor(0.2370, grad_fn=)\n", + "tensor(0.2369, grad_fn=)\n", + "tensor(0.2368, grad_fn=)\n", + "tensor(0.2366, grad_fn=)\n", + "tensor(0.2364, grad_fn=)\n", + "tensor([[-7.2875]])\n", + "tensor([[-6.4202]])\n", + "------------------------\n", + "tensor([[-8.1616]])\n", + "tensor([[-7.1427]])\n", + "------------------------\n", + "tensor([[-8.6448]])\n", + "tensor([[-8.0506]])\n", "------------------------\n", - "Epoch : 20 \t train loss: 2.278400489595547 train MSE: tensor(2.2255, grad_fn=) test MSE: 3.2161544208592248\n", - "Corr: 0.07495513133904257\n", - "tensor(0.0512, grad_fn=)\n", - "tensor(0.0513, grad_fn=)\n", - "tensor(0.0514, grad_fn=)\n", - "tensor(0.0514, grad_fn=)\n", - "tensor(0.0515, grad_fn=)\n", - "tensor(0.0516, grad_fn=)\n", - "tensor(0.0517, grad_fn=)\n", - "tensor(0.0518, grad_fn=)\n", - "tensor(0.0520, grad_fn=)\n", - "tensor(0.0521, grad_fn=)\n", - "tensor(0.0522, grad_fn=)\n", - "tensor(0.0523, grad_fn=)\n", - "tensor(0.0523, grad_fn=)\n", - "tensor(0.0524, grad_fn=)\n", - "tensor(0.0525, grad_fn=)\n", - "tensor(0.0526, grad_fn=)\n", - "tensor(0.0527, grad_fn=)\n", - "tensor(0.0528, grad_fn=)\n", - "tensor(0.0529, grad_fn=)\n", - "tensor(0.0530, grad_fn=)\n", - "tensor([[-7.6134]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.3344]])\n", - "tensor([[-11.2441]])\n", - "------------------------\n", - "tensor([[-8.4264]])\n", - "tensor([[-7.5986]])\n", + "tensor([[-8.4333]])\n", + "tensor([[-7.0362]])\n", "------------------------\n", - "tensor([[-7.1868]])\n", - "tensor([[-4.5086]])\n", + "tensor([[-8.3288]])\n", + "tensor([[-9.2733]])\n", "------------------------\n", - "tensor([[-7.5315]])\n", - "tensor([[-9.1612]])\n", + "tensor([[-7.4372]])\n", + "tensor([[-8.1643]])\n", "------------------------\n", - "tensor([[-8.0185]])\n", - "tensor([[-7.]])\n", + "tensor([[-7.3385]])\n", + "tensor([[-7.9208]])\n", "------------------------\n", - "tensor([[-8.0954]])\n", - "tensor([[-8.1643]])\n", + "tensor([[-7.5938]])\n", + "tensor([[-6.8386]])\n", "------------------------\n", - "tensor([[-7.9988]])\n", - "tensor([[-9.0969]])\n", + "tensor([[-8.8122]])\n", + "tensor([[-11.2441]])\n", "------------------------\n", - "tensor([[-8.3181]])\n", - "tensor([[-7.5229]])\n", + "tensor([[-7.5100]])\n", + "tensor([[-7.8539]])\n", "------------------------\n", - "tensor([[-8.2484]])\n", - "tensor([[-9.9914]])\n", + "tensor([[-7.3729]])\n", + "tensor([[-5.3098]])\n", "------------------------\n", - "tensor([[-6.4718]])\n", - "tensor([[-8.4559]])\n", + "tensor([[-7.3901]])\n", + "tensor([[-5.8327]])\n", "------------------------\n", - "tensor([[-7.7128]])\n", - "tensor([[-8.1308]])\n", + "tensor([[-8.3297]])\n", + "tensor([[-9.7905]])\n", "------------------------\n", - "tensor([[-7.7635]])\n", - "tensor([[-10.5229]])\n", + "tensor([[-7.2941]])\n", + "tensor([[-7.6021]])\n", "------------------------\n", - "tensor([[-7.9776]])\n", - "tensor([[-4.3979]])\n", + "tensor([[-7.3111]])\n", + "tensor([[-6.6198]])\n", "------------------------\n", - "tensor([[-8.3180]])\n", - "tensor([[-8.]])\n", + "tensor([[-8.1336]])\n", + "tensor([[-11.3010]])\n", "------------------------\n", - "tensor([[-8.5750]])\n", - "tensor([[-6.5229]])\n", + "tensor([[-8.3151]])\n", + "tensor([[-8.0044]])\n", "------------------------\n", - "tensor([[-8.5275]])\n", - "tensor([[-9.3010]])\n", + "tensor([[-8.3971]])\n", + "tensor([[-8.8539]])\n", "------------------------\n", - "tensor([[-8.3918]])\n", - "tensor([[-9.7696]])\n", + "tensor([[-7.3501]])\n", + "tensor([[-6.9586]])\n", "------------------------\n", - "tensor([[-8.4333]])\n", - "tensor([[-8.3010]])\n", + "tensor([[-8.3473]])\n", + "tensor([[-8.5376]])\n", "------------------------\n", - "tensor([[-8.5383]])\n", - "tensor([[-5.8861]])\n", + "tensor([[-8.6368]])\n", + "tensor([[-11.3979]])\n", "------------------------\n", - "tensor([[-7.8061]])\n", - "tensor([[-7.4559]])\n", + "tensor([[-8.2814]])\n", + "tensor([[-11.2218]])\n", "------------------------\n", - "Epoch : 21 \t train loss: 2.1575419906690887 train MSE: tensor(2.1032, grad_fn=) test MSE: 3.155672526585736\n", - "Corr: 0.07549308274963411\n", - "tensor(0.0530, grad_fn=)\n", - "tensor(0.0530, grad_fn=)\n", - "tensor(0.0531, grad_fn=)\n", - "tensor(0.0532, grad_fn=)\n", - "tensor(0.0532, grad_fn=)\n", - "tensor(0.0533, grad_fn=)\n", - "tensor(0.0533, grad_fn=)\n", - "tensor(0.0534, grad_fn=)\n", - "tensor(0.0534, grad_fn=)\n", - "tensor(0.0535, grad_fn=)\n", - "tensor(0.0535, grad_fn=)\n", - "tensor(0.0536, grad_fn=)\n", - "tensor(0.0537, grad_fn=)\n", - "tensor(0.0537, grad_fn=)\n", - "tensor(0.0538, grad_fn=)\n", - "tensor(0.0539, grad_fn=)\n", - "tensor(0.0539, grad_fn=)\n", - "tensor(0.0540, grad_fn=)\n", - "tensor(0.0540, grad_fn=)\n", - "tensor(0.0541, grad_fn=)\n", - "tensor([[-7.5152]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.2629]])\n", - "tensor([[-11.2441]])\n", + "Epoch : 21 \t train loss: 2.4748361313265135 train MSE: tensor(2.2273, grad_fn=) test MSE: 2.2111185142262415\n", + "Corr: 0.6836510665144331\n", + "tensor(0.2363, grad_fn=)\n", + "tensor(0.2362, grad_fn=)\n", + "tensor(0.2362, grad_fn=)\n", + "tensor(0.2361, grad_fn=)\n", + "tensor(0.2362, grad_fn=)\n", + "tensor(0.2362, grad_fn=)\n", + "tensor(0.2362, grad_fn=)\n", + "tensor(0.2363, grad_fn=)\n", + "tensor(0.2363, grad_fn=)\n", + "tensor(0.2364, grad_fn=)\n", + "tensor(0.2365, grad_fn=)\n", + "tensor(0.2365, grad_fn=)\n", + "tensor(0.2364, grad_fn=)\n", + "tensor(0.2364, grad_fn=)\n", + "tensor(0.2363, grad_fn=)\n", + "tensor(0.2363, grad_fn=)\n", + "tensor(0.2361, grad_fn=)\n", + "tensor(0.2360, grad_fn=)\n", + "tensor(0.2359, grad_fn=)\n", + "tensor(0.2358, grad_fn=)\n", + "tensor([[-7.1470]])\n", + "tensor([[-6.4202]])\n", "------------------------\n", - "tensor([[-8.3526]])\n", - "tensor([[-7.5986]])\n", + "tensor([[-8.0426]])\n", + "tensor([[-7.1427]])\n", "------------------------\n", - "tensor([[-7.0505]])\n", - "tensor([[-4.5086]])\n", + "tensor([[-8.5761]])\n", + "tensor([[-8.0506]])\n", "------------------------\n", - "tensor([[-7.5643]])\n", - "tensor([[-9.1612]])\n", + "tensor([[-8.3408]])\n", + "tensor([[-7.0362]])\n", "------------------------\n", - "tensor([[-7.9166]])\n", - "tensor([[-7.]])\n", + "tensor([[-8.2450]])\n", + "tensor([[-9.2733]])\n", "------------------------\n", - "tensor([[-8.0227]])\n", + "tensor([[-7.3042]])\n", "tensor([[-8.1643]])\n", "------------------------\n", - "tensor([[-7.9222]])\n", - "tensor([[-9.0969]])\n", + "tensor([[-7.1996]])\n", + "tensor([[-7.9208]])\n", + "------------------------\n", + "tensor([[-7.4702]])\n", + "tensor([[-6.8386]])\n", + "------------------------\n", + "tensor([[-8.7254]])\n", + "tensor([[-11.2441]])\n", "------------------------\n", - "tensor([[-8.2566]])\n", - "tensor([[-7.5229]])\n", + "tensor([[-7.3816]])\n", + "tensor([[-7.8539]])\n", "------------------------\n", - "tensor([[-8.1828]])\n", - "tensor([[-9.9914]])\n", + "tensor([[-7.2309]])\n", + "tensor([[-5.3098]])\n", "------------------------\n", - "tensor([[-6.5015]])\n", - "tensor([[-8.4559]])\n", + "tensor([[-7.2499]])\n", + "tensor([[-5.8327]])\n", "------------------------\n", - "tensor([[-7.6392]])\n", - "tensor([[-8.1308]])\n", + "tensor([[-8.2404]])\n", + "tensor([[-9.7905]])\n", "------------------------\n", - "tensor([[-7.7908]])\n", - "tensor([[-10.5229]])\n", + "tensor([[-7.1514]])\n", + "tensor([[-7.6021]])\n", "------------------------\n", - "tensor([[-7.8860]])\n", - "tensor([[-4.3979]])\n", + "tensor([[-7.1654]])\n", + "tensor([[-6.6198]])\n", "------------------------\n", - "tensor([[-8.2506]])\n", - "tensor([[-8.]])\n", + "tensor([[-8.0248]])\n", + "tensor([[-11.3010]])\n", "------------------------\n", - "tensor([[-8.5159]])\n", - "tensor([[-6.5229]])\n", + "tensor([[-8.2263]])\n", + "tensor([[-8.0044]])\n", "------------------------\n", - "tensor([[-8.4602]])\n", - "tensor([[-9.3010]])\n", + "tensor([[-8.2857]])\n", + "tensor([[-8.8539]])\n", "------------------------\n", - "tensor([[-8.3319]])\n", - "tensor([[-9.7696]])\n", + "tensor([[-7.2054]])\n", + "tensor([[-6.9586]])\n", "------------------------\n", - "tensor([[-8.3443]])\n", - "tensor([[-8.3010]])\n", + "tensor([[-8.2419]])\n", + "tensor([[-8.5376]])\n", "------------------------\n", - "tensor([[-8.4747]])\n", - "tensor([[-5.8861]])\n", + "tensor([[-8.5374]])\n", + "tensor([[-11.3979]])\n", "------------------------\n", - "tensor([[-7.7142]])\n", - "tensor([[-7.4559]])\n", + "tensor([[-8.1876]])\n", + "tensor([[-11.2218]])\n", "------------------------\n", - "Epoch : 22 \t train loss: 2.1341663565954607 train MSE: tensor(2.0783, grad_fn=) test MSE: 3.094154747097664\n", - "Corr: 0.11575124841384607\n", - "tensor(0.0542, grad_fn=)\n", - "tensor(0.0543, grad_fn=)\n", - "tensor(0.0544, grad_fn=)\n", - "tensor(0.0545, grad_fn=)\n", - "tensor(0.0546, grad_fn=)\n", - "tensor(0.0547, grad_fn=)\n", - "tensor(0.0548, grad_fn=)\n", - "tensor(0.0548, grad_fn=)\n", - "tensor(0.0549, grad_fn=)\n", - "tensor(0.0550, grad_fn=)\n", - "tensor(0.0551, grad_fn=)\n", - "tensor(0.0551, grad_fn=)\n", - "tensor(0.0552, grad_fn=)\n", - "tensor(0.0552, grad_fn=)\n", - "tensor(0.0553, grad_fn=)\n", - "tensor(0.0553, grad_fn=)\n", - "tensor(0.0554, grad_fn=)\n", - "tensor(0.0554, grad_fn=)\n", - "tensor(0.0555, grad_fn=)\n", - "tensor(0.0555, grad_fn=)\n", - "tensor([[-7.4760]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.2766]])\n", - "tensor([[-11.2441]])\n", + "Epoch : 22 \t train loss: 2.356171215281767 train MSE: tensor(2.1091, grad_fn=) test MSE: 2.2657371673055673\n", + "Corr: 0.6829383843289197\n", + "tensor(0.2357, grad_fn=)\n", + "tensor(0.2357, grad_fn=)\n", + "tensor(0.2356, grad_fn=)\n", + "tensor(0.2356, grad_fn=)\n", + "tensor(0.2356, grad_fn=)\n", + "tensor(0.2357, grad_fn=)\n", + "tensor(0.2357, grad_fn=)\n", + "tensor(0.2357, grad_fn=)\n", + "tensor(0.2358, grad_fn=)\n", + "tensor(0.2358, grad_fn=)\n", + "tensor(0.2358, grad_fn=)\n", + "tensor(0.2358, grad_fn=)\n", + "tensor(0.2358, grad_fn=)\n", + "tensor(0.2358, grad_fn=)\n", + "tensor(0.2358, grad_fn=)\n", + "tensor(0.2357, grad_fn=)\n", + "tensor(0.2356, grad_fn=)\n", + "tensor(0.2356, grad_fn=)\n", + "tensor(0.2355, grad_fn=)\n", + "tensor(0.2354, grad_fn=)\n", + "tensor([[-7.3377]])\n", + "tensor([[-6.4202]])\n", "------------------------\n", - "tensor([[-8.3643]])\n", - "tensor([[-7.5986]])\n", + "tensor([[-8.2364]])\n", + "tensor([[-7.1427]])\n", "------------------------\n", - "tensor([[-6.9658]])\n", - "tensor([[-4.5086]])\n", + "tensor([[-8.7102]])\n", + "tensor([[-8.0506]])\n", "------------------------\n", - "tensor([[-7.5909]])\n", - "tensor([[-9.1612]])\n", + "tensor([[-8.5315]])\n", + "tensor([[-7.0362]])\n", "------------------------\n", - "tensor([[-7.8774]])\n", - "tensor([[-7.]])\n", + "tensor([[-8.4418]])\n", + "tensor([[-9.2733]])\n", "------------------------\n", - "tensor([[-8.0213]])\n", + "tensor([[-7.4986]])\n", "tensor([[-8.1643]])\n", "------------------------\n", - "tensor([[-7.9014]])\n", - "tensor([[-9.0969]])\n", + "tensor([[-7.3901]])\n", + "tensor([[-7.9208]])\n", "------------------------\n", - "tensor([[-8.2811]])\n", - "tensor([[-7.5229]])\n", + "tensor([[-7.6433]])\n", + "tensor([[-6.8386]])\n", "------------------------\n", - "tensor([[-8.1909]])\n", - "tensor([[-9.9914]])\n", + "tensor([[-8.9334]])\n", + "tensor([[-11.2441]])\n", "------------------------\n", - "tensor([[-6.5253]])\n", - "tensor([[-8.4559]])\n", + "tensor([[-7.5754]])\n", + "tensor([[-7.8539]])\n", "------------------------\n", - "tensor([[-7.6349]])\n", - "tensor([[-8.1308]])\n", + "tensor([[-7.4250]])\n", + "tensor([[-5.3098]])\n", "------------------------\n", - "tensor([[-7.8068]])\n", - "tensor([[-10.5229]])\n", + "tensor([[-7.4435]])\n", + "tensor([[-5.8327]])\n", "------------------------\n", - "tensor([[-7.8541]])\n", - "tensor([[-4.3979]])\n", + "tensor([[-8.4329]])\n", + "tensor([[-9.7905]])\n", "------------------------\n", - "tensor([[-8.2569]])\n", - "tensor([[-8.]])\n", + "tensor([[-7.3415]])\n", + "tensor([[-7.6021]])\n", "------------------------\n", - "tensor([[-8.5337]])\n", - "tensor([[-6.5229]])\n", + "tensor([[-7.3565]])\n", + "tensor([[-6.6198]])\n", "------------------------\n", - "tensor([[-8.4986]])\n", - "tensor([[-9.3010]])\n", + "tensor([[-8.1871]])\n", + "tensor([[-11.3010]])\n", "------------------------\n", - "tensor([[-8.3508]])\n", - "tensor([[-9.7696]])\n", + "tensor([[-8.3963]])\n", + "tensor([[-8.0044]])\n", "------------------------\n", - "tensor([[-8.3425]])\n", - "tensor([[-8.3010]])\n", + "tensor([[-8.4827]])\n", + "tensor([[-8.8539]])\n", "------------------------\n", - "tensor([[-8.4676]])\n", - "tensor([[-5.8861]])\n", + "tensor([[-7.3997]])\n", + "tensor([[-6.9586]])\n", "------------------------\n", - "tensor([[-7.6804]])\n", - "tensor([[-7.4559]])\n", + "tensor([[-8.4107]])\n", + "tensor([[-8.5376]])\n", "------------------------\n", - "Epoch : 23 \t train loss: 2.1289222244337376 train MSE: tensor(2.0715, grad_fn=) test MSE: 3.0495575808398865\n", - "Corr: 0.14561442205953318\n", - "tensor(0.0556, grad_fn=)\n", - "tensor(0.0557, grad_fn=)\n", - "tensor(0.0558, grad_fn=)\n", - "tensor(0.0559, grad_fn=)\n", - "tensor(0.0559, grad_fn=)\n", - "tensor(0.0560, grad_fn=)\n", - "tensor(0.0561, grad_fn=)\n", - "tensor(0.0562, grad_fn=)\n", - "tensor(0.0562, grad_fn=)\n", - "tensor(0.0563, grad_fn=)\n", - "tensor(0.0564, grad_fn=)\n", - "tensor(0.0565, grad_fn=)\n", - "tensor(0.0566, grad_fn=)\n", - "tensor(0.0567, grad_fn=)\n", - "tensor(0.0568, grad_fn=)\n", - "tensor(0.0569, grad_fn=)\n", - "tensor(0.0570, grad_fn=)\n", - "tensor(0.0571, grad_fn=)\n", - "tensor(0.0571, grad_fn=)\n", - "tensor(0.0572, grad_fn=)\n", - "tensor([[-7.5684]])\n", - "tensor([[-9.3010]])\n", + "tensor([[-8.7296]])\n", + "tensor([[-11.3979]])\n", "------------------------\n", - "tensor([[-8.4113]])\n", - "tensor([[-11.2441]])\n", + "tensor([[-8.3957]])\n", + "tensor([[-11.2218]])\n", "------------------------\n", - "tensor([[-8.5000]])\n", - "tensor([[-7.5986]])\n", + "Epoch : 23 \t train loss: 2.36837728039112 train MSE: tensor(2.1219, grad_fn=) test MSE: 2.1371544730764898\n", + "Corr: 0.688611814705158\n", + "tensor(0.2354, grad_fn=)\n", + "tensor(0.2354, grad_fn=)\n", + "tensor(0.2354, grad_fn=)\n", + "tensor(0.2354, grad_fn=)\n", + "tensor(0.2355, grad_fn=)\n", + "tensor(0.2355, grad_fn=)\n", + "tensor(0.2354, grad_fn=)\n", + "tensor(0.2354, grad_fn=)\n", + "tensor(0.2353, grad_fn=)\n", + "tensor(0.2352, grad_fn=)\n", + "tensor(0.2352, grad_fn=)\n", + "tensor(0.2352, grad_fn=)\n", + "tensor(0.2351, grad_fn=)\n", + "tensor(0.2351, grad_fn=)\n", + "tensor(0.2350, grad_fn=)\n", + "tensor(0.2350, grad_fn=)\n", + "tensor(0.2349, grad_fn=)\n", + "tensor(0.2349, grad_fn=)\n", + "tensor(0.2350, grad_fn=)\n", + "tensor(0.2349, grad_fn=)\n", + "tensor([[-7.3793]])\n", + "tensor([[-6.4202]])\n", "------------------------\n", - "tensor([[-7.0253]])\n", - "tensor([[-4.5086]])\n", + "tensor([[-8.2695]])\n", + "tensor([[-7.1427]])\n", "------------------------\n", - "tensor([[-7.6849]])\n", - "tensor([[-9.1612]])\n", + "tensor([[-8.7938]])\n", + "tensor([[-8.0506]])\n", + "------------------------\n", + "tensor([[-8.5956]])\n", + "tensor([[-7.0362]])\n", "------------------------\n", - "tensor([[-7.9678]])\n", - "tensor([[-7.]])\n", + "tensor([[-8.5142]])\n", + "tensor([[-9.2733]])\n", "------------------------\n", - "tensor([[-8.1439]])\n", + "tensor([[-7.5463]])\n", "tensor([[-8.1643]])\n", "------------------------\n", - "tensor([[-8.0045]])\n", - "tensor([[-9.0969]])\n", + "tensor([[-7.4311]])\n", + "tensor([[-7.9208]])\n", "------------------------\n", - "tensor([[-8.4166]])\n", - "tensor([[-7.5229]])\n", + "tensor([[-7.6752]])\n", + "tensor([[-6.8386]])\n", "------------------------\n", - "tensor([[-8.3285]])\n", - "tensor([[-9.9914]])\n", + "tensor([[-9.0064]])\n", + "tensor([[-11.2441]])\n", "------------------------\n", - "tensor([[-6.6029]])\n", - "tensor([[-8.4559]])\n", + "tensor([[-7.6243]])\n", + "tensor([[-7.8539]])\n", "------------------------\n", - "tensor([[-7.7418]])\n", - "tensor([[-8.1308]])\n", + "tensor([[-7.4691]])\n", + "tensor([[-5.3098]])\n", "------------------------\n", - "tensor([[-7.8928]])\n", - "tensor([[-10.5229]])\n", + "tensor([[-7.4873]])\n", + "tensor([[-5.8327]])\n", "------------------------\n", - "tensor([[-7.9570]])\n", - "tensor([[-4.3979]])\n", + "tensor([[-8.5001]])\n", + "tensor([[-9.7905]])\n", "------------------------\n", - "tensor([[-8.3744]])\n", - "tensor([[-8.]])\n", + "tensor([[-7.3791]])\n", + "tensor([[-7.6021]])\n", "------------------------\n", - "tensor([[-8.6813]])\n", - "tensor([[-6.5229]])\n", + "tensor([[-7.3977]])\n", + "tensor([[-6.6198]])\n", "------------------------\n", - "tensor([[-8.6293]])\n", - "tensor([[-9.3010]])\n", + "tensor([[-8.2381]])\n", + "tensor([[-11.3010]])\n", "------------------------\n", - "tensor([[-8.4767]])\n", - "tensor([[-9.7696]])\n", + "tensor([[-8.4548]])\n", + "tensor([[-8.0044]])\n", "------------------------\n", - "tensor([[-8.4667]])\n", - "tensor([[-8.3010]])\n", + "tensor([[-8.5233]])\n", + "tensor([[-8.8539]])\n", "------------------------\n", - "tensor([[-8.6056]])\n", - "tensor([[-5.8861]])\n", + "tensor([[-7.4402]])\n", + "tensor([[-6.9586]])\n", "------------------------\n", - "tensor([[-7.7772]])\n", - "tensor([[-7.4559]])\n", + "tensor([[-8.4833]])\n", + "tensor([[-8.5376]])\n", + "------------------------\n", + "tensor([[-8.7905]])\n", + "tensor([[-11.3979]])\n", "------------------------\n", - "Epoch : 24 \t train loss: 2.19265831703074 train MSE: tensor(2.1338, grad_fn=) test MSE: 3.031657790776253\n", - "Corr: 0.1481021435536777\n", - "tensor(0.0572, grad_fn=)\n", - "tensor(0.0573, grad_fn=)\n", - "tensor(0.0573, grad_fn=)\n", - "tensor(0.0574, grad_fn=)\n", - "tensor(0.0575, grad_fn=)\n", - "tensor(0.0576, grad_fn=)\n", - "tensor(0.0576, grad_fn=)\n", - "tensor(0.0577, grad_fn=)\n" + "tensor([[-8.4577]])\n", + "tensor([[-11.2218]])\n", + "------------------------\n", + "Epoch : 24 \t train loss: 2.3189810646904836 train MSE: tensor(2.0730, grad_fn=) test MSE: 2.100901799022474\n", + "Corr: 0.6886826171997339\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "tensor(0.0577, grad_fn=)\n", - "tensor(0.0578, grad_fn=)\n", - "tensor(0.0578, grad_fn=)\n", - "tensor(0.0579, grad_fn=)\n", - "tensor(0.0579, grad_fn=)\n", - "tensor(0.0580, grad_fn=)\n", - "tensor(0.0581, grad_fn=)\n", - "tensor(0.0581, grad_fn=)\n", - "tensor(0.0582, grad_fn=)\n", - "tensor(0.0583, grad_fn=)\n", - "tensor(0.0584, grad_fn=)\n", - "tensor(0.0584, grad_fn=)\n", - "tensor([[-7.4434]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.2993]])\n", - "tensor([[-11.2441]])\n", + "tensor(0.2349, grad_fn=)\n", + "tensor(0.2347, grad_fn=)\n", + "tensor(0.2347, grad_fn=)\n", + "tensor(0.2346, grad_fn=)\n", + "tensor(0.2345, grad_fn=)\n", + "tensor(0.2344, grad_fn=)\n", + "tensor(0.2343, grad_fn=)\n", + "tensor(0.2343, grad_fn=)\n", + "tensor(0.2343, grad_fn=)\n", + "tensor(0.2343, grad_fn=)\n", + "tensor(0.2343, grad_fn=)\n", + "tensor(0.2344, grad_fn=)\n", + "tensor(0.2344, grad_fn=)\n", + "tensor(0.2344, grad_fn=)\n", + "tensor(0.2344, grad_fn=)\n", + "tensor(0.2344, grad_fn=)\n", + "tensor(0.2343, grad_fn=)\n", + "tensor(0.2343, grad_fn=)\n", + "tensor(0.2341, grad_fn=)\n", + "tensor(0.2340, grad_fn=)\n", + "tensor([[-7.2348]])\n", + "tensor([[-6.4202]])\n", "------------------------\n", - "tensor([[-8.3995]])\n", - "tensor([[-7.5986]])\n", + "tensor([[-8.1056]])\n", + "tensor([[-7.1427]])\n", "------------------------\n", - "tensor([[-6.8568]])\n", - "tensor([[-4.5086]])\n", + "tensor([[-8.6699]])\n", + "tensor([[-8.0506]])\n", "------------------------\n", - "tensor([[-7.6775]])\n", - "tensor([[-9.1612]])\n", + "tensor([[-8.4588]])\n", + "tensor([[-7.0362]])\n", "------------------------\n", - "tensor([[-7.8053]])\n", - "tensor([[-7.]])\n", + "tensor([[-8.3883]])\n", + "tensor([[-9.2733]])\n", "------------------------\n", - "tensor([[-8.0383]])\n", + "tensor([[-7.4029]])\n", "tensor([[-8.1643]])\n", "------------------------\n", - "tensor([[-7.8638]])\n", - "tensor([[-9.0969]])\n", + "tensor([[-7.2835]])\n", + "tensor([[-7.9208]])\n", "------------------------\n", - "tensor([[-8.3257]])\n", - "tensor([[-7.5229]])\n", + "tensor([[-7.5231]])\n", + "tensor([[-6.8386]])\n", "------------------------\n", - "tensor([[-8.2356]])\n", - "tensor([[-9.9914]])\n", + "tensor([[-8.8701]])\n", + "tensor([[-11.2441]])\n", "------------------------\n", - "tensor([[-6.5856]])\n", - "tensor([[-8.4559]])\n", + "tensor([[-7.4832]])\n", + "tensor([[-7.8539]])\n", "------------------------\n", - "tensor([[-7.6010]])\n", - "tensor([[-8.1308]])\n", + "tensor([[-7.3239]])\n", + "tensor([[-5.3098]])\n", "------------------------\n", - "tensor([[-7.8596]])\n", - "tensor([[-10.5229]])\n", + "tensor([[-7.3427]])\n", + "tensor([[-5.8327]])\n", "------------------------\n", - "tensor([[-7.8184]])\n", - "tensor([[-4.3979]])\n", + "tensor([[-8.3707]])\n", + "tensor([[-9.7905]])\n", "------------------------\n", - "tensor([[-8.2396]])\n", - "tensor([[-8.]])\n", + "tensor([[-7.2302]])\n", + "tensor([[-7.6021]])\n", "------------------------\n", - "tensor([[-8.5918]])\n", - "tensor([[-6.5229]])\n", + "tensor([[-7.2466]])\n", + "tensor([[-6.6198]])\n", "------------------------\n", - "tensor([[-8.4973]])\n", - "tensor([[-9.3010]])\n", + "tensor([[-8.1058]])\n", + "tensor([[-11.3010]])\n", "------------------------\n", - "tensor([[-8.3448]])\n", - "tensor([[-9.7696]])\n", + "tensor([[-8.3198]])\n", + "tensor([[-8.0044]])\n", "------------------------\n", - "tensor([[-8.3410]])\n", - "tensor([[-8.3010]])\n", + "tensor([[-8.3605]])\n", + "tensor([[-8.8539]])\n", "------------------------\n", - "tensor([[-8.4845]])\n", - "tensor([[-5.8861]])\n", + "tensor([[-7.2881]])\n", + "tensor([[-6.9586]])\n", "------------------------\n", - "tensor([[-7.6351]])\n", - "tensor([[-7.4559]])\n", + "tensor([[-8.3521]])\n", + "tensor([[-8.5376]])\n", "------------------------\n", - "Epoch : 25 \t train loss: 1.9808680315002145 train MSE: tensor(1.9205, grad_fn=) test MSE: 2.9886893145130244\n", - "Corr: 0.18276699971402458\n", - "tensor(0.0585, grad_fn=)\n", - "tensor(0.0585, grad_fn=)\n", - "tensor(0.0586, grad_fn=)\n", - "tensor(0.0586, grad_fn=)\n", - "tensor(0.0587, grad_fn=)\n", - "tensor(0.0587, grad_fn=)\n", - "tensor(0.0588, grad_fn=)\n", - "tensor(0.0589, grad_fn=)\n", - "tensor(0.0590, grad_fn=)\n", - "tensor(0.0590, grad_fn=)\n", - "tensor(0.0591, grad_fn=)\n", - "tensor(0.0592, grad_fn=)\n", - "tensor(0.0593, grad_fn=)\n", - "tensor(0.0593, grad_fn=)\n", - "tensor(0.0593, grad_fn=)\n", - "tensor(0.0594, grad_fn=)\n", - "tensor(0.0594, grad_fn=)\n", - "tensor(0.0595, grad_fn=)\n", - "tensor(0.0596, grad_fn=)\n", - "tensor(0.0596, grad_fn=)\n", - "tensor([[-7.3982]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.2882]])\n", - "tensor([[-11.2441]])\n", + "tensor([[-8.6468]])\n", + "tensor([[-11.3979]])\n", "------------------------\n", - "tensor([[-8.3967]])\n", - "tensor([[-7.5986]])\n", + "tensor([[-8.3224]])\n", + "tensor([[-11.2218]])\n", "------------------------\n", - "tensor([[-6.7706]])\n", - "tensor([[-4.5086]])\n", + "Epoch : 25 \t train loss: 2.2902483566134584 train MSE: tensor(2.0451, grad_fn=) test MSE: 2.1619849020445887\n", + "Corr: 0.6902941300786523\n", + "tensor(0.2338, grad_fn=)\n", + "tensor(0.2336, grad_fn=)\n", + "tensor(0.2334, grad_fn=)\n", + "tensor(0.2334, grad_fn=)\n", + "tensor(0.2333, grad_fn=)\n", + "tensor(0.2334, grad_fn=)\n", + "tensor(0.2334, grad_fn=)\n", + "tensor(0.2335, grad_fn=)\n", + "tensor(0.2336, grad_fn=)\n", + "tensor(0.2338, grad_fn=)\n", + "tensor(0.2339, grad_fn=)\n", + "tensor(0.2341, grad_fn=)\n", + "tensor(0.2342, grad_fn=)\n", + "tensor(0.2343, grad_fn=)\n", + "tensor(0.2343, grad_fn=)\n", + "tensor(0.2342, grad_fn=)\n", + "tensor(0.2340, grad_fn=)\n", + "tensor(0.2338, grad_fn=)\n", + "tensor(0.2336, grad_fn=)\n", + "tensor(0.2334, grad_fn=)\n", + "tensor([[-7.2124]])\n", + "tensor([[-6.4202]])\n", + "------------------------\n", + "tensor([[-8.0735]])\n", + "tensor([[-7.1427]])\n", + "------------------------\n", + "tensor([[-8.6369]])\n", + "tensor([[-8.0506]])\n", "------------------------\n", - "tensor([[-7.6764]])\n", - "tensor([[-9.1612]])\n", + "tensor([[-8.4226]])\n", + "tensor([[-7.0362]])\n", "------------------------\n", - "tensor([[-7.7596]])\n", - "tensor([[-7.]])\n", + "tensor([[-8.3720]])\n", + "tensor([[-9.2733]])\n", "------------------------\n", - "tensor([[-8.0323]])\n", + "tensor([[-7.3865]])\n", "tensor([[-8.1643]])\n", "------------------------\n", - "tensor([[-7.8398]])\n", - "tensor([[-9.0969]])\n", - "------------------------\n", - "tensor([[-8.3241]])\n", - "tensor([[-7.5229]])\n", + "tensor([[-7.2584]])\n", + "tensor([[-7.9208]])\n", "------------------------\n", - "tensor([[-8.2275]])\n", - "tensor([[-9.9914]])\n", + "tensor([[-7.4817]])\n", + "tensor([[-6.8386]])\n", "------------------------\n", - "tensor([[-6.5840]])\n", - "tensor([[-8.4559]])\n", - "------------------------\n", - "tensor([[-7.5594]])\n", - "tensor([[-8.1308]])\n", + "tensor([[-8.8473]])\n", + "tensor([[-11.2441]])\n", "------------------------\n", - "tensor([[-7.8489]])\n", - "tensor([[-10.5229]])\n", + "tensor([[-7.4616]])\n", + "tensor([[-7.8539]])\n", "------------------------\n", - "tensor([[-7.7920]])\n", - "tensor([[-4.3979]])\n", + "tensor([[-7.3057]])\n", + "tensor([[-5.3098]])\n", "------------------------\n", - "tensor([[-8.2116]])\n", - "tensor([[-8.]])\n", + "tensor([[-7.3246]])\n", + "tensor([[-5.8327]])\n", "------------------------\n", - "tensor([[-8.5968]])\n", - "tensor([[-6.5229]])\n", + "tensor([[-8.3439]])\n", + "tensor([[-9.7905]])\n", "------------------------\n", - "tensor([[-8.4631]])\n", - "tensor([[-9.3010]])\n", + "tensor([[-7.2041]])\n", + "tensor([[-7.6021]])\n", "------------------------\n", - "tensor([[-8.3161]])\n", - "tensor([[-9.7696]])\n", + "tensor([[-7.2256]])\n", + "tensor([[-6.6198]])\n", "------------------------\n", - "tensor([[-8.3148]])\n", - "tensor([[-8.3010]])\n", + "tensor([[-8.0350]])\n", + "tensor([[-11.3010]])\n", "------------------------\n", - "tensor([[-8.4550]])\n", - "tensor([[-5.8861]])\n", + "tensor([[-8.2796]])\n", + "tensor([[-8.0044]])\n", "------------------------\n", - "tensor([[-7.5984]])\n", - "tensor([[-7.4559]])\n", + "tensor([[-8.3338]])\n", + "tensor([[-8.8539]])\n", "------------------------\n", - "Epoch : 26 \t train loss: 2.0071298309873793 train MSE: tensor(1.9455, grad_fn=) test MSE: 2.9773742128496195\n", - "Corr: 0.1952925041638278\n", - "tensor(0.0597, grad_fn=)\n", - "tensor(0.0598, grad_fn=)\n", - "tensor(0.0598, grad_fn=)\n", - "tensor(0.0599, grad_fn=)\n", - "tensor(0.0600, grad_fn=)\n", - "tensor(0.0600, grad_fn=)\n", - "tensor(0.0601, grad_fn=)\n", - "tensor(0.0602, grad_fn=)\n", - "tensor(0.0602, grad_fn=)\n", - "tensor(0.0603, grad_fn=)\n", - "tensor(0.0604, grad_fn=)\n", - "tensor(0.0605, grad_fn=)\n", - "tensor(0.0606, grad_fn=)\n", - "tensor(0.0607, grad_fn=)\n", - "tensor(0.0608, grad_fn=)\n", - "tensor(0.0609, grad_fn=)\n", - "tensor(0.0611, grad_fn=)\n", - "tensor(0.0612, grad_fn=)\n", - "tensor(0.0613, grad_fn=)\n", - "tensor(0.0614, grad_fn=)\n", - "tensor([[-7.5922]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.5515]])\n", - "tensor([[-11.2441]])\n", + "tensor([[-7.2589]])\n", + "tensor([[-6.9586]])\n", "------------------------\n", - "tensor([[-8.6535]])\n", - "tensor([[-7.5986]])\n", + "tensor([[-8.3037]])\n", + "tensor([[-8.5376]])\n", "------------------------\n", - "tensor([[-6.9356]])\n", - "tensor([[-4.5086]])\n", + "tensor([[-8.5931]])\n", + "tensor([[-11.3979]])\n", "------------------------\n", - "tensor([[-7.8120]])\n", - "tensor([[-9.1612]])\n", + "tensor([[-8.3103]])\n", + "tensor([[-11.2218]])\n", "------------------------\n", - "tensor([[-7.9763]])\n", - "tensor([[-7.]])\n", + "Epoch : 26 \t train loss: 2.370212857240166 train MSE: tensor(2.1258, grad_fn=) test MSE: 2.1935315558856185\n", + "Corr: 0.6874482058743973\n", + "tensor(0.2331, grad_fn=)\n", + "tensor(0.2329, grad_fn=)\n", + "tensor(0.2328, grad_fn=)\n", + "tensor(0.2327, grad_fn=)\n", + "tensor(0.2327, grad_fn=)\n", + "tensor(0.2328, grad_fn=)\n", + "tensor(0.2329, grad_fn=)\n", + "tensor(0.2330, grad_fn=)\n", + "tensor(0.2331, grad_fn=)\n", + "tensor(0.2332, grad_fn=)\n", + "tensor(0.2332, grad_fn=)\n", + "tensor(0.2333, grad_fn=)\n", + "tensor(0.2333, grad_fn=)\n", + "tensor(0.2332, grad_fn=)\n", + "tensor(0.2331, grad_fn=)\n", + "tensor(0.2330, grad_fn=)\n", + "tensor(0.2328, grad_fn=)\n", + "tensor(0.2326, grad_fn=)\n", + "tensor(0.2324, grad_fn=)\n", + "tensor(0.2323, grad_fn=)\n", + "tensor([[-6.9212]])\n", + "tensor([[-6.4202]])\n", "------------------------\n", - "tensor([[-8.2736]])\n", - "tensor([[-8.1643]])\n", + "tensor([[-7.7962]])\n", + "tensor([[-7.1427]])\n", "------------------------\n", - "tensor([[-8.0628]])\n", - "tensor([[-9.0969]])\n", + "tensor([[-8.3845]])\n", + "tensor([[-8.0506]])\n", "------------------------\n", - "tensor([[-8.5754]])\n", - "tensor([[-7.5229]])\n", + "tensor([[-8.1749]])\n", + "tensor([[-7.0362]])\n", "------------------------\n", - "tensor([[-8.4748]])\n", - "tensor([[-9.9914]])\n", + "tensor([[-8.1251]])\n", + "tensor([[-9.2733]])\n", "------------------------\n", - "tensor([[-6.7109]])\n", - "tensor([[-8.4559]])\n", + "tensor([[-7.0957]])\n", + "tensor([[-8.1643]])\n", "------------------------\n", - "tensor([[-7.7648]])\n", - "tensor([[-8.1308]])\n", + "tensor([[-6.9664]])\n", + "tensor([[-7.9208]])\n", "------------------------\n", - "tensor([[-7.9904]])\n", - "tensor([[-10.5229]])\n", + "tensor([[-7.1973]])\n", + "tensor([[-6.8386]])\n", "------------------------\n", - "tensor([[-8.0271]])\n", - "tensor([[-4.3979]])\n", + "tensor([[-8.5932]])\n", + "tensor([[-11.2441]])\n", "------------------------\n", - "tensor([[-8.4427]])\n", - "tensor([[-8.]])\n", + "tensor([[-7.1787]])\n", + "tensor([[-7.8539]])\n", "------------------------\n", - "tensor([[-8.8550]])\n", - "tensor([[-6.5229]])\n", + "tensor([[-7.0100]])\n", + "tensor([[-5.3098]])\n", "------------------------\n", - "tensor([[-8.7031]])\n", - "tensor([[-9.3010]])\n", + "tensor([[-7.0305]])\n", + "tensor([[-5.8327]])\n", "------------------------\n", - "tensor([[-8.5535]])\n", - "tensor([[-9.7696]])\n", + "tensor([[-8.0928]])\n", + "tensor([[-9.7905]])\n", "------------------------\n", - "tensor([[-8.5616]])\n", - "tensor([[-8.3010]])\n", + "tensor([[-6.9083]])\n", + "tensor([[-7.6021]])\n", "------------------------\n", - "tensor([[-8.6674]])\n", - "tensor([[-5.8861]])\n", + "tensor([[-6.9239]])\n", + "tensor([[-6.6198]])\n", "------------------------\n", - "tensor([[-7.8265]])\n", - "tensor([[-7.4559]])\n", + "tensor([[-7.7857]])\n", + "tensor([[-11.3010]])\n", + "------------------------\n", + "tensor([[-8.0359]])\n", + "tensor([[-8.0044]])\n", + "------------------------\n", + "tensor([[-8.0587]])\n", + "tensor([[-8.8539]])\n", + "------------------------\n", + "tensor([[-6.9615]])\n", + "tensor([[-6.9586]])\n", + "------------------------\n", + "tensor([[-8.0543]])\n", + "tensor([[-8.5376]])\n", + "------------------------\n", + "tensor([[-8.3331]])\n", + "tensor([[-11.3979]])\n", + "------------------------\n", + "tensor([[-8.0523]])\n", + "tensor([[-11.2218]])\n", + "------------------------\n", + "Epoch : 27 \t train loss: 2.3406703550052015 train MSE: tensor(2.0971, grad_fn=) test MSE: 2.432478301189638\n", + "Corr: 0.6885222376201827\n", + "tensor(0.2321, grad_fn=)\n", + "tensor(0.2319, grad_fn=)\n", + "tensor(0.2318, grad_fn=)\n", + "tensor(0.2318, grad_fn=)\n", + "tensor(0.2319, grad_fn=)\n", + "tensor(0.2320, grad_fn=)\n", + "tensor(0.2321, grad_fn=)\n", + "tensor(0.2322, grad_fn=)\n", + "tensor(0.2323, grad_fn=)\n", + "tensor(0.2323, grad_fn=)\n", + "tensor(0.2323, grad_fn=)\n", + "tensor(0.2323, grad_fn=)\n", + "tensor(0.2322, grad_fn=)\n", + "tensor(0.2321, grad_fn=)\n", + "tensor(0.2321, grad_fn=)\n", + "tensor(0.2321, grad_fn=)\n", + "tensor(0.2320, grad_fn=)\n", + "tensor(0.2320, grad_fn=)\n", + "tensor(0.2319, grad_fn=)\n", + "tensor(0.2318, grad_fn=)\n", + "tensor([[-7.3565]])\n", + "tensor([[-6.4202]])\n", + "------------------------\n", + "tensor([[-8.1625]])\n", + "tensor([[-7.1427]])\n", "------------------------\n", - "Epoch : 27 \t train loss: 1.9461875591931488 train MSE: tensor(1.8831, grad_fn=) test MSE: 2.9814621152444962\n", - "Corr: 0.18261231698578848\n", - "tensor(0.0615, grad_fn=)\n", - "tensor(0.0615, grad_fn=)\n", - "tensor(0.0616, grad_fn=)\n", - "tensor(0.0617, grad_fn=)\n", - "tensor(0.0618, grad_fn=)\n", - "tensor(0.0618, grad_fn=)\n", - "tensor(0.0618, grad_fn=)\n", - "tensor(0.0618, grad_fn=)\n", - "tensor(0.0619, grad_fn=)\n", - "tensor(0.0619, grad_fn=)\n", - "tensor(0.0619, grad_fn=)\n", - "tensor(0.0620, grad_fn=)\n", - "tensor(0.0620, grad_fn=)\n", - "tensor(0.0621, grad_fn=)\n", - "tensor(0.0621, grad_fn=)\n", - "tensor(0.0622, grad_fn=)\n", - "tensor(0.0623, grad_fn=)\n", - "tensor(0.0624, grad_fn=)\n", - "tensor(0.0626, grad_fn=)\n", - "tensor(0.0627, grad_fn=)\n", - "tensor([[-7.4941]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.4805]])\n", - "tensor([[-11.2441]])\n", + "tensor([[-8.7796]])\n", + "tensor([[-8.0506]])\n", "------------------------\n", - "tensor([[-8.6013]])\n", - "tensor([[-7.5986]])\n", + "tensor([[-8.6326]])\n", + "tensor([[-7.0362]])\n", "------------------------\n", - "tensor([[-6.7796]])\n", - "tensor([[-4.5086]])\n", + "tensor([[-8.5600]])\n", + "tensor([[-9.2733]])\n", "------------------------\n", - "tensor([[-7.8012]])\n", - "tensor([[-9.1612]])\n", + "tensor([[-7.5350]])\n", + "tensor([[-8.1643]])\n", "------------------------\n", - "tensor([[-7.8699]])\n", - "tensor([[-7.]])\n", + "tensor([[-7.3990]])\n", + "tensor([[-7.9208]])\n", "------------------------\n", - "tensor([[-8.2122]])\n", - "tensor([[-8.1643]])\n", + "tensor([[-7.6199]])\n", + "tensor([[-6.8386]])\n", "------------------------\n", - "tensor([[-7.9966]])\n", - "tensor([[-9.0969]])\n", + "tensor([[-9.0438]])\n", + "tensor([[-11.2441]])\n", "------------------------\n", - "tensor([[-8.5333]])\n", - "tensor([[-7.5229]])\n", + "tensor([[-7.6108]])\n", + "tensor([[-7.8539]])\n", "------------------------\n", - "tensor([[-8.4191]])\n", - "tensor([[-9.9914]])\n", + "tensor([[-7.4545]])\n", + "tensor([[-5.3098]])\n", "------------------------\n", - "tensor([[-6.6998]])\n", - "tensor([[-8.4559]])\n", + "tensor([[-7.4709]])\n", + "tensor([[-5.8327]])\n", "------------------------\n", - "tensor([[-7.6772]])\n", - "tensor([[-8.1308]])\n", + "tensor([[-8.5319]])\n", + "tensor([[-9.7905]])\n", "------------------------\n", - "tensor([[-7.9637]])\n", - "tensor([[-10.5229]])\n", + "tensor([[-7.3426]])\n", + "tensor([[-7.6021]])\n", "------------------------\n", - "tensor([[-7.9527]])\n", - "tensor([[-4.3979]])\n", + "tensor([[-7.3667]])\n", + "tensor([[-6.6198]])\n", "------------------------\n", - "tensor([[-8.3544]])\n", - "tensor([[-8.]])\n", + "tensor([[-8.2605]])\n", + "tensor([[-11.3010]])\n", "------------------------\n", - "tensor([[-8.8094]])\n", - "tensor([[-6.5229]])\n", + "tensor([[-8.4678]])\n", + "tensor([[-8.0044]])\n", "------------------------\n", - "tensor([[-8.6138]])\n", - "tensor([[-9.3010]])\n", + "tensor([[-8.4259]])\n", + "tensor([[-8.8539]])\n", "------------------------\n", - "tensor([[-8.4698]])\n", - "tensor([[-9.7696]])\n", + "tensor([[-7.3999]])\n", + "tensor([[-6.9586]])\n", "------------------------\n", - "tensor([[-8.4812]])\n", - "tensor([[-8.3010]])\n", + "tensor([[-8.5443]])\n", + "tensor([[-8.5376]])\n", "------------------------\n", - "tensor([[-8.5774]])\n", - "tensor([[-5.8861]])\n", + "tensor([[-8.8084]])\n", + "tensor([[-11.3979]])\n", "------------------------\n", - "tensor([[-7.7369]])\n", - "tensor([[-7.4559]])\n", + "tensor([[-8.4800]])\n", + "tensor([[-11.2218]])\n", "------------------------\n", - "Epoch : 28 \t train loss: 1.9571806703850652 train MSE: tensor(1.8925, grad_fn=) test MSE: 2.939212246919938\n", - "Corr: 0.20548675930473037\n", - "tensor(0.0627, grad_fn=)\n", - "tensor(0.0628, grad_fn=)\n", - "tensor(0.0630, grad_fn=)\n", - "tensor(0.0630, grad_fn=)\n", - "tensor(0.0631, grad_fn=)\n", - "tensor(0.0632, grad_fn=)\n", - "tensor(0.0632, grad_fn=)\n", - "tensor(0.0632, grad_fn=)\n", - "tensor(0.0633, grad_fn=)\n", - "tensor(0.0633, grad_fn=)\n", - "tensor(0.0633, grad_fn=)\n", - "tensor(0.0633, grad_fn=)\n", - "tensor(0.0634, grad_fn=)\n", - "tensor(0.0635, grad_fn=)\n", - "tensor(0.0636, grad_fn=)\n", - "tensor(0.0637, grad_fn=)\n", - "tensor(0.0638, grad_fn=)\n" + "Epoch : 28 \t train loss: 2.464195986978369 train MSE: tensor(2.2215, grad_fn=) test MSE: 2.0562633876017404\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "tensor(0.0639, grad_fn=)\n", - "tensor(0.0640, grad_fn=)\n", - "tensor(0.0641, grad_fn=)\n", - "tensor([[-7.4750]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.5055]])\n", - "tensor([[-11.2441]])\n", - "------------------------\n", - "tensor([[-8.6279]])\n", - "tensor([[-7.5986]])\n", - "------------------------\n", - "tensor([[-6.7537]])\n", - "tensor([[-4.5086]])\n", - "------------------------\n", - "tensor([[-7.8199]])\n", - "tensor([[-9.1612]])\n", - "------------------------\n", - "tensor([[-7.8606]])\n", - "tensor([[-7.]])\n", - "------------------------\n", - "tensor([[-8.2292]])\n", + "Corr: 0.6996754507980063\n", + "tensor(0.2317, grad_fn=)\n", + "tensor(0.2316, grad_fn=)\n", + "tensor(0.2315, grad_fn=)\n", + "tensor(0.2315, grad_fn=)\n", + "tensor(0.2315, grad_fn=)\n", + "tensor(0.2315, grad_fn=)\n", + "tensor(0.2315, grad_fn=)\n", + "tensor(0.2316, grad_fn=)\n", + "tensor(0.2317, grad_fn=)\n", + "tensor(0.2318, grad_fn=)\n", + "tensor(0.2319, grad_fn=)\n", + "tensor(0.2319, grad_fn=)\n", + "tensor(0.2318, grad_fn=)\n", + "tensor(0.2317, grad_fn=)\n", + "tensor(0.2317, grad_fn=)\n", + "tensor(0.2316, grad_fn=)\n", + "tensor(0.2315, grad_fn=)\n", + "tensor(0.2314, grad_fn=)\n", + "tensor(0.2314, grad_fn=)\n", + "tensor(0.2314, grad_fn=)\n", + "tensor([[-7.3143]])\n", + "tensor([[-6.4202]])\n", + "------------------------\n", + "tensor([[-8.1846]])\n", + "tensor([[-7.1427]])\n", + "------------------------\n", + "tensor([[-8.7672]])\n", + "tensor([[-8.0506]])\n", + "------------------------\n", + "tensor([[-8.6253]])\n", + "tensor([[-7.0362]])\n", + "------------------------\n", + "tensor([[-8.5528]])\n", + "tensor([[-9.2733]])\n", + "------------------------\n", + "tensor([[-7.4974]])\n", "tensor([[-8.1643]])\n", "------------------------\n", - "tensor([[-7.9964]])\n", - "tensor([[-9.0969]])\n", - "------------------------\n", - "tensor([[-8.5443]])\n", - "tensor([[-7.5229]])\n", - "------------------------\n", - "tensor([[-8.4383]])\n", - "tensor([[-9.9914]])\n", - "------------------------\n", - "tensor([[-6.7196]])\n", - "tensor([[-8.4559]])\n", - "------------------------\n", - "tensor([[-7.6758]])\n", - "tensor([[-8.1308]])\n", - "------------------------\n", - "tensor([[-7.9784]])\n", - "tensor([[-10.5229]])\n", + "tensor([[-7.3542]])\n", + "tensor([[-7.9208]])\n", "------------------------\n", - "tensor([[-7.9407]])\n", - "tensor([[-4.3979]])\n", + "tensor([[-7.5949]])\n", + "tensor([[-6.8386]])\n", "------------------------\n", - "tensor([[-8.3708]])\n", - "tensor([[-8.]])\n", - "------------------------\n", - "tensor([[-8.8352]])\n", - "tensor([[-6.5229]])\n", - "------------------------\n", - "tensor([[-8.6364]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.4938]])\n", - "tensor([[-9.7696]])\n", - "------------------------\n", - "tensor([[-8.4858]])\n", - "tensor([[-8.3010]])\n", - "------------------------\n", - "tensor([[-8.5860]])\n", - "tensor([[-5.8861]])\n", - "------------------------\n", - "tensor([[-7.7398]])\n", - "tensor([[-7.4559]])\n", - "------------------------\n", - "Epoch : 29 \t train loss: 1.9490793206368924 train MSE: tensor(1.8829, grad_fn=) test MSE: 2.9213861844812827\n", - "Corr: 0.21604763992330092\n", - "tensor(0.0641, grad_fn=)\n", - "tensor(0.0642, grad_fn=)\n", - "tensor(0.0642, grad_fn=)\n", - "tensor(0.0642, grad_fn=)\n", - "tensor(0.0642, grad_fn=)\n", - "tensor(0.0643, grad_fn=)\n", - "tensor(0.0643, grad_fn=)\n", - "tensor(0.0643, grad_fn=)\n", - "tensor(0.0643, grad_fn=)\n", - "tensor(0.0644, grad_fn=)\n", - "tensor(0.0645, grad_fn=)\n", - "tensor(0.0646, grad_fn=)\n", - "tensor(0.0647, grad_fn=)\n", - "tensor(0.0648, grad_fn=)\n", - "tensor(0.0649, grad_fn=)\n", - "tensor(0.0650, grad_fn=)\n", - "tensor(0.0651, grad_fn=)\n", - "tensor(0.0653, grad_fn=)\n", - "tensor(0.0654, grad_fn=)\n", - "tensor(0.0655, grad_fn=)\n", - "tensor([[-7.5784]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.6621]])\n", + "tensor([[-9.0404]])\n", "tensor([[-11.2441]])\n", "------------------------\n", - "tensor([[-8.7840]])\n", - "tensor([[-7.5986]])\n", + "tensor([[-7.5766]])\n", + "tensor([[-7.8539]])\n", "------------------------\n", - "tensor([[-6.8354]])\n", - "tensor([[-4.5086]])\n", + "tensor([[-7.4143]])\n", + "tensor([[-5.3098]])\n", "------------------------\n", - "tensor([[-7.8919]])\n", - "tensor([[-9.1612]])\n", + "tensor([[-7.4321]])\n", + "tensor([[-5.8327]])\n", "------------------------\n", - "tensor([[-7.9594]])\n", - "tensor([[-7.]])\n", - "------------------------\n", - "tensor([[-8.3754]])\n", - "tensor([[-8.1643]])\n", - "------------------------\n", - "tensor([[-8.1369]])\n", - "tensor([[-9.0969]])\n", + "tensor([[-8.5315]])\n", + "tensor([[-9.7905]])\n", "------------------------\n", - "tensor([[-8.6998]])\n", - "tensor([[-7.5229]])\n", + "tensor([[-7.2971]])\n", + "tensor([[-7.6021]])\n", "------------------------\n", - "tensor([[-8.5876]])\n", - "tensor([[-9.9914]])\n", + "tensor([[-7.3192]])\n", + "tensor([[-6.6198]])\n", "------------------------\n", - "tensor([[-6.7810]])\n", - "tensor([[-8.4559]])\n", + "tensor([[-8.2557]])\n", + "tensor([[-11.3010]])\n", "------------------------\n", - "tensor([[-7.8161]])\n", - "tensor([[-8.1308]])\n", + "tensor([[-8.4502]])\n", + "tensor([[-8.0044]])\n", "------------------------\n", - "tensor([[-8.0393]])\n", - "tensor([[-10.5229]])\n", + "tensor([[-8.4525]])\n", + "tensor([[-8.8539]])\n", "------------------------\n", - "tensor([[-8.0762]])\n", - "tensor([[-4.3979]])\n", + "tensor([[-7.3555]])\n", + "tensor([[-6.9586]])\n", "------------------------\n", - "tensor([[-8.5172]])\n", - "tensor([[-8.]])\n", + "tensor([[-8.5113]])\n", + "tensor([[-8.5376]])\n", "------------------------\n", - "tensor([[-8.9947]])\n", - "tensor([[-6.5229]])\n", + "tensor([[-8.8029]])\n", + "tensor([[-11.3979]])\n", + "------------------------\n", + "tensor([[-8.4751]])\n", + "tensor([[-11.2218]])\n", + "------------------------\n", + "Epoch : 29 \t train loss: 2.3574766832239487 train MSE: tensor(2.1153, grad_fn=) test MSE: 2.0426646057775626\n", + "Corr: 0.6998041331935552\n", + "tensor(0.2315, grad_fn=)\n", + "tensor(0.2315, grad_fn=)\n", + "tensor(0.2317, grad_fn=)\n", + "tensor(0.2318, grad_fn=)\n", + "tensor(0.2320, grad_fn=)\n", + "tensor(0.2321, grad_fn=)\n", + "tensor(0.2321, grad_fn=)\n", + "tensor(0.2321, grad_fn=)\n", + "tensor(0.2320, grad_fn=)\n", + "tensor(0.2319, grad_fn=)\n", + "tensor(0.2318, grad_fn=)\n", + "tensor(0.2316, grad_fn=)\n", + "tensor(0.2316, grad_fn=)\n", + "tensor(0.2315, grad_fn=)\n", + "tensor(0.2314, grad_fn=)\n", + "tensor(0.2314, grad_fn=)\n", + "tensor(0.2313, grad_fn=)\n", + "tensor(0.2314, grad_fn=)\n", + "tensor(0.2313, grad_fn=)\n", + "tensor(0.2312, grad_fn=)\n", + "tensor([[-7.4244]])\n", + "tensor([[-6.4202]])\n", + "------------------------\n", + "tensor([[-8.3681]])\n", + "tensor([[-7.1427]])\n", + "------------------------\n", + "tensor([[-8.7603]])\n", + "tensor([[-8.0506]])\n", + "------------------------\n", + "tensor([[-8.6537]])\n", + "tensor([[-7.0362]])\n", + "------------------------\n", + "tensor([[-8.6121]])\n", + "tensor([[-9.2733]])\n", "------------------------\n", - "tensor([[-8.7983]])\n", - "tensor([[-9.3010]])\n", + "tensor([[-7.6137]])\n", + "tensor([[-8.1643]])\n", "------------------------\n", - "tensor([[-8.6528]])\n", - "tensor([[-9.7696]])\n", + "tensor([[-7.4612]])\n", + "tensor([[-7.9208]])\n", "------------------------\n", - "tensor([[-8.6212]])\n", - "tensor([[-8.3010]])\n", + "tensor([[-7.6665]])\n", + "tensor([[-6.8386]])\n", "------------------------\n", - "tensor([[-8.7368]])\n", - "tensor([[-5.8861]])\n", + "tensor([[-9.0885]])\n", + "tensor([[-11.2441]])\n", "------------------------\n", - "tensor([[-7.8622]])\n", - "tensor([[-7.4559]])\n", + "tensor([[-7.6775]])\n", + "tensor([[-7.8539]])\n", "------------------------\n", - "Epoch : 30 \t train loss: 1.961636193230335 train MSE: tensor(1.8942, grad_fn=) test MSE: 2.960971608757973\n", - "Corr: 0.20658304059133886\n", - "tensor(0.0656, grad_fn=)\n", - "tensor(0.0657, grad_fn=)\n", - "tensor(0.0657, grad_fn=)\n", - "tensor(0.0657, grad_fn=)\n", - "tensor(0.0658, grad_fn=)\n", - "tensor(0.0658, grad_fn=)\n", - "tensor(0.0659, grad_fn=)\n", - "tensor(0.0660, grad_fn=)\n", - "tensor(0.0660, grad_fn=)\n", - "tensor(0.0661, grad_fn=)\n", - "tensor(0.0662, grad_fn=)\n", - "tensor(0.0663, grad_fn=)\n", - "tensor(0.0664, grad_fn=)\n", - "tensor(0.0665, grad_fn=)\n", - "tensor(0.0666, grad_fn=)\n", - "tensor(0.0666, grad_fn=)\n", - "tensor(0.0667, grad_fn=)\n", - "tensor(0.0668, grad_fn=)\n", - "tensor(0.0668, grad_fn=)\n", - "tensor(0.0669, grad_fn=)\n", - "tensor([[-7.2225]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.3309]])\n", - "tensor([[-11.2441]])\n", + "tensor([[-7.5324]])\n", + "tensor([[-5.3098]])\n", "------------------------\n", - "tensor([[-8.4475]])\n", - "tensor([[-7.5986]])\n", + "tensor([[-7.5510]])\n", + "tensor([[-5.8327]])\n", "------------------------\n", - "tensor([[-6.4444]])\n", - "tensor([[-4.5086]])\n", + "tensor([[-8.5868]])\n", + "tensor([[-9.7905]])\n", "------------------------\n", - "tensor([[-7.7616]])\n", - "tensor([[-9.1612]])\n", + "tensor([[-7.4036]])\n", + "tensor([[-7.6021]])\n", "------------------------\n", - "tensor([[-7.5872]])\n", - "tensor([[-7.]])\n", + "tensor([[-7.4353]])\n", + "tensor([[-6.6198]])\n", "------------------------\n", - "tensor([[-8.0361]])\n", - "tensor([[-8.1643]])\n", + "tensor([[-8.2285]])\n", + "tensor([[-11.3010]])\n", "------------------------\n", - "tensor([[-7.7468]])\n", - "tensor([[-9.0969]])\n", + "tensor([[-8.4524]])\n", + "tensor([[-8.0044]])\n", "------------------------\n", - "tensor([[-8.3674]])\n", - "tensor([[-7.5229]])\n", + "tensor([[-8.6379]])\n", + "tensor([[-8.8539]])\n", "------------------------\n", - "tensor([[-8.2496]])\n", - "tensor([[-9.9914]])\n", + "tensor([[-7.4650]])\n", + "tensor([[-6.9586]])\n", "------------------------\n", - "tensor([[-6.6635]])\n", - "tensor([[-8.4559]])\n", + "tensor([[-8.4806]])\n", + "tensor([[-8.5376]])\n", "------------------------\n", - "tensor([[-7.5048]])\n", - "tensor([[-8.1308]])\n", + "tensor([[-8.8092]])\n", + "tensor([[-11.3979]])\n", "------------------------\n", - "tensor([[-7.8862]])\n", - "tensor([[-10.5229]])\n", + "tensor([[-8.5749]])\n", + "tensor([[-11.2218]])\n", "------------------------\n", - "tensor([[-7.6924]])\n", - "tensor([[-4.3979]])\n", + "Epoch : 30 \t train loss: 2.361808116139929 train MSE: tensor(2.1196, grad_fn=) test MSE: 2.0748268323421306\n", + "Corr: 0.690529477562814\n", + "tensor(0.2313, grad_fn=)\n", + "tensor(0.2314, grad_fn=)\n", + "tensor(0.2315, grad_fn=)\n", + "tensor(0.2315, grad_fn=)\n", + "tensor(0.2316, grad_fn=)\n", + "tensor(0.2317, grad_fn=)\n", + "tensor(0.2316, grad_fn=)\n", + "tensor(0.2314, grad_fn=)\n", + "tensor(0.2312, grad_fn=)\n", + "tensor(0.2310, grad_fn=)\n", + "tensor(0.2308, grad_fn=)\n", + "tensor(0.2306, grad_fn=)\n", + "tensor(0.2305, grad_fn=)\n", + "tensor(0.2304, grad_fn=)\n", + "tensor(0.2303, grad_fn=)\n", + "tensor(0.2303, grad_fn=)\n", + "tensor(0.2303, grad_fn=)\n", + "tensor(0.2303, grad_fn=)\n", + "tensor(0.2303, grad_fn=)\n", + "tensor(0.2304, grad_fn=)\n", + "tensor([[-7.1991]])\n", + "tensor([[-6.4202]])\n", "------------------------\n", - "tensor([[-8.1954]])\n", - "tensor([[-8.]])\n", + "tensor([[-8.2122]])\n", + "tensor([[-7.1427]])\n", "------------------------\n", - "tensor([[-8.6641]])\n", - "tensor([[-6.5229]])\n", + "tensor([[-8.7304]])\n", + "tensor([[-8.0506]])\n", "------------------------\n", - "tensor([[-8.4796]])\n", - "tensor([[-9.3010]])\n", + "tensor([[-8.6256]])\n", + "tensor([[-7.0362]])\n", "------------------------\n", - "tensor([[-8.3378]])\n", - "tensor([[-9.7696]])\n", + "tensor([[-8.5240]])\n", + "tensor([[-9.2733]])\n", "------------------------\n", - "tensor([[-8.2663]])\n", - "tensor([[-8.3010]])\n", + "tensor([[-7.3971]])\n", + "tensor([[-8.1643]])\n", "------------------------\n", - "tensor([[-8.3937]])\n", - "tensor([[-5.8861]])\n", + "tensor([[-7.2376]])\n", + "tensor([[-7.9208]])\n", "------------------------\n", - "tensor([[-7.4962]])\n", - "tensor([[-7.4559]])\n", + "tensor([[-7.5272]])\n", + "tensor([[-6.8386]])\n", "------------------------\n", - "Epoch : 31 \t train loss: 1.901170142517588 train MSE: tensor(1.8320, grad_fn=) test MSE: 2.8673116592191423\n", - "Corr: 0.26769995758806164\n", - "tensor(0.0669, grad_fn=)\n", - "tensor(0.0669, grad_fn=)\n", - "tensor(0.0670, grad_fn=)\n", - "tensor(0.0670, grad_fn=)\n", - "tensor(0.0671, grad_fn=)\n", - "tensor(0.0671, grad_fn=)\n", - "tensor(0.0672, grad_fn=)\n", - "tensor(0.0673, grad_fn=)\n", - "tensor(0.0674, grad_fn=)\n", - "tensor(0.0675, grad_fn=)\n", - "tensor(0.0676, grad_fn=)\n", - "tensor(0.0676, grad_fn=)\n", - "tensor(0.0677, grad_fn=)\n", - "tensor(0.0679, grad_fn=)\n", - "tensor(0.0680, grad_fn=)\n", - "tensor(0.0681, grad_fn=)\n", - "tensor(0.0682, grad_fn=)\n", - "tensor(0.0683, grad_fn=)\n", - "tensor(0.0683, grad_fn=)\n", - "tensor(0.0684, grad_fn=)\n", - "tensor([[-7.4281]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.5756]])\n", + "tensor([[-9.0387]])\n", "tensor([[-11.2441]])\n", "------------------------\n", - "tensor([[-8.7013]])\n", - "tensor([[-7.5986]])\n", + "tensor([[-7.4704]])\n", + "tensor([[-7.8539]])\n", "------------------------\n", - "tensor([[-6.6260]])\n", - "tensor([[-4.5086]])\n", + "tensor([[-7.3023]])\n", + "tensor([[-5.3098]])\n", "------------------------\n", - "tensor([[-7.8612]])\n", - "tensor([[-9.1612]])\n", + "tensor([[-7.3236]])\n", + "tensor([[-5.8327]])\n", "------------------------\n", - "tensor([[-7.7914]])\n", - "tensor([[-7.]])\n", - "------------------------\n", - "tensor([[-8.2861]])\n", + "tensor([[-8.5297]])\n", + "tensor([[-9.7905]])\n", + "------------------------\n", + "tensor([[-7.1732]])\n", + "tensor([[-7.6021]])\n", + "------------------------\n", + "tensor([[-7.1999]])\n", + "tensor([[-6.6198]])\n", + "------------------------\n", + "tensor([[-8.2865]])\n", + "tensor([[-11.3010]])\n", + "------------------------\n", + "tensor([[-8.4173]])\n", + "tensor([[-8.0044]])\n", + "------------------------\n", + "tensor([[-8.5017]])\n", + "tensor([[-8.8539]])\n", + "------------------------\n", + "tensor([[-7.2327]])\n", + "tensor([[-6.9586]])\n", + "------------------------\n", + "tensor([[-8.4862]])\n", + "tensor([[-8.5376]])\n", + "------------------------\n", + "tensor([[-8.8385]])\n", + "tensor([[-11.3979]])\n", + "------------------------\n", + "tensor([[-8.4400]])\n", + "tensor([[-11.2218]])\n", + "------------------------\n", + "Epoch : 31 \t train loss: 2.4660070207383895 train MSE: tensor(2.2245, grad_fn=) test MSE: 1.9951095726256345\n", + "Corr: 0.703206544935706\n", + "tensor(0.2304, grad_fn=)\n", + "tensor(0.2304, grad_fn=)\n", + "tensor(0.2304, grad_fn=)\n", + "tensor(0.2305, grad_fn=)\n", + "tensor(0.2305, grad_fn=)\n", + "tensor(0.2304, grad_fn=)\n", + "tensor(0.2304, grad_fn=)\n", + "tensor(0.2303, grad_fn=)\n", + "tensor(0.2302, grad_fn=)\n", + "tensor(0.2301, grad_fn=)\n", + "tensor(0.2300, grad_fn=)\n", + "tensor(0.2298, grad_fn=)\n", + "tensor(0.2297, grad_fn=)\n", + "tensor(0.2295, grad_fn=)\n", + "tensor(0.2293, grad_fn=)\n", + "tensor(0.2292, grad_fn=)\n", + "tensor(0.2291, grad_fn=)\n", + "tensor(0.2291, grad_fn=)\n", + "tensor(0.2291, grad_fn=)\n", + "tensor(0.2291, grad_fn=)\n", + "tensor([[-7.1198]])\n", + "tensor([[-6.4202]])\n", + "------------------------\n", + "tensor([[-8.0363]])\n", + "tensor([[-7.1427]])\n", + "------------------------\n", + "tensor([[-8.6649]])\n", + "tensor([[-8.0506]])\n", + "------------------------\n", + "tensor([[-8.4312]])\n", + "tensor([[-7.0362]])\n", + "------------------------\n", + "tensor([[-8.3601]])\n", + "tensor([[-9.2733]])\n", + "------------------------\n", + "tensor([[-7.3160]])\n", "tensor([[-8.1643]])\n", "------------------------\n", - "tensor([[-7.9868]])\n", - "tensor([[-9.0969]])\n", + "tensor([[-7.1497]])\n", + "tensor([[-7.9208]])\n", "------------------------\n", - "tensor([[-8.6161]])\n", - "tensor([[-7.5229]])\n", + "tensor([[-7.4212]])\n", + "tensor([[-6.8386]])\n", "------------------------\n", - "tensor([[-8.4983]])\n", - "tensor([[-9.9914]])\n", + "tensor([[-8.8089]])\n", + "tensor([[-11.2441]])\n", "------------------------\n", - "tensor([[-6.7523]])\n", - "tensor([[-8.4559]])\n", + "tensor([[-7.3732]])\n", + "tensor([[-7.8539]])\n", "------------------------\n", - "tensor([[-7.7103]])\n", - "tensor([[-8.1308]])\n", + "tensor([[-7.2268]])\n", + "tensor([[-5.3098]])\n", "------------------------\n", - "tensor([[-7.9835]])\n", - "tensor([[-10.5229]])\n", + "tensor([[-7.2461]])\n", + "tensor([[-5.8327]])\n", "------------------------\n", - "tensor([[-7.9215]])\n", - "tensor([[-4.3979]])\n", + "tensor([[-8.3586]])\n", + "tensor([[-9.7905]])\n", "------------------------\n", - "tensor([[-8.4166]])\n", - "tensor([[-8.]])\n", + "tensor([[-7.0872]])\n", + "tensor([[-7.6021]])\n", "------------------------\n", - "tensor([[-8.9206]])\n", - "tensor([[-6.5229]])\n", + "tensor([[-7.1246]])\n", + "tensor([[-6.6198]])\n", "------------------------\n", - "tensor([[-8.6900]])\n", - "tensor([[-9.3010]])\n", + "tensor([[-8.1558]])\n", + "tensor([[-11.3010]])\n", "------------------------\n", - "tensor([[-8.5603]])\n", - "tensor([[-9.7696]])\n", + "tensor([[-8.2474]])\n", + "tensor([[-8.0044]])\n", "------------------------\n", - "tensor([[-8.5036]])\n", - "tensor([[-8.3010]])\n", + "tensor([[-8.3148]])\n", + "tensor([[-8.8539]])\n", "------------------------\n", - "tensor([[-8.6112]])\n", - "tensor([[-5.8861]])\n", + "tensor([[-7.1440]])\n", + "tensor([[-6.9586]])\n", "------------------------\n", - "tensor([[-7.7290]])\n", - "tensor([[-7.4559]])\n", + "tensor([[-8.3150]])\n", + "tensor([[-8.5376]])\n", "------------------------\n", - "Epoch : 32 \t train loss: 1.8837127281052057 train MSE: tensor(1.8132, grad_fn=) test MSE: 2.8837598742739785\n", - "Corr: 0.24109026616452528\n", - "tensor(0.0684, grad_fn=)\n", - "tensor(0.0684, grad_fn=)\n", - "tensor(0.0684, grad_fn=)\n", - "tensor(0.0684, grad_fn=)\n", - "tensor(0.0685, grad_fn=)\n", - "tensor(0.0685, grad_fn=)\n", - "tensor(0.0686, grad_fn=)\n" + "tensor([[-8.6056]])\n", + "tensor([[-11.3979]])\n", + "------------------------\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "tensor(0.0687, grad_fn=)\n", - "tensor(0.0688, grad_fn=)\n", - "tensor(0.0689, grad_fn=)\n", - "tensor(0.0689, grad_fn=)\n", - "tensor(0.0690, grad_fn=)\n", - "tensor(0.0690, grad_fn=)\n", - "tensor(0.0691, grad_fn=)\n", - "tensor(0.0692, grad_fn=)\n", - "tensor(0.0692, grad_fn=)\n", - "tensor(0.0693, grad_fn=)\n", - "tensor(0.0694, grad_fn=)\n", - "tensor(0.0694, grad_fn=)\n", - "tensor(0.0695, grad_fn=)\n", - "tensor([[-7.2895]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.4654]])\n", - "tensor([[-11.2441]])\n", - "------------------------\n", - "tensor([[-8.5976]])\n", - "tensor([[-7.5986]])\n", - "------------------------\n", - "tensor([[-6.4684]])\n", - "tensor([[-4.5086]])\n", - "------------------------\n", - "tensor([[-7.8441]])\n", - "tensor([[-9.1612]])\n", - "------------------------\n", - "tensor([[-7.6442]])\n", - "tensor([[-7.]])\n", - "------------------------\n", - "tensor([[-8.1782]])\n", + "tensor([[-8.2804]])\n", + "tensor([[-11.2218]])\n", + "------------------------\n", + "Epoch : 32 \t train loss: 2.2725167118645966 train MSE: tensor(2.0321, grad_fn=) test MSE: 2.1490281872789967\n", + "Corr: 0.6963120535336127\n", + "tensor(0.2290, grad_fn=)\n", + "tensor(0.2290, grad_fn=)\n", + "tensor(0.2290, grad_fn=)\n", + "tensor(0.2290, grad_fn=)\n", + "tensor(0.2290, grad_fn=)\n", + "tensor(0.2291, grad_fn=)\n", + "tensor(0.2291, grad_fn=)\n", + "tensor(0.2292, grad_fn=)\n", + "tensor(0.2292, grad_fn=)\n", + "tensor(0.2292, grad_fn=)\n", + "tensor(0.2292, grad_fn=)\n", + "tensor(0.2290, grad_fn=)\n", + "tensor(0.2289, grad_fn=)\n", + "tensor(0.2288, grad_fn=)\n", + "tensor(0.2286, grad_fn=)\n", + "tensor(0.2285, grad_fn=)\n", + "tensor(0.2285, grad_fn=)\n", + "tensor(0.2286, grad_fn=)\n", + "tensor(0.2287, grad_fn=)\n", + "tensor(0.2287, grad_fn=)\n", + "tensor([[-7.3232]])\n", + "tensor([[-6.4202]])\n", + "------------------------\n", + "tensor([[-8.2119]])\n", + "tensor([[-7.1427]])\n", + "------------------------\n", + "tensor([[-8.8476]])\n", + "tensor([[-8.0506]])\n", + "------------------------\n", + "tensor([[-8.6388]])\n", + "tensor([[-7.0362]])\n", + "------------------------\n", + "tensor([[-8.5699]])\n", + "tensor([[-9.2733]])\n", + "------------------------\n", + "tensor([[-7.5235]])\n", "tensor([[-8.1643]])\n", "------------------------\n", - "tensor([[-7.8712]])\n", - "tensor([[-9.0969]])\n", - "------------------------\n", - "tensor([[-8.5143]])\n", - "tensor([[-7.5229]])\n", - "------------------------\n", - "tensor([[-8.3943]])\n", - "tensor([[-9.9914]])\n", - "------------------------\n", - "tensor([[-6.7388]])\n", - "tensor([[-8.4559]])\n", + "tensor([[-7.3529]])\n", + "tensor([[-7.9208]])\n", "------------------------\n", - "tensor([[-7.5695]])\n", - "tensor([[-8.1308]])\n", + "tensor([[-7.6091]])\n", + "tensor([[-6.8386]])\n", "------------------------\n", - "tensor([[-7.9571]])\n", - "tensor([[-10.5229]])\n", - "------------------------\n", - "tensor([[-7.7869]])\n", - "tensor([[-4.3979]])\n", - "------------------------\n", - "tensor([[-8.2852]])\n", - "tensor([[-8.]])\n", + "tensor([[-9.0227]])\n", + "tensor([[-11.2441]])\n", "------------------------\n", - "tensor([[-8.8244]])\n", - "tensor([[-6.5229]])\n", + "tensor([[-7.5804]])\n", + "tensor([[-7.8539]])\n", "------------------------\n", - "tensor([[-8.5525]])\n", - "tensor([[-9.3010]])\n", + "tensor([[-7.4346]])\n", + "tensor([[-5.3098]])\n", "------------------------\n", - "tensor([[-8.4240]])\n", - "tensor([[-9.7696]])\n", + "tensor([[-7.4520]])\n", + "tensor([[-5.8327]])\n", "------------------------\n", - "tensor([[-8.3820]])\n", - "tensor([[-8.3010]])\n", + "tensor([[-8.5658]])\n", + "tensor([[-9.7905]])\n", "------------------------\n", - "tensor([[-8.4818]])\n", - "tensor([[-5.8861]])\n", + "tensor([[-7.2923]])\n", + "tensor([[-7.6021]])\n", "------------------------\n", - "tensor([[-7.6000]])\n", - "tensor([[-7.4559]])\n", + "tensor([[-7.3295]])\n", + "tensor([[-6.6198]])\n", "------------------------\n", - "Epoch : 33 \t train loss: 1.9293939674464566 train MSE: tensor(1.8575, grad_fn=) test MSE: 2.839934925445483\n", - "Corr: 0.26783314128837893\n", - "tensor(0.0696, grad_fn=)\n", - "tensor(0.0697, grad_fn=)\n", - "tensor(0.0698, grad_fn=)\n", - "tensor(0.0699, grad_fn=)\n", - "tensor(0.0700, grad_fn=)\n", - "tensor(0.0701, grad_fn=)\n", - "tensor(0.0702, grad_fn=)\n", - "tensor(0.0702, grad_fn=)\n", - "tensor(0.0703, grad_fn=)\n", - "tensor(0.0704, grad_fn=)\n", - "tensor(0.0705, grad_fn=)\n", - "tensor(0.0705, grad_fn=)\n", - "tensor(0.0706, grad_fn=)\n", - "tensor(0.0707, grad_fn=)\n", - "tensor(0.0707, grad_fn=)\n", - "tensor(0.0708, grad_fn=)\n", - "tensor(0.0709, grad_fn=)\n", - "tensor(0.0710, grad_fn=)\n", - "tensor(0.0710, grad_fn=)\n", - "tensor(0.0711, grad_fn=)\n", - "tensor([[-7.2238]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.4595]])\n", - "tensor([[-11.2441]])\n", + "tensor([[-8.3446]])\n", + "tensor([[-11.3010]])\n", "------------------------\n", - "tensor([[-8.5819]])\n", - "tensor([[-7.5986]])\n", + "tensor([[-8.4380]])\n", + "tensor([[-8.0044]])\n", "------------------------\n", - "tensor([[-6.3845]])\n", - "tensor([[-4.5086]])\n", + "tensor([[-8.4931]])\n", + "tensor([[-8.8539]])\n", "------------------------\n", - "tensor([[-7.8559]])\n", - "tensor([[-9.1612]])\n", + "tensor([[-7.3497]])\n", + "tensor([[-6.9586]])\n", "------------------------\n", - "tensor([[-7.5798]])\n", - "tensor([[-7.]])\n", + "tensor([[-8.5300]])\n", + "tensor([[-8.5376]])\n", "------------------------\n", - "tensor([[-8.1601]])\n", - "tensor([[-8.1643]])\n", + "tensor([[-8.8118]])\n", + "tensor([[-11.3979]])\n", "------------------------\n", - "tensor([[-7.8645]])\n", - "tensor([[-9.0969]])\n", + "tensor([[-8.4898]])\n", + "tensor([[-11.2218]])\n", "------------------------\n", - "tensor([[-8.4882]])\n", - "tensor([[-7.5229]])\n", + "Epoch : 33 \t train loss: 2.4235341689165897 train MSE: tensor(2.1841, grad_fn=) test MSE: 2.0269902342727373\n", + "Corr: 0.6997691543952321\n", + "tensor(0.2286, grad_fn=)\n", + "tensor(0.2285, grad_fn=)\n", + "tensor(0.2284, grad_fn=)\n", + "tensor(0.2284, grad_fn=)\n", + "tensor(0.2283, grad_fn=)\n", + "tensor(0.2283, grad_fn=)\n", + "tensor(0.2282, grad_fn=)\n", + "tensor(0.2282, grad_fn=)\n", + "tensor(0.2282, grad_fn=)\n", + "tensor(0.2282, grad_fn=)\n", + "tensor(0.2281, grad_fn=)\n", + "tensor(0.2281, grad_fn=)\n", + "tensor(0.2283, grad_fn=)\n", + "tensor(0.2285, grad_fn=)\n", + "tensor(0.2287, grad_fn=)\n", + "tensor(0.2287, grad_fn=)\n", + "tensor(0.2287, grad_fn=)\n", + "tensor(0.2284, grad_fn=)\n", + "tensor(0.2282, grad_fn=)\n", + "tensor(0.2280, grad_fn=)\n", + "tensor([[-7.0508]])\n", + "tensor([[-6.4202]])\n", "------------------------\n", - "tensor([[-8.3722]])\n", - "tensor([[-9.9914]])\n", + "tensor([[-7.9720]])\n", + "tensor([[-7.1427]])\n", "------------------------\n", - "tensor([[-6.7630]])\n", - "tensor([[-8.4559]])\n", + "tensor([[-8.5451]])\n", + "tensor([[-8.0506]])\n", "------------------------\n", - "tensor([[-7.5789]])\n", - "tensor([[-8.1308]])\n", + "tensor([[-8.3705]])\n", + "tensor([[-7.0362]])\n", "------------------------\n", - "tensor([[-7.9715]])\n", - "tensor([[-10.5229]])\n", + "tensor([[-8.3201]])\n", + "tensor([[-9.2733]])\n", "------------------------\n", - "tensor([[-7.7699]])\n", - "tensor([[-4.3979]])\n", - "------------------------\n", - "tensor([[-8.3041]])\n", - "tensor([[-8.]])\n", - "------------------------\n", - "tensor([[-8.8097]])\n", - "tensor([[-6.5229]])\n", - "------------------------\n", - "tensor([[-8.5693]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.4497]])\n", - "tensor([[-9.7696]])\n", - "------------------------\n", - "tensor([[-8.3400]])\n", - "tensor([[-8.3010]])\n", - "------------------------\n", - "tensor([[-8.4867]])\n", - "tensor([[-5.8861]])\n", - "------------------------\n", - "tensor([[-7.5679]])\n", - "tensor([[-7.4559]])\n", - "------------------------\n", - "Epoch : 34 \t train loss: 1.8311194377855613 train MSE: tensor(1.7576, grad_fn=) test MSE: 2.8140002848678183\n", - "Corr: 0.28310159938223595\n", - "tensor(0.0711, grad_fn=)\n", - "tensor(0.0712, grad_fn=)\n", - "tensor(0.0713, grad_fn=)\n", - "tensor(0.0714, grad_fn=)\n", - "tensor(0.0715, grad_fn=)\n", - "tensor(0.0715, grad_fn=)\n", - "tensor(0.0716, grad_fn=)\n", - "tensor(0.0716, grad_fn=)\n", - "tensor(0.0717, grad_fn=)\n", - "tensor(0.0717, grad_fn=)\n", - "tensor(0.0718, grad_fn=)\n", - "tensor(0.0720, grad_fn=)\n", - "tensor(0.0721, grad_fn=)\n", - "tensor(0.0722, grad_fn=)\n", - "tensor(0.0723, grad_fn=)\n", - "tensor(0.0724, grad_fn=)\n", - "tensor(0.0725, grad_fn=)\n", - "tensor(0.0726, grad_fn=)\n", - "tensor(0.0726, grad_fn=)\n", - "tensor(0.0726, grad_fn=)\n", - "tensor([[-7.3216]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.5778]])\n", - "tensor([[-11.2441]])\n", - "------------------------\n", - "tensor([[-8.7058]])\n", - "tensor([[-7.5986]])\n", - "------------------------\n", - "tensor([[-6.4648]])\n", - "tensor([[-4.5086]])\n", - "------------------------\n", - "tensor([[-7.9044]])\n", - "tensor([[-9.1612]])\n", - "------------------------\n", - "tensor([[-7.6645]])\n", - "tensor([[-7.]])\n", - "------------------------\n", - "tensor([[-8.2974]])\n", - "tensor([[-8.1643]])\n", - "------------------------\n", - "tensor([[-7.9847]])\n", - "tensor([[-9.0969]])\n", - "------------------------\n", - "tensor([[-8.6049]])\n", - "tensor([[-7.5229]])\n", - "------------------------\n", - "tensor([[-8.5140]])\n", - "tensor([[-9.9914]])\n", - "------------------------\n", - "tensor([[-6.8027]])\n", - "tensor([[-8.4559]])\n", - "------------------------\n", - "tensor([[-7.6678]])\n", - "tensor([[-8.1308]])\n", - "------------------------\n", - "tensor([[-8.0122]])\n", - "tensor([[-10.5229]])\n", - "------------------------\n", - "tensor([[-7.8714]])\n", - "tensor([[-4.3979]])\n", - "------------------------\n", - "tensor([[-8.3997]])\n", - "tensor([[-8.]])\n", - "------------------------\n", - "tensor([[-8.9412]])\n", - "tensor([[-6.5229]])\n", - "------------------------\n", - "tensor([[-8.6725]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.5593]])\n", - "tensor([[-9.7696]])\n", - "------------------------\n", - "tensor([[-8.4421]])\n", - "tensor([[-8.3010]])\n", - "------------------------\n", - "tensor([[-8.6038]])\n", - "tensor([[-5.8861]])\n", - "------------------------\n", - "tensor([[-7.6866]])\n", - "tensor([[-7.4559]])\n", - "------------------------\n", - "Epoch : 35 \t train loss: 1.823707723695341 train MSE: tensor(1.7486, grad_fn=) test MSE: 2.8263039902030003\n", - "Corr: 0.2720839706606775\n", - "tensor(0.0727, grad_fn=)\n", - "tensor(0.0727, grad_fn=)\n", - "tensor(0.0727, grad_fn=)\n", - "tensor(0.0728, grad_fn=)\n", - "tensor(0.0728, grad_fn=)\n", - "tensor(0.0729, grad_fn=)\n", - "tensor(0.0730, grad_fn=)\n", - "tensor(0.0730, grad_fn=)\n", - "tensor(0.0731, grad_fn=)\n", - "tensor(0.0732, grad_fn=)\n", - "tensor(0.0732, grad_fn=)\n", - "tensor(0.0733, grad_fn=)\n", - "tensor(0.0734, grad_fn=)\n", - "tensor(0.0734, grad_fn=)\n", - "tensor(0.0735, grad_fn=)\n", - "tensor(0.0736, grad_fn=)\n", - "tensor(0.0737, grad_fn=)\n", - "tensor(0.0737, grad_fn=)\n", - "tensor(0.0738, grad_fn=)\n", - "tensor(0.0739, grad_fn=)\n", - "tensor([[-7.2308]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.5117]])\n", - "tensor([[-11.2441]])\n", - "------------------------\n", - "tensor([[-8.6506]])\n", - "tensor([[-7.5986]])\n", - "------------------------\n", - "tensor([[-6.3599]])\n", - "tensor([[-4.5086]])\n", - "------------------------\n", - "tensor([[-7.9145]])\n", - "tensor([[-9.1612]])\n", - "------------------------\n", - "tensor([[-7.5670]])\n", - "tensor([[-7.]])\n", - "------------------------\n", - "tensor([[-8.2334]])\n", - "tensor([[-8.1643]])\n", - "------------------------\n", - "tensor([[-7.9081]])\n", - "tensor([[-9.0969]])\n", - "------------------------\n", - "tensor([[-8.5386]])\n", - "tensor([[-7.5229]])\n", - "------------------------\n", - "tensor([[-8.4472]])\n", - "tensor([[-9.9914]])\n", - "------------------------\n", - "tensor([[-6.8329]])\n", - "tensor([[-8.4559]])\n", - "------------------------\n", - "tensor([[-7.5860]])\n", - "tensor([[-8.1308]])\n", - "------------------------\n", - "tensor([[-8.0308]])\n", - "tensor([[-10.5229]])\n", - "------------------------\n", - "tensor([[-7.7763]])\n", - "tensor([[-4.3979]])\n", - "------------------------\n", - "tensor([[-8.3262]])\n", - "tensor([[-8.]])\n", - "------------------------\n", - "tensor([[-8.8811]])\n", - "tensor([[-6.5229]])\n", - "------------------------\n", - "tensor([[-8.6006]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.4861]])\n", - "tensor([[-9.7696]])\n", - "------------------------\n", - "tensor([[-8.3692]])\n", - "tensor([[-8.3010]])\n", - "------------------------\n", - "tensor([[-8.5276]])\n", - "tensor([[-5.8861]])\n", - "------------------------\n", - "tensor([[-7.6068]])\n", - "tensor([[-7.4559]])\n", - "------------------------\n", - "Epoch : 36 \t train loss: 1.7861102121300254 train MSE: tensor(1.7097, grad_fn=) test MSE: 2.779066004879063\n", - "Corr: 0.2969233743031664\n", - "tensor(0.0740, grad_fn=)\n", - "tensor(0.0740, grad_fn=)\n", - "tensor(0.0741, grad_fn=)\n", - "tensor(0.0742, grad_fn=)\n", - "tensor(0.0743, grad_fn=)\n", - "tensor(0.0743, grad_fn=)\n", - "tensor(0.0744, grad_fn=)\n", - "tensor(0.0745, grad_fn=)\n", - "tensor(0.0745, grad_fn=)\n", - "tensor(0.0745, grad_fn=)\n", - "tensor(0.0745, grad_fn=)\n", - "tensor(0.0746, grad_fn=)\n", - "tensor(0.0746, grad_fn=)\n", - "tensor(0.0747, grad_fn=)\n", - "tensor(0.0747, grad_fn=)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "tensor(0.0747, grad_fn=)\n", - "tensor(0.0748, grad_fn=)\n", - "tensor(0.0748, grad_fn=)\n", - "tensor(0.0749, grad_fn=)\n", - "tensor(0.0750, grad_fn=)\n", - "tensor([[-7.0186]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.3355]])\n", - "tensor([[-11.2441]])\n", - "------------------------\n", - "tensor([[-8.4818]])\n", - "tensor([[-7.5986]])\n", - "------------------------\n", - "tensor([[-6.1339]])\n", - "tensor([[-4.5086]])\n", - "------------------------\n", - "tensor([[-7.8013]])\n", - "tensor([[-9.1612]])\n", - "------------------------\n", - "tensor([[-7.3434]])\n", - "tensor([[-7.]])\n", - "------------------------\n", - "tensor([[-8.0531]])\n", - "tensor([[-8.1643]])\n", - "------------------------\n", - "tensor([[-7.7254]])\n", - "tensor([[-9.0969]])\n", - "------------------------\n", - "tensor([[-8.3588]])\n", - "tensor([[-7.5229]])\n", - "------------------------\n", - "tensor([[-8.2711]])\n", - "tensor([[-9.9914]])\n", - "------------------------\n", - "tensor([[-6.7294]])\n", - "tensor([[-8.4559]])\n", - "------------------------\n", - "tensor([[-7.3637]])\n", - "tensor([[-8.1308]])\n", - "------------------------\n", - "tensor([[-7.9004]])\n", - "tensor([[-10.5229]])\n", - "------------------------\n", - "tensor([[-7.5773]])\n", - "tensor([[-4.3979]])\n", - "------------------------\n", - "tensor([[-8.1186]])\n", - "tensor([[-8.]])\n", - "------------------------\n", - "tensor([[-8.7053]])\n", - "tensor([[-6.5229]])\n", - "------------------------\n", - "tensor([[-8.3750]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.2676]])\n", - "tensor([[-9.7696]])\n", - "------------------------\n", - "tensor([[-8.1750]])\n", - "tensor([[-8.3010]])\n", - "------------------------\n", - "tensor([[-8.3115]])\n", - "tensor([[-5.8861]])\n", - "------------------------\n", - "tensor([[-7.3989]])\n", - "tensor([[-7.4559]])\n", - "------------------------\n", - "Epoch : 37 \t train loss: 1.808695828934089 train MSE: tensor(1.7309, grad_fn=) test MSE: 2.8074760242986185\n", - "Corr: 0.31595141736533766\n", - "tensor(0.0750, grad_fn=)\n", - "tensor(0.0751, grad_fn=)\n", - "tensor(0.0752, grad_fn=)\n", - "tensor(0.0753, grad_fn=)\n", - "tensor(0.0754, grad_fn=)\n", - "tensor(0.0755, grad_fn=)\n", - "tensor(0.0756, grad_fn=)\n", - "tensor(0.0758, grad_fn=)\n", - "tensor(0.0759, grad_fn=)\n", - "tensor(0.0760, grad_fn=)\n", - "tensor(0.0761, grad_fn=)\n", - "tensor(0.0762, grad_fn=)\n", - "tensor(0.0763, grad_fn=)\n", - "tensor(0.0764, grad_fn=)\n", - "tensor(0.0765, grad_fn=)\n", - "tensor(0.0765, grad_fn=)\n", - "tensor(0.0766, grad_fn=)\n", - "tensor(0.0766, grad_fn=)\n", - "tensor(0.0766, grad_fn=)\n", - "tensor(0.0766, grad_fn=)\n", - "tensor([[-7.0898]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.4364]])\n", - "tensor([[-11.2441]])\n", - "------------------------\n", - "tensor([[-8.5776]])\n", - "tensor([[-7.5986]])\n", - "------------------------\n", - "tensor([[-6.1780]])\n", - "tensor([[-4.5086]])\n", - "------------------------\n", - "tensor([[-7.8579]])\n", - "tensor([[-9.1612]])\n", - "------------------------\n", - "tensor([[-7.4027]])\n", - "tensor([[-7.]])\n", - "------------------------\n", - "tensor([[-8.1536]])\n", - "tensor([[-8.1643]])\n", - "------------------------\n", - "tensor([[-7.8006]])\n", - "tensor([[-9.0969]])\n", - "------------------------\n", - "tensor([[-8.4569]])\n", - "tensor([[-7.5229]])\n", - "------------------------\n", - "tensor([[-8.3759]])\n", - "tensor([[-9.9914]])\n", - "------------------------\n", - "tensor([[-6.7877]])\n", - "tensor([[-8.4559]])\n", - "------------------------\n", - "tensor([[-7.4850]])\n", - "tensor([[-8.1308]])\n", - "------------------------\n", - "tensor([[-7.9556]])\n", - "tensor([[-10.5229]])\n", - "------------------------\n", - "tensor([[-7.6647]])\n", - "tensor([[-4.3979]])\n", - "------------------------\n", - "tensor([[-8.2373]])\n", - "tensor([[-8.]])\n", - "------------------------\n", - "tensor([[-8.8064]])\n", - "tensor([[-6.5229]])\n", - "------------------------\n", - "tensor([[-8.5302]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.3991]])\n", - "tensor([[-9.7696]])\n", - "------------------------\n", - "tensor([[-8.2604]])\n", - "tensor([[-8.3010]])\n", - "------------------------\n", - "tensor([[-8.4237]])\n", - "tensor([[-5.8861]])\n", - "------------------------\n", - "tensor([[-7.4904]])\n", - "tensor([[-7.4559]])\n", - "------------------------\n", - "Epoch : 38 \t train loss: 2.0121441603095844 train MSE: tensor(1.9328, grad_fn=) test MSE: 2.770948552158924\n", - "Corr: 0.31451907539195384\n", - "tensor(0.0766, grad_fn=)\n", - "tensor(0.0767, grad_fn=)\n", - "tensor(0.0767, grad_fn=)\n", - "tensor(0.0768, grad_fn=)\n", - "tensor(0.0769, grad_fn=)\n", - "tensor(0.0770, grad_fn=)\n", - "tensor(0.0771, grad_fn=)\n", - "tensor(0.0773, grad_fn=)\n", - "tensor(0.0774, grad_fn=)\n", - "tensor(0.0775, grad_fn=)\n", - "tensor(0.0776, grad_fn=)\n", - "tensor(0.0778, grad_fn=)\n", - "tensor(0.0779, grad_fn=)\n", - "tensor(0.0780, grad_fn=)\n", - "tensor(0.0781, grad_fn=)\n", - "tensor(0.0782, grad_fn=)\n", - "tensor(0.0783, grad_fn=)\n", - "tensor(0.0784, grad_fn=)\n", - "tensor(0.0785, grad_fn=)\n", - "tensor(0.0786, grad_fn=)\n", - "tensor([[-7.3387]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.6951]])\n", - "tensor([[-11.2441]])\n", - "------------------------\n", - "tensor([[-8.8693]])\n", - "tensor([[-7.5986]])\n", - "------------------------\n", - "tensor([[-6.4470]])\n", - "tensor([[-4.5086]])\n", - "------------------------\n", - "tensor([[-8.0170]])\n", - "tensor([[-9.1612]])\n", - "------------------------\n", - "tensor([[-7.6431]])\n", - "tensor([[-7.]])\n", - "------------------------\n", - "tensor([[-8.4445]])\n", - "tensor([[-8.1643]])\n", - "------------------------\n", - "tensor([[-8.0852]])\n", - "tensor([[-9.0969]])\n", - "------------------------\n", - "tensor([[-8.7207]])\n", - "tensor([[-7.5229]])\n", - "------------------------\n", - "tensor([[-8.6710]])\n", - "tensor([[-9.9914]])\n", - "------------------------\n", - "tensor([[-6.9372]])\n", - "tensor([[-8.4559]])\n", - "------------------------\n", - "tensor([[-7.6889]])\n", - "tensor([[-8.1308]])\n", - "------------------------\n", - "tensor([[-8.1255]])\n", - "tensor([[-10.5229]])\n", - "------------------------\n", - "tensor([[-7.9119]])\n", - "tensor([[-4.3979]])\n", - "------------------------\n", - "tensor([[-8.4925]])\n", - "tensor([[-8.]])\n", - "------------------------\n", - "tensor([[-9.0988]])\n", - "tensor([[-6.5229]])\n", - "------------------------\n", - "tensor([[-8.8029]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.6663]])\n", - "tensor([[-9.7696]])\n", - "------------------------\n", - "tensor([[-8.5391]])\n", - "tensor([[-8.3010]])\n", - "------------------------\n", - "tensor([[-8.7072]])\n", - "tensor([[-5.8861]])\n", - "------------------------\n", - "tensor([[-7.7653]])\n", - "tensor([[-7.4559]])\n", - "------------------------\n", - "Epoch : 39 \t train loss: 1.8016220173672401 train MSE: tensor(1.7206, grad_fn=) test MSE: 2.7987747187060976\n", - "Corr: 0.2908567882774882\n", - "tensor(0.0787, grad_fn=)\n", - "tensor(0.0788, grad_fn=)\n", - "tensor(0.0789, grad_fn=)\n", - "tensor(0.0790, grad_fn=)\n", - "tensor(0.0791, grad_fn=)\n", - "tensor(0.0792, grad_fn=)\n", - "tensor(0.0793, grad_fn=)\n", - "tensor(0.0793, grad_fn=)\n", - "tensor(0.0794, grad_fn=)\n", - "tensor(0.0794, grad_fn=)\n", - "tensor(0.0795, grad_fn=)\n", - "tensor(0.0796, grad_fn=)\n", - "tensor(0.0797, grad_fn=)\n", - "tensor(0.0798, grad_fn=)\n", - "tensor(0.0798, grad_fn=)\n", - "tensor(0.0799, grad_fn=)\n", - "tensor(0.0800, grad_fn=)\n", - "tensor(0.0800, grad_fn=)\n", - "tensor(0.0800, grad_fn=)\n", - "tensor(0.0801, grad_fn=)\n", - "tensor([[-6.9891]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.3871]])\n", - "tensor([[-11.2441]])\n", - "------------------------\n", - "tensor([[-8.5691]])\n", - "tensor([[-7.5986]])\n", - "------------------------\n", - "tensor([[-6.0691]])\n", - "tensor([[-4.5086]])\n", - "------------------------\n", - "tensor([[-7.9272]])\n", - "tensor([[-9.1612]])\n", - "------------------------\n", - "tensor([[-7.2914]])\n", - "tensor([[-7.]])\n", - "------------------------\n", - "tensor([[-8.1208]])\n", - "tensor([[-8.1643]])\n", - "------------------------\n", - "tensor([[-7.7528]])\n", - "tensor([[-9.0969]])\n", - "------------------------\n", - "tensor([[-8.4075]])\n", - "tensor([[-7.5229]])\n", - "------------------------\n", - "tensor([[-8.3523]])\n", - "tensor([[-9.9914]])\n", - "------------------------\n", - "tensor([[-6.8762]])\n", - "tensor([[-8.4559]])\n", - "------------------------\n", - "tensor([[-7.3835]])\n", - "tensor([[-8.1308]])\n", - "------------------------\n", - "tensor([[-8.0364]])\n", - "tensor([[-10.5229]])\n", - "------------------------\n", - "tensor([[-7.5634]])\n", - "tensor([[-4.3979]])\n", - "------------------------\n", - "tensor([[-8.1897]])\n", - "tensor([[-8.]])\n", - "------------------------\n", - "tensor([[-8.7944]])\n", - "tensor([[-6.5229]])\n", - "------------------------\n", - "tensor([[-8.4998]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.3490]])\n", - "tensor([[-9.7696]])\n", - "------------------------\n", - "tensor([[-8.2125]])\n", - "tensor([[-8.3010]])\n", - "------------------------\n", - "tensor([[-8.3721]])\n", - "tensor([[-5.8861]])\n", - "------------------------\n", - "tensor([[-7.4231]])\n", - "tensor([[-7.4559]])\n", - "------------------------\n", - "Epoch : 40 \t train loss: 1.8109015547237428 train MSE: tensor(1.7279, grad_fn=) test MSE: 2.717672065998029\n", - "Corr: 0.345814624137993\n", - "tensor(0.0800, grad_fn=)\n", - "tensor(0.0800, grad_fn=)\n", - "tensor(0.0800, grad_fn=)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "tensor(0.0800, grad_fn=)\n", - "tensor(0.0800, grad_fn=)\n", - "tensor(0.0801, grad_fn=)\n", - "tensor(0.0801, grad_fn=)\n", - "tensor(0.0802, grad_fn=)\n", - "tensor(0.0803, grad_fn=)\n", - "tensor(0.0804, grad_fn=)\n", - "tensor(0.0805, grad_fn=)\n", - "tensor(0.0807, grad_fn=)\n", - "tensor(0.0808, grad_fn=)\n", - "tensor(0.0809, grad_fn=)\n", - "tensor(0.0811, grad_fn=)\n", - "tensor(0.0812, grad_fn=)\n", - "tensor(0.0813, grad_fn=)\n", - "tensor(0.0814, grad_fn=)\n", - "tensor(0.0814, grad_fn=)\n", - "tensor(0.0815, grad_fn=)\n", - "tensor([[-7.4309]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.8447]])\n", - "tensor([[-11.2441]])\n", - "------------------------\n", - "tensor([[-9.0356]])\n", - "tensor([[-7.5986]])\n", - "------------------------\n", - "tensor([[-6.5227]])\n", - "tensor([[-4.5086]])\n", - "------------------------\n", - "tensor([[-8.1122]])\n", - "tensor([[-9.1612]])\n", - "------------------------\n", - "tensor([[-7.7517]])\n", - "tensor([[-7.]])\n", - "------------------------\n", - "tensor([[-8.5811]])\n", - "tensor([[-8.1643]])\n", - "------------------------\n", - "tensor([[-8.2140]])\n", - "tensor([[-9.0969]])\n", - "------------------------\n", - "tensor([[-8.8571]])\n", - "tensor([[-7.5229]])\n", - "------------------------\n", - "tensor([[-8.8203]])\n", - "tensor([[-9.9914]])\n", - "------------------------\n", - "tensor([[-7.0431]])\n", - "tensor([[-8.4559]])\n", - "------------------------\n", - "tensor([[-7.8266]])\n", - "tensor([[-8.1308]])\n", - "------------------------\n", - "tensor([[-8.2304]])\n", - "tensor([[-10.5229]])\n", - "------------------------\n", - "tensor([[-8.0103]])\n", - "tensor([[-4.3979]])\n", - "------------------------\n", - "tensor([[-8.6423]])\n", - "tensor([[-8.]])\n", - "------------------------\n", - "tensor([[-9.2585]])\n", - "tensor([[-6.5229]])\n", - "------------------------\n", - "tensor([[-8.9622]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.8160]])\n", - "tensor([[-9.7696]])\n", - "------------------------\n", - "tensor([[-8.6775]])\n", - "tensor([[-8.3010]])\n", - "------------------------\n", - "tensor([[-8.8468]])\n", - "tensor([[-5.8861]])\n", - "------------------------\n", - "tensor([[-7.8928]])\n", - "tensor([[-7.4559]])\n", - "------------------------\n", - "Epoch : 41 \t train loss: 1.8620615612235387 train MSE: tensor(1.7779, grad_fn=) test MSE: 2.8361028979221974\n", - "Corr: 0.29217123655049576\n", - "tensor(0.0815, grad_fn=)\n", - "tensor(0.0816, grad_fn=)\n", - "tensor(0.0817, grad_fn=)\n", - "tensor(0.0817, grad_fn=)\n", - "tensor(0.0817, grad_fn=)\n", - "tensor(0.0818, grad_fn=)\n", - "tensor(0.0818, grad_fn=)\n", - "tensor(0.0818, grad_fn=)\n", - "tensor(0.0818, grad_fn=)\n", - "tensor(0.0818, grad_fn=)\n", - "tensor(0.0818, grad_fn=)\n", - "tensor(0.0819, grad_fn=)\n", - "tensor(0.0820, grad_fn=)\n", - "tensor(0.0821, grad_fn=)\n", - "tensor(0.0822, grad_fn=)\n", - "tensor(0.0823, grad_fn=)\n", - "tensor(0.0824, grad_fn=)\n", - "tensor(0.0825, grad_fn=)\n", - "tensor(0.0826, grad_fn=)\n", - "tensor(0.0826, grad_fn=)\n", - "tensor([[-7.2095]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.6321]])\n", - "tensor([[-11.2441]])\n", - "------------------------\n", - "tensor([[-8.8223]])\n", - "tensor([[-7.5986]])\n", - "------------------------\n", - "tensor([[-6.2497]])\n", - "tensor([[-4.5086]])\n", - "------------------------\n", - "tensor([[-8.0268]])\n", - "tensor([[-9.1612]])\n", - "------------------------\n", - "tensor([[-7.4804]])\n", - "tensor([[-7.]])\n", - "------------------------\n", - "tensor([[-8.3820]])\n", - "tensor([[-8.1643]])\n", - "------------------------\n", - "tensor([[-8.0146]])\n", - "tensor([[-9.0969]])\n", - "------------------------\n", - "tensor([[-8.6579]])\n", - "tensor([[-7.5229]])\n", - "------------------------\n", - "tensor([[-8.6307]])\n", - "tensor([[-9.9914]])\n", - "------------------------\n", - "tensor([[-6.9583]])\n", - "tensor([[-8.4559]])\n", - "------------------------\n", - "tensor([[-7.6097]])\n", - "tensor([[-8.1308]])\n", - "------------------------\n", - "tensor([[-8.1228]])\n", - "tensor([[-10.5229]])\n", - "------------------------\n", - "tensor([[-7.7926]])\n", - "tensor([[-4.3979]])\n", - "------------------------\n", - "tensor([[-8.3991]])\n", - "tensor([[-8.]])\n", - "------------------------\n", - "tensor([[-9.0695]])\n", - "tensor([[-6.5229]])\n", - "------------------------\n", - "tensor([[-8.7187]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.5731]])\n", - "tensor([[-9.7696]])\n", - "------------------------\n", - "tensor([[-8.4436]])\n", - "tensor([[-8.3010]])\n", - "------------------------\n", - "tensor([[-8.6579]])\n", - "tensor([[-5.8861]])\n", - "------------------------\n", - "tensor([[-7.6621]])\n", - "tensor([[-7.4559]])\n", - "------------------------\n", - "Epoch : 42 \t train loss: 1.8667565823379193 train MSE: tensor(1.7812, grad_fn=) test MSE: 2.741002650133201\n", - "Corr: 0.316359838620394\n", - "tensor(0.0828, grad_fn=)\n", - "tensor(0.0829, grad_fn=)\n", - "tensor(0.0830, grad_fn=)\n", - "tensor(0.0831, grad_fn=)\n", - "tensor(0.0832, grad_fn=)\n", - "tensor(0.0833, grad_fn=)\n", - "tensor(0.0834, grad_fn=)\n", - "tensor(0.0834, grad_fn=)\n", - "tensor(0.0835, grad_fn=)\n", - "tensor(0.0835, grad_fn=)\n", - "tensor(0.0836, grad_fn=)\n", - "tensor(0.0836, grad_fn=)\n", - "tensor(0.0837, grad_fn=)\n", - "tensor(0.0837, grad_fn=)\n", - "tensor(0.0838, grad_fn=)\n", - "tensor(0.0838, grad_fn=)\n", - "tensor(0.0839, grad_fn=)\n", - "tensor(0.0840, grad_fn=)\n", - "tensor(0.0841, grad_fn=)\n", - "tensor(0.0842, grad_fn=)\n", - "tensor([[-7.1315]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.5754]])\n", - "tensor([[-11.2441]])\n", - "------------------------\n", - "tensor([[-8.7845]])\n", - "tensor([[-7.5986]])\n", - "------------------------\n", - "tensor([[-6.1590]])\n", - "tensor([[-4.5086]])\n", - "------------------------\n", - "tensor([[-7.9929]])\n", - "tensor([[-9.1612]])\n", - "------------------------\n", - "tensor([[-7.4052]])\n", - "tensor([[-7.]])\n", - "------------------------\n", - "tensor([[-8.3369]])\n", - "tensor([[-8.1643]])\n", - "------------------------\n", - "tensor([[-7.9958]])\n", - "tensor([[-9.0969]])\n", - "------------------------\n", - "tensor([[-8.6192]])\n", - "tensor([[-7.5229]])\n", - "------------------------\n", - "tensor([[-8.5981]])\n", - "tensor([[-9.9914]])\n", - "------------------------\n", - "tensor([[-6.9342]])\n", - "tensor([[-8.4559]])\n", - "------------------------\n", - "tensor([[-7.5382]])\n", - "tensor([[-8.1308]])\n", - "------------------------\n", - "tensor([[-8.0785]])\n", - "tensor([[-10.5229]])\n", - "------------------------\n", - "tensor([[-7.7599]])\n", - "tensor([[-4.3979]])\n", - "------------------------\n", - "tensor([[-8.3333]])\n", - "tensor([[-8.]])\n", - "------------------------\n", - "tensor([[-9.0477]])\n", - "tensor([[-6.5229]])\n", - "------------------------\n", - "tensor([[-8.6407]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.5034]])\n", - "tensor([[-9.7696]])\n", - "------------------------\n", - "tensor([[-8.3819]])\n", - "tensor([[-8.3010]])\n", - "------------------------\n", - "tensor([[-8.6087]])\n", - "tensor([[-5.8861]])\n", - "------------------------\n", - "tensor([[-7.6064]])\n", - "tensor([[-7.4559]])\n", - "------------------------\n", - "Epoch : 43 \t train loss: 1.7702214892886783 train MSE: tensor(1.6830, grad_fn=) test MSE: 2.7516446890575543\n", - "Corr: 0.31439769780568133\n", - "tensor(0.0843, grad_fn=)\n", - "tensor(0.0844, grad_fn=)\n", - "tensor(0.0845, grad_fn=)\n", - "tensor(0.0847, grad_fn=)\n", - "tensor(0.0847, grad_fn=)\n", - "tensor(0.0848, grad_fn=)\n", - "tensor(0.0848, grad_fn=)\n", - "tensor(0.0849, grad_fn=)\n", - "tensor(0.0849, grad_fn=)\n", - "tensor(0.0850, grad_fn=)\n", - "tensor(0.0850, grad_fn=)\n", - "tensor(0.0851, grad_fn=)\n", - "tensor(0.0851, grad_fn=)\n", - "tensor(0.0852, grad_fn=)\n", - "tensor(0.0852, grad_fn=)\n", - "tensor(0.0853, grad_fn=)\n", - "tensor(0.0854, grad_fn=)\n", - "tensor(0.0855, grad_fn=)\n", - "tensor(0.0856, grad_fn=)\n", - "tensor(0.0857, grad_fn=)\n", - "tensor([[-7.1153]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.6122]])\n", - "tensor([[-11.2441]])\n", - "------------------------\n", - "tensor([[-8.8254]])\n", - "tensor([[-7.5986]])\n", - "------------------------\n", - "tensor([[-6.1458]])\n", - "tensor([[-4.5086]])\n", - "------------------------\n", - "tensor([[-7.9927]])\n", - "tensor([[-9.1612]])\n", - "------------------------\n", - "tensor([[-7.4286]])\n", - "tensor([[-7.]])\n", - "------------------------\n", - "tensor([[-8.3555]])\n", - "tensor([[-8.1643]])\n", - "------------------------\n", - "tensor([[-8.0088]])\n", - "tensor([[-9.0969]])\n", - "------------------------\n", - "tensor([[-8.6469]])\n", - "tensor([[-7.5229]])\n", - "------------------------\n", - "tensor([[-8.6174]])\n", - "tensor([[-9.9914]])\n", - "------------------------\n", - "tensor([[-6.9327]])\n", - "tensor([[-8.4559]])\n", - "------------------------\n", - "tensor([[-7.5669]])\n", - "tensor([[-8.1308]])\n", - "------------------------\n", - "tensor([[-8.0733]])\n", - "tensor([[-10.5229]])\n", - "------------------------\n", - "tensor([[-7.7866]])\n", - "tensor([[-4.3979]])\n", - "------------------------\n", - "tensor([[-8.3584]])\n", - "tensor([[-8.]])\n", - "------------------------\n", - "tensor([[-9.0873]])\n", - "tensor([[-6.5229]])\n", - "------------------------\n", - "tensor([[-8.6619]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.5203]])\n", - "tensor([[-9.7696]])\n", - "------------------------\n", - "tensor([[-8.4099]])\n", - "tensor([[-8.3010]])\n", - "------------------------\n", - "tensor([[-8.6429]])\n", - "tensor([[-5.8861]])\n", - "------------------------\n", - "tensor([[-7.6162]])\n", - "tensor([[-7.4559]])\n", - "------------------------\n", - "Epoch : 44 \t train loss: 1.6809687077707411 train MSE: tensor(1.5922, grad_fn=) test MSE: 2.7735719155254106\n", - "Corr: 0.30627065861679903\n", - "tensor(0.0858, grad_fn=)\n", - "tensor(0.0858, grad_fn=)\n", - "tensor(0.0859, grad_fn=)\n", - "tensor(0.0860, grad_fn=)\n", - "tensor(0.0860, grad_fn=)\n", - "tensor(0.0861, grad_fn=)\n", - "tensor(0.0861, grad_fn=)\n", - "tensor(0.0861, grad_fn=)\n", - "tensor(0.0862, grad_fn=)\n", - "tensor(0.0862, grad_fn=)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "tensor(0.0863, grad_fn=)\n", - "tensor(0.0863, grad_fn=)\n", - "tensor(0.0864, grad_fn=)\n", - "tensor(0.0865, grad_fn=)\n", - "tensor(0.0866, grad_fn=)\n", - "tensor(0.0867, grad_fn=)\n", - "tensor(0.0868, grad_fn=)\n", - "tensor(0.0870, grad_fn=)\n", - "tensor(0.0871, grad_fn=)\n", - "tensor(0.0872, grad_fn=)\n", - "tensor([[-7.2141]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.7207]])\n", - "tensor([[-11.2441]])\n", - "------------------------\n", - "tensor([[-8.9546]])\n", - "tensor([[-7.5986]])\n", - "------------------------\n", - "tensor([[-6.2353]])\n", - "tensor([[-4.5086]])\n", - "------------------------\n", - "tensor([[-8.0424]])\n", - "tensor([[-9.1612]])\n", - "------------------------\n", - "tensor([[-7.4990]])\n", - "tensor([[-7.]])\n", - "------------------------\n", - "tensor([[-8.4871]])\n", - "tensor([[-8.1643]])\n", - "------------------------\n", - "tensor([[-8.1171]])\n", - "tensor([[-9.0969]])\n", - "------------------------\n", - "tensor([[-8.7544]])\n", - "tensor([[-7.5229]])\n", - "------------------------\n", - "tensor([[-8.7516]])\n", - "tensor([[-9.9914]])\n", - "------------------------\n", - "tensor([[-6.9908]])\n", - "tensor([[-8.4559]])\n", - "------------------------\n", - "tensor([[-7.6454]])\n", - "tensor([[-8.1308]])\n", - "------------------------\n", - "tensor([[-8.1299]])\n", - "tensor([[-10.5229]])\n", - "------------------------\n", - "tensor([[-7.8664]])\n", - "tensor([[-4.3979]])\n", - "------------------------\n", - "tensor([[-8.4549]])\n", - "tensor([[-8.]])\n", - "------------------------\n", - "tensor([[-9.2075]])\n", - "tensor([[-6.5229]])\n", - "------------------------\n", - "tensor([[-8.7629]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.6179]])\n", - "tensor([[-9.7696]])\n", - "------------------------\n", - "tensor([[-8.5170]])\n", - "tensor([[-8.3010]])\n", - "------------------------\n", - "tensor([[-8.7289]])\n", - "tensor([[-5.8861]])\n", - "------------------------\n", - "tensor([[-7.7359]])\n", - "tensor([[-7.4559]])\n", - "------------------------\n", - "Epoch : 45 \t train loss: 1.700740238581746 train MSE: tensor(1.6106, grad_fn=) test MSE: 2.787480822631291\n", - "Corr: 0.302754853992019\n", - "tensor(0.0872, grad_fn=)\n", - "tensor(0.0873, grad_fn=)\n", - "tensor(0.0873, grad_fn=)\n", - "tensor(0.0874, grad_fn=)\n", - "tensor(0.0874, grad_fn=)\n", - "tensor(0.0874, grad_fn=)\n", - "tensor(0.0874, grad_fn=)\n", - "tensor(0.0874, grad_fn=)\n", - "tensor(0.0875, grad_fn=)\n", - "tensor(0.0876, grad_fn=)\n", - "tensor(0.0877, grad_fn=)\n", - "tensor(0.0878, grad_fn=)\n", - "tensor(0.0879, grad_fn=)\n", - "tensor(0.0880, grad_fn=)\n", - "tensor(0.0881, grad_fn=)\n", - "tensor(0.0882, grad_fn=)\n", - "tensor(0.0883, grad_fn=)\n", - "tensor(0.0884, grad_fn=)\n", - "tensor(0.0885, grad_fn=)\n", - "tensor(0.0885, grad_fn=)\n", - "tensor([[-7.1329]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.7005]])\n", - "tensor([[-11.2441]])\n", - "------------------------\n", - "tensor([[-8.9290]])\n", - "tensor([[-7.5986]])\n", - "------------------------\n", - "tensor([[-6.1510]])\n", - "tensor([[-4.5086]])\n", - "------------------------\n", - "tensor([[-8.0398]])\n", - "tensor([[-9.1612]])\n", - "------------------------\n", - "tensor([[-7.4224]])\n", - "tensor([[-7.]])\n", - "------------------------\n", - "tensor([[-8.4425]])\n", - "tensor([[-8.1643]])\n", - "------------------------\n", - "tensor([[-8.0673]])\n", - "tensor([[-9.0969]])\n", - "------------------------\n", - "tensor([[-8.7139]])\n", - "tensor([[-7.5229]])\n", - "------------------------\n", - "tensor([[-8.6991]])\n", - "tensor([[-9.9914]])\n", - "------------------------\n", - "tensor([[-6.9916]])\n", - "tensor([[-8.4559]])\n", - "------------------------\n", - "tensor([[-7.5929]])\n", - "tensor([[-8.1308]])\n", - "------------------------\n", - "tensor([[-8.1187]])\n", - "tensor([[-10.5229]])\n", - "------------------------\n", - "tensor([[-7.8203]])\n", - "tensor([[-4.3979]])\n", - "------------------------\n", - "tensor([[-8.4172]])\n", - "tensor([[-8.]])\n", - "------------------------\n", - "tensor([[-9.1689]])\n", - "tensor([[-6.5229]])\n", - "------------------------\n", - "tensor([[-8.7254]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.5731]])\n", - "tensor([[-9.7696]])\n", - "------------------------\n", - "tensor([[-8.4722]])\n", - "tensor([[-8.3010]])\n", - "------------------------\n", - "tensor([[-8.6670]])\n", - "tensor([[-5.8861]])\n", - "------------------------\n", - "tensor([[-7.6759]])\n", - "tensor([[-7.4559]])\n", - "------------------------\n", - "Epoch : 46 \t train loss: 1.815729069670884 train MSE: tensor(1.7241, grad_fn=) test MSE: 2.7607571122546988\n", - "Corr: 0.3134676222512477\n", - "tensor(0.0886, grad_fn=)\n", - "tensor(0.0887, grad_fn=)\n", - "tensor(0.0889, grad_fn=)\n", - "tensor(0.0890, grad_fn=)\n", - "tensor(0.0891, grad_fn=)\n", - "tensor(0.0892, grad_fn=)\n", - "tensor(0.0893, grad_fn=)\n", - "tensor(0.0894, grad_fn=)\n", - "tensor(0.0895, grad_fn=)\n", - "tensor(0.0896, grad_fn=)\n", - "tensor(0.0897, grad_fn=)\n", - "tensor(0.0898, grad_fn=)\n", - "tensor(0.0899, grad_fn=)\n", - "tensor(0.0900, grad_fn=)\n", - "tensor(0.0900, grad_fn=)\n", - "tensor(0.0901, grad_fn=)\n", - "tensor(0.0901, grad_fn=)\n", - "tensor(0.0901, grad_fn=)\n", - "tensor(0.0901, grad_fn=)\n", - "tensor(0.0902, grad_fn=)\n", - "tensor([[-6.8620]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.4294]])\n", - "tensor([[-11.2441]])\n", - "------------------------\n", - "tensor([[-8.6603]])\n", - "tensor([[-7.5986]])\n", - "------------------------\n", - "tensor([[-5.8490]])\n", - "tensor([[-4.5086]])\n", - "------------------------\n", - "tensor([[-7.9888]])\n", - "tensor([[-9.1612]])\n", - "------------------------\n", - "tensor([[-7.1379]])\n", - "tensor([[-7.]])\n", - "------------------------\n", - "tensor([[-8.1699]])\n", - "tensor([[-8.1643]])\n", - "------------------------\n", - "tensor([[-7.7193]])\n", - "tensor([[-9.0969]])\n", - "------------------------\n", - "tensor([[-8.4547]])\n", - "tensor([[-7.5229]])\n", - "------------------------\n", - "tensor([[-8.4412]])\n", - "tensor([[-9.9914]])\n", - "------------------------\n", - "tensor([[-6.9470]])\n", - "tensor([[-8.4559]])\n", - "------------------------\n", - "tensor([[-7.2892]])\n", - "tensor([[-8.1308]])\n", - "------------------------\n", - "tensor([[-8.0636]])\n", - "tensor([[-10.5229]])\n", - "------------------------\n", - "tensor([[-7.4904]])\n", - "tensor([[-4.3979]])\n", - "------------------------\n", - "tensor([[-8.1030]])\n", - "tensor([[-8.]])\n", - "------------------------\n", - "tensor([[-8.9094]])\n", - "tensor([[-6.5229]])\n", - "------------------------\n", - "tensor([[-8.4113]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.2751]])\n", - "tensor([[-9.7696]])\n", - "------------------------\n", - "tensor([[-8.1867]])\n", - "tensor([[-8.3010]])\n", - "------------------------\n", - "tensor([[-8.3447]])\n", - "tensor([[-5.8861]])\n", - "------------------------\n", - "tensor([[-7.3937]])\n", - "tensor([[-7.4559]])\n", - "------------------------\n", - "Epoch : 47 \t train loss: 1.6800588417986675 train MSE: tensor(1.5866, grad_fn=) test MSE: 2.702260692329132\n", - "Corr: 0.36007971857669163\n", - "tensor(0.0903, grad_fn=)\n", - "tensor(0.0904, grad_fn=)\n", - "tensor(0.0905, grad_fn=)\n", - "tensor(0.0906, grad_fn=)\n", - "tensor(0.0908, grad_fn=)\n", - "tensor(0.0909, grad_fn=)\n", - "tensor(0.0910, grad_fn=)\n", - "tensor(0.0911, grad_fn=)\n", - "tensor(0.0912, grad_fn=)\n", - "tensor(0.0913, grad_fn=)\n", - "tensor(0.0913, grad_fn=)\n", - "tensor(0.0913, grad_fn=)\n", - "tensor(0.0914, grad_fn=)\n", - "tensor(0.0914, grad_fn=)\n", - "tensor(0.0914, grad_fn=)\n", - "tensor(0.0914, grad_fn=)\n", - "tensor(0.0915, grad_fn=)\n", - "tensor(0.0916, grad_fn=)\n", - "tensor(0.0917, grad_fn=)\n", - "tensor(0.0918, grad_fn=)\n", - "tensor([[-7.0030]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.6120]])\n", - "tensor([[-11.2441]])\n", - "------------------------\n", - "tensor([[-8.8462]])\n", - "tensor([[-7.5986]])\n", - "------------------------\n", - "tensor([[-6.0082]])\n", - "tensor([[-4.5086]])\n", - "------------------------\n", - "tensor([[-8.0453]])\n", - "tensor([[-9.1612]])\n", - "------------------------\n", - "tensor([[-7.2758]])\n", - "tensor([[-7.]])\n", - "------------------------\n", - "tensor([[-8.3350]])\n", - "tensor([[-8.1643]])\n", - "------------------------\n", - "tensor([[-7.8916]])\n", - "tensor([[-9.0969]])\n", - "------------------------\n", - "tensor([[-8.6122]])\n", - "tensor([[-7.5229]])\n", - "------------------------\n", - "tensor([[-8.6142]])\n", - "tensor([[-9.9914]])\n", - "------------------------\n", - "tensor([[-6.9950]])\n", - "tensor([[-8.4559]])\n", - "------------------------\n", - "tensor([[-7.5123]])\n", - "tensor([[-8.1308]])\n", - "------------------------\n", - "tensor([[-8.1144]])\n", - "tensor([[-10.5229]])\n", - "------------------------\n", - "tensor([[-7.6533]])\n", - "tensor([[-4.3979]])\n", - "------------------------\n", - "tensor([[-8.3197]])\n", - "tensor([[-8.]])\n", - "------------------------\n", - "tensor([[-9.0840]])\n", - "tensor([[-6.5229]])\n", - "------------------------\n", - "tensor([[-8.6591]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.5071]])\n", - "tensor([[-9.7696]])\n", - "------------------------\n", - "tensor([[-8.3591]])\n", - "tensor([[-8.3010]])\n", - "------------------------\n", - "tensor([[-8.5885]])\n", - "tensor([[-5.8861]])\n", - "------------------------\n", - "tensor([[-7.5580]])\n", - "tensor([[-7.4559]])\n", - "------------------------\n", - "Epoch : 48 \t train loss: 1.7316220456196474 train MSE: tensor(1.6365, grad_fn=) test MSE: 2.7047435267872753\n", - "Corr: 0.33936409809583207\n", - "tensor(0.0919, grad_fn=)\n", - "tensor(0.0921, grad_fn=)\n", - "tensor(0.0922, grad_fn=)\n", - "tensor(0.0923, grad_fn=)\n", - "tensor(0.0924, grad_fn=)\n", - "tensor(0.0926, grad_fn=)\n", - "tensor(0.0927, grad_fn=)\n", - "tensor(0.0928, grad_fn=)\n", - "tensor(0.0928, grad_fn=)\n", - "tensor(0.0929, grad_fn=)\n", - "tensor(0.0929, grad_fn=)\n", - "tensor(0.0929, grad_fn=)\n", - "tensor(0.0929, grad_fn=)\n", - "tensor(0.0929, grad_fn=)\n", - "tensor(0.0928, grad_fn=)\n", - "tensor(0.0928, grad_fn=)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "tensor(0.0928, grad_fn=)\n", - "tensor(0.0928, grad_fn=)\n", - "tensor(0.0929, grad_fn=)\n", - "tensor(0.0929, grad_fn=)\n", - "tensor([[-6.6363]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.3427]])\n", - "tensor([[-11.2441]])\n", - "------------------------\n", - "tensor([[-8.5228]])\n", - "tensor([[-7.5986]])\n", - "------------------------\n", - "tensor([[-5.6529]])\n", - "tensor([[-4.5086]])\n", - "------------------------\n", - "tensor([[-7.8649]])\n", - "tensor([[-9.1612]])\n", - "------------------------\n", - "tensor([[-6.9078]])\n", - "tensor([[-7.]])\n", - "------------------------\n", - "tensor([[-7.9897]])\n", - "tensor([[-8.1643]])\n", - "------------------------\n", - "tensor([[-7.5344]])\n", - "tensor([[-9.0969]])\n", - "------------------------\n", - "tensor([[-8.2726]])\n", - "tensor([[-7.5229]])\n", - "------------------------\n", - "tensor([[-8.2684]])\n", - "tensor([[-9.9914]])\n", - "------------------------\n", - "tensor([[-6.8470]])\n", - "tensor([[-8.4559]])\n", - "------------------------\n", - "tensor([[-7.1483]])\n", - "tensor([[-8.1308]])\n", - "------------------------\n", - "tensor([[-7.9275]])\n", - "tensor([[-10.5229]])\n", - "------------------------\n", - "tensor([[-7.2867]])\n", - "tensor([[-4.3979]])\n", - "------------------------\n", - "tensor([[-7.9625]])\n", - "tensor([[-8.]])\n", - "------------------------\n", - "tensor([[-8.7513]])\n", - "tensor([[-6.5229]])\n", - "------------------------\n", - "tensor([[-8.2885]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.1259]])\n", - "tensor([[-9.7696]])\n", - "------------------------\n", - "tensor([[-8.0134]])\n", - "tensor([[-8.3010]])\n", - "------------------------\n", - "tensor([[-8.2114]])\n", - "tensor([[-5.8861]])\n", - "------------------------\n", - "tensor([[-7.1929]])\n", - "tensor([[-7.4559]])\n", - "------------------------\n", - "Epoch : 49 \t train loss: 1.68701748124538 train MSE: tensor(1.5903, grad_fn=) test MSE: 2.774386301736481\n", - "Corr: 0.374518718549834\n", - "tensor(0.0931, grad_fn=)\n", - "tensor(0.0932, grad_fn=)\n", - "tensor(0.0934, grad_fn=)\n", - "tensor(0.0936, grad_fn=)\n", - "tensor(0.0938, grad_fn=)\n", - "tensor(0.0940, grad_fn=)\n", - "tensor(0.0942, grad_fn=)\n", - "tensor(0.0943, grad_fn=)\n", - "tensor(0.0944, grad_fn=)\n", - "tensor(0.0945, grad_fn=)\n", - "tensor(0.0945, grad_fn=)\n", - "tensor(0.0945, grad_fn=)\n", - "tensor(0.0945, grad_fn=)\n", - "tensor(0.0945, grad_fn=)\n", - "tensor(0.0945, grad_fn=)\n", - "tensor(0.0945, grad_fn=)\n", - "tensor(0.0945, grad_fn=)\n", - "tensor(0.0945, grad_fn=)\n", - "tensor(0.0945, grad_fn=)\n", - "tensor(0.0946, grad_fn=)\n", - "tensor([[-6.7315]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.5206]])\n", - "tensor([[-11.2441]])\n", - "------------------------\n", - "tensor([[-8.6896]])\n", - "tensor([[-7.5986]])\n", - "------------------------\n", - "tensor([[-5.7711]])\n", - "tensor([[-4.5086]])\n", - "------------------------\n", - "tensor([[-7.9100]])\n", - "tensor([[-9.1612]])\n", - "------------------------\n", - "tensor([[-7.0262]])\n", - "tensor([[-7.]])\n", - "------------------------\n", - "tensor([[-8.1107]])\n", - "tensor([[-8.1643]])\n", - "------------------------\n", - "tensor([[-7.6907]])\n", - "tensor([[-9.0969]])\n", - "------------------------\n", - "tensor([[-8.4032]])\n", - "tensor([[-7.5229]])\n", - "------------------------\n", - "tensor([[-8.3911]])\n", - "tensor([[-9.9914]])\n", - "------------------------\n", - "tensor([[-6.8951]])\n", - "tensor([[-8.4559]])\n", - "------------------------\n", - "tensor([[-7.2836]])\n", - "tensor([[-8.1308]])\n", - "------------------------\n", - "tensor([[-7.9732]])\n", - "tensor([[-10.5229]])\n", - "------------------------\n", - "tensor([[-7.4181]])\n", - "tensor([[-4.3979]])\n", - "------------------------\n", - "tensor([[-8.1231]])\n", - "tensor([[-8.]])\n", - "------------------------\n", - "tensor([[-8.8889]])\n", - "tensor([[-6.5229]])\n", - "------------------------\n", - "tensor([[-8.4523]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.2713]])\n", - "tensor([[-9.7696]])\n", - "------------------------\n", - "tensor([[-8.1655]])\n", - "tensor([[-8.3010]])\n", - "------------------------\n", - "tensor([[-8.3624]])\n", - "tensor([[-5.8861]])\n", - "------------------------\n", - "tensor([[-7.3138]])\n", - "tensor([[-7.4559]])\n", - "------------------------\n", - "Epoch : 50 \t train loss: 1.7193435059091589 train MSE: tensor(1.6210, grad_fn=) test MSE: 2.724383768154352\n", - "Corr: 0.36139768568721364\n", - "tensor(0.0947, grad_fn=)\n", - "tensor(0.0948, grad_fn=)\n", - "tensor(0.0950, grad_fn=)\n", - "tensor(0.0951, grad_fn=)\n", - "tensor(0.0953, grad_fn=)\n", - "tensor(0.0954, grad_fn=)\n", - "tensor(0.0956, grad_fn=)\n", - "tensor(0.0956, grad_fn=)\n", - "tensor(0.0957, grad_fn=)\n", - "tensor(0.0957, grad_fn=)\n", - "tensor(0.0957, grad_fn=)\n", - "tensor(0.0957, grad_fn=)\n", - "tensor(0.0957, grad_fn=)\n", - "tensor(0.0957, grad_fn=)\n", - "tensor(0.0957, grad_fn=)\n", - "tensor(0.0957, grad_fn=)\n", - "tensor(0.0957, grad_fn=)\n", - "tensor(0.0958, grad_fn=)\n", - "tensor(0.0958, grad_fn=)\n", - "tensor(0.0959, grad_fn=)\n", - "tensor([[-6.7862]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.5993]])\n", - "tensor([[-11.2441]])\n", - "------------------------\n", - "tensor([[-8.7796]])\n", - "tensor([[-7.5986]])\n", - "------------------------\n", - "tensor([[-5.8198]])\n", - "tensor([[-4.5086]])\n", - "------------------------\n", - "tensor([[-7.9598]])\n", - "tensor([[-9.1612]])\n", - "------------------------\n", - "tensor([[-7.0770]])\n", - "tensor([[-7.]])\n", - "------------------------\n", - "tensor([[-8.1962]])\n", - "tensor([[-8.1643]])\n", - "------------------------\n", - "tensor([[-7.7584]])\n", - "tensor([[-9.0969]])\n", - "------------------------\n", - "tensor([[-8.4876]])\n", - "tensor([[-7.5229]])\n", - "------------------------\n", - "tensor([[-8.4726]])\n", - "tensor([[-9.9914]])\n", - "------------------------\n", - "tensor([[-6.9451]])\n", - "tensor([[-8.4559]])\n", - "------------------------\n", - "tensor([[-7.3337]])\n", - "tensor([[-8.1308]])\n", - "------------------------\n", - "tensor([[-8.0222]])\n", - "tensor([[-10.5229]])\n", - "------------------------\n", - "tensor([[-7.4900]])\n", - "tensor([[-4.3979]])\n", - "------------------------\n", - "tensor([[-8.1867]])\n", - "tensor([[-8.]])\n", - "------------------------\n", - "tensor([[-8.9790]])\n", - "tensor([[-6.5229]])\n", - "------------------------\n", - "tensor([[-8.5118]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.3319]])\n", - "tensor([[-9.7696]])\n", - "------------------------\n", - "tensor([[-8.2412]])\n", - "tensor([[-8.3010]])\n", - "------------------------\n", - "tensor([[-8.4163]])\n", - "tensor([[-5.8861]])\n", - "------------------------\n", - "tensor([[-7.3947]])\n", - "tensor([[-7.4559]])\n", - "------------------------\n", - "Epoch : 51 \t train loss: 1.6955552155586482 train MSE: tensor(1.5958, grad_fn=) test MSE: 2.705319132655859\n", - "Corr: 0.35690961288422707\n", - "tensor(0.0960, grad_fn=)\n", - "tensor(0.0961, grad_fn=)\n", - "tensor(0.0961, grad_fn=)\n", - "tensor(0.0962, grad_fn=)\n", - "tensor(0.0963, grad_fn=)\n", - "tensor(0.0963, grad_fn=)\n", - "tensor(0.0964, grad_fn=)\n", - "tensor(0.0965, grad_fn=)\n", - "tensor(0.0967, grad_fn=)\n", - "tensor(0.0968, grad_fn=)\n", - "tensor(0.0969, grad_fn=)\n", - "tensor(0.0971, grad_fn=)\n", - "tensor(0.0972, grad_fn=)\n", - "tensor(0.0973, grad_fn=)\n", - "tensor(0.0974, grad_fn=)\n", - "tensor(0.0975, grad_fn=)\n", - "tensor(0.0975, grad_fn=)\n", - "tensor(0.0976, grad_fn=)\n", - "tensor(0.0976, grad_fn=)\n", - "tensor(0.0976, grad_fn=)\n", - "tensor([[-6.9684]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.8272]])\n", - "tensor([[-11.2441]])\n", - "------------------------\n", - "tensor([[-8.9996]])\n", - "tensor([[-7.5986]])\n", - "------------------------\n", - "tensor([[-5.9998]])\n", - "tensor([[-4.5086]])\n", - "------------------------\n", - "tensor([[-8.0031]])\n", - "tensor([[-9.1612]])\n", - "------------------------\n", - "tensor([[-7.2544]])\n", - "tensor([[-7.]])\n", - "------------------------\n", - "tensor([[-8.4085]])\n", - "tensor([[-8.1643]])\n", - "------------------------\n", - "tensor([[-7.9992]])\n", - "tensor([[-9.0969]])\n", - "------------------------\n", - "tensor([[-8.6939]])\n", - "tensor([[-7.5229]])\n", - "------------------------\n", - "tensor([[-8.6830]])\n", - "tensor([[-9.9914]])\n", - "------------------------\n", - "tensor([[-6.9880]])\n", - "tensor([[-8.4559]])\n", - "------------------------\n", - "tensor([[-7.5443]])\n", - "tensor([[-8.1308]])\n", - "------------------------\n", - "tensor([[-8.0640]])\n", - "tensor([[-10.5229]])\n", - "------------------------\n", - "tensor([[-7.7123]])\n", - "tensor([[-4.3979]])\n", - "------------------------\n", - "tensor([[-8.3976]])\n", - "tensor([[-8.]])\n", - "------------------------\n", - "tensor([[-9.1890]])\n", - "tensor([[-6.5229]])\n", - "------------------------\n", - "tensor([[-8.7178]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.5401]])\n", - "tensor([[-9.7696]])\n", - "------------------------\n", - "tensor([[-8.4460]])\n", - "tensor([[-8.3010]])\n", - "------------------------\n", - "tensor([[-8.6960]])\n", - "tensor([[-5.8861]])\n", - "------------------------\n", - "tensor([[-7.6072]])\n", - "tensor([[-7.4559]])\n", - "------------------------\n", - "Epoch : 52 \t train loss: 1.6054600969224342 train MSE: tensor(1.5043, grad_fn=) test MSE: 2.752841176110365\n", - "Corr: 0.32472064299025505\n", - "tensor(0.0976, grad_fn=)\n", - "tensor(0.0976, grad_fn=)\n", - "tensor(0.0976, grad_fn=)\n", - "tensor(0.0976, grad_fn=)\n", - "tensor(0.0977, grad_fn=)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "tensor(0.0978, grad_fn=)\n", - "tensor(0.0978, grad_fn=)\n", - "tensor(0.0979, grad_fn=)\n", - "tensor(0.0980, grad_fn=)\n", - "tensor(0.0981, grad_fn=)\n", - "tensor(0.0982, grad_fn=)\n", - "tensor(0.0982, grad_fn=)\n", - "tensor(0.0983, grad_fn=)\n", - "tensor(0.0983, grad_fn=)\n", - "tensor(0.0984, grad_fn=)\n", - "tensor(0.0984, grad_fn=)\n", - "tensor(0.0985, grad_fn=)\n", - "tensor(0.0986, grad_fn=)\n", - "tensor(0.0987, grad_fn=)\n", - "tensor(0.0987, grad_fn=)\n", - "tensor([[-7.0827]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.9685]])\n", - "tensor([[-11.2441]])\n", - "------------------------\n", - "tensor([[-9.1373]])\n", - "tensor([[-7.5986]])\n", - "------------------------\n", - "tensor([[-6.1182]])\n", - "tensor([[-4.5086]])\n", - "------------------------\n", - "tensor([[-8.0288]])\n", - "tensor([[-9.1612]])\n", - "------------------------\n", - "tensor([[-7.3636]])\n", - "tensor([[-7.]])\n", - "------------------------\n", - "tensor([[-8.5476]])\n", - "tensor([[-8.1643]])\n", - "------------------------\n", - "tensor([[-8.1290]])\n", - "tensor([[-9.0969]])\n", - "------------------------\n", - "tensor([[-8.8247]])\n", - "tensor([[-7.5229]])\n", - "------------------------\n", - "tensor([[-8.8171]])\n", - "tensor([[-9.9914]])\n", - "------------------------\n", - "tensor([[-7.0147]])\n", - "tensor([[-8.4559]])\n", - "------------------------\n", - "tensor([[-7.6364]])\n", - "tensor([[-8.1308]])\n", - "------------------------\n", - "tensor([[-8.0916]])\n", - "tensor([[-10.5229]])\n", - "------------------------\n", - "tensor([[-7.8193]])\n", - "tensor([[-4.3979]])\n", - "------------------------\n", - "tensor([[-8.4997]])\n", - "tensor([[-8.]])\n", - "------------------------\n", - "tensor([[-9.3295]])\n", - "tensor([[-6.5229]])\n", - "------------------------\n", - "tensor([[-8.8188]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.6396]])\n", - "tensor([[-9.7696]])\n", - "------------------------\n", - "tensor([[-8.5739]])\n", - "tensor([[-8.3010]])\n", - "------------------------\n", - "tensor([[-8.8059]])\n", - "tensor([[-5.8861]])\n", - "------------------------\n", - "tensor([[-7.7303]])\n", - "tensor([[-7.4559]])\n", - "------------------------\n", - "Epoch : 53 \t train loss: 1.6298820719633365 train MSE: tensor(1.5275, grad_fn=) test MSE: 2.80377872323706\n", - "Corr: 0.3102098531339265\n", - "tensor(0.0989, grad_fn=)\n", - "tensor(0.0991, grad_fn=)\n", - "tensor(0.0992, grad_fn=)\n", - "tensor(0.0993, grad_fn=)\n", - "tensor(0.0994, grad_fn=)\n", - "tensor(0.0995, grad_fn=)\n", - "tensor(0.0995, grad_fn=)\n", - "tensor(0.0996, grad_fn=)\n", - "tensor(0.0996, grad_fn=)\n", - "tensor(0.0996, grad_fn=)\n", - "tensor(0.0996, grad_fn=)\n", - "tensor(0.0996, grad_fn=)\n", - "tensor(0.0996, grad_fn=)\n", - "tensor(0.0996, grad_fn=)\n", - "tensor(0.0997, grad_fn=)\n", - "tensor(0.0997, grad_fn=)\n", - "tensor(0.0998, grad_fn=)\n", - "tensor(0.0999, grad_fn=)\n", - "tensor(0.1000, grad_fn=)\n", - "tensor(0.1001, grad_fn=)\n", - "tensor([[-6.8643]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.7922]])\n", - "tensor([[-11.2441]])\n", - "------------------------\n", - "tensor([[-8.9542]])\n", - "tensor([[-7.5986]])\n", - "------------------------\n", - "tensor([[-5.8753]])\n", - "tensor([[-4.5086]])\n", - "------------------------\n", - "tensor([[-8.0020]])\n", - "tensor([[-9.1612]])\n", - "------------------------\n", - "tensor([[-7.1347]])\n", - "tensor([[-7.]])\n", - "------------------------\n", - "tensor([[-8.3533]])\n", - "tensor([[-8.1643]])\n", - "------------------------\n", - "tensor([[-7.9362]])\n", - "tensor([[-9.0969]])\n", - "------------------------\n", - "tensor([[-8.6324]])\n", - "tensor([[-7.5229]])\n", - "------------------------\n", - "tensor([[-8.6236]])\n", - "tensor([[-9.9914]])\n", - "------------------------\n", - "tensor([[-7.0024]])\n", - "tensor([[-8.4559]])\n", - "------------------------\n", - "tensor([[-7.4579]])\n", - "tensor([[-8.1308]])\n", - "------------------------\n", - "tensor([[-8.0683]])\n", - "tensor([[-10.5229]])\n", - "------------------------\n", - "tensor([[-7.6219]])\n", - "tensor([[-4.3979]])\n", - "------------------------\n", - "tensor([[-8.3104]])\n", - "tensor([[-8.]])\n", - "------------------------\n", - "tensor([[-9.1388]])\n", - "tensor([[-6.5229]])\n", - "------------------------\n", - "tensor([[-8.6402]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.4586]])\n", - "tensor([[-9.7696]])\n", - "------------------------\n", - "tensor([[-8.3684]])\n", - "tensor([[-8.3010]])\n", - "------------------------\n", - "tensor([[-8.6157]])\n", - "tensor([[-5.8861]])\n", - "------------------------\n", - "tensor([[-7.5255]])\n", - "tensor([[-7.4559]])\n", - "------------------------\n", - "Epoch : 54 \t train loss: 1.613544177853458 train MSE: tensor(1.5096, grad_fn=) test MSE: 2.7162542909915954\n", - "Corr: 0.3427154866038581\n", - "tensor(0.1002, grad_fn=)\n", - "tensor(0.1003, grad_fn=)\n", - "tensor(0.1004, grad_fn=)\n", - "tensor(0.1005, grad_fn=)\n", - "tensor(0.1006, grad_fn=)\n", - "tensor(0.1007, grad_fn=)\n", - "tensor(0.1008, grad_fn=)\n", - "tensor(0.1009, grad_fn=)\n", - "tensor(0.1010, grad_fn=)\n", - "tensor(0.1010, grad_fn=)\n", - "tensor(0.1011, grad_fn=)\n", - "tensor(0.1011, grad_fn=)\n", - "tensor(0.1011, grad_fn=)\n", - "tensor(0.1012, grad_fn=)\n", - "tensor(0.1012, grad_fn=)\n", - "tensor(0.1013, grad_fn=)\n", - "tensor(0.1013, grad_fn=)\n", - "tensor(0.1013, grad_fn=)\n", - "tensor(0.1014, grad_fn=)\n", - "tensor(0.1016, grad_fn=)\n", - "tensor([[-6.9276]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.8781]])\n", - "tensor([[-11.2441]])\n", - "------------------------\n", - "tensor([[-9.0463]])\n", - "tensor([[-7.5986]])\n", - "------------------------\n", - "tensor([[-5.9380]])\n", - "tensor([[-4.5086]])\n", - "------------------------\n", - "tensor([[-8.0537]])\n", - "tensor([[-9.1612]])\n", - "------------------------\n", - "tensor([[-7.1879]])\n", - "tensor([[-7.]])\n", - "------------------------\n", - "tensor([[-8.4477]])\n", - "tensor([[-8.1643]])\n", - "------------------------\n", - "tensor([[-8.0254]])\n", - "tensor([[-9.0969]])\n", - "------------------------\n", - "tensor([[-8.7104]])\n", - "tensor([[-7.5229]])\n", - "------------------------\n", - "tensor([[-8.7073]])\n", - "tensor([[-9.9914]])\n", - "------------------------\n", - "tensor([[-7.0598]])\n", - "tensor([[-8.4559]])\n", - "------------------------\n", - "tensor([[-7.5307]])\n", - "tensor([[-8.1308]])\n", - "------------------------\n", - "tensor([[-8.1286]])\n", - "tensor([[-10.5229]])\n", - "------------------------\n", - "tensor([[-7.7060]])\n", - "tensor([[-4.3979]])\n", - "------------------------\n", - "tensor([[-8.3937]])\n", - "tensor([[-8.]])\n", - "------------------------\n", - "tensor([[-9.2162]])\n", - "tensor([[-6.5229]])\n", - "------------------------\n", - "tensor([[-8.7262]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.5312]])\n", - "tensor([[-9.7696]])\n", - "------------------------\n", - "tensor([[-8.4456]])\n", - "tensor([[-8.3010]])\n", - "------------------------\n", - "tensor([[-8.6996]])\n", - "tensor([[-5.8861]])\n", - "------------------------\n", - "tensor([[-7.6155]])\n", - "tensor([[-7.4559]])\n", - "------------------------\n", - "Epoch : 55 \t train loss: 1.569295917405195 train MSE: tensor(1.4639, grad_fn=) test MSE: 2.720939888042353\n", - "Corr: 0.3390693722354583\n", - "tensor(0.1017, grad_fn=)\n", - "tensor(0.1017, grad_fn=)\n", - "tensor(0.1018, grad_fn=)\n", - "tensor(0.1019, grad_fn=)\n", - "tensor(0.1020, grad_fn=)\n", - "tensor(0.1021, grad_fn=)\n", - "tensor(0.1021, grad_fn=)\n", - "tensor(0.1022, grad_fn=)\n", - "tensor(0.1023, grad_fn=)\n", - "tensor(0.1024, grad_fn=)\n", - "tensor(0.1025, grad_fn=)\n", - "tensor(0.1026, grad_fn=)\n", - "tensor(0.1027, grad_fn=)\n", - "tensor(0.1029, grad_fn=)\n", - "tensor(0.1030, grad_fn=)\n", - "tensor(0.1030, grad_fn=)\n", - "tensor(0.1031, grad_fn=)\n", - "tensor(0.1031, grad_fn=)\n", - "tensor(0.1032, grad_fn=)\n", - "tensor(0.1033, grad_fn=)\n", - "tensor([[-6.9959]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.9543]])\n", - "tensor([[-11.2441]])\n", - "------------------------\n", - "tensor([[-9.1444]])\n", - "tensor([[-7.5986]])\n", - "------------------------\n", - "tensor([[-6.0039]])\n", - "tensor([[-4.5086]])\n", - "------------------------\n", - "tensor([[-8.1451]])\n", - "tensor([[-9.1612]])\n", - "------------------------\n", - "tensor([[-7.2684]])\n", - "tensor([[-7.]])\n", - "------------------------\n", - "tensor([[-8.5203]])\n", - "tensor([[-8.1643]])\n", - "------------------------\n", - "tensor([[-8.1171]])\n", - "tensor([[-9.0969]])\n", - "------------------------\n", - "tensor([[-8.7968]])\n", - "tensor([[-7.5229]])\n", - "------------------------\n", - "tensor([[-8.7871]])\n", - "tensor([[-9.9914]])\n", - "------------------------\n", - "tensor([[-7.1486]])\n", - "tensor([[-8.4559]])\n", - "------------------------\n", - "tensor([[-7.5938]])\n", - "tensor([[-8.1308]])\n", - "------------------------\n", - "tensor([[-8.2345]])\n", - "tensor([[-10.5229]])\n", - "------------------------\n", - "tensor([[-7.7857]])\n", - "tensor([[-4.3979]])\n", - "------------------------\n", - "tensor([[-8.4841]])\n", - "tensor([[-8.]])\n", - "------------------------\n", - "tensor([[-9.3098]])\n", - "tensor([[-6.5229]])\n", - "------------------------\n", - "tensor([[-8.8080]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.6099]])\n", - "tensor([[-9.7696]])\n", - "------------------------\n", - "tensor([[-8.5318]])\n", - "tensor([[-8.3010]])\n", - "------------------------\n", - "tensor([[-8.8043]])\n", - "tensor([[-5.8861]])\n", - "------------------------\n", - "tensor([[-7.6856]])\n", - "tensor([[-7.4559]])\n", - "------------------------\n", - "Epoch : 56 \t train loss: 1.5710191462207188 train MSE: tensor(1.4640, grad_fn=) test MSE: 2.731824910534279\n", - "Corr: 0.33757433454730346\n", - "tensor(0.1033, grad_fn=)\n", - "tensor(0.1033, grad_fn=)\n", - "tensor(0.1033, grad_fn=)\n", - "tensor(0.1033, grad_fn=)\n", - "tensor(0.1034, grad_fn=)\n", - "tensor(0.1034, grad_fn=)\n", - "tensor(0.1034, grad_fn=)\n", - "tensor(0.1034, grad_fn=)\n", - "tensor(0.1034, grad_fn=)\n", - "tensor(0.1035, grad_fn=)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "tensor(0.1035, grad_fn=)\n", - "tensor(0.1035, grad_fn=)\n", - "tensor(0.1036, grad_fn=)\n", - "tensor(0.1038, grad_fn=)\n", - "tensor(0.1039, grad_fn=)\n", - "tensor(0.1040, grad_fn=)\n", - "tensor(0.1041, grad_fn=)\n", - "tensor(0.1042, grad_fn=)\n", - "tensor(0.1043, grad_fn=)\n", - "tensor(0.1043, grad_fn=)\n", - "tensor([[-7.0338]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-9.0020]])\n", - "tensor([[-11.2441]])\n", + "tensor([[-7.2492]])\n", + "tensor([[-8.1643]])\n", "------------------------\n", - "tensor([[-9.2079]])\n", - "tensor([[-7.5986]])\n", + "tensor([[-7.0795]])\n", + "tensor([[-7.9208]])\n", "------------------------\n", - "tensor([[-6.0404]])\n", - "tensor([[-4.5086]])\n", + "tensor([[-7.3097]])\n", + "tensor([[-6.8386]])\n", "------------------------\n", - "tensor([[-8.0642]])\n", - "tensor([[-9.1612]])\n", + "tensor([[-8.7596]])\n", + "tensor([[-11.2441]])\n", "------------------------\n", - "tensor([[-7.2128]])\n", - "tensor([[-7.]])\n", + "tensor([[-7.3161]])\n", + "tensor([[-7.8539]])\n", "------------------------\n", - "tensor([[-8.5869]])\n", - "tensor([[-8.1643]])\n", + "tensor([[-7.1604]])\n", + "tensor([[-5.3098]])\n", "------------------------\n", - "tensor([[-8.1576]])\n", - "tensor([[-9.0969]])\n", + "tensor([[-7.1792]])\n", + "tensor([[-5.8327]])\n", "------------------------\n", - "tensor([[-8.8454]])\n", - "tensor([[-7.5229]])\n", + "tensor([[-8.3056]])\n", + "tensor([[-9.7905]])\n", "------------------------\n", - "tensor([[-8.8596]])\n", - "tensor([[-9.9914]])\n", + "tensor([[-7.0124]])\n", + "tensor([[-7.6021]])\n", "------------------------\n", - "tensor([[-7.0831]])\n", - "tensor([[-8.4559]])\n", + "tensor([[-7.0471]])\n", + "tensor([[-6.6198]])\n", "------------------------\n", - "tensor([[-7.6323]])\n", - "tensor([[-8.1308]])\n", + "tensor([[-8.0089]])\n", + "tensor([[-11.3010]])\n", "------------------------\n", - "tensor([[-8.1437]])\n", - "tensor([[-10.5229]])\n", + "tensor([[-8.1584]])\n", + "tensor([[-8.0044]])\n", + "------------------------\n", + "tensor([[-8.2493]])\n", + "tensor([[-8.8539]])\n", + "------------------------\n", + "tensor([[-7.0748]])\n", + "tensor([[-6.9586]])\n", + "------------------------\n", + "tensor([[-8.2447]])\n", + "tensor([[-8.5376]])\n", + "------------------------\n", + "tensor([[-8.5153]])\n", + "tensor([[-11.3979]])\n", + "------------------------\n", + "tensor([[-8.2438]])\n", + "tensor([[-11.2218]])\n", + "------------------------\n", + "Epoch : 34 \t train loss: 2.2770232530980334 train MSE: tensor(2.0382, grad_fn=) test MSE: 2.2148172757588327\n", + "Corr: 0.6948222828465335\n", + "tensor(0.2278, grad_fn=)\n", + "tensor(0.2276, grad_fn=)\n", + "tensor(0.2276, grad_fn=)\n", + "tensor(0.2275, grad_fn=)\n", + "tensor(0.2276, grad_fn=)\n", + "tensor(0.2276, grad_fn=)\n", + "tensor(0.2277, grad_fn=)\n", + "tensor(0.2279, grad_fn=)\n", + "tensor(0.2282, grad_fn=)\n", + "tensor(0.2285, grad_fn=)\n", + "tensor(0.2288, grad_fn=)\n", + "tensor(0.2290, grad_fn=)\n", + "tensor(0.2289, grad_fn=)\n", + "tensor(0.2289, grad_fn=)\n", + "tensor(0.2287, grad_fn=)\n", + "tensor(0.2285, grad_fn=)\n", + "tensor(0.2282, grad_fn=)\n", + "tensor(0.2280, grad_fn=)\n", + "tensor(0.2278, grad_fn=)\n", + "tensor(0.2276, grad_fn=)\n", + "tensor([[-7.0613]])\n", + "tensor([[-6.4202]])\n", + "------------------------\n", + "tensor([[-7.9805]])\n", + "tensor([[-7.1427]])\n", + "------------------------\n", + "tensor([[-8.4824]])\n", + "tensor([[-8.0506]])\n", + "------------------------\n", + "tensor([[-8.3047]])\n", + "tensor([[-7.0362]])\n", + "------------------------\n", + "tensor([[-8.2981]])\n", + "tensor([[-9.2733]])\n", + "------------------------\n", + "tensor([[-7.2623]])\n", + "tensor([[-8.1643]])\n", "------------------------\n", - "tensor([[-7.8017]])\n", - "tensor([[-4.3979]])\n", + "tensor([[-7.0833]])\n", + "tensor([[-7.9208]])\n", "------------------------\n", - "tensor([[-8.5245]])\n", - "tensor([[-8.]])\n", + "tensor([[-7.2748]])\n", + "tensor([[-6.8386]])\n", "------------------------\n", - "tensor([[-9.3751]])\n", - "tensor([[-6.5229]])\n", + "tensor([[-8.7193]])\n", + "tensor([[-11.2441]])\n", "------------------------\n", - "tensor([[-8.8673]])\n", - "tensor([[-9.3010]])\n", + "tensor([[-7.3240]])\n", + "tensor([[-7.8539]])\n", + "------------------------\n", + "tensor([[-7.1754]])\n", + "tensor([[-5.3098]])\n", + "------------------------\n", + "tensor([[-7.1945]])\n", + "tensor([[-5.8327]])\n", + "------------------------\n", + "tensor([[-8.2700]])\n", + "tensor([[-9.7905]])\n", + "------------------------\n", + "tensor([[-7.0178]])\n", + "tensor([[-7.6021]])\n", + "------------------------\n", + "tensor([[-7.0577]])\n", + "tensor([[-6.6198]])\n", + "------------------------\n", + "tensor([[-7.8878]])\n", + "tensor([[-11.3010]])\n", + "------------------------\n", + "tensor([[-8.0820]])\n", + "tensor([[-8.0044]])\n", + "------------------------\n", + "tensor([[-8.2565]])\n", + "tensor([[-8.8539]])\n", + "------------------------\n", + "tensor([[-7.0829]])\n", + "tensor([[-6.9586]])\n", + "------------------------\n", + "tensor([[-8.1376]])\n", + "tensor([[-8.5376]])\n", + "------------------------\n", + "tensor([[-8.4215]])\n", + "tensor([[-11.3979]])\n", + "------------------------\n", + "tensor([[-8.2461]])\n", + "tensor([[-11.2218]])\n", + "------------------------\n", + "Epoch : 35 \t train loss: 2.3079343745911043 train MSE: tensor(2.0694, grad_fn=) test MSE: 2.2864960075186738\n", + "Corr: 0.6880423131838064\n", + "tensor(0.2274, grad_fn=)\n", + "tensor(0.2272, grad_fn=)\n", + "tensor(0.2271, grad_fn=)\n", + "tensor(0.2270, grad_fn=)\n", + "tensor(0.2270, grad_fn=)\n", + "tensor(0.2270, grad_fn=)\n", + "tensor(0.2270, grad_fn=)\n", + "tensor(0.2271, grad_fn=)\n", + "tensor(0.2273, grad_fn=)\n", + "tensor(0.2275, grad_fn=)\n", + "tensor(0.2276, grad_fn=)\n", + "tensor(0.2276, grad_fn=)\n", + "tensor(0.2277, grad_fn=)\n", + "tensor(0.2277, grad_fn=)\n", + "tensor(0.2275, grad_fn=)\n", + "tensor(0.2274, grad_fn=)\n", + "tensor(0.2272, grad_fn=)\n", + "tensor(0.2270, grad_fn=)\n", + "tensor(0.2269, grad_fn=)\n", + "tensor(0.2268, grad_fn=)\n", + "tensor([[-7.2811]])\n", + "tensor([[-6.4202]])\n", + "------------------------\n", + "tensor([[-8.1456]])\n", + "tensor([[-7.1427]])\n", + "------------------------\n", + "tensor([[-8.7678]])\n", + "tensor([[-8.0506]])\n", + "------------------------\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor([[-8.6581]])\n", + "tensor([[-7.0362]])\n", "------------------------\n", - "tensor([[-8.6638]])\n", - "tensor([[-9.7696]])\n", + "tensor([[-8.5934]])\n", + "tensor([[-9.2733]])\n", "------------------------\n", - "tensor([[-8.5671]])\n", - "tensor([[-8.3010]])\n", + "tensor([[-7.4886]])\n", + "tensor([[-8.1643]])\n", "------------------------\n", - "tensor([[-8.8388]])\n", - "tensor([[-5.8861]])\n", + "tensor([[-7.3041]])\n", + "tensor([[-7.9208]])\n", "------------------------\n", - "tensor([[-7.7243]])\n", - "tensor([[-7.4559]])\n", + "tensor([[-7.5429]])\n", + "tensor([[-6.8386]])\n", "------------------------\n", - "Epoch : 57 \t train loss: 1.5885559660769988 train MSE: tensor(1.4803, grad_fn=) test MSE: 2.785957961564972\n", - "Corr: 0.32322883400825464\n", - "tensor(0.1044, grad_fn=)\n", - "tensor(0.1045, grad_fn=)\n", - "tensor(0.1045, grad_fn=)\n", - "tensor(0.1045, grad_fn=)\n", - "tensor(0.1046, grad_fn=)\n", - "tensor(0.1047, grad_fn=)\n", - "tensor(0.1047, grad_fn=)\n", - "tensor(0.1048, grad_fn=)\n", - "tensor(0.1049, grad_fn=)\n", - "tensor(0.1051, grad_fn=)\n", - "tensor(0.1052, grad_fn=)\n", - "tensor(0.1052, grad_fn=)\n", - "tensor(0.1053, grad_fn=)\n", - "tensor(0.1054, grad_fn=)\n", - "tensor(0.1054, grad_fn=)\n", - "tensor(0.1054, grad_fn=)\n", - "tensor(0.1055, grad_fn=)\n", - "tensor(0.1056, grad_fn=)\n", - "tensor(0.1056, grad_fn=)\n", - "tensor(0.1058, grad_fn=)\n", - "tensor([[-6.9470]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.9059]])\n", + "tensor([[-9.0564]])\n", "tensor([[-11.2441]])\n", "------------------------\n", - "tensor([[-9.1315]])\n", - "tensor([[-7.5986]])\n", + "tensor([[-7.5497]])\n", + "tensor([[-7.8539]])\n", "------------------------\n", - "tensor([[-5.9312]])\n", - "tensor([[-4.5086]])\n", + "tensor([[-7.4001]])\n", + "tensor([[-5.3098]])\n", "------------------------\n", - "tensor([[-8.0524]])\n", - "tensor([[-9.1612]])\n", + "tensor([[-7.4155]])\n", + "tensor([[-5.8327]])\n", "------------------------\n", - "tensor([[-7.1397]])\n", - "tensor([[-7.]])\n", + "tensor([[-8.5875]])\n", + "tensor([[-9.7905]])\n", "------------------------\n", - "tensor([[-8.5110]])\n", - "tensor([[-8.1643]])\n", + "tensor([[-7.2370]])\n", + "tensor([[-7.6021]])\n", "------------------------\n", - "tensor([[-8.1127]])\n", - "tensor([[-9.0969]])\n", + "tensor([[-7.2806]])\n", + "tensor([[-6.6198]])\n", "------------------------\n", - "tensor([[-8.7639]])\n", - "tensor([[-7.5229]])\n", + "tensor([[-8.3162]])\n", + "tensor([[-11.3010]])\n", "------------------------\n", - "tensor([[-8.7867]])\n", - "tensor([[-9.9914]])\n", + "tensor([[-8.4176]])\n", + "tensor([[-8.0044]])\n", "------------------------\n", - "tensor([[-7.0868]])\n", - "tensor([[-8.4559]])\n", + "tensor([[-8.4272]])\n", + "tensor([[-8.8539]])\n", "------------------------\n", - "tensor([[-7.5259]])\n", - "tensor([[-8.1308]])\n", + "tensor([[-7.3003]])\n", + "tensor([[-6.9586]])\n", "------------------------\n", - "tensor([[-8.1473]])\n", - "tensor([[-10.5229]])\n", + "tensor([[-8.5395]])\n", + "tensor([[-8.5376]])\n", "------------------------\n", - "tensor([[-7.7261]])\n", - "tensor([[-4.3979]])\n", + "tensor([[-8.8274]])\n", + "tensor([[-11.3979]])\n", "------------------------\n", - "tensor([[-8.4323]])\n", - "tensor([[-8.]])\n", + "tensor([[-8.5046]])\n", + "tensor([[-11.2218]])\n", "------------------------\n", - "tensor([[-9.2981]])\n", - "tensor([[-6.5229]])\n", + "Epoch : 36 \t train loss: 2.2805641398710366 train MSE: tensor(2.0429, grad_fn=) test MSE: 1.992130545944292\n", + "Corr: 0.7091114547474036\n", + "tensor(0.2266, grad_fn=)\n", + "tensor(0.2265, grad_fn=)\n", + "tensor(0.2264, grad_fn=)\n", + "tensor(0.2264, grad_fn=)\n", + "tensor(0.2263, grad_fn=)\n", + "tensor(0.2263, grad_fn=)\n", + "tensor(0.2263, grad_fn=)\n", + "tensor(0.2263, grad_fn=)\n", + "tensor(0.2264, grad_fn=)\n", + "tensor(0.2264, grad_fn=)\n", + "tensor(0.2263, grad_fn=)\n", + "tensor(0.2263, grad_fn=)\n", + "tensor(0.2262, grad_fn=)\n", + "tensor(0.2262, grad_fn=)\n", + "tensor(0.2261, grad_fn=)\n", + "tensor(0.2260, grad_fn=)\n", + "tensor(0.2258, grad_fn=)\n", + "tensor(0.2257, grad_fn=)\n", + "tensor(0.2256, grad_fn=)\n", + "tensor(0.2255, grad_fn=)\n", + "tensor([[-7.0598]])\n", + "tensor([[-6.4202]])\n", "------------------------\n", - "tensor([[-8.7493]])\n", - "tensor([[-9.3010]])\n", + "tensor([[-7.8828]])\n", + "tensor([[-7.1427]])\n", "------------------------\n", - "tensor([[-8.5581]])\n", - "tensor([[-9.7696]])\n", + "tensor([[-8.4938]])\n", + "tensor([[-8.0506]])\n", "------------------------\n", - "tensor([[-8.4800]])\n", - "tensor([[-8.3010]])\n", + "tensor([[-8.3799]])\n", + "tensor([[-7.0362]])\n", "------------------------\n", - "tensor([[-8.7752]])\n", - "tensor([[-5.8861]])\n", + "tensor([[-8.3503]])\n", + "tensor([[-9.2733]])\n", "------------------------\n", - "tensor([[-7.6517]])\n", - "tensor([[-7.4559]])\n", + "tensor([[-7.2723]])\n", + "tensor([[-8.1643]])\n", "------------------------\n", - "Epoch : 58 \t train loss: 1.6223459726056693 train MSE: tensor(1.5127, grad_fn=) test MSE: 2.750013292811456\n", - "Corr: 0.3324407597748777\n", - "tensor(0.1060, grad_fn=)\n", - "tensor(0.1061, grad_fn=)\n", - "tensor(0.1063, grad_fn=)\n", - "tensor(0.1064, grad_fn=)\n", - "tensor(0.1066, grad_fn=)\n", - "tensor(0.1066, grad_fn=)\n", - "tensor(0.1067, grad_fn=)\n", - "tensor(0.1067, grad_fn=)\n", - "tensor(0.1067, grad_fn=)\n", - "tensor(0.1067, grad_fn=)\n", - "tensor(0.1067, grad_fn=)\n", - "tensor(0.1067, grad_fn=)\n", - "tensor(0.1068, grad_fn=)\n", - "tensor(0.1069, grad_fn=)\n", - "tensor(0.1069, grad_fn=)\n", - "tensor(0.1070, grad_fn=)\n", - "tensor(0.1071, grad_fn=)\n", - "tensor(0.1073, grad_fn=)\n", - "tensor(0.1074, grad_fn=)\n", - "tensor(0.1075, grad_fn=)\n", - "tensor([[-6.9572]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.9133]])\n", - "tensor([[-11.2441]])\n", + "tensor([[-7.0822]])\n", + "tensor([[-7.9208]])\n", "------------------------\n", - "tensor([[-9.1479]])\n", - "tensor([[-7.5986]])\n", + "tensor([[-7.2848]])\n", + "tensor([[-6.8386]])\n", "------------------------\n", - "tensor([[-5.8930]])\n", - "tensor([[-4.5086]])\n", + "tensor([[-8.7748]])\n", + "tensor([[-11.2441]])\n", "------------------------\n", - "tensor([[-8.0510]])\n", - "tensor([[-9.1612]])\n", + "tensor([[-7.3301]])\n", + "tensor([[-7.8539]])\n", "------------------------\n", - "tensor([[-7.1693]])\n", - "tensor([[-7.]])\n", + "tensor([[-7.1806]])\n", + "tensor([[-5.3098]])\n", "------------------------\n", - "tensor([[-8.5371]])\n", - "tensor([[-8.1643]])\n", + "tensor([[-7.1981]])\n", + "tensor([[-5.8327]])\n", "------------------------\n", - "tensor([[-8.1317]])\n", - "tensor([[-9.0969]])\n", + "tensor([[-8.3277]])\n", + "tensor([[-9.7905]])\n", "------------------------\n", - "tensor([[-8.8036]])\n", - "tensor([[-7.5229]])\n", + "tensor([[-7.0121]])\n", + "tensor([[-7.6021]])\n", "------------------------\n", - "tensor([[-8.8335]])\n", - "tensor([[-9.9914]])\n", + "tensor([[-7.0562]])\n", + "tensor([[-6.6198]])\n", "------------------------\n", - "tensor([[-7.0768]])\n", - "tensor([[-8.4559]])\n", + "tensor([[-7.9897]])\n", + "tensor([[-11.3010]])\n", "------------------------\n", - "tensor([[-7.5550]])\n", - "tensor([[-8.1308]])\n", + "tensor([[-8.1382]])\n", + "tensor([[-8.0044]])\n", "------------------------\n", - "tensor([[-8.1303]])\n", - "tensor([[-10.5229]])\n", + "tensor([[-8.1578]])\n", + "tensor([[-8.8539]])\n", "------------------------\n", - "tensor([[-7.7529]])\n", - "tensor([[-4.3979]])\n", + "tensor([[-7.0768]])\n", + "tensor([[-6.9586]])\n", + "------------------------\n", + "tensor([[-8.2424]])\n", + "tensor([[-8.5376]])\n", + "------------------------\n", + "tensor([[-8.5090]])\n", + "tensor([[-11.3979]])\n", + "------------------------\n", + "tensor([[-8.2730]])\n", + "tensor([[-11.2218]])\n", + "------------------------\n", + "Epoch : 37 \t train loss: 2.21258384106206 train MSE: tensor(1.9761, grad_fn=) test MSE: 2.206052633637393\n", + "Corr: 0.7050837460775241\n", + "tensor(0.2254, grad_fn=)\n", + "tensor(0.2253, grad_fn=)\n", + "tensor(0.2253, grad_fn=)\n", + "tensor(0.2253, grad_fn=)\n", + "tensor(0.2254, grad_fn=)\n", + "tensor(0.2256, grad_fn=)\n", + "tensor(0.2259, grad_fn=)\n", + "tensor(0.2262, grad_fn=)\n", + "tensor(0.2264, grad_fn=)\n", + "tensor(0.2265, grad_fn=)\n", + "tensor(0.2265, grad_fn=)\n", + "tensor(0.2264, grad_fn=)\n", + "tensor(0.2262, grad_fn=)\n", + "tensor(0.2259, grad_fn=)\n", + "tensor(0.2256, grad_fn=)\n", + "tensor(0.2254, grad_fn=)\n", + "tensor(0.2252, grad_fn=)\n", + "tensor(0.2250, grad_fn=)\n", + "tensor(0.2249, grad_fn=)\n", + "tensor(0.2248, grad_fn=)\n", + "tensor([[-6.8219]])\n", + "tensor([[-6.4202]])\n", "------------------------\n", - "tensor([[-8.4351]])\n", - "tensor([[-8.]])\n", + "tensor([[-7.6849]])\n", + "tensor([[-7.1427]])\n", "------------------------\n", - "tensor([[-9.3486]])\n", - "tensor([[-6.5229]])\n", + "tensor([[-8.2434]])\n", + "tensor([[-8.0506]])\n", "------------------------\n", - "tensor([[-8.7613]])\n", - "tensor([[-9.3010]])\n", + "tensor([[-8.1077]])\n", + "tensor([[-7.0362]])\n", "------------------------\n", - "tensor([[-8.5655]])\n", - "tensor([[-9.7696]])\n", + "tensor([[-8.0993]])\n", + "tensor([[-9.2733]])\n", "------------------------\n", - "tensor([[-8.4761]])\n", - "tensor([[-8.3010]])\n", + "tensor([[-7.0358]])\n", + "tensor([[-8.1643]])\n", "------------------------\n", - "tensor([[-8.8041]])\n", - "tensor([[-5.8861]])\n", + "tensor([[-6.8397]])\n", + "tensor([[-7.9208]])\n", "------------------------\n", - "tensor([[-7.6663]])\n", - "tensor([[-7.4559]])\n", + "tensor([[-7.0311]])\n", + "tensor([[-6.8386]])\n", "------------------------\n", - "Epoch : 59 \t train loss: 1.5747786890624205 train MSE: tensor(1.4633, grad_fn=) test MSE: 2.7749592050732597\n", - "Corr: 0.32604543569154093\n", - "tensor(0.1076, grad_fn=)\n", - "tensor(0.1076, grad_fn=)\n", - "tensor(0.1077, grad_fn=)\n", - "tensor(0.1078, grad_fn=)\n", - "tensor(0.1078, grad_fn=)\n", - "tensor(0.1079, grad_fn=)\n", - "tensor(0.1080, grad_fn=)\n", - "tensor(0.1081, grad_fn=)\n", - "tensor(0.1081, grad_fn=)\n", - "tensor(0.1081, grad_fn=)\n", - "tensor(0.1082, grad_fn=)\n", - "tensor(0.1082, grad_fn=)\n", - "tensor(0.1082, grad_fn=)\n", - "tensor(0.1083, grad_fn=)\n", - "tensor(0.1083, grad_fn=)\n", - "tensor(0.1084, grad_fn=)\n", - "tensor(0.1085, grad_fn=)\n", - "tensor(0.1086, grad_fn=)\n", - "tensor(0.1086, grad_fn=)\n", - "tensor(0.1087, grad_fn=)\n", - "tensor([[-6.7951]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.8073]])\n", + "tensor([[-8.4969]])\n", "tensor([[-11.2441]])\n", "------------------------\n", - "tensor([[-9.0425]])\n", - "tensor([[-7.5986]])\n", + "tensor([[-7.0915]])\n", + "tensor([[-7.8539]])\n", + "------------------------\n", + "tensor([[-6.9414]])\n", + "tensor([[-5.3098]])\n", + "------------------------\n", + "tensor([[-6.9608]])\n", + "tensor([[-5.8327]])\n", + "------------------------\n", + "tensor([[-8.0715]])\n", + "tensor([[-9.7905]])\n", + "------------------------\n", + "tensor([[-6.7674]])\n", + "tensor([[-7.6021]])\n", + "------------------------\n", + "tensor([[-6.8108]])\n", + "tensor([[-6.6198]])\n", + "------------------------\n", + "tensor([[-7.7053]])\n", + "tensor([[-11.3010]])\n", + "------------------------\n", + "tensor([[-7.8675]])\n", + "tensor([[-8.0044]])\n", + "------------------------\n", + "tensor([[-7.9619]])\n", + "tensor([[-8.8539]])\n", + "------------------------\n", + "tensor([[-6.8275]])\n", + "tensor([[-6.9586]])\n", + "------------------------\n", + "tensor([[-7.9321]])\n", + "tensor([[-8.5376]])\n", + "------------------------\n", + "tensor([[-8.2053]])\n", + "tensor([[-11.3979]])\n", + "------------------------\n", + "tensor([[-8.0309]])\n", + "tensor([[-11.2218]])\n", + "------------------------\n", + "Epoch : 38 \t train loss: 2.287588833204282 train MSE: tensor(2.0516, grad_fn=) test MSE: 2.534181223928251\n", + "Corr: 0.6976401699171778\n", + "tensor(0.2248, grad_fn=)\n", + "tensor(0.2248, grad_fn=)\n", + "tensor(0.2249, grad_fn=)\n", + "tensor(0.2250, grad_fn=)\n", + "tensor(0.2251, grad_fn=)\n", + "tensor(0.2253, grad_fn=)\n", + "tensor(0.2256, grad_fn=)\n", + "tensor(0.2259, grad_fn=)\n", + "tensor(0.2261, grad_fn=)\n", + "tensor(0.2261, grad_fn=)\n", + "tensor(0.2260, grad_fn=)\n", + "tensor(0.2256, grad_fn=)\n", + "tensor(0.2252, grad_fn=)\n", + "tensor(0.2249, grad_fn=)\n", + "tensor(0.2246, grad_fn=)\n", + "tensor(0.2245, grad_fn=)\n", + "tensor(0.2244, grad_fn=)\n", + "tensor(0.2244, grad_fn=)\n", + "tensor(0.2243, grad_fn=)\n", + "tensor(0.2244, grad_fn=)\n", + "tensor([[-7.1725]])\n", + "tensor([[-6.4202]])\n", + "------------------------\n", + "tensor([[-8.0207]])\n", + "tensor([[-7.1427]])\n", "------------------------\n", - "tensor([[-5.7577]])\n", - "tensor([[-4.5086]])\n", + "tensor([[-8.6236]])\n", + "tensor([[-8.0506]])\n", "------------------------\n", - "tensor([[-8.0299]])\n", - "tensor([[-9.1612]])\n", + "tensor([[-8.5064]])\n", + "tensor([[-7.0362]])\n", "------------------------\n", - "tensor([[-7.0319]])\n", - "tensor([[-7.]])\n", + "tensor([[-8.4593]])\n", + "tensor([[-9.2733]])\n", "------------------------\n", - "tensor([[-8.4067]])\n", + "tensor([[-7.3898]])\n", "tensor([[-8.1643]])\n", "------------------------\n", - "tensor([[-8.0242]])\n", - "tensor([[-9.0969]])\n", + "tensor([[-7.1901]])\n", + "tensor([[-7.9208]])\n", "------------------------\n", - "tensor([[-8.6727]])\n", - "tensor([[-7.5229]])\n", + "tensor([[-7.4161]])\n", + "tensor([[-6.8386]])\n", "------------------------\n", - "tensor([[-8.7027]])\n", - "tensor([[-9.9914]])\n", + "tensor([[-8.8698]])\n", + "tensor([[-11.2441]])\n", "------------------------\n", - "tensor([[-7.0736]])\n", - "tensor([[-8.4559]])\n", + "tensor([[-7.4399]])\n", + "tensor([[-7.8539]])\n", "------------------------\n", - "tensor([[-7.4625]])\n", - "tensor([[-8.1308]])\n", + "tensor([[-7.2977]])\n", + "tensor([[-5.3098]])\n", "------------------------\n", - "tensor([[-8.1183]])\n", - "tensor([[-10.5229]])\n", + "tensor([[-7.3144]])\n", + "tensor([[-5.8327]])\n", "------------------------\n", - "tensor([[-7.6162]])\n", - "tensor([[-4.3979]])\n", + "tensor([[-8.4551]])\n", + "tensor([[-9.7905]])\n", "------------------------\n", - "tensor([[-8.3372]])\n", - "tensor([[-8.]])\n", + "tensor([[-7.1223]])\n", + "tensor([[-7.6021]])\n", "------------------------\n", - "tensor([[-9.2216]])\n", - "tensor([[-6.5229]])\n", + "tensor([[-7.1678]])\n", + "tensor([[-6.6198]])\n", "------------------------\n", - "tensor([[-8.6584]])\n", - "tensor([[-9.3010]])\n", + "tensor([[-8.1783]])\n", + "tensor([[-11.3010]])\n", "------------------------\n", - "tensor([[-8.4522]])\n", - "tensor([[-9.7696]])\n", + "tensor([[-8.2524]])\n", + "tensor([[-8.0044]])\n", "------------------------\n", - "tensor([[-8.3589]])\n", "tensor([[-8.3010]])\n", + "tensor([[-8.8539]])\n", "------------------------\n", - "tensor([[-8.7053]])\n", - "tensor([[-5.8861]])\n", - "------------------------\n", - "tensor([[-7.5385]])\n", - "tensor([[-7.4559]])\n", + "tensor([[-7.1794]])\n", + "tensor([[-6.9586]])\n", "------------------------\n", - "Epoch : 60 \t train loss: 1.4963308275232112 train MSE: tensor(1.3834, grad_fn=) test MSE: 2.7302753968119977\n", - "Corr: 0.3430034422629716\n", - "tensor(0.1089, grad_fn=)\n" + "tensor([[-8.3579]])\n", + "tensor([[-8.5376]])\n", + "------------------------\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "tensor(0.1090, grad_fn=)\n", - "tensor(0.1091, grad_fn=)\n", - "tensor(0.1092, grad_fn=)\n", - "tensor(0.1093, grad_fn=)\n", - "tensor(0.1094, grad_fn=)\n", - "tensor(0.1094, grad_fn=)\n", - "tensor(0.1095, grad_fn=)\n", - "tensor(0.1095, grad_fn=)\n", - "tensor(0.1096, grad_fn=)\n", - "tensor(0.1096, grad_fn=)\n", - "tensor(0.1096, grad_fn=)\n", - "tensor(0.1096, grad_fn=)\n", - "tensor(0.1097, grad_fn=)\n", - "tensor(0.1097, grad_fn=)\n", - "tensor(0.1097, grad_fn=)\n", - "tensor(0.1098, grad_fn=)\n", - "tensor(0.1098, grad_fn=)\n", - "tensor(0.1099, grad_fn=)\n", - "tensor(0.1100, grad_fn=)\n", - "tensor([[-6.6826]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.6890]])\n", - "tensor([[-11.2441]])\n", - "------------------------\n", - "tensor([[-8.9264]])\n", - "tensor([[-7.5986]])\n", + "tensor([[-8.6332]])\n", + "tensor([[-11.3979]])\n", + "------------------------\n", + "tensor([[-8.3834]])\n", + "tensor([[-11.2218]])\n", + "------------------------\n", + "Epoch : 39 \t train loss: 2.3593856649461133 train MSE: tensor(2.1240, grad_fn=) test MSE: 2.096628463403745\n", + "Corr: 0.7078580706340328\n", + "tensor(0.2244, grad_fn=)\n", + "tensor(0.2244, grad_fn=)\n", + "tensor(0.2245, grad_fn=)\n", + "tensor(0.2245, grad_fn=)\n", + "tensor(0.2245, grad_fn=)\n", + "tensor(0.2246, grad_fn=)\n", + "tensor(0.2246, grad_fn=)\n", + "tensor(0.2245, grad_fn=)\n", + "tensor(0.2243, grad_fn=)\n", + "tensor(0.2243, grad_fn=)\n", + "tensor(0.2242, grad_fn=)\n", + "tensor(0.2242, grad_fn=)\n", + "tensor(0.2241, grad_fn=)\n", + "tensor(0.2241, grad_fn=)\n", + "tensor(0.2241, grad_fn=)\n", + "tensor(0.2240, grad_fn=)\n", + "tensor(0.2240, grad_fn=)\n", + "tensor(0.2240, grad_fn=)\n", + "tensor(0.2240, grad_fn=)\n", + "tensor(0.2239, grad_fn=)\n", + "tensor([[-7.3577]])\n", + "tensor([[-6.4202]])\n", + "------------------------\n", + "tensor([[-8.1460]])\n", + "tensor([[-7.1427]])\n", + "------------------------\n", + "tensor([[-8.7120]])\n", + "tensor([[-8.0506]])\n", + "------------------------\n", + "tensor([[-8.6931]])\n", + "tensor([[-7.0362]])\n", + "------------------------\n", + "tensor([[-8.6383]])\n", + "tensor([[-9.2733]])\n", "------------------------\n", - "tensor([[-5.6360]])\n", - "tensor([[-4.5086]])\n", + "tensor([[-7.5784]])\n", + "tensor([[-8.1643]])\n", "------------------------\n", - "tensor([[-8.0125]])\n", - "tensor([[-9.1612]])\n", + "tensor([[-7.3743]])\n", + "tensor([[-7.9208]])\n", "------------------------\n", - "tensor([[-6.8703]])\n", - "tensor([[-7.]])\n", + "tensor([[-7.5796]])\n", + "tensor([[-6.8386]])\n", "------------------------\n", - "tensor([[-8.2929]])\n", - "tensor([[-8.1643]])\n", + "tensor([[-9.0582]])\n", + "tensor([[-11.2441]])\n", "------------------------\n", - "tensor([[-7.8870]])\n", - "tensor([[-9.0969]])\n", + "tensor([[-7.6198]])\n", + "tensor([[-7.8539]])\n", "------------------------\n", - "tensor([[-8.5552]])\n", - "tensor([[-7.5229]])\n", + "tensor([[-7.4877]])\n", + "tensor([[-5.3098]])\n", "------------------------\n", - "tensor([[-8.5913]])\n", - "tensor([[-9.9914]])\n", + "tensor([[-7.5006]])\n", + "tensor([[-5.8327]])\n", "------------------------\n", - "tensor([[-7.0449]])\n", - "tensor([[-8.4559]])\n", + "tensor([[-8.6367]])\n", + "tensor([[-9.7905]])\n", "------------------------\n", - "tensor([[-7.3004]])\n", - "tensor([[-8.1308]])\n", + "tensor([[-7.3075]])\n", + "tensor([[-7.6021]])\n", "------------------------\n", - "tensor([[-8.0840]])\n", - "tensor([[-10.5229]])\n", + "tensor([[-7.3572]])\n", + "tensor([[-6.6198]])\n", "------------------------\n", - "tensor([[-7.4772]])\n", - "tensor([[-4.3979]])\n", + "tensor([[-8.3523]])\n", + "tensor([[-11.3010]])\n", + "------------------------\n", + "tensor([[-8.4143]])\n", + "tensor([[-8.0044]])\n", + "------------------------\n", + "tensor([[-8.4271]])\n", + "tensor([[-8.8539]])\n", + "------------------------\n", + "tensor([[-7.3620]])\n", + "tensor([[-6.9586]])\n", + "------------------------\n", + "tensor([[-8.5499]])\n", + "tensor([[-8.5376]])\n", + "------------------------\n", + "tensor([[-8.8249]])\n", + "tensor([[-11.3979]])\n", + "------------------------\n", + "tensor([[-8.5622]])\n", + "tensor([[-11.2218]])\n", + "------------------------\n", + "Epoch : 40 \t train loss: 2.271057851953444 train MSE: tensor(2.0365, grad_fn=) test MSE: 1.9947603683103807\n", + "Corr: 0.7179147938593157\n", + "tensor(0.2237, grad_fn=)\n", + "tensor(0.2237, grad_fn=)\n", + "tensor(0.2236, grad_fn=)\n", + "tensor(0.2236, grad_fn=)\n", + "tensor(0.2235, grad_fn=)\n", + "tensor(0.2235, grad_fn=)\n", + "tensor(0.2235, grad_fn=)\n", + "tensor(0.2234, grad_fn=)\n", + "tensor(0.2234, grad_fn=)\n", + "tensor(0.2234, grad_fn=)\n", + "tensor(0.2234, grad_fn=)\n", + "tensor(0.2233, grad_fn=)\n", + "tensor(0.2232, grad_fn=)\n", + "tensor(0.2231, grad_fn=)\n", + "tensor(0.2229, grad_fn=)\n", + "tensor(0.2228, grad_fn=)\n", + "tensor(0.2227, grad_fn=)\n", + "tensor(0.2226, grad_fn=)\n", + "tensor(0.2226, grad_fn=)\n", + "tensor(0.2226, grad_fn=)\n", + "tensor([[-7.2254]])\n", + "tensor([[-6.4202]])\n", "------------------------\n", - "tensor([[-8.1708]])\n", - "tensor([[-8.]])\n", + "tensor([[-7.9630]])\n", + "tensor([[-7.1427]])\n", "------------------------\n", - "tensor([[-9.1026]])\n", - "tensor([[-6.5229]])\n", + "tensor([[-8.6614]])\n", + "tensor([[-8.0506]])\n", "------------------------\n", - "tensor([[-8.4901]])\n", - "tensor([[-9.3010]])\n", + "tensor([[-8.6051]])\n", + "tensor([[-7.0362]])\n", "------------------------\n", - "tensor([[-8.2830]])\n", - "tensor([[-9.7696]])\n", + "tensor([[-8.5373]])\n", + "tensor([[-9.2733]])\n", "------------------------\n", - "tensor([[-8.2274]])\n", - "tensor([[-8.3010]])\n", + "tensor([[-7.4521]])\n", + "tensor([[-8.1643]])\n", "------------------------\n", - "tensor([[-8.5682]])\n", - "tensor([[-5.8861]])\n", + "tensor([[-7.2425]])\n", + "tensor([[-7.9208]])\n", "------------------------\n", - "tensor([[-7.4033]])\n", - "tensor([[-7.4559]])\n", + "tensor([[-7.4805]])\n", + "tensor([[-6.8386]])\n", "------------------------\n", - "Epoch : 61 \t train loss: 1.496375007691625 train MSE: tensor(1.3820, grad_fn=) test MSE: 2.7202616344494297\n", - "Corr: 0.3569691397809295\n", - "tensor(0.1101, grad_fn=)\n", - "tensor(0.1102, grad_fn=)\n", - "tensor(0.1103, grad_fn=)\n", - "tensor(0.1104, grad_fn=)\n", - "tensor(0.1106, grad_fn=)\n", - "tensor(0.1107, grad_fn=)\n", - "tensor(0.1108, grad_fn=)\n", - "tensor(0.1108, grad_fn=)\n", - "tensor(0.1109, grad_fn=)\n", - "tensor(0.1109, grad_fn=)\n", - "tensor(0.1109, grad_fn=)\n", - "tensor(0.1110, grad_fn=)\n", - "tensor(0.1110, grad_fn=)\n", - "tensor(0.1110, grad_fn=)\n", - "tensor(0.1110, grad_fn=)\n", - "tensor(0.1111, grad_fn=)\n", - "tensor(0.1112, grad_fn=)\n", - "tensor(0.1112, grad_fn=)\n", - "tensor(0.1113, grad_fn=)\n", - "tensor(0.1114, grad_fn=)\n", - "tensor([[-6.8594]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.9090]])\n", + "tensor([[-8.9520]])\n", "tensor([[-11.2441]])\n", "------------------------\n", - "tensor([[-9.1563]])\n", - "tensor([[-7.5986]])\n", + "tensor([[-7.4887]])\n", + "tensor([[-7.8539]])\n", + "------------------------\n", + "tensor([[-7.3563]])\n", + "tensor([[-5.3098]])\n", + "------------------------\n", + "tensor([[-7.3703]])\n", + "tensor([[-5.8327]])\n", + "------------------------\n", + "tensor([[-8.5406]])\n", + "tensor([[-9.7905]])\n", + "------------------------\n", + "tensor([[-7.1720]])\n", + "tensor([[-7.6021]])\n", + "------------------------\n", + "tensor([[-7.2268]])\n", + "tensor([[-6.6198]])\n", + "------------------------\n", + "tensor([[-8.3281]])\n", + "tensor([[-11.3010]])\n", + "------------------------\n", + "tensor([[-8.3419]])\n", + "tensor([[-8.0044]])\n", + "------------------------\n", + "tensor([[-8.2349]])\n", + "tensor([[-8.8539]])\n", + "------------------------\n", + "tensor([[-7.2246]])\n", + "tensor([[-6.9586]])\n", + "------------------------\n", + "tensor([[-8.4836]])\n", + "tensor([[-8.5376]])\n", + "------------------------\n", + "tensor([[-8.7467]])\n", + "tensor([[-11.3979]])\n", + "------------------------\n", + "tensor([[-8.4430]])\n", + "tensor([[-11.2218]])\n", + "------------------------\n", + "Epoch : 41 \t train loss: 2.2193467944276093 train MSE: tensor(1.9859, grad_fn=) test MSE: 2.013301665820605\n", + "Corr: 0.721670052240262\n", + "tensor(0.2227, grad_fn=)\n", + "tensor(0.2230, grad_fn=)\n", + "tensor(0.2233, grad_fn=)\n", + "tensor(0.2235, grad_fn=)\n", + "tensor(0.2236, grad_fn=)\n", + "tensor(0.2235, grad_fn=)\n", + "tensor(0.2234, grad_fn=)\n", + "tensor(0.2233, grad_fn=)\n", + "tensor(0.2231, grad_fn=)\n", + "tensor(0.2230, grad_fn=)\n", + "tensor(0.2230, grad_fn=)\n", + "tensor(0.2229, grad_fn=)\n", + "tensor(0.2228, grad_fn=)\n", + "tensor(0.2228, grad_fn=)\n", + "tensor(0.2228, grad_fn=)\n", + "tensor(0.2227, grad_fn=)\n", + "tensor(0.2226, grad_fn=)\n", + "tensor(0.2226, grad_fn=)\n", + "tensor(0.2226, grad_fn=)\n", + "tensor(0.2227, grad_fn=)\n", + "tensor([[-7.2532]])\n", + "tensor([[-6.4202]])\n", + "------------------------\n", + "tensor([[-8.0830]])\n", + "tensor([[-7.1427]])\n", "------------------------\n", - "tensor([[-5.8314]])\n", - "tensor([[-4.5086]])\n", + "tensor([[-8.6179]])\n", + "tensor([[-8.0506]])\n", "------------------------\n", - "tensor([[-8.0828]])\n", - "tensor([[-9.1612]])\n", + "tensor([[-8.5558]])\n", + "tensor([[-7.0362]])\n", "------------------------\n", - "tensor([[-7.0450]])\n", - "tensor([[-7.]])\n", + "tensor([[-8.5256]])\n", + "tensor([[-9.2733]])\n", "------------------------\n", - "tensor([[-8.5141]])\n", + "tensor([[-7.4887]])\n", "tensor([[-8.1643]])\n", "------------------------\n", - "tensor([[-8.1029]])\n", - "tensor([[-9.0969]])\n", + "tensor([[-7.2710]])\n", + "tensor([[-7.9208]])\n", "------------------------\n", - "tensor([[-8.7563]])\n", - "tensor([[-7.5229]])\n", + "tensor([[-7.4780]])\n", + "tensor([[-6.8386]])\n", "------------------------\n", - "tensor([[-8.8086]])\n", - "tensor([[-9.9914]])\n", + "tensor([[-8.9294]])\n", + "tensor([[-11.2441]])\n", "------------------------\n", - "tensor([[-7.1139]])\n", - "tensor([[-8.4559]])\n", + "tensor([[-7.5187]])\n", + "tensor([[-7.8539]])\n", "------------------------\n", - "tensor([[-7.5112]])\n", - "tensor([[-8.1308]])\n", + "tensor([[-7.3891]])\n", + "tensor([[-5.3098]])\n", "------------------------\n", - "tensor([[-8.1561]])\n", - "tensor([[-10.5229]])\n", + "tensor([[-7.4061]])\n", + "tensor([[-5.8327]])\n", "------------------------\n", - "tensor([[-7.6780]])\n", - "tensor([[-4.3979]])\n", + "tensor([[-8.5186]])\n", + "tensor([[-9.7905]])\n", "------------------------\n", - "tensor([[-8.4069]])\n", - "tensor([[-8.]])\n", + "tensor([[-7.1999]])\n", + "tensor([[-7.6021]])\n", "------------------------\n", - "tensor([[-9.3250]])\n", - "tensor([[-6.5229]])\n", + "tensor([[-7.2589]])\n", + "tensor([[-6.6198]])\n", "------------------------\n", - "tensor([[-8.7282]])\n", - "tensor([[-9.3010]])\n", + "tensor([[-8.2167]])\n", + "tensor([[-11.3010]])\n", "------------------------\n", - "tensor([[-8.5194]])\n", - "tensor([[-9.7696]])\n", + "tensor([[-8.2845]])\n", + "tensor([[-8.0044]])\n", "------------------------\n", - "tensor([[-8.4399]])\n", - "tensor([[-8.3010]])\n", + "tensor([[-8.3500]])\n", + "tensor([[-8.8539]])\n", "------------------------\n", - "tensor([[-8.7950]])\n", - "tensor([[-5.8861]])\n", + "tensor([[-7.2531]])\n", + "tensor([[-6.9586]])\n", "------------------------\n", - "tensor([[-7.6127]])\n", - "tensor([[-7.4559]])\n", + "tensor([[-8.3547]])\n", + "tensor([[-8.5376]])\n", "------------------------\n", - "Epoch : 62 \t train loss: 1.5082784749166418 train MSE: tensor(1.3926, grad_fn=) test MSE: 2.749821045646621\n", - "Corr: 0.3371767240681808\n", - "tensor(0.1116, grad_fn=)\n", - "tensor(0.1116, grad_fn=)\n", - "tensor(0.1117, grad_fn=)\n", - "tensor(0.1118, grad_fn=)\n", - "tensor(0.1118, grad_fn=)\n", - "tensor(0.1119, grad_fn=)\n", - "tensor(0.1120, grad_fn=)\n", - "tensor(0.1121, grad_fn=)\n", - "tensor(0.1122, grad_fn=)\n", - "tensor(0.1122, grad_fn=)\n", - "tensor(0.1123, grad_fn=)\n", - "tensor(0.1123, grad_fn=)\n", - "tensor(0.1124, grad_fn=)\n", - "tensor(0.1124, grad_fn=)\n", - "tensor(0.1124, grad_fn=)\n", - "tensor(0.1125, grad_fn=)\n", - "tensor(0.1125, grad_fn=)\n", - "tensor(0.1126, grad_fn=)\n", - "tensor(0.1127, grad_fn=)\n", - "tensor(0.1128, grad_fn=)\n", - "tensor([[-6.7504]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.7673]])\n", - "tensor([[-11.2441]])\n", + "tensor([[-8.6596]])\n", + "tensor([[-11.3979]])\n", "------------------------\n", - "tensor([[-9.0216]])\n", - "tensor([[-7.5986]])\n", + "tensor([[-8.4750]])\n", + "tensor([[-11.2218]])\n", "------------------------\n", - "tensor([[-5.6835]])\n", - "tensor([[-4.5086]])\n", + "Epoch : 42 \t train loss: 2.2687128291410557 train MSE: tensor(2.0355, grad_fn=) test MSE: 2.0691905372183435\n", + "Corr: 0.7141239577027345\n", + "tensor(0.2227, grad_fn=)\n", + "tensor(0.2228, grad_fn=)\n", + "tensor(0.2228, grad_fn=)\n", + "tensor(0.2229, grad_fn=)\n", + "tensor(0.2230, grad_fn=)\n", + "tensor(0.2231, grad_fn=)\n", + "tensor(0.2232, grad_fn=)\n", + "tensor(0.2234, grad_fn=)\n", + "tensor(0.2234, grad_fn=)\n", + "tensor(0.2233, grad_fn=)\n", + "tensor(0.2232, grad_fn=)\n", + "tensor(0.2232, grad_fn=)\n", + "tensor(0.2231, grad_fn=)\n", + "tensor(0.2230, grad_fn=)\n", + "tensor(0.2228, grad_fn=)\n", + "tensor(0.2228, grad_fn=)\n", + "tensor(0.2227, grad_fn=)\n", + "tensor(0.2226, grad_fn=)\n", + "tensor(0.2226, grad_fn=)\n", + "tensor(0.2226, grad_fn=)\n", + "tensor([[-7.2386]])\n", + "tensor([[-6.4202]])\n", + "------------------------\n", + "tensor([[-8.1313]])\n", + "tensor([[-7.1427]])\n", + "------------------------\n", + "tensor([[-8.6989]])\n", + "tensor([[-8.0506]])\n", + "------------------------\n", + "tensor([[-8.6914]])\n", + "tensor([[-7.0362]])\n", + "------------------------\n", + "tensor([[-8.6268]])\n", + "tensor([[-9.2733]])\n", + "------------------------\n", + "tensor([[-7.4775]])\n", + "tensor([[-8.1643]])\n", "------------------------\n", - "tensor([[-8.0563]])\n", - "tensor([[-9.1612]])\n", + "tensor([[-7.2591]])\n", + "tensor([[-7.9208]])\n", "------------------------\n", - "tensor([[-6.8894]])\n", - "tensor([[-7.]])\n", + "tensor([[-7.5163]])\n", + "tensor([[-6.8386]])\n", "------------------------\n", - "tensor([[-8.3953]])\n", - "tensor([[-8.1643]])\n", + "tensor([[-9.0772]])\n", + "tensor([[-11.2441]])\n", "------------------------\n", - "tensor([[-7.9565]])\n", - "tensor([[-9.0969]])\n", + "tensor([[-7.5234]])\n", + "tensor([[-7.8539]])\n", "------------------------\n", - "tensor([[-8.6481]])\n", - "tensor([[-7.5229]])\n", + "tensor([[-7.3745]])\n", + "tensor([[-5.3098]])\n", "------------------------\n", - "tensor([[-8.6908]])\n", - "tensor([[-9.9914]])\n", + "tensor([[-7.3924]])\n", + "tensor([[-5.8327]])\n", "------------------------\n", - "tensor([[-7.1008]])\n", - "tensor([[-8.4559]])\n", + "tensor([[-8.6275]])\n", + "tensor([[-9.7905]])\n", "------------------------\n", - "tensor([[-7.3401]])\n", - "tensor([[-8.1308]])\n", + "tensor([[-7.1847]])\n", + "tensor([[-7.6021]])\n", "------------------------\n", - "tensor([[-8.1316]])\n", - "tensor([[-10.5229]])\n", + "tensor([[-7.2368]])\n", + "tensor([[-6.6198]])\n", "------------------------\n", - "tensor([[-7.4999]])\n", - "tensor([[-4.3979]])\n", + "tensor([[-8.3257]])\n", + "tensor([[-11.3010]])\n", "------------------------\n", - "tensor([[-8.2381]])\n", - "tensor([[-8.]])\n", + "tensor([[-8.4059]])\n", + "tensor([[-8.0044]])\n", "------------------------\n", - "tensor([[-9.1953]])\n", - "tensor([[-6.5229]])\n", + "tensor([[-8.4104]])\n", + "tensor([[-8.8539]])\n", "------------------------\n", - "tensor([[-8.5434]])\n", - "tensor([[-9.3010]])\n", + "tensor([[-7.2372]])\n", + "tensor([[-6.9586]])\n", "------------------------\n", - "tensor([[-8.3386]])\n", - "tensor([[-9.7696]])\n", + "tensor([[-8.4820]])\n", + "tensor([[-8.5376]])\n", "------------------------\n", - "tensor([[-8.2910]])\n", - "tensor([[-8.3010]])\n", + "tensor([[-8.8107]])\n", + "tensor([[-11.3979]])\n", "------------------------\n", - "tensor([[-8.6345]])\n", - "tensor([[-5.8861]])\n", + "tensor([[-8.5674]])\n", + "tensor([[-11.2218]])\n", "------------------------\n", - "tensor([[-7.4768]])\n", - "tensor([[-7.4559]])\n", + "Epoch : 43 \t train loss: 2.1340732792623682 train MSE: tensor(1.9009, grad_fn=) test MSE: 1.9560645672450352\n", + "Corr: 0.7175093602915522\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor(0.2226, grad_fn=)\n", + "tensor(0.2228, grad_fn=)\n", + "tensor(0.2230, grad_fn=)\n", + "tensor(0.2231, grad_fn=)\n", + "tensor(0.2233, grad_fn=)\n", + "tensor(0.2232, grad_fn=)\n", + "tensor(0.2231, grad_fn=)\n", + "tensor(0.2231, grad_fn=)\n", + "tensor(0.2230, grad_fn=)\n", + "tensor(0.2228, grad_fn=)\n", + "tensor(0.2226, grad_fn=)\n", + "tensor(0.2224, grad_fn=)\n", + "tensor(0.2223, grad_fn=)\n", + "tensor(0.2222, grad_fn=)\n", + "tensor(0.2222, grad_fn=)\n", + "tensor(0.2223, grad_fn=)\n", + "tensor(0.2223, grad_fn=)\n", + "tensor(0.2224, grad_fn=)\n", + "tensor(0.2224, grad_fn=)\n", + "tensor(0.2224, grad_fn=)\n", + "tensor([[-7.2390]])\n", + "tensor([[-6.4202]])\n", + "------------------------\n", + "tensor([[-8.1558]])\n", + "tensor([[-7.1427]])\n", + "------------------------\n", + "tensor([[-8.6976]])\n", + "tensor([[-8.0506]])\n", + "------------------------\n", + "tensor([[-8.6704]])\n", + "tensor([[-7.0362]])\n", + "------------------------\n", + "tensor([[-8.6141]])\n", + "tensor([[-9.2733]])\n", + "------------------------\n", + "tensor([[-7.4808]])\n", + "tensor([[-8.1643]])\n", "------------------------\n", - "Epoch : 63 \t train loss: 1.57910637909981 train MSE: tensor(1.4620, grad_fn=) test MSE: 2.703171952781434\n", - "Corr: 0.3577999489009626\n", - "tensor(0.1128, grad_fn=)\n", - "tensor(0.1129, grad_fn=)\n", - "tensor(0.1129, grad_fn=)\n", - "tensor(0.1130, grad_fn=)\n", - "tensor(0.1131, grad_fn=)\n", - "tensor(0.1132, grad_fn=)\n", - "tensor(0.1133, grad_fn=)\n", - "tensor(0.1134, grad_fn=)\n", - "tensor(0.1135, grad_fn=)\n", - "tensor(0.1136, grad_fn=)\n", - "tensor(0.1137, grad_fn=)\n", - "tensor(0.1137, grad_fn=)\n", - "tensor(0.1138, grad_fn=)\n", - "tensor(0.1139, grad_fn=)\n", - "tensor(0.1140, grad_fn=)\n", - "tensor(0.1141, grad_fn=)\n", - "tensor(0.1142, grad_fn=)\n", - "tensor(0.1142, grad_fn=)\n", - "tensor(0.1143, grad_fn=)\n", - "tensor(0.1143, grad_fn=)\n", - "tensor([[-6.8775]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.8970]])\n", + "tensor([[-7.2586]])\n", + "tensor([[-7.9208]])\n", + "------------------------\n", + "tensor([[-7.5017]])\n", + "tensor([[-6.8386]])\n", + "------------------------\n", + "tensor([[-9.0458]])\n", "tensor([[-11.2441]])\n", "------------------------\n", - "tensor([[-9.1793]])\n", - "tensor([[-7.5986]])\n", + "tensor([[-7.5258]])\n", + "tensor([[-7.8539]])\n", "------------------------\n", - "tensor([[-5.8074]])\n", - "tensor([[-4.5086]])\n", + "tensor([[-7.3771]])\n", + "tensor([[-5.3098]])\n", "------------------------\n", - "tensor([[-8.1218]])\n", - "tensor([[-9.1612]])\n", + "tensor([[-7.3952]])\n", + "tensor([[-5.8327]])\n", "------------------------\n", - "tensor([[-6.9106]])\n", - "tensor([[-7.]])\n", + "tensor([[-8.6155]])\n", + "tensor([[-9.7905]])\n", "------------------------\n", - "tensor([[-8.5639]])\n", - "tensor([[-8.1643]])\n", + "tensor([[-7.1843]])\n", + "tensor([[-7.6021]])\n", "------------------------\n", - "tensor([[-8.1091]])\n", - "tensor([[-9.0969]])\n", + "tensor([[-7.2359]])\n", + "tensor([[-6.6198]])\n", "------------------------\n", - "tensor([[-8.7766]])\n", - "tensor([[-7.5229]])\n", + "tensor([[-8.3052]])\n", + "tensor([[-11.3010]])\n", "------------------------\n", - "tensor([[-8.8674]])\n", - "tensor([[-9.9914]])\n", + "tensor([[-8.3815]])\n", + "tensor([[-8.0044]])\n", "------------------------\n", - "tensor([[-7.1645]])\n", - "tensor([[-8.4559]])\n", + "tensor([[-8.4313]])\n", + "tensor([[-8.8539]])\n", "------------------------\n", - "tensor([[-7.5218]])\n", - "tensor([[-8.1308]])\n", + "tensor([[-7.2387]])\n", + "tensor([[-6.9586]])\n", "------------------------\n", - "tensor([[-8.1916]])\n", - "tensor([[-10.5229]])\n", + "tensor([[-8.4662]])\n", + "tensor([[-8.5376]])\n", "------------------------\n", - "tensor([[-7.6162]])\n", - "tensor([[-4.3979]])\n", + "tensor([[-8.7749]])\n", + "tensor([[-11.3979]])\n", "------------------------\n", - "tensor([[-8.4161]])\n", - "tensor([[-8.]])\n", + "tensor([[-8.5577]])\n", + "tensor([[-11.2218]])\n", "------------------------\n", - "tensor([[-9.3580]])\n", - "tensor([[-6.5229]])\n", + "Epoch : 44 \t train loss: 2.200891987171049 train MSE: tensor(1.9680, grad_fn=) test MSE: 1.9778929822866547\n", + "Corr: 0.7133789566587042\n", + "tensor(0.2222, grad_fn=)\n", + "tensor(0.2220, grad_fn=)\n", + "tensor(0.2218, grad_fn=)\n", + "tensor(0.2217, grad_fn=)\n", + "tensor(0.2216, grad_fn=)\n", + "tensor(0.2216, grad_fn=)\n", + "tensor(0.2216, grad_fn=)\n", + "tensor(0.2216, grad_fn=)\n", + "tensor(0.2216, grad_fn=)\n", + "tensor(0.2217, grad_fn=)\n", + "tensor(0.2218, grad_fn=)\n", + "tensor(0.2219, grad_fn=)\n", + "tensor(0.2221, grad_fn=)\n", + "tensor(0.2222, grad_fn=)\n", + "tensor(0.2223, grad_fn=)\n", + "tensor(0.2222, grad_fn=)\n", + "tensor(0.2221, grad_fn=)\n", + "tensor(0.2220, grad_fn=)\n", + "tensor(0.2218, grad_fn=)\n", + "tensor(0.2216, grad_fn=)\n", + "tensor([[-7.1502]])\n", + "tensor([[-6.4202]])\n", "------------------------\n", - "tensor([[-8.7351]])\n", - "tensor([[-9.3010]])\n", + "tensor([[-7.9471]])\n", + "tensor([[-7.1427]])\n", "------------------------\n", - "tensor([[-8.5297]])\n", - "tensor([[-9.7696]])\n", + "tensor([[-8.5955]])\n", + "tensor([[-8.0506]])\n", "------------------------\n", - "tensor([[-8.4149]])\n", - "tensor([[-8.3010]])\n", + "tensor([[-8.5447]])\n", + "tensor([[-7.0362]])\n", "------------------------\n", - "tensor([[-8.8305]])\n", - "tensor([[-5.8861]])\n", + "tensor([[-8.5058]])\n", + "tensor([[-9.2733]])\n", "------------------------\n", - "tensor([[-7.6205]])\n", - "tensor([[-7.4559]])\n", + "tensor([[-7.3962]])\n", + "tensor([[-8.1643]])\n", "------------------------\n", - "Epoch : 64 \t train loss: 1.4959377114574437 train MSE: tensor(1.3773, grad_fn=) test MSE: 2.725498201902069\n", - "Corr: 0.3484267777216248\n", - "tensor(0.1144, grad_fn=)\n", - "tensor(0.1145, grad_fn=)\n", - "tensor(0.1146, grad_fn=)\n", - "tensor(0.1146, grad_fn=)\n", - "tensor(0.1147, grad_fn=)\n", - "tensor(0.1148, grad_fn=)\n", - "tensor(0.1148, grad_fn=)\n", - "tensor(0.1149, grad_fn=)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "tensor(0.1150, grad_fn=)\n", - "tensor(0.1150, grad_fn=)\n", - "tensor(0.1151, grad_fn=)\n", - "tensor(0.1152, grad_fn=)\n", - "tensor(0.1153, grad_fn=)\n", - "tensor(0.1153, grad_fn=)\n", - "tensor(0.1154, grad_fn=)\n", - "tensor(0.1154, grad_fn=)\n", - "tensor(0.1155, grad_fn=)\n", - "tensor(0.1155, grad_fn=)\n", - "tensor(0.1155, grad_fn=)\n", - "tensor(0.1156, grad_fn=)\n", - "tensor([[-6.6884]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.7200]])\n", + "tensor([[-7.1700]])\n", + "tensor([[-7.9208]])\n", + "------------------------\n", + "tensor([[-7.3826]])\n", + "tensor([[-6.8386]])\n", + "------------------------\n", + "tensor([[-8.8941]])\n", "tensor([[-11.2441]])\n", "------------------------\n", - "tensor([[-8.9996]])\n", - "tensor([[-7.5986]])\n", + "tensor([[-7.4415]])\n", + "tensor([[-7.8539]])\n", "------------------------\n", - "tensor([[-5.6142]])\n", - "tensor([[-4.5086]])\n", + "tensor([[-7.2928]])\n", + "tensor([[-5.3098]])\n", "------------------------\n", - "tensor([[-8.0159]])\n", - "tensor([[-9.1612]])\n", + "tensor([[-7.3099]])\n", + "tensor([[-5.8327]])\n", "------------------------\n", - "tensor([[-6.6922]])\n", - "tensor([[-7.]])\n", + "tensor([[-8.4893]])\n", + "tensor([[-9.7905]])\n", "------------------------\n", - "tensor([[-8.3869]])\n", - "tensor([[-8.1643]])\n", + "tensor([[-7.0955]])\n", + "tensor([[-7.6021]])\n", "------------------------\n", - "tensor([[-7.9219]])\n", - "tensor([[-9.0969]])\n", + "tensor([[-7.1507]])\n", + "tensor([[-6.6198]])\n", "------------------------\n", - "tensor([[-8.5954]])\n", - "tensor([[-7.5229]])\n", + "tensor([[-8.1790]])\n", + "tensor([[-11.3010]])\n", "------------------------\n", - "tensor([[-8.7064]])\n", - "tensor([[-9.9914]])\n", + "tensor([[-8.2695]])\n", + "tensor([[-8.0044]])\n", "------------------------\n", - "tensor([[-7.0785]])\n", - "tensor([[-8.4559]])\n", + "tensor([[-8.2099]])\n", + "tensor([[-8.8539]])\n", "------------------------\n", - "tensor([[-7.3121]])\n", - "tensor([[-8.1308]])\n", + "tensor([[-7.1513]])\n", + "tensor([[-6.9586]])\n", "------------------------\n", - "tensor([[-8.0788]])\n", - "tensor([[-10.5229]])\n", + "tensor([[-8.3679]])\n", + "tensor([[-8.5376]])\n", "------------------------\n", - "tensor([[-7.4275]])\n", - "tensor([[-4.3979]])\n", + "tensor([[-8.6147]])\n", + "tensor([[-11.3979]])\n", + "------------------------\n", + "tensor([[-8.4417]])\n", + "tensor([[-11.2218]])\n", + "------------------------\n", + "Epoch : 45 \t train loss: 2.2881120918622986 train MSE: tensor(2.0561, grad_fn=) test MSE: 2.072899988937107\n", + "Corr: 0.7133467622602973\n", + "tensor(0.2211, grad_fn=)\n", + "tensor(0.2208, grad_fn=)\n", + "tensor(0.2207, grad_fn=)\n", + "tensor(0.2206, grad_fn=)\n", + "tensor(0.2205, grad_fn=)\n", + "tensor(0.2205, grad_fn=)\n", + "tensor(0.2205, grad_fn=)\n", + "tensor(0.2206, grad_fn=)\n", + "tensor(0.2207, grad_fn=)\n", + "tensor(0.2209, grad_fn=)\n", + "tensor(0.2209, grad_fn=)\n", + "tensor(0.2209, grad_fn=)\n", + "tensor(0.2209, grad_fn=)\n", + "tensor(0.2209, grad_fn=)\n", + "tensor(0.2208, grad_fn=)\n", + "tensor(0.2207, grad_fn=)\n", + "tensor(0.2207, grad_fn=)\n", + "tensor(0.2206, grad_fn=)\n", + "tensor(0.2206, grad_fn=)\n", + "tensor(0.2205, grad_fn=)\n", + "tensor([[-7.3856]])\n", + "tensor([[-6.4202]])\n", "------------------------\n", - "tensor([[-8.2088]])\n", - "tensor([[-8.]])\n", + "tensor([[-8.1369]])\n", + "tensor([[-7.1427]])\n", "------------------------\n", - "tensor([[-9.1906]])\n", - "tensor([[-6.5229]])\n", + "tensor([[-8.7971]])\n", + "tensor([[-8.0506]])\n", "------------------------\n", - "tensor([[-8.5122]])\n", - "tensor([[-9.3010]])\n", + "tensor([[-8.7512]])\n", + "tensor([[-7.0362]])\n", "------------------------\n", - "tensor([[-8.3133]])\n", - "tensor([[-9.7696]])\n", + "tensor([[-8.6984]])\n", + "tensor([[-9.2733]])\n", "------------------------\n", - "tensor([[-8.2242]])\n", - "tensor([[-8.3010]])\n", + "tensor([[-7.6383]])\n", + "tensor([[-8.1643]])\n", "------------------------\n", - "tensor([[-8.6256]])\n", - "tensor([[-5.8861]])\n", + "tensor([[-7.4077]])\n", + "tensor([[-7.9208]])\n", "------------------------\n", - "tensor([[-7.4302]])\n", - "tensor([[-7.4559]])\n", + "tensor([[-7.6103]])\n", + "tensor([[-6.8386]])\n", "------------------------\n", - "Epoch : 65 \t train loss: 1.4996381700525083 train MSE: tensor(1.3795, grad_fn=) test MSE: 2.7216092717135316\n", - "Corr: 0.35944233249325097\n", - "tensor(0.1156, grad_fn=)\n", - "tensor(0.1156, grad_fn=)\n", - "tensor(0.1156, grad_fn=)\n", - "tensor(0.1157, grad_fn=)\n", - "tensor(0.1157, grad_fn=)\n", - "tensor(0.1158, grad_fn=)\n", - "tensor(0.1159, grad_fn=)\n", - "tensor(0.1161, grad_fn=)\n", - "tensor(0.1163, grad_fn=)\n", - "tensor(0.1163, grad_fn=)\n", - "tensor(0.1164, grad_fn=)\n", - "tensor(0.1164, grad_fn=)\n", - "tensor(0.1165, grad_fn=)\n", - "tensor(0.1165, grad_fn=)\n", - "tensor(0.1166, grad_fn=)\n", - "tensor(0.1166, grad_fn=)\n", - "tensor(0.1167, grad_fn=)\n", - "tensor(0.1167, grad_fn=)\n", - "tensor(0.1167, grad_fn=)\n", - "tensor(0.1168, grad_fn=)\n", - "tensor([[-6.7518]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.8128]])\n", + "tensor([[-9.0826]])\n", "tensor([[-11.2441]])\n", "------------------------\n", - "tensor([[-9.0845]])\n", - "tensor([[-7.5986]])\n", - "------------------------\n", - "tensor([[-5.6683]])\n", - "tensor([[-4.5086]])\n", + "tensor([[-7.6736]])\n", + "tensor([[-7.8539]])\n", "------------------------\n", - "tensor([[-8.0574]])\n", - "tensor([[-9.1612]])\n", + "tensor([[-7.5362]])\n", + "tensor([[-5.3098]])\n", "------------------------\n", - "tensor([[-6.7871]])\n", - "tensor([[-7.]])\n", + "tensor([[-7.5499]])\n", + "tensor([[-5.8327]])\n", "------------------------\n", - "tensor([[-8.4508]])\n", - "tensor([[-8.1643]])\n", + "tensor([[-8.6909]])\n", + "tensor([[-9.7905]])\n", "------------------------\n", - "tensor([[-7.9803]])\n", - "tensor([[-9.0969]])\n", + "tensor([[-7.3369]])\n", + "tensor([[-7.6021]])\n", "------------------------\n", - "tensor([[-8.6796]])\n", - "tensor([[-7.5229]])\n", + "tensor([[-7.3974]])\n", + "tensor([[-6.6198]])\n", "------------------------\n", - "tensor([[-8.7668]])\n", - "tensor([[-9.9914]])\n", + "tensor([[-8.4113]])\n", + "tensor([[-11.3010]])\n", + "------------------------\n", + "tensor([[-8.4584]])\n", + "tensor([[-8.0044]])\n", + "------------------------\n", + "tensor([[-8.3941]])\n", + "tensor([[-8.8539]])\n", + "------------------------\n", + "tensor([[-7.3939]])\n", + "tensor([[-6.9586]])\n", + "------------------------\n", + "tensor([[-8.6101]])\n", + "tensor([[-8.5376]])\n", + "------------------------\n", + "tensor([[-8.8157]])\n", + "tensor([[-11.3979]])\n", + "------------------------\n", + "tensor([[-8.6271]])\n", + "tensor([[-11.2218]])\n", + "------------------------\n", + "Epoch : 46 \t train loss: 2.2401059686748033 train MSE: tensor(2.0093, grad_fn=) test MSE: 1.9882870216388253\n", + "Corr: 0.7142524907839832\n", + "tensor(0.2203, grad_fn=)\n", + "tensor(0.2202, grad_fn=)\n", + "tensor(0.2202, grad_fn=)\n", + "tensor(0.2202, grad_fn=)\n", + "tensor(0.2202, grad_fn=)\n", + "tensor(0.2202, grad_fn=)\n", + "tensor(0.2202, grad_fn=)\n", + "tensor(0.2202, grad_fn=)\n", + "tensor(0.2203, grad_fn=)\n", + "tensor(0.2204, grad_fn=)\n", + "tensor(0.2204, grad_fn=)\n", + "tensor(0.2204, grad_fn=)\n", + "tensor(0.2203, grad_fn=)\n", + "tensor(0.2203, grad_fn=)\n", + "tensor(0.2202, grad_fn=)\n", + "tensor(0.2203, grad_fn=)\n", + "tensor(0.2204, grad_fn=)\n", + "tensor(0.2205, grad_fn=)\n", + "tensor(0.2205, grad_fn=)\n", + "tensor(0.2204, grad_fn=)\n", + "tensor([[-7.5765]])\n", + "tensor([[-6.4202]])\n", + "------------------------\n", + "tensor([[-8.3804]])\n", + "tensor([[-7.1427]])\n", + "------------------------\n", + "tensor([[-9.0144]])\n", + "tensor([[-8.0506]])\n", + "------------------------\n", + "tensor([[-8.9423]])\n", + "tensor([[-7.0362]])\n", + "------------------------\n", + "tensor([[-8.8887]])\n", + "tensor([[-9.2733]])\n", + "------------------------\n", + "tensor([[-7.8343]])\n", + "tensor([[-8.1643]])\n", "------------------------\n", - "tensor([[-7.1146]])\n", - "tensor([[-8.4559]])\n", + "tensor([[-7.5985]])\n", + "tensor([[-7.9208]])\n", "------------------------\n", - "tensor([[-7.4166]])\n", - "tensor([[-8.1308]])\n", + "tensor([[-7.8122]])\n", + "tensor([[-6.8386]])\n", "------------------------\n", - "tensor([[-8.1272]])\n", - "tensor([[-10.5229]])\n", + "tensor([[-9.2890]])\n", + "tensor([[-11.2441]])\n", "------------------------\n", - "tensor([[-7.5160]])\n", - "tensor([[-4.3979]])\n", + "tensor([[-7.8644]])\n", + "tensor([[-7.8539]])\n", "------------------------\n", - "tensor([[-8.2965]])\n", - "tensor([[-8.]])\n", + "tensor([[-7.7316]])\n", + "tensor([[-5.3098]])\n", "------------------------\n", - "tensor([[-9.2588]])\n", - "tensor([[-6.5229]])\n", + "tensor([[-7.7434]])\n", + "tensor([[-5.8327]])\n", "------------------------\n", - "tensor([[-8.6053]])\n", - "tensor([[-9.3010]])\n", + "tensor([[-8.8967]])\n", + "tensor([[-9.7905]])\n", "------------------------\n", - "tensor([[-8.4006]])\n", - "tensor([[-9.7696]])\n", + "tensor([[-7.5315]])\n", + "tensor([[-7.6021]])\n", "------------------------\n", - "tensor([[-8.3098]])\n", - "tensor([[-8.3010]])\n", + "tensor([[-7.5920]])\n", + "tensor([[-6.6198]])\n", "------------------------\n", - "tensor([[-8.7247]])\n", - "tensor([[-5.8861]])\n", + "tensor([[-8.6127]])\n", + "tensor([[-11.3010]])\n", "------------------------\n", - "tensor([[-7.5075]])\n", - "tensor([[-7.4559]])\n", + "tensor([[-8.6308]])\n", + "tensor([[-8.0044]])\n", "------------------------\n", - "Epoch : 66 \t train loss: 1.4990289790789806 train MSE: tensor(1.3777, grad_fn=) test MSE: 2.721690301339896\n", - "Corr: 0.3535868036045738\n", - "tensor(0.1168, grad_fn=)\n", - "tensor(0.1168, grad_fn=)\n", - "tensor(0.1169, grad_fn=)\n", - "tensor(0.1169, grad_fn=)\n", - "tensor(0.1171, grad_fn=)\n", - "tensor(0.1171, grad_fn=)\n", - "tensor(0.1172, grad_fn=)\n", - "tensor(0.1173, grad_fn=)\n", - "tensor(0.1175, grad_fn=)\n", - "tensor(0.1176, grad_fn=)\n", - "tensor(0.1177, grad_fn=)\n", - "tensor(0.1179, grad_fn=)\n", - "tensor(0.1180, grad_fn=)\n", - "tensor(0.1181, grad_fn=)\n", - "tensor(0.1181, grad_fn=)\n", - "tensor(0.1181, grad_fn=)\n", - "tensor(0.1182, grad_fn=)\n", - "tensor(0.1182, grad_fn=)\n", - "tensor(0.1182, grad_fn=)\n", - "tensor(0.1182, grad_fn=)\n", - "tensor([[-6.8192]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.8962]])\n", - "tensor([[-11.2441]])\n", + "tensor([[-8.6326]])\n", + "tensor([[-8.8539]])\n", "------------------------\n", - "tensor([[-9.1669]])\n", - "tensor([[-7.5986]])\n", + "tensor([[-7.5893]])\n", + "tensor([[-6.9586]])\n", "------------------------\n", - "tensor([[-5.7303]])\n", - "tensor([[-4.5086]])\n", + "tensor([[-8.8093]])\n", + "tensor([[-8.5376]])\n", "------------------------\n", - "tensor([[-8.1631]])\n", - "tensor([[-9.1612]])\n", + "tensor([[-9.0182]])\n", + "tensor([[-11.3979]])\n", "------------------------\n", - "tensor([[-6.8662]])\n", - "tensor([[-7.]])\n", + "tensor([[-8.8277]])\n", + "tensor([[-11.2218]])\n", "------------------------\n", - "tensor([[-8.5167]])\n", + "Epoch : 47 \t train loss: 2.212683908300462 train MSE: tensor(1.9823, grad_fn=) test MSE: 1.9710189656583346\n", + "Corr: 0.7132999424042724\n", + "tensor(0.2203, grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor(0.2202, grad_fn=)\n", + "tensor(0.2200, grad_fn=)\n", + "tensor(0.2199, grad_fn=)\n", + "tensor(0.2200, grad_fn=)\n", + "tensor(0.2200, grad_fn=)\n", + "tensor(0.2200, grad_fn=)\n", + "tensor(0.2199, grad_fn=)\n", + "tensor(0.2198, grad_fn=)\n", + "tensor(0.2198, grad_fn=)\n", + "tensor(0.2197, grad_fn=)\n", + "tensor(0.2196, grad_fn=)\n", + "tensor(0.2195, grad_fn=)\n", + "tensor(0.2194, grad_fn=)\n", + "tensor(0.2195, grad_fn=)\n", + "tensor(0.2196, grad_fn=)\n", + "tensor(0.2197, grad_fn=)\n", + "tensor(0.2197, grad_fn=)\n", + "tensor(0.2198, grad_fn=)\n", + "tensor(0.2198, grad_fn=)\n", + "tensor([[-7.4687]])\n", + "tensor([[-6.4202]])\n", + "------------------------\n", + "tensor([[-8.2732]])\n", + "tensor([[-7.1427]])\n", + "------------------------\n", + "tensor([[-8.9603]])\n", + "tensor([[-8.0506]])\n", + "------------------------\n", + "tensor([[-8.9099]])\n", + "tensor([[-7.0362]])\n", + "------------------------\n", + "tensor([[-8.8293]])\n", + "tensor([[-9.2733]])\n", + "------------------------\n", + "tensor([[-7.7348]])\n", "tensor([[-8.1643]])\n", "------------------------\n", - "tensor([[-8.0570]])\n", - "tensor([[-9.0969]])\n", + "tensor([[-7.4947]])\n", + "tensor([[-7.9208]])\n", "------------------------\n", - "tensor([[-8.7651]])\n", - "tensor([[-7.5229]])\n", + "tensor([[-7.7392]])\n", + "tensor([[-6.8386]])\n", "------------------------\n", - "tensor([[-8.8398]])\n", - "tensor([[-9.9914]])\n", + "tensor([[-9.2292]])\n", + "tensor([[-11.2441]])\n", "------------------------\n", - "tensor([[-7.2046]])\n", - "tensor([[-8.4559]])\n", + "tensor([[-7.7647]])\n", + "tensor([[-7.8539]])\n", "------------------------\n", - "tensor([[-7.4984]])\n", - "tensor([[-8.1308]])\n", + "tensor([[-7.6260]])\n", + "tensor([[-5.3098]])\n", "------------------------\n", - "tensor([[-8.2355]])\n", - "tensor([[-10.5229]])\n", + "tensor([[-7.6369]])\n", + "tensor([[-5.8327]])\n", "------------------------\n", - "tensor([[-7.5821]])\n", - "tensor([[-4.3979]])\n", + "tensor([[-8.8479]])\n", + "tensor([[-9.7905]])\n", "------------------------\n", - "tensor([[-8.3763]])\n", - "tensor([[-8.]])\n", + "tensor([[-7.4212]])\n", + "tensor([[-7.6021]])\n", "------------------------\n", - "tensor([[-9.3362]])\n", - "tensor([[-6.5229]])\n", + "tensor([[-7.4874]])\n", + "tensor([[-6.6198]])\n", "------------------------\n", - "tensor([[-8.6967]])\n", - "tensor([[-9.3010]])\n", + "tensor([[-8.6452]])\n", + "tensor([[-11.3010]])\n", "------------------------\n", - "tensor([[-8.4697]])\n", - "tensor([[-9.7696]])\n", + "tensor([[-8.5992]])\n", + "tensor([[-8.0044]])\n", "------------------------\n", - "tensor([[-8.3895]])\n", - "tensor([[-8.3010]])\n", + "tensor([[-8.5291]])\n", + "tensor([[-8.8539]])\n", "------------------------\n", - "tensor([[-8.8342]])\n", - "tensor([[-5.8861]])\n", + "tensor([[-7.4811]])\n", + "tensor([[-6.9586]])\n", "------------------------\n", - "tensor([[-7.5659]])\n", - "tensor([[-7.4559]])\n", + "tensor([[-8.7815]])\n", + "tensor([[-8.5376]])\n", "------------------------\n", - "Epoch : 67 \t train loss: 1.4710588346297746 train MSE: tensor(1.3483, grad_fn=) test MSE: 2.708227756344492\n", - "Corr: 0.3559022209555045\n", - "tensor(0.1183, grad_fn=)\n", - "tensor(0.1184, grad_fn=)\n", - "tensor(0.1185, grad_fn=)\n", - "tensor(0.1186, grad_fn=)\n", - "tensor(0.1187, grad_fn=)\n", - "tensor(0.1188, grad_fn=)\n", - "tensor(0.1189, grad_fn=)\n", - "tensor(0.1190, grad_fn=)\n", - "tensor(0.1191, grad_fn=)\n", - "tensor(0.1191, grad_fn=)\n", - "tensor(0.1192, grad_fn=)\n", - "tensor(0.1192, grad_fn=)\n", - "tensor(0.1193, grad_fn=)\n", - "tensor(0.1193, grad_fn=)\n", - "tensor(0.1193, grad_fn=)\n", - "tensor(0.1193, grad_fn=)\n", - "tensor(0.1194, grad_fn=)\n", - "tensor(0.1194, grad_fn=)\n", - "tensor(0.1195, grad_fn=)\n", - "tensor(0.1196, grad_fn=)\n", - "tensor([[-6.5801]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.6531]])\n", - "tensor([[-11.2441]])\n", + "tensor([[-8.9989]])\n", + "tensor([[-11.3979]])\n", "------------------------\n", - "tensor([[-8.9271]])\n", - "tensor([[-7.5986]])\n", + "tensor([[-8.7563]])\n", + "tensor([[-11.2218]])\n", + "------------------------\n", + "Epoch : 48 \t train loss: 2.1751296348821105 train MSE: tensor(1.9453, grad_fn=) test MSE: 1.9150571493770587\n", + "Corr: 0.7205562467722416\n", + "tensor(0.2196, grad_fn=)\n", + "tensor(0.2195, grad_fn=)\n", + "tensor(0.2194, grad_fn=)\n", + "tensor(0.2193, grad_fn=)\n", + "tensor(0.2193, grad_fn=)\n", + "tensor(0.2194, grad_fn=)\n", + "tensor(0.2195, grad_fn=)\n", + "tensor(0.2196, grad_fn=)\n", + "tensor(0.2196, grad_fn=)\n", + "tensor(0.2197, grad_fn=)\n", + "tensor(0.2197, grad_fn=)\n", + "tensor(0.2197, grad_fn=)\n", + "tensor(0.2197, grad_fn=)\n", + "tensor(0.2196, grad_fn=)\n", + "tensor(0.2195, grad_fn=)\n", + "tensor(0.2195, grad_fn=)\n", + "tensor(0.2195, grad_fn=)\n", + "tensor(0.2196, grad_fn=)\n", + "tensor(0.2196, grad_fn=)\n", + "tensor(0.2195, grad_fn=)\n", + "tensor([[-7.4375]])\n", + "tensor([[-6.4202]])\n", + "------------------------\n", + "tensor([[-8.2231]])\n", + "tensor([[-7.1427]])\n", "------------------------\n", - "tensor([[-5.4599]])\n", - "tensor([[-4.5086]])\n", + "tensor([[-8.7513]])\n", + "tensor([[-8.0506]])\n", "------------------------\n", - "tensor([[-8.0054]])\n", - "tensor([[-9.1612]])\n", + "tensor([[-8.7441]])\n", + "tensor([[-7.0362]])\n", "------------------------\n", - "tensor([[-6.6049]])\n", - "tensor([[-7.]])\n", + "tensor([[-8.7232]])\n", + "tensor([[-9.2733]])\n", "------------------------\n", - "tensor([[-8.2817]])\n", + "tensor([[-7.7075]])\n", "tensor([[-8.1643]])\n", "------------------------\n", - "tensor([[-7.8383]])\n", - "tensor([[-9.0969]])\n", + "tensor([[-7.4559]])\n", + "tensor([[-7.9208]])\n", + "------------------------\n", + "tensor([[-7.6202]])\n", + "tensor([[-6.8386]])\n", "------------------------\n", - "tensor([[-8.5123]])\n", - "tensor([[-7.5229]])\n", + "tensor([[-9.0879]])\n", + "tensor([[-11.2441]])\n", "------------------------\n", - "tensor([[-8.6094]])\n", - "tensor([[-9.9914]])\n", + "tensor([[-7.7202]])\n", + "tensor([[-7.8539]])\n", "------------------------\n", - "tensor([[-7.0694]])\n", - "tensor([[-8.4559]])\n", + "tensor([[-7.6021]])\n", + "tensor([[-5.3098]])\n", "------------------------\n", - "tensor([[-7.2667]])\n", - "tensor([[-8.1308]])\n", + "tensor([[-7.6125]])\n", + "tensor([[-5.8327]])\n", "------------------------\n", - "tensor([[-8.0643]])\n", - "tensor([[-10.5229]])\n", + "tensor([[-8.7140]])\n", + "tensor([[-9.7905]])\n", "------------------------\n", - "tensor([[-7.3336]])\n", - "tensor([[-4.3979]])\n", + "tensor([[-7.3851]])\n", + "tensor([[-7.6021]])\n", "------------------------\n", - "tensor([[-8.1410]])\n", - "tensor([[-8.]])\n", + "tensor([[-7.4594]])\n", + "tensor([[-6.6198]])\n", "------------------------\n", - "tensor([[-9.1010]])\n", - "tensor([[-6.5229]])\n", + "tensor([[-8.3559]])\n", + "tensor([[-11.3010]])\n", "------------------------\n", - "tensor([[-8.4512]])\n", - "tensor([[-9.3010]])\n", + "tensor([[-8.4102]])\n", + "tensor([[-8.0044]])\n", "------------------------\n", - "tensor([[-8.2168]])\n", - "tensor([[-9.7696]])\n", + "tensor([[-8.4730]])\n", + "tensor([[-8.8539]])\n", "------------------------\n", - "tensor([[-8.1320]])\n", - "tensor([[-8.3010]])\n", + "tensor([[-7.4423]])\n", + "tensor([[-6.9586]])\n", "------------------------\n", - "tensor([[-8.6838]])\n", - "tensor([[-5.8861]])\n", + "tensor([[-8.5879]])\n", + "tensor([[-8.5376]])\n", "------------------------\n", - "tensor([[-7.3165]])\n", - "tensor([[-7.4559]])\n", + "tensor([[-8.7752]])\n", + "tensor([[-11.3979]])\n", "------------------------\n", - "Epoch : 68 \t train loss: 1.4870356237713316 train MSE: tensor(1.3628, grad_fn=) test MSE: 2.751059710314231\n", - "Corr: 0.36185214692012013\n", - "tensor(0.1196, grad_fn=)\n", - "tensor(0.1195, grad_fn=)\n", - "tensor(0.1195, grad_fn=)\n", - "tensor(0.1196, grad_fn=)\n", - "tensor(0.1197, grad_fn=)\n", - "tensor(0.1198, grad_fn=)\n", - "tensor(0.1199, grad_fn=)\n", - "tensor(0.1201, grad_fn=)\n", - "tensor(0.1202, grad_fn=)\n", - "tensor(0.1204, grad_fn=)\n", - "tensor(0.1205, grad_fn=)\n", - "tensor(0.1206, grad_fn=)\n", - "tensor(0.1206, grad_fn=)\n", - "tensor(0.1206, grad_fn=)\n", - "tensor(0.1206, grad_fn=)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "tensor(0.1206, grad_fn=)\n", - "tensor(0.1205, grad_fn=)\n", - "tensor(0.1205, grad_fn=)\n", - "tensor(0.1206, grad_fn=)\n", - "tensor(0.1206, grad_fn=)\n", - "tensor([[-6.6149]])\n", - "tensor([[-9.3010]])\n", - "------------------------\n", - "tensor([[-8.7055]])\n", - "tensor([[-11.2441]])\n", + "tensor([[-8.6796]])\n", + "tensor([[-11.2218]])\n", + "------------------------\n", + "Epoch : 49 \t train loss: 2.1947336072236103 train MSE: tensor(1.9652, grad_fn=) test MSE: 2.023215690828775\n", + "Corr: 0.7107333872094919\n", + "tensor(0.2192, grad_fn=)\n", + "tensor(0.2189, grad_fn=)\n", + "tensor(0.2188, grad_fn=)\n", + "tensor(0.2187, grad_fn=)\n", + "tensor(0.2187, grad_fn=)\n", + "tensor(0.2186, grad_fn=)\n", + "tensor(0.2187, grad_fn=)\n", + "tensor(0.2187, grad_fn=)\n", + "tensor(0.2188, grad_fn=)\n", + "tensor(0.2189, grad_fn=)\n", + "tensor(0.2190, grad_fn=)\n", + "tensor(0.2191, grad_fn=)\n", + "tensor(0.2191, grad_fn=)\n", + "tensor(0.2190, grad_fn=)\n", + "tensor(0.2188, grad_fn=)\n", + "tensor(0.2188, grad_fn=)\n", + "tensor(0.2188, grad_fn=)\n", + "tensor(0.2187, grad_fn=)\n", + "tensor(0.2187, grad_fn=)\n", + "tensor(0.2186, grad_fn=)\n", + "tensor([[-7.3241]])\n", + "tensor([[-6.4202]])\n", "------------------------\n", - "tensor([[-8.9682]])\n", - "tensor([[-7.5986]])\n", + "tensor([[-8.1728]])\n", + "tensor([[-7.1427]])\n", "------------------------\n", - "tensor([[-5.4799]])\n", - "tensor([[-4.5086]])\n", + "tensor([[-8.9022]])\n", + "tensor([[-8.0506]])\n", "------------------------\n", - "tensor([[-8.0399]])\n", - "tensor([[-9.1612]])\n", + "tensor([[-8.8995]])\n", + "tensor([[-7.0362]])\n", "------------------------\n", - "tensor([[-6.6459]])\n", - "tensor([[-7.]])\n", + "tensor([[-8.7872]])\n", + "tensor([[-9.2733]])\n", "------------------------\n", - "tensor([[-8.3442]])\n", + "tensor([[-7.5984]])\n", "tensor([[-8.1643]])\n", "------------------------\n", - "tensor([[-7.9014]])\n", - "tensor([[-9.0969]])\n", + "tensor([[-7.3436]])\n", + "tensor([[-7.9208]])\n", "------------------------\n", - "tensor([[-8.5762]])\n", - "tensor([[-7.5229]])\n", + "tensor([[-7.6325]])\n", + "tensor([[-6.8386]])\n", "------------------------\n", - "tensor([[-8.6494]])\n", - "tensor([[-9.9914]])\n", + "tensor([[-9.2160]])\n", + "tensor([[-11.2441]])\n", "------------------------\n", - "tensor([[-7.0862]])\n", - "tensor([[-8.4559]])\n", + "tensor([[-7.6302]])\n", + "tensor([[-7.8539]])\n", "------------------------\n", - "tensor([[-7.2882]])\n", - "tensor([[-8.1308]])\n", + "tensor([[-7.4833]])\n", + "tensor([[-5.3098]])\n", "------------------------\n", - "tensor([[-8.0788]])\n", - "tensor([[-10.5229]])\n", + "tensor([[-7.4955]])\n", + "tensor([[-5.8327]])\n", "------------------------\n", - "tensor([[-7.3732]])\n", - "tensor([[-4.3979]])\n", + "tensor([[-8.8151]])\n", + "tensor([[-9.7905]])\n", "------------------------\n", - "tensor([[-8.1725]])\n", - "tensor([[-8.]])\n", + "tensor([[-7.2629]])\n", + "tensor([[-7.6021]])\n", "------------------------\n", - "tensor([[-9.1418]])\n", - "tensor([[-6.5229]])\n", + "tensor([[-7.3345]])\n", + "tensor([[-6.6198]])\n", "------------------------\n", - "tensor([[-8.4768]])\n", - "tensor([[-9.3010]])\n", + "tensor([[-8.6452]])\n", + "tensor([[-11.3010]])\n", "------------------------\n", - "tensor([[-8.2277]])\n", - "tensor([[-9.7696]])\n", + "tensor([[-8.5681]])\n", + "tensor([[-8.0044]])\n", "------------------------\n", - "tensor([[-8.1659]])\n", - "tensor([[-8.3010]])\n", + "tensor([[-8.4349]])\n", + "tensor([[-8.8539]])\n", "------------------------\n", - "tensor([[-8.6975]])\n", - "tensor([[-5.8861]])\n", + "tensor([[-7.3258]])\n", + "tensor([[-6.9586]])\n", "------------------------\n", - "tensor([[-7.3598]])\n", - "tensor([[-7.4559]])\n", + "tensor([[-8.7849]])\n", + "tensor([[-8.5376]])\n", + "------------------------\n", + "tensor([[-9.0102]])\n", + "tensor([[-11.3979]])\n", + "------------------------\n", + "tensor([[-8.6936]])\n", + "tensor([[-11.2218]])\n", "------------------------\n", - "Epoch : 69 \t train loss: 1.4831422055914976 train MSE: tensor(1.3576, grad_fn=) test MSE: 2.739154483058623\n", - "Corr: 0.36117474288444007\n" + "Epoch : 50 \t train loss: 2.11564413083145 train MSE: tensor(1.8868, grad_fn=) test MSE: 1.8482574403963306\n", + "Corr: 0.7228780377857388\n" ] } ], "source": [ "model.train()\n", - "n_max_epochs = 23 * 3\n", - "max_corr = 0.4\n", + "n_max_epochs = 50 # This is just a super short example. You can increase this.\n", + "max_corr = 0.87\n", "batch_size = 32\n", "\n", "train_loss, test_loss, inter_filter, y_test, output_test = training_routine(model, criterion, optimiser, train_x, test_x, train_y, test_y, n_max_epochs=n_max_epochs, max_corr=max_corr, batch_size=batch_size)\n", @@ -6422,23 +4804,13 @@ }, { "cell_type": "code", - "execution_count": 16, - "id": "e935aa30", - "metadata": {}, - "outputs": [], - "source": [ - "#optimiser.param_groups[0]['lr'] = 0.00027253018778843 * 0.15" - ] - }, - { - "cell_type": "code", - "execution_count": 24, + "execution_count": 12, "id": "1c5a2419", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -6462,23 +4834,13 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 13, "id": "033248ae", "metadata": {}, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Total image is product of this image\n", - "Total image is product of this image\n", - "Total image is product of this image\n", - "Total image is product of this image\n" - ] - }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -6498,16 +4860,14 @@ " if j == 1 and i == (n_filters+1)//2-1 and n_filters % 2 != 0:\n", " im_ = learnt_filter\n", " else:\n", - " print('Total image is product of this image')\n", " im_ = np.multiply(np.mean(inter_filter, axis=0)[2*i+j], model.fc1.weight.data.numpy().reshape(n_filters,size_le**2)[2*i+j].reshape(size_le, size_le))\n", " learnt_filter += im_\n", - " im = axs[i,j].imshow(im_, origin='lower', cmap='seismic', norm=CenteredNorm())\n", - " axs[i,j].set_title('Weight: '+str(im_.sum()), size=title_size)" + " im = axs[i,j].imshow(im_, origin='lower', cmap='seismic', norm=CenteredNorm())" ] }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 14, "id": "ea015d2c", "metadata": { "scrolled": true @@ -6515,7 +4875,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -6537,7 +4897,7 @@ }, { "cell_type": "code", - "execution_count": 98, + "execution_count": 15, "id": "64fa6b14", "metadata": { "scrolled": true @@ -6545,7 +4905,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -6567,7 +4927,7 @@ }, { "cell_type": "code", - "execution_count": 99, + "execution_count": 16, "id": "71d94a68", "metadata": { "scrolled": true @@ -6575,7 +4935,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -6598,228 +4958,50 @@ ] }, { - "cell_type": "code", - "execution_count": 100, - "id": "518b7ecd", - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "fig = plt.figure(figsize=(8, 6))\n", - "plt.title('Outlier distribution', size=title_size)\n", - "plt.hist(np.abs((model(train_x)[0]-train_y).detach().numpy()), 25)\n", - "plt.xlabel('$\\Delta\\log_{10}(K_D)$', size=font_size)\n", - "plt.ylabel('Frequency', size=font_size)\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "id": "27006e6f", - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "data": { - "text/plain": [ - "tensor([[-7.8488],\n", - " [-8.8119],\n", - " [-6.8079],\n", - " [-8.4229],\n", - " [-7.6609],\n", - " [-8.6647],\n", - " [-7.5039],\n", - " [-7.3520],\n", - " [-7.5180],\n", - " [-8.0300],\n", - " [-8.9547],\n", - " [-7.4532],\n", - " [-8.0866],\n", - " [-7.6879],\n", - " [-8.0589],\n", - " [-6.1069],\n", - " [-7.9266],\n", - " [-6.8946],\n", - " [-8.6947],\n", - " [-8.1570],\n", - " [-7.4921],\n", - " [-6.7924],\n", - " [-7.9947],\n", - " [-8.2423],\n", - " [-8.1894],\n", - " [-7.9848],\n", - " [-8.8121],\n", - " [-8.3136],\n", - " [-7.2671],\n", - " [-7.5069],\n", - " [-8.0406],\n", - " [-8.3701],\n", - " [-7.9674],\n", - " [-8.3605],\n", - " [-7.7745],\n", - " [-9.2119],\n", - " [-7.6806],\n", - " [-7.9661],\n", - " [-7.1673],\n", - " [-6.9482]], grad_fn=)" - ] - }, - "execution_count": 31, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "model(train_x[80:120])[0]" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "id": "4264d33e", - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "data": { - "text/plain": [ - "tensor([[ -8.7852],\n", - " [ -9.3768],\n", - " [ -6.0809],\n", - " [ -9.8539],\n", - " [ -7.0269],\n", - " [-10.1904],\n", - " [ -5.6737],\n", - " [ -8.3979],\n", - " [ -7.2396],\n", - " [ -8.2291],\n", - " [ -9.6990],\n", - " [ -8.0044],\n", - " [ -7.9586],\n", - " [ -7.5086],\n", - " [ -7.7959],\n", - " [ -6.9101],\n", - " [ -6.8210],\n", - " [ -7.7799],\n", - " [ -8.7447],\n", - " [-10.3799],\n", - " [ -6.7773],\n", - " [ -6.1500],\n", - " [ -7.8416],\n", - " [ -9.7447],\n", - " [ -8.2076],\n", - " [ -8.1141],\n", - " [ -9.3468],\n", - " [ -9.3665],\n", - " [ -7.7212],\n", - " [ -6.8962],\n", - " [ -8.0223],\n", - " [ -9.0269],\n", - " [ -8.2518],\n", - " [ -9.9586],\n", - " [ -8.7423],\n", - " [-10.5229],\n", - " [ -7.6576],\n", - " [ -7.6383],\n", - " [ -5.3979],\n", - " [ -6.6021]])" - ] - }, - "execution_count": 32, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "train_y[80:120]" - ] - }, - { - "attachments": {}, "cell_type": "markdown", "id": "7fa7fb7c", "metadata": {}, "source": [ - "# Training" + "# Checkpoints" ] }, { "cell_type": "code", - "execution_count": 42, + "execution_count": null, "id": "5f8707ae", "metadata": {}, "outputs": [], "source": [ "##### Uncomment the following lines to save a checkpoint\n", "\n", - "path = '../checkpoints/model_epochs_' + str(len(train_losses)) + '_modes_' + str(modes) + '_pool_' + str(pooling_size) + '_filters_' + str(n_filters) + '_size_' + str(filter_size) + '.pt'\n", - "save_checkpoint(path, model, optimiser, train_losses, test_losses)\n", - "np.save('../checkpoints/learnt_filter_epochs_'+str(len(train_losses))+'_modes_'+str(modes)+'_pool_'+str(pooling_size)+'_filters_'+str(n_filters)+'_size_'+str(filter_size)+'.npy', learnt_filter)" + "#path = '../checkpoints/model_epochs_' + str(len(train_losses)) + '_modes_' + str(modes) + '_pool_' + str(pooling_size) + '_filters_' + str(n_filters) + '_size_' + str(filter_size) + '.pt'\n", + "#save_checkpoint(path, model, optimiser, train_losses, test_losses)\n", + "#np.save('../checkpoints/learnt_filter_epochs_'+str(len(train_losses))+'_modes_'+str(modes)+'_pool_'+str(pooling_size)+'_filters_'+str(n_filters)+'_size_'+str(filter_size)+'.npy', learnt_filter)" ] }, { "cell_type": "code", - "execution_count": 21, + "execution_count": null, "id": "dc802940", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[31mPlease check your arguments if you have upgraded adabelief-pytorch from version 0.0.5.\n", - "\u001b[31mModifications to default arguments:\n", - "\u001b[31m eps weight_decouple rectify\n", - "----------------------- ----- ----------------- ---------\n", - "adabelief-pytorch=0.0.5 1e-08 False False\n", - ">=0.1.0 (Current 0.2.0) 1e-16 True True\n", - "\u001b[34mSGD better than Adam (e.g. CNN for Image Classification) Adam better than SGD (e.g. Transformer, GAN)\n", - "---------------------------------------------------------- ----------------------------------------------\n", - "Recommended eps = 1e-8 Recommended eps = 1e-16\n", - "\u001b[34mFor a complete table of recommended hyperparameters, see\n", - "\u001b[34mhttps://github.com/juntang-zhuang/Adabelief-Optimizer\n", - "\u001b[32mYou can disable the log message by setting \"print_change_log = False\", though it is recommended to keep as a reminder.\n", - "\u001b[0m\n", - "Weight decoupling enabled in AdaBelief\n", - "Rectification enabled in AdaBelief\n" - ] - } - ], + "outputs": [], "source": [ "##### Uncomment the following lines to load a checkpoint\n", "\n", - "from antipasti.utils.torch_utils import load_checkpoint\n", + "#from antipasti.utils.torch_utils import load_checkpoint\n", "#\n", - "nf_chckpt = 4\n", - "pool_chckpt = 2\n", - "k_chckpt = 4\n", - "ep_chckpt = 221\n", - "modes_chckpt = 'all'\n", - "input_shape = 292\n", + "#nf_chckpt = \n", + "#pool_chckpt = \n", + "#k_chckpt = \n", + "#ep_chckpt = \n", + "#modes_chckpt = \n", + "#input_shape = \n", "\n", - "path = '../checkpoints/contact_maps/seed_398/model_epochs_' + str(ep_chckpt) + '_modes_' + str(modes_chckpt) + '_pool_' + str(pool_chckpt) + '_filters_' + str(nf_chckpt) + '_size_' + str(k_chckpt) + '.pt'\n", - "model,optimiser,_,train_losses, test_losses = load_checkpoint(path, input_shape)" + "#path = '../checkpoints/.../model_epochs_' + str(ep_chckpt) + '_modes_' + str(modes_chckpt) + '_pool_' + str(pool_chckpt) + '_filters_' + str(nf_chckpt) + '_size_' + str(k_chckpt) + '.pt'\n", + "#model,optimiser,_,train_losses, test_losses = load_checkpoint(path, input_shape)" ] }, { - "attachments": {}, "cell_type": "markdown", "id": "31110205", "metadata": {}, @@ -6829,12 +5011,12 @@ }, { "cell_type": "code", - "execution_count": 193, + "execution_count": null, "id": "84c865ef", "metadata": {}, "outputs": [], "source": [ - "n_max_epochs = 23\n", + "n_max_epochs = 1000 # Your value\n", "max_corr = 0.87\n", "batch_size = 32\n", "\n", @@ -6888,82 +5070,12 @@ }, { "cell_type": "code", - "execution_count": 195, + "execution_count": null, "id": "581af68a", "metadata": { "scrolled": true }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\u001b[32m[I 2023-11-04 18:43:25,969]\u001b[0m A new study created in memory with name: no-name-ada222f8-f214-4ff1-ad7b-660a773fef3c\u001b[0m\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Filters:\n", - "8\n", - "with size:\n", - "4\n", - "Pooling size:\n", - "1\n", - "Learning rate:\n", - "1e-05\n", - "Weight decoupling enabled in AdaBelief\n", - "Rectification enabled in AdaBelief\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\u001b[33m[W 2023-11-04 18:43:26,790]\u001b[0m Trial 0 failed with parameters: {'n_filters': 8, 'filter_size': 4, 'pooling_size': 1, 'learning_rate': 1e-05} because of the following error: KeyboardInterrupt().\u001b[0m\n", - "Traceback (most recent call last):\n", - " File \"/Users/kevinmicha/opt/anaconda3/envs/nma-cnn-env/lib/python3.11/site-packages/optuna/study/_optimize.py\", line 200, in _run_trial\n", - " value_or_values = func(trial)\n", - " ^^^^^^^^^^^\n", - " File \"/var/folders/4j/fmrt0mln14zcmrb74g6z93bh0000gn/T/ipykernel_40484/3691434214.py\", line 38, in objective\n", - " train_loss, val_loss, _, _, _ = training_routine(model, criterion, optimiser, train_x_fold, val_x_fold, train_y_fold, val_y_fold, n_max_epochs=n_max_epochs, max_corr=max_corr, batch_size=batch_size, verbose=False)\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"/Users/kevinmicha/Documents/PhD/ANTIPASTI/antipasti/utils/torch_utils.py\", line 227, in training_routine\n", - " train_losses, test_losses, inter_filter, y_test, output_test = training_step(model, criterion, optimiser, train_x, test_x, train_y, test_y, train_losses, test_losses, epoch, batch_size, verbose)\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"/Users/kevinmicha/Documents/PhD/ANTIPASTI/antipasti/utils/torch_utils.py\", line 150, in training_step\n", - " loss_train.backward()\n", - " File \"/Users/kevinmicha/opt/anaconda3/envs/nma-cnn-env/lib/python3.11/site-packages/torch/_tensor.py\", line 487, in backward\n", - " torch.autograd.backward(\n", - " File \"/Users/kevinmicha/opt/anaconda3/envs/nma-cnn-env/lib/python3.11/site-packages/torch/autograd/__init__.py\", line 200, in backward\n", - " Variable._execution_engine.run_backward( # Calls into the C++ engine to run the backward pass\n", - "KeyboardInterrupt\n", - "\u001b[33m[W 2023-11-04 18:43:26,793]\u001b[0m Trial 0 failed with value None.\u001b[0m\n" - ] - }, - { - "ename": "KeyboardInterrupt", - "evalue": "", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[195], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m study \u001b[38;5;241m=\u001b[39m optuna\u001b[38;5;241m.\u001b[39mcreate_study(direction\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mminimize\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[0;32m----> 2\u001b[0m study\u001b[38;5;241m.\u001b[39moptimize(objective, n_trials\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m100\u001b[39m)\n\u001b[1;32m 3\u001b[0m trial \u001b[38;5;241m=\u001b[39m study\u001b[38;5;241m.\u001b[39mbest_trial\n\u001b[1;32m 4\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mBest Score: \u001b[39m\u001b[38;5;124m\"\u001b[39m, trial\u001b[38;5;241m.\u001b[39mvalue)\n", - "File \u001b[0;32m~/opt/anaconda3/envs/nma-cnn-env/lib/python3.11/site-packages/optuna/study/study.py:425\u001b[0m, in \u001b[0;36mStudy.optimize\u001b[0;34m(self, func, n_trials, timeout, n_jobs, catch, callbacks, gc_after_trial, show_progress_bar)\u001b[0m\n\u001b[1;32m 321\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21moptimize\u001b[39m(\n\u001b[1;32m 322\u001b[0m \u001b[38;5;28mself\u001b[39m,\n\u001b[1;32m 323\u001b[0m func: ObjectiveFuncType,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 330\u001b[0m show_progress_bar: \u001b[38;5;28mbool\u001b[39m \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mFalse\u001b[39;00m,\n\u001b[1;32m 331\u001b[0m ) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 332\u001b[0m \u001b[38;5;124;03m\"\"\"Optimize an objective function.\u001b[39;00m\n\u001b[1;32m 333\u001b[0m \n\u001b[1;32m 334\u001b[0m \u001b[38;5;124;03m Optimization is done by choosing a suitable set of hyperparameter values from a given\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 422\u001b[0m \u001b[38;5;124;03m If nested invocation of this method occurs.\u001b[39;00m\n\u001b[1;32m 423\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m--> 425\u001b[0m _optimize(\n\u001b[1;32m 426\u001b[0m study\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m,\n\u001b[1;32m 427\u001b[0m func\u001b[38;5;241m=\u001b[39mfunc,\n\u001b[1;32m 428\u001b[0m n_trials\u001b[38;5;241m=\u001b[39mn_trials,\n\u001b[1;32m 429\u001b[0m timeout\u001b[38;5;241m=\u001b[39mtimeout,\n\u001b[1;32m 430\u001b[0m n_jobs\u001b[38;5;241m=\u001b[39mn_jobs,\n\u001b[1;32m 431\u001b[0m catch\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mtuple\u001b[39m(catch) \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(catch, Iterable) \u001b[38;5;28;01melse\u001b[39;00m (catch,),\n\u001b[1;32m 432\u001b[0m callbacks\u001b[38;5;241m=\u001b[39mcallbacks,\n\u001b[1;32m 433\u001b[0m gc_after_trial\u001b[38;5;241m=\u001b[39mgc_after_trial,\n\u001b[1;32m 434\u001b[0m show_progress_bar\u001b[38;5;241m=\u001b[39mshow_progress_bar,\n\u001b[1;32m 435\u001b[0m )\n", - "File \u001b[0;32m~/opt/anaconda3/envs/nma-cnn-env/lib/python3.11/site-packages/optuna/study/_optimize.py:66\u001b[0m, in \u001b[0;36m_optimize\u001b[0;34m(study, func, n_trials, timeout, n_jobs, catch, callbacks, gc_after_trial, show_progress_bar)\u001b[0m\n\u001b[1;32m 64\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m 65\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m n_jobs \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m1\u001b[39m:\n\u001b[0;32m---> 66\u001b[0m _optimize_sequential(\n\u001b[1;32m 67\u001b[0m study,\n\u001b[1;32m 68\u001b[0m func,\n\u001b[1;32m 69\u001b[0m n_trials,\n\u001b[1;32m 70\u001b[0m timeout,\n\u001b[1;32m 71\u001b[0m catch,\n\u001b[1;32m 72\u001b[0m callbacks,\n\u001b[1;32m 73\u001b[0m gc_after_trial,\n\u001b[1;32m 74\u001b[0m reseed_sampler_rng\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m,\n\u001b[1;32m 75\u001b[0m time_start\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m,\n\u001b[1;32m 76\u001b[0m progress_bar\u001b[38;5;241m=\u001b[39mprogress_bar,\n\u001b[1;32m 77\u001b[0m )\n\u001b[1;32m 78\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 79\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m n_jobs \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m:\n", - "File \u001b[0;32m~/opt/anaconda3/envs/nma-cnn-env/lib/python3.11/site-packages/optuna/study/_optimize.py:163\u001b[0m, in \u001b[0;36m_optimize_sequential\u001b[0;34m(study, func, n_trials, timeout, catch, callbacks, gc_after_trial, reseed_sampler_rng, time_start, progress_bar)\u001b[0m\n\u001b[1;32m 160\u001b[0m \u001b[38;5;28;01mbreak\u001b[39;00m\n\u001b[1;32m 162\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 163\u001b[0m frozen_trial \u001b[38;5;241m=\u001b[39m _run_trial(study, func, catch)\n\u001b[1;32m 164\u001b[0m \u001b[38;5;28;01mfinally\u001b[39;00m:\n\u001b[1;32m 165\u001b[0m \u001b[38;5;66;03m# The following line mitigates memory problems that can be occurred in some\u001b[39;00m\n\u001b[1;32m 166\u001b[0m \u001b[38;5;66;03m# environments (e.g., services that use computing containers such as GitHub Actions).\u001b[39;00m\n\u001b[1;32m 167\u001b[0m \u001b[38;5;66;03m# Please refer to the following PR for further details:\u001b[39;00m\n\u001b[1;32m 168\u001b[0m \u001b[38;5;66;03m# https://github.com/optuna/optuna/pull/325.\u001b[39;00m\n\u001b[1;32m 169\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m gc_after_trial:\n", - "File \u001b[0;32m~/opt/anaconda3/envs/nma-cnn-env/lib/python3.11/site-packages/optuna/study/_optimize.py:251\u001b[0m, in \u001b[0;36m_run_trial\u001b[0;34m(study, func, catch)\u001b[0m\n\u001b[1;32m 244\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m \u001b[38;5;28;01mFalse\u001b[39;00m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mShould not reach.\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 246\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m (\n\u001b[1;32m 247\u001b[0m frozen_trial\u001b[38;5;241m.\u001b[39mstate \u001b[38;5;241m==\u001b[39m TrialState\u001b[38;5;241m.\u001b[39mFAIL\n\u001b[1;32m 248\u001b[0m \u001b[38;5;129;01mand\u001b[39;00m func_err \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 249\u001b[0m \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(func_err, catch)\n\u001b[1;32m 250\u001b[0m ):\n\u001b[0;32m--> 251\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m func_err\n\u001b[1;32m 252\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m frozen_trial\n", - "File \u001b[0;32m~/opt/anaconda3/envs/nma-cnn-env/lib/python3.11/site-packages/optuna/study/_optimize.py:200\u001b[0m, in \u001b[0;36m_run_trial\u001b[0;34m(study, func, catch)\u001b[0m\n\u001b[1;32m 198\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m get_heartbeat_thread(trial\u001b[38;5;241m.\u001b[39m_trial_id, study\u001b[38;5;241m.\u001b[39m_storage):\n\u001b[1;32m 199\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 200\u001b[0m value_or_values \u001b[38;5;241m=\u001b[39m func(trial)\n\u001b[1;32m 201\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m exceptions\u001b[38;5;241m.\u001b[39mTrialPruned \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[1;32m 202\u001b[0m \u001b[38;5;66;03m# TODO(mamu): Handle multi-objective cases.\u001b[39;00m\n\u001b[1;32m 203\u001b[0m state \u001b[38;5;241m=\u001b[39m TrialState\u001b[38;5;241m.\u001b[39mPRUNED\n", - "Cell \u001b[0;32mIn[193], line 38\u001b[0m, in \u001b[0;36mobjective\u001b[0;34m(trial)\u001b[0m\n\u001b[1;32m 36\u001b[0m criterion \u001b[38;5;241m=\u001b[39m MSELoss() \n\u001b[1;32m 37\u001b[0m optimiser \u001b[38;5;241m=\u001b[39m AdaBelief(model\u001b[38;5;241m.\u001b[39mparameters(), lr\u001b[38;5;241m=\u001b[39mlearning_rate, weight_decay\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m, eps\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1e-8\u001b[39m, print_change_log\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m) \n\u001b[0;32m---> 38\u001b[0m train_loss, val_loss, _, _, _ \u001b[38;5;241m=\u001b[39m training_routine(model, criterion, optimiser, train_x_fold, val_x_fold, train_y_fold, val_y_fold, n_max_epochs\u001b[38;5;241m=\u001b[39mn_max_epochs, max_corr\u001b[38;5;241m=\u001b[39mmax_corr, batch_size\u001b[38;5;241m=\u001b[39mbatch_size, verbose\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m)\n\u001b[1;32m 40\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mFold number\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m 41\u001b[0m \u001b[38;5;28mprint\u001b[39m(fold) \n", - "File \u001b[0;32m~/Documents/PhD/ANTIPASTI/antipasti/utils/torch_utils.py:227\u001b[0m, in \u001b[0;36mtraining_routine\u001b[0;34m(model, criterion, optimiser, train_x, test_x, train_y, test_y, n_max_epochs, max_corr, batch_size, verbose)\u001b[0m\n\u001b[1;32m 224\u001b[0m test_losses \u001b[38;5;241m=\u001b[39m []\n\u001b[1;32m 226\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m epoch \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(n_max_epochs):\n\u001b[0;32m--> 227\u001b[0m train_losses, test_losses, inter_filter, y_test, output_test \u001b[38;5;241m=\u001b[39m training_step(model, criterion, optimiser, train_x, test_x, train_y, test_y, train_losses, test_losses, epoch, batch_size, verbose)\n\u001b[1;32m 229\u001b[0m \u001b[38;5;66;03m# Computing and printing the correlation coefficient\u001b[39;00m\n\u001b[1;32m 230\u001b[0m corr \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39mcorrcoef(np\u001b[38;5;241m.\u001b[39marray(output_test)\u001b[38;5;241m.\u001b[39mT, y_test[:,\u001b[38;5;241m0\u001b[39m]\u001b[38;5;241m.\u001b[39mdetach()\u001b[38;5;241m.\u001b[39mnumpy()\u001b[38;5;241m.\u001b[39mT)[\u001b[38;5;241m1\u001b[39m,\u001b[38;5;241m0\u001b[39m]\n", - "File \u001b[0;32m~/Documents/PhD/ANTIPASTI/antipasti/utils/torch_utils.py:150\u001b[0m, in \u001b[0;36mtraining_step\u001b[0;34m(model, criterion, optimiser, train_x, test_x, train_y, test_y, train_losses, test_losses, epoch, batch_size, verbose)\u001b[0m\n\u001b[1;32m 148\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m verbose:\n\u001b[1;32m 149\u001b[0m \u001b[38;5;28mprint\u001b[39m(l1_loss)\n\u001b[0;32m--> 150\u001b[0m loss_train\u001b[38;5;241m.\u001b[39mbackward()\n\u001b[1;32m 151\u001b[0m optimiser\u001b[38;5;241m.\u001b[39mstep()\n\u001b[1;32m 152\u001b[0m \u001b[38;5;66;03m# Adding batch contribution to training loss\u001b[39;00m\n", - "File \u001b[0;32m~/opt/anaconda3/envs/nma-cnn-env/lib/python3.11/site-packages/torch/_tensor.py:487\u001b[0m, in \u001b[0;36mTensor.backward\u001b[0;34m(self, gradient, retain_graph, create_graph, inputs)\u001b[0m\n\u001b[1;32m 477\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m has_torch_function_unary(\u001b[38;5;28mself\u001b[39m):\n\u001b[1;32m 478\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m handle_torch_function(\n\u001b[1;32m 479\u001b[0m Tensor\u001b[38;5;241m.\u001b[39mbackward,\n\u001b[1;32m 480\u001b[0m (\u001b[38;5;28mself\u001b[39m,),\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 485\u001b[0m inputs\u001b[38;5;241m=\u001b[39minputs,\n\u001b[1;32m 486\u001b[0m )\n\u001b[0;32m--> 487\u001b[0m torch\u001b[38;5;241m.\u001b[39mautograd\u001b[38;5;241m.\u001b[39mbackward(\n\u001b[1;32m 488\u001b[0m \u001b[38;5;28mself\u001b[39m, gradient, retain_graph, create_graph, inputs\u001b[38;5;241m=\u001b[39minputs\n\u001b[1;32m 489\u001b[0m )\n", - "File \u001b[0;32m~/opt/anaconda3/envs/nma-cnn-env/lib/python3.11/site-packages/torch/autograd/__init__.py:200\u001b[0m, in \u001b[0;36mbackward\u001b[0;34m(tensors, grad_tensors, retain_graph, create_graph, grad_variables, inputs)\u001b[0m\n\u001b[1;32m 195\u001b[0m retain_graph \u001b[38;5;241m=\u001b[39m create_graph\n\u001b[1;32m 197\u001b[0m \u001b[38;5;66;03m# The reason we repeat same the comment below is that\u001b[39;00m\n\u001b[1;32m 198\u001b[0m \u001b[38;5;66;03m# some Python versions print out the first line of a multi-line function\u001b[39;00m\n\u001b[1;32m 199\u001b[0m \u001b[38;5;66;03m# calls in the traceback and some print out the last line\u001b[39;00m\n\u001b[0;32m--> 200\u001b[0m Variable\u001b[38;5;241m.\u001b[39m_execution_engine\u001b[38;5;241m.\u001b[39mrun_backward( \u001b[38;5;66;03m# Calls into the C++ engine to run the backward pass\u001b[39;00m\n\u001b[1;32m 201\u001b[0m tensors, grad_tensors_, retain_graph, create_graph, inputs,\n\u001b[1;32m 202\u001b[0m allow_unreachable\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m, accumulate_grad\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m)\n", - "\u001b[0;31mKeyboardInterrupt\u001b[0m: " - ] - } - ], + "outputs": [], "source": [ "study = optuna.create_study(direction='minimize')\n", "study.optimize(objective, n_trials=100)\n",